class_docstr: Classifier implementing the k-nearest neighbors vote for Time Series.
  
  Parameters
  ----------
  n_neighbors : int (default: 5)
      Number of nearest neighbors to be considered for the decision.
  weights : str or callable, optional (default: 'uniform')
      Weight function used in prediction. Possible values:
  
      - 'uniform' : uniform weights. All points in each neighborhood are
        weighted equally.
      - 'distance' : weight points by the inverse of their distance. in this
        case, closer neighbors of a query point
        will have a greater influence than neighbors which are further away.
      - [callable] : a user-defined function which accepts an array of
        distances, and returns an array of the same
        shape containing the weights.
  metric : one of the metrics allowed for :class:`.KNeighborsTimeSeries`
  class (default: 'dtw')
      Metric to be used at the core of the nearest neighbor procedure
  metric_params : dict or None (default: None)
      Dictionnary of metric parameters.
      For metrics that accept parallelization of the cross-distance matrix
      computations, `n_jobs` and `verbose` keys passed in `metric_params`
      are overridden by the `n_jobs` and `verbose` arguments.
      For 'sax' metric, these are hyper-parameters to be passed at the 
      creation of the `SymbolicAggregateApproximation` object.
  
  n_jobs : int or None, optional (default=None)
      The number of jobs to run in parallel for cross-distance matrix
      computations.
      Ignored if the cross-distance matrix cannot be computed using
      parallelization.
      ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
      ``-1`` means using all processors. See scikit-learns'
      `Glossary <https://scikit-learn.org/stable/glossary.html#term-n-jobs>`__
      for more details.
  
  verbose : int, optional (default=0)
      The verbosity level: if non zero, progress messages are printed.
      Above 50, the output is sent to stdout.
      The frequency of the messages increases with the verbosity level.
      If it more than 10, all iterations are reported.
      `Glossary <https://joblib.readthedocs.io/en/latest/parallel.html#parallel-reference-documentation>`__
      for more details.
  
  Notes
  -----
      The training data are saved to disk if this model is
      serialized and may result in a large model file if the training
      dataset is large.
  
  Examples
  --------
  >>> clf = KNeighborsTimeSeriesClassifier(n_neighbors=2, metric="dtw")
  >>> clf.fit([[1, 2, 3], [1, 1.2, 3.2], [3, 2, 1]],
  ...         y=[0, 0, 1]).predict([[1, 2.2, 3.5]])
  array([0])
  >>> clf = KNeighborsTimeSeriesClassifier(n_neighbors=2,
  ...                                      metric="dtw",
  ...                                      n_jobs=2)
  >>> clf.fit([[1, 2, 3], [1, 1.2, 3.2], [3, 2, 1]],
  ...         y=[0, 0, 1]).predict([[1, 2.2, 3.5]])
  array([0])
  >>> clf = KNeighborsTimeSeriesClassifier(n_neighbors=2,
  ...                                      metric="dtw",
  ...                                      metric_params={
  ...                                          "itakura_max_slope": 2.},
  ...                                      n_jobs=2)
  >>> clf.fit([[1, 2, 3], [1, 1.2, 3.2], [3, 2, 1]],
  ...         y=[0, 0, 1]).predict([[1, 2.2, 3.5]])
  array([0])
code: def _get_model_params(self):
      return {
          "_X_fit": self._X_fit,
          "_ts_fit": self._ts_fit,
          "_d": self._d,
          "classes_": self.classes_,
          "_y": self._y,
          "outputs_2d_": self.outputs_2d_,
      }
  
imports: import numpy
  from sklearn import neighbors
  from sklearn.neighbors import KNeighborsClassifier, NearestNeighbors, KNeighborsRegressor
  from sklearn.utils import check_array
  from sklearn.utils.validation import check_is_fitted
  from scipy.spatial.distance import cdist
  from tslearn.metrics import cdist_dtw, cdist_ctw, cdist_soft_dtw, cdist_sax, TSLEARN_VALID_METRICS
  from tslearn.piecewise import SymbolicAggregateApproximation
  from tslearn.utils import to_time_series_dataset, to_sklearn_dataset, check_dims
  from tslearn.bases import BaseModelPackage
label_desc: Use image node_id 3 for calling the KNeighborsTimeSeriesClassifier obj's underlying member method code with example usage: obj._get_model_params() and returns: dict