class_docstr: Time series K-mean implementation.
  
  Parameters
  ----------
  n_clusters: int, defaults = 8
      The number of clusters to form as well as the number of
      centroids to generate.
  init_algorithm: str, np.ndarray (3d array of shape (n_clusters, n_dimensions,
      series_length)), defaults = 'random'
      Method for initializing cluster centers or an array of initial cluster centers.
      If string, any of the following strings are valid:
          ['kmeans++', 'random', 'forgy'].
      If 3D np.ndarray, initializes cluster centers with the provided array. The array
          must have shape (n_clusters, n_dimensions, series_length) and the number of
          clusters in the array must be the same as what is provided to the n_clusters
          argument.
  metric: str or Callable, defaults = 'dtw'
      Distance metric to compute similarity between time series. Any of the following
      are valid: ['dtw', 'euclidean', 'erp', 'edr', 'lcss', 'squared', 'ddtw', 'wdtw',
      'wddtw']
  n_init: int, defaults = 10
      Number of times the k-means algorithm will be run with different
      centroid seeds. The final result will be the best output of n_init
      consecutive runs in terms of inertia.
  max_iter: int, defaults = 30
      Maximum number of iterations of the k-means algorithm for a single
      run.
  tol: float, defaults = 1e-6
      Relative tolerance with regards to Frobenius norm of the difference
      in the cluster centers of two consecutive iterations to declare
      convergence.
  verbose: bool, defaults = False
      Verbosity mode.
  random_state: int or np.random.RandomState instance or None, defaults = None
      Determines random number generation for centroid initialization.
  averaging_method: str or Callable, defaults = 'mean'
      Averaging method to compute the average of a cluster. Any of the following
      strings are valid: ['mean', 'dba']. If a Callable is provided must take the form
      Callable[[np.ndarray], np.ndarray].
  average_params: dict, defaults = None = no parameters
      Dictionary containing kwargs for averaging_method.
  distance_params: dict, defaults = None = no parameters
      Dictionary containing kwargs for the distance metric being used.
  
  Attributes
  ----------
  cluster_centers_: np.ndarray (3d array of shape (n_clusters, n_dimensions,
      series_length))
      Time series that represent each of the cluster centers. If the algorithm stops
      before fully converging these will not be consistent with labels_.
  labels_: np.ndarray (1d array of shape (n_instance,))
      Labels that is the index each time series belongs to.
  inertia_: float
      Sum of squared distances of samples to their closest cluster center, weighted by
      the sample weights if provided.
  n_iter_: int
      Number of iterations run.
  
  Examples
  --------
  >>> from sktime.datasets import load_arrow_head
  >>> from sktime.clustering.k_means import TimeSeriesKMeans
  >>> X_train, y_train = load_arrow_head(split="train")
  >>> X_test, y_test = load_arrow_head(split="test")
  >>> clusterer = TimeSeriesKMeans(n_clusters=3)  # doctest: +SKIP
  >>> clusterer.fit(X_train)  # doctest: +SKIP
  TimeSeriesKMeans(n_clusters=3)
  >>> y_pred = clusterer.predict(X_test)  # doctest: +SKIP
code: def __init__(
      self,
      n_clusters: int = 8,
      init_algorithm: Union[str, Callable] = "random",
      metric: Union[str, Callable] = "dtw",
      n_init: int = 10,
      max_iter: int = 300,
      tol: float = 1e-6,
      verbose: bool = False,
      random_state: Union[int, RandomState] = None,
      averaging_method: Union[
          str, Callable[[np.ndarray], np.ndarray]
      ] = "mean",
      distance_params: dict = None,
      average_params: dict = None,
  ):
      self.averaging_method = averaging_method
      self._averaging_method = _resolve_average_callable(
          averaging_method
      )
  
      self.average_params = average_params
      self._average_params = average_params
      if self.average_params is None:
          self._average_params = {}
      if averaging_method == "dba":
          self._dba_medoids_distance_metric = "dtw"
          self._precomputed_pairwise = None
          if "medoids_distance_metric" in self._average_params:
              self._dba_medoids_distance_metric = self._average_params[
                  "medoids_distance_metric"
              ]
          if "averaging_distance_metric" in self._average_params:
              average_dist = self._average_params[
                  "averaging_distance_metric"
              ]
              if average_dist == "ddtw":
                  self._average_params[
                      "averaging_distance_metric"
                  ] = "dtw"
              if average_dist == "wddtw":
                  self._average_params[
                      "averaging_distance_metric"
                  ] = "wdtw"
  
      super().__init__(
          n_clusters,
          init_algorithm,
          metric,
          n_init,
          max_iter,
          tol,
          verbose,
          random_state,
          distance_params,
      )
  
file_path: sktime/sktime/clustering/k_means/_k_means.py
imports: from typing import Callable, Union
  import numpy
  from numpy.random import RandomState
  from sktime.clustering.metrics.averaging import _resolve_average_callable
  from sktime.clustering.partitioning import TimeSeriesLloyds
  from sktime.distances import pairwise_distance
label_desc: Use image node_id 1 to create a new TimeSeriesKMeans object from inherited base classes: TimeSeriesLloyds with example: obj = TimeSeriesKMeans(n_clusters, init_algorithm, metric, n_init, max_iter, tol, verbose, random_state, averaging_method, distance_params, average_params)