class_docstr: K-Means clustering
  
  Read more in the :ref:`User Guide <k_means>`.
  
  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, default: 300
      Maximum number of iterations of the k-means algorithm for a
      single run.
  
  n_init : int, default: 10
      Number of time the k-means algorithm will be run with different
      centroid seeds. The final results will be the best output of
      n_init consecutive runs in terms of inertia.
  
  init : {'k-means++', 'random' or an ndarray}
      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.
  
  algorithm : "auto", "full" or "elkan", default="auto"
      K-means algorithm to use. The classical EM-style algorithm is "full".
      The "elkan" variation is more efficient by using the triangle
      inequality, but currently doesn't support sparse data. "auto" chooses
      "elkan" for dense data and "full" for sparse data.
  
  precompute_distances : {'auto', True, False}
      Precompute distances (faster but takes more memory).
  
      'auto' : do not precompute distances if n_samples * n_clusters > 12
      million. This corresponds to about 100MB overhead per job using
      double precision.
  
      True : always precompute distances
  
      False : never precompute distances
  
  tol : float, default: 1e-4
      Relative tolerance with regards to inertia to declare convergence
  
  n_jobs : int
      The number of jobs to use for the computation. This works by computing
      each of the n_init runs in parallel.
  
      If -1 all CPUs are used. If 1 is given, no parallel computing code is
      used at all, which is useful for debugging. For n_jobs below -1,
      (n_cpus + 1 + n_jobs) are used. Thus for n_jobs = -2, all CPUs but one
      are used.
  
  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.
  
  verbose : int, default 0
      Verbosity mode.
  
  copy_x : boolean, default True
      When pre-computing distances it is more numerically accurate to center
      the data first.  If copy_x is True, then the original data is not
      modified.  If False, the original data is modified, and put back before
      the function returns, but small numerical differences may be introduced
      by subtracting and then adding the data mean.
  
  Attributes
  ----------
  cluster_centers_ : array, [n_clusters, n_features]
      Coordinates of cluster centers
  
  labels_ :
      Labels of each point
  
  inertia_ : float
      Sum of distances of samples to their closest cluster center.
  
  Examples
  --------
  
  >>> from sklearn.cluster import KMeans
  >>> import numpy as np
  >>> X = np.array([[1, 2], [1, 4], [1, 0],
  ...               [4, 2], [4, 4], [4, 0]])
  >>> kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
  >>> kmeans.labels_
  array([0, 0, 0, 1, 1, 1], dtype=int32)
  >>> kmeans.predict([[0, 0], [4, 4]])
  array([0, 1], dtype=int32)
  >>> kmeans.cluster_centers_
  array([[ 1.,  2.],
         [ 4.,  2.]])
  
  See also
  --------
  
  MiniBatchKMeans
      Alternative online implementation that does incremental updates
      of the centers positions using mini-batches.
      For large scale learning (say n_samples > 10k) MiniBatchKMeans is
      probably much faster than the default batch implementation.
  
  Notes
  ------
  The k-means problem is solved using Lloyd's algorithm.
  
  The average complexity is given by O(k n T), were n is the number of
  samples and T is the number of iteration.
  
  The worst case complexity is given by O(n^(k+2/p)) with
  n = n_samples, p = n_features. (D. Arthur and S. Vassilvitskii,
  'How slow is the k-means method?' SoCG2006)
  
  In practice, the k-means algorithm is very fast (one of the fastest
  clustering algorithms available), but it falls in local minima. That's why
  it can be useful to restart it several times.
docstr: Opposite of the value of X on the K-means objective.
  
  Parameters
  ----------
  X : {array-like, sparse matrix}, shape = [n_samples, n_features]
      New data.
  
  Returns
  -------
  score : float
      Opposite of the value of X on the K-means objective.
docstr_tok: ["Opposite","of","the","value","of","X","on","the","K-means","objective",".","Parameters","--","--","--","--","--","X",":","{","array-like",",","sparse","matrix","}",",","shape","=","[","n_samples",",","n_features","]","New","data",".","Returns","--","--","--","-","score",":","float","Opposite","of","the","value","of","X","on","the","K-means","objective","."]
code: def score(self, X, y=None):
      """Opposite of the value of X on the K-means objective.
  
      Parameters
      ----------
      X : {array-like, sparse matrix}, shape = [n_samples, n_features]
          New data.
  
      Returns
      -------
      score : float
          Opposite of the value of X on the K-means objective.
      """
      check_is_fitted(self, "cluster_centers_")
  
      X = self._check_test_data(X)
      x_squared_norms = row_norms(X, squared=True)
      return -_labels_inertia(
          X, x_squared_norms, self.cluster_centers_
      )[1]
  
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 10 for calling the KMeans obj's underlying member method code with example usage: obj.score(X, y) and returns: unknown