class_docstr: K-Means clustering.
  
  Read more in the :ref:`User Guide <k_means>`.
  
  Parameters
  ----------
  
  n_clusters : int, default=8
      The number of clusters to form as well as the number of
      centroids to generate.
  
  init : {'k-means++', 'k-means||', 'random'} or tensor of shape             (n_clusters, n_features), 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.
  
      'k-means||': scalable k-means++.
  
      'random': choose k observations (rows) at random from data for
      the initial centroids.
  
      If a tensor is passed, it should be of shape (n_clusters, n_features)
      and gives the initial centers.
  
  n_init : int, default=1
      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.
  
  max_iter : int, default=300
      Maximum number of iterations of the k-means algorithm for a
      single run.
  
  tol : float, default=1e-4
      Relative tolerance with regards to inertia to declare convergence.
  
  verbose : int, default=0
      Verbosity mode.
  
  random_state : int, RandomState instance, default=None
      Determines random number generation for centroid initialization. Use
      an int to make the randomness deterministic.
      See :term:`Glossary <random_state>`.
  
  copy_x : bool, default=True
      When pre-computing distances it is more numerically accurate to center
      the data first.  If copy_x is True (default), then the original data is
      not modified, ensuring X is C-contiguous.  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, in this case it will also not ensure that data is
      C-contiguous which may cause a significant slowdown.
  
  algorithm : {"auto", "full", "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.
  
  oversampling_factor: int, default=2
      Only work for kmeans||, used in each iteration in kmeans||.
  
  init_iter: int, default=5
      Only work for kmeans||, indicates how may iterations required.
  
  Attributes
  ----------
  cluster_centers_ : tensor of shape (n_clusters, n_features)
      Coordinates of cluster centers. If the algorithm stops before fully
      converging (see ``tol`` and ``max_iter``), these will not be
      consistent with ``labels_``.
  
  labels_ : tensor of shape (n_samples,)
      Labels of each point
  
  inertia_ : float
      Sum of squared distances of samples to their closest cluster center.
  
  n_iter_ : int
      Number of iterations run.
  
  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 either Lloyd's or Elkan'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.
  
  If the algorithm stops before fully converging (because of ``tol`` or
  ``max_iter``), ``labels_`` and ``cluster_centers_`` will not be consistent,
  i.e. the ``cluster_centers_`` will not be the means of the points in each
  cluster. Also, the estimator will reassign ``labels_`` after the last
  iteration to make ``labels_`` consistent with ``predict`` on the training
  set.
  
  Examples
  --------
  
  >>> from mars.learn.cluster import KMeans
  >>> import mars.tensor as mt
  >>> X = mt.array([[1, 2], [1, 4], [1, 0],
  ...               [10, 2], [10, 4], [10, 0]])
  >>> kmeans = KMeans(n_clusters=2, random_state=0, init='k-means++').fit(X)
  >>> kmeans.labels_
  array([1, 1, 1, 0, 0, 0], dtype=int32)
  >>> kmeans.predict([[0, 0], [12, 3]])
  array([1, 0], dtype=int32)
  >>> kmeans.cluster_centers_
  array([[10.,  2.],
         [ 1.,  2.]])
docstr: Opposite of the value of X on the K-means objective.
  
  Parameters
  ----------
  X : {array-like, sparse matrix} of shape (n_samples, n_features)
      New data.
  
  y : Ignored
      Not used, present here for API consistency by convention.
  
  sample_weight : array-like of shape (n_samples,), default=None
      The weights for each observation in X. If None, all observations
      are assigned equal weight.
  
  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","}","of","shape","(","n_samples",",","n_features",")","New","data",".","y",":","Ignored","Not","used",",","present","here","for","API","consistency","by","convention",".","sample_weight",":","array-like","of","shape","(","n_samples",",",")",",","default=None","The","weights","for","each","observation","in","X",".","If","None",",","all","observations","are","assigned","equal","weight",".","Returns","--","--","--","-","score",":","float","Opposite","of","the","value","of","X","on","the","K-means","objective","."]
code: def score(
      self, X, y=None, sample_weight=None, session=None, run_kwargs=None
  ):
      """Opposite of the value of X on the K-means objective.
  
      Parameters
      ----------
      X : {array-like, sparse matrix} of shape (n_samples, n_features)
          New data.
  
      y : Ignored
          Not used, present here for API consistency by convention.
  
      sample_weight : array-like of shape (n_samples,), default=None
          The weights for each observation in X. If None, all observations
          are assigned equal weight.
  
      Returns
      -------
      score : float
          Opposite of the value of X on the K-means objective.
      """
      check_is_fitted(self)
  
      X = self._check_test_data(X)
      x_squared_norms = row_norms(X, squared=True)
  
      result = -_labels_inertia(
          X,
          sample_weight,
          x_squared_norms,
          self.cluster_centers_,
          session=session,
          run_kwargs=run_kwargs,
      )[1]
      result.execute(session=session, **(run_kwargs or dict()))
      return result
  
imports: import warnings
  import numpy
  from sklearn.base import ClusterMixin, TransformerMixin
  from sklearn.exceptions import ConvergenceWarning
  from ...None import tensor
  from ...tensor.utils import check_random_state
  from ..base import BaseEstimator
  from ..metrics.pairwise import euclidean_distances
  from ..utils.extmath import row_norms
  from ..utils.validation import _check_sample_weight, check_array, _num_samples, check_is_fitted
  from ._k_means_common import _inertia
  from ._k_means_elkan_iter import init_bounds, elkan_iter
  from ._k_means_init import _k_init, _scalable_k_init
  from ._k_means_lloyd_iter import lloyd_iter
label_desc: Use image node_id 10 for calling the KMeans obj's underlying member method code with example usage: obj.score(X, y, sample_weight, session, run_kwargs) and returns: result