class_docstr: Mini-Batch K-Means clustering
  
  Read more in the :ref:`User Guide <mini_batch_kmeans>`.
  
  Parameters
  ----------
  
  n_clusters : int, optional, default: 8
      The number of clusters to form as well as the number of
      centroids to generate.
  
  max_iter : int, optional
      Maximum number of iterations over the complete dataset before
      stopping independently of any early stopping criterion heuristics.
  
  max_no_improvement : int, default: 10
      Control early stopping based on the consecutive number of mini
      batches that does not yield an improvement on the smoothed inertia.
  
      To disable convergence detection based on inertia, set
      max_no_improvement to None.
  
  tol : float, default: 0.0
      Control early stopping based on the relative center changes as
      measured by a smoothed, variance-normalized of the mean center
      squared position changes. This early stopping heuristics is
      closer to the one used for the batch variant of the algorithms
      but induces a slight computational and memory overhead over the
      inertia heuristic.
  
      To disable convergence detection based on normalized center
      change, set tol to 0.0 (default).
  
  batch_size : int, optional, default: 100
      Size of the mini batches.
  
  init_size : int, optional, default: 3 * batch_size
      Number of samples to randomly sample for speeding up the
      initialization (sometimes at the expense of accuracy): the
      only algorithm is initialized by running a batch KMeans on a
      random subset of the data. This needs to be larger than n_clusters.
  
  init : {'k-means++', 'random' or an ndarray}, default: 'k-means++'
      Method for initialization, defaults to 'k-means++':
  
      'k-means++' : selects initial cluster centers for k-mean
      clustering in a smart way to speed up convergence. See section
      Notes in k_init for more details.
  
      'random': choose k observations (rows) at random from data for
      the initial centroids.
  
      If an ndarray is passed, it should be of shape (n_clusters, n_features)
      and gives the initial centers.
  
  n_init : int, default=3
      Number of random initializations that are tried.
      In contrast to KMeans, the algorithm is only run once, using the
      best of the ``n_init`` initializations as measured by inertia.
  
  compute_labels : boolean, default=True
      Compute label assignment and inertia for the complete dataset
      once the minibatch optimization has converged in fit.
  
  random_state : integer or numpy.RandomState, optional
      The generator used to initialize the centers. If an integer is
      given, it fixes the seed. Defaults to the global numpy random
      number generator.
  
  reassignment_ratio : float, default: 0.01
      Control the fraction of the maximum number of counts for a
      center to be reassigned. A higher value means that low count
      centers are more easily reassigned, which means that the
      model will take longer to converge, but should converge in a
      better clustering.
  
  verbose : boolean, optional
      Verbosity mode.
  
  Attributes
  ----------
  
  cluster_centers_ : array, [n_clusters, n_features]
      Coordinates of cluster centers
  
  labels_ :
      Labels of each point (if compute_labels is set to True).
  
  inertia_ : float
      The value of the inertia criterion associated with the chosen
      partition (if compute_labels is set to True). The inertia is
      defined as the sum of square distances of samples to their nearest
      neighbor.
  
  See also
  --------
  
  KMeans
      The classic implementation of the clustering method based on the
      Lloyd's algorithm. It consumes the whole set of input data at each
      iteration.
  
  Notes
  -----
  See http://www.eecs.tufts.edu/~dsculley/papers/fastkmeans.pdf
docstr: Compute labels and inertia using mini batches.
  
  This is slightly slower than doing everything at once but preventes
  memory errors / segfaults.
  
  Parameters
  ----------
  X : array-like, shape (n_samples, n_features)
      Input data.
  
  Returns
  -------
  labels : array, shap (n_samples,)
      Cluster labels for each point.
  
  inertia : float
      Sum of squared distances of points to nearest cluster.
docstr_tok: ["Compute","labels","and","inertia","using","mini","batches",".","This","is","slightly","slower","than","doing","everything","at","once","but","preventes","memory","errors","\/","segfaults",".","Parameters","--","--","--","--","--","X",":","array-like",",","shape","(","n_samples",",","n_features",")","Input","data",".","Returns","--","--","--","-","labels",":","array",",","shap","(","n_samples",",",")","Cluster","labels","for","each","point",".","inertia",":","float","Sum","of","squared","distances","of","points","to","nearest","cluster","."]
code: def _labels_inertia_minibatch(self, X):
      """Compute labels and inertia using mini batches.
  
      This is slightly slower than doing everything at once but preventes
      memory errors / segfaults.
  
      Parameters
      ----------
      X : array-like, shape (n_samples, n_features)
          Input data.
  
      Returns
      -------
      labels : array, shap (n_samples,)
          Cluster labels for each point.
  
      inertia : float
          Sum of squared distances of points to nearest cluster.
      """
      if self.verbose:
          print("Computing label assignment and total inertia")
      x_squared_norms = row_norms(X, squared=True)
      slices = gen_batches(X.shape[0], self.batch_size)
      results = [
          _labels_inertia(
              X[s], x_squared_norms[s], self.cluster_centers_
          )
          for s in slices
      ]
      labels, inertia = zip(*results)
      return np.hstack(labels), np.sum(inertia)
  
imports: import warnings
  import numpy
  import scipy.sparse
  from ..base import BaseEstimator, ClusterMixin, TransformerMixin
  from ..metrics.pairwise import euclidean_distances
  from ..metrics.pairwise import pairwise_distances_argmin_min
  from ..utils.extmath import row_norms, squared_norm
  from ..utils.sparsefuncs_fast import assign_rows_csr
  from ..utils.sparsefuncs import mean_variance_axis
  from ..utils.fixes import astype
  from ..utils import check_array
  from ..utils import check_random_state
  from ..utils import as_float_array
  from ..utils import gen_batches
  from ..utils.validation import check_is_fitted
  from ..utils.validation import FLOAT_DTYPES
  from ..utils.random import choice
  from ..externals.joblib import Parallel
  from ..externals.joblib import delayed
  from ..externals.six import string_types
  from .None import _k_means
  from ._k_means_elkan import k_means_elkan
label_desc: Use image node_id 3 for calling the MiniBatchKMeans obj's underlying member method code with example usage: obj._labels_inertia_minibatch(X) and returns: np,  np