def _get_kernel(self, X, Y=None):
kernel_params = self._get_kernel_params()
if self.kernel == "gak":
return cdist_gak(X, Y, n_jobs=self.n_jobs, verbose=self.verbose,
**kernel_params)
else:
X_sklearn = to_sklearn_dataset(X)
if Y is not None:
Y_sklearn = to_sklearn_dataset(Y)
else:
Y_sklearn = Y
return pairwise_kernels(X_sklearn, Y_sklearn, metric=self.kernel,
n_jobs=self.n_jobs, **kernel_params)
def fit(self, X, y):
"""Fit the model using X as training data and y as target values
Parameters
----------
X : array-like, shape (n_ts, sz, d)
Training data.
y : array-like, shape (n_ts, ) or (n_ts, dim_y)
Target values.
Returns
-------
KNeighborsTimeSeriesRegressor
The fitted estimator
"""
if self.metric in VARIABLE_LENGTH_METRICS:
self._ts_metric = self.metric
self.metric = "precomputed"
X = check_array(X,
allow_nd=True,
force_all_finite=(self.metric != "precomputed"))
X = to_time_series_dataset(X)
X = check_dims(X, X_fit=None)
if self.metric == "precomputed" and hasattr(self, '_ts_metric'):
self._ts_fit = X
self._d = X.shape[2]
self._X_fit = numpy.zeros(
(self._ts_fit.shape[0], self._ts_fit.shape[0]))
else:
self._X_fit, self._d = to_sklearn_dataset(X, return_dim=True)
super(KNeighborsTimeSeriesRegressor, self).fit(self._X_fit, y)
if hasattr(self, '_ts_metric'):
self.metric = self._ts_metric
return self
def predict(self, X):
"""Predict the target for the provided data
Parameters
----------
X : array-like, shape (n_ts, sz, d)
Test samples.
Returns
-------
array, shape = (n_ts, ) or (n_ts, dim_y)
Array of predicted targets
"""
if self.metric in TSLEARN_VALID_METRICS:
check_is_fitted(self, '_ts_fit')
X = to_time_series_dataset(X)
X = check_dims(X, X_fit_dims=self._ts_fit.shape, extend=True,
check_n_features_only=True)
X_ = self._precompute_cross_dist(X)
pred = super().predict(X_)
self.metric = self._ts_metric
return pred
else:
check_is_fitted(self, '_X_fit')
X = check_array(X, allow_nd=True)
X = to_time_series_dataset(X)
X_ = to_sklearn_dataset(X)
X_ = check_dims(X_, X_fit_dims=self._X_fit.shape, extend=False)
return super().predict(X_)
def fit(self, X, y=None):
"""Fit the model using X as training data
Parameters
----------
X : array-like, shape (n_ts, sz, d)
Training data.
"""
if self.metric in TSLEARN_VALID_METRICS:
self._ts_metric = self.metric
self.metric = "precomputed"
X = check_array(X,
allow_nd=True,
force_all_finite=(self.metric != "precomputed"))
X = to_time_series_dataset(X)
X = check_dims(X)
if self.metric == "precomputed" and hasattr(self, '_ts_metric'):
self._ts_fit = X
self._d = X.shape[2]
self._X_fit = numpy.zeros((self._ts_fit.shape[0],
self._ts_fit.shape[0]))
else:
self._X_fit, self._d = to_sklearn_dataset(X, return_dim=True)
super().fit(self._X_fit, y)
if hasattr(self, '_ts_metric'):
self.metric = self._ts_metric
return self
def predict_proba(self, X):
"""Predict the class probabilities for the provided data
Parameters
----------
X : array-like, shape (n_ts, sz, d)
Test samples.
"""
X_ = to_sklearn_dataset(X)
return super(KNeighborsTimeSeriesClassifier, self).predict_proba(X_)
def fit(self, X, y):
"""Fit the model using X as training data and y as target values
Parameters
----------
X : array-like, shape (n_ts, sz, d)
Training data.
y : array-like, shape (n_ts, )
Target values.
"""
X_, self.d = to_sklearn_dataset(X, return_dim=True)
return super(KNeighborsTimeSeriesClassifier, self).fit(X_, y)
def predict_proba(self, X):
"""Predict the class probabilities for the provided data
Parameters
----------
X : array-like, shape (n_ts, sz, d)
Test samples.
Returns
-------
array, shape = (n_ts, n_classes)
Array of predicted class probabilities
"""
if self.metric in VARIABLE_LENGTH_METRICS:
self._ts_metric = self.metric
self.metric = "precomputed"
if self.metric_params is None:
metric_params = {}
else:
metric_params = self.metric_params.copy()
if "n_jobs" in metric_params.keys():
del metric_params["n_jobs"]
if "verbose" in metric_params.keys():
del metric_params["verbose"]
check_is_fitted(self, '_ts_fit')
X = check_array(X, allow_nd=True, force_all_finite=False)
X = to_time_series_dataset(X)
if self._ts_metric == "dtw":
X_ = cdist_dtw(X,
self._ts_fit,
n_jobs=self.n_jobs,
verbose=self.verbose,
**metric_params)
elif self._ts_metric == "softdtw":
X_ = cdist_soft_dtw(X, self._ts_fit, **metric_params)
else:
raise ValueError("Invalid metric recorded: %s" %
self._ts_metric)
pred = super(KNeighborsTimeSeriesClassifier,
self).predict_proba(X_)
self.metric = self._ts_metric
return pred
else:
check_is_fitted(self, '_X_fit')
X = check_array(X, allow_nd=True)
X = to_time_series_dataset(X)
X_ = to_sklearn_dataset(X)
X_ = check_dims(X_, self._X_fit, extend=False)
return super(KNeighborsTimeSeriesClassifier,
self).predict_proba(X_)
def _preprocess_sklearn(self, X, y=None, fit_time=False):
force_all_finite = self.kernel not in VARIABLE_LENGTH_METRICS
if y is None:
X = check_array(X,
allow_nd=True,
force_all_finite=force_all_finite)
else:
X, y = check_X_y(X,
y,
allow_nd=True,
force_all_finite=force_all_finite)
X = to_time_series_dataset(X)
if fit_time:
self._X_fit = X
if self.gamma == "auto":
self.gamma_ = gamma_soft_dtw(X)
else:
self.gamma_ = self.gamma
self.classes_ = numpy.unique(y)
else:
check_is_fitted(self, ['svm_estimator_', '_X_fit'])
X = check_dims(X,
X_fit_dims=self._X_fit.shape,
extend=True,
check_n_features_only=(self.kernel
in VARIABLE_LENGTH_METRICS))
if self.kernel in VARIABLE_LENGTH_METRICS:
assert self.kernel == "gak"
self.estimator_kernel_ = "precomputed"
if fit_time:
sklearn_X = cdist_gak(X,
sigma=numpy.sqrt(self.gamma_ / 2.),
n_jobs=self.n_jobs,
verbose=self.verbose)
else:
sklearn_X = cdist_gak(X,
self._X_fit,
sigma=numpy.sqrt(self.gamma_ / 2.),
n_jobs=self.n_jobs,
verbose=self.verbose)
else:
self.estimator_kernel_ = self.kernel
sklearn_X = to_sklearn_dataset(X)
if y is None:
return sklearn_X
else:
return sklearn_X, y
def fit(self, X, y):
"""Fit the model using X as training data and y as target values
Parameters
----------
X : array-like, shape (n_ts, sz, d)
Training data.
y : array-like, shape (n_ts, )
Target values.
Returns
-------
KNeighborsTimeSeriesClassifier
The fitted estimator
"""
if self.metric in TSLEARN_VALID_METRICS:
self._ts_metric = self.metric
self.metric = "precomputed"
X = check_array(X,
allow_nd=True,
force_all_finite=(self.metric != "precomputed"))
X = to_time_series_dataset(X)
X = check_dims(X)
if self.metric == "precomputed" and hasattr(self, '_ts_metric'):
self._ts_fit = X
if self._ts_metric == 'sax':
self._sax_mu = None
self._sax_sigma = None
if self.metric_params is not None:
self._ts_fit = self._sax_preprocess(
X, **self.metric_params)
else:
self._ts_fit = self._sax_preprocess(X)
self._d = X.shape[2]
self._X_fit = numpy.zeros(
(self._ts_fit.shape[0], self._ts_fit.shape[0]))
else:
self._X_fit, self._d = to_sklearn_dataset(X, return_dim=True)
super().fit(self._X_fit, y)
if hasattr(self, '_ts_metric'):
self.metric = self._ts_metric
return self
def kneighbors(self, X=None, n_neighbors=None, return_distance=True):
"""Finds the K-neighbors of a point.
Returns indices of and distances to the neighbors of each point.
Parameters
----------
X : array-like, shape (n_ts, sz, d)
The query time series.
If not provided, neighbors of each indexed point are returned.
In this case, the query point is not considered its own neighbor.
n_neighbors : int
Number of neighbors to get (default is the value passed to the
constructor).
return_distance : boolean, optional. Defaults to True.
If False, distances will not be returned
Returns
-------
dist : array
Array representing the distance to points, only present if
return_distance=True
ind : array
Indices of the nearest points in the population matrix.
"""
if self.metric in VARIABLE_LENGTH_METRICS:
self._ts_metric = self.metric
self.metric = "precomputed"
if self.metric_params is None:
metric_params = {}
else:
metric_params = self.metric_params.copy()
if "n_jobs" in metric_params.keys():
del metric_params["n_jobs"]
if "verbose" in metric_params.keys():
del metric_params["verbose"]
check_is_fitted(self, '_ts_fit')
X = check_array(X, allow_nd=True, force_all_finite=False)
X = to_time_series_dataset(X)
if self._ts_metric == "dtw":
X_ = cdist_dtw(X,
self._ts_fit,
n_jobs=self.n_jobs,
verbose=self.verbose,
**metric_params)
elif self._ts_metric == "softdtw":
X_ = cdist_soft_dtw(X, self._ts_fit, **metric_params)
else:
raise ValueError("Invalid metric recorded: %s" %
self._ts_metric)
pred = KNeighborsTimeSeriesMixin.kneighbors(
self,
X=X_,
n_neighbors=n_neighbors,
return_distance=return_distance)
self.metric = self._ts_metric
return pred
else:
check_is_fitted(self, '_X_fit')
if X is None:
X_ = None
else:
X = check_array(X, allow_nd=True)
X = to_time_series_dataset(X)
X_ = to_sklearn_dataset(X)
X_ = check_dims(X_, self._X_fit, extend=False)
return KNeighborsTimeSeriesMixin.kneighbors(
self,
X=X_,
n_neighbors=n_neighbors,
return_distance=return_distance)
