def test_tsfresh_extractor(default_fc_parameters):
X, y = make_classification_problem()
X_train, X_test, y_train, y_test = train_test_split(X, y)
transformer = TSFreshFeatureExtractor(
default_fc_parameters=default_fc_parameters, disable_progressbar=True)
Xt = transformer.fit_transform(X_train, y_train)
actual = Xt.filter(like="__mean", axis=1).values.ravel()
expected = from_nested_to_2d_array(X_train).mean(axis=1).values
assert expected[0] == X_train.iloc[0, 0].mean()
np.testing.assert_allclose(actual, expected)
def test_tsfresh_extractor(default_fc_parameters):
"""Test that mean feature of TSFreshFeatureExtract is identical with sample mean."""
X, _ = make_classification_problem()
transformer = TSFreshFeatureExtractor(
default_fc_parameters=default_fc_parameters, disable_progressbar=True)
Xt = transformer.fit_transform(X)
actual = Xt.filter(like="__mean", axis=1).values.ravel()
converted = convert(X, from_type="nested_univ", to_type="pd-wide")
expected = converted.mean(axis=1).values
assert expected[0] == X.iloc[0, 0].mean()
np.testing.assert_allclose(actual, expected)
def _fit(self, X, y):
"""Fit a pipeline on cases (X,y), where y is the target variable.
Parameters
----------
X : 3D np.array of shape = [n_instances, n_dimensions, series_length]
The training data.
y : array-like, shape = [n_instances]
The class labels.
Returns
-------
self :
Reference to self.
Notes
-----
Changes state by creating a fitted model that updates attributes
ending in "_" and sets is_fitted flag to True.
"""
self.n_instances_, self.n_dims_, self.series_length_ = X.shape
self._rotf = RotationForest(
n_estimators=self.n_estimators,
save_transformed_data=self.save_transformed_data,
n_jobs=self._threads_to_use,
random_state=self.random_state,
)
self._tsfresh = TSFreshFeatureExtractor(
default_fc_parameters=self.default_fc_parameters,
n_jobs=self._threads_to_use,
chunksize=self.chunksize,
show_warnings=self.verbose > 1,
disable_progressbar=self.verbose < 1,
)
X_t = self._tsfresh.fit_transform(X, y)
self._rotf.fit(X_t, y)
if self.save_transformed_data:
self.transformed_data_ = X_t
return self
def _fit(self, X, y):
"""Fit a pipeline on cases (X,y), where y is the target variable.
Parameters
----------
X : 3D np.array of shape = [n_instances, n_dimensions, series_length]
The training data.
y : array-like, shape = [n_instances]
The class labels.
Returns
-------
self :
Reference to self.
Notes
-----
Changes state by creating a fitted model that updates attributes
ending in "_" and sets is_fitted flag to True.
"""
self._transformer = (TSFreshRelevantFeatureExtractor(
default_fc_parameters=self.default_fc_parameters,
n_jobs=self._threads_to_use,
chunksize=self.chunksize,
) if self.relevant_feature_extractor else TSFreshFeatureExtractor(
default_fc_parameters=self.default_fc_parameters,
n_jobs=self._threads_to_use,
chunksize=self.chunksize,
))
self._estimator = _clone_estimator(
RandomForestClassifier(n_estimators=200)
if self.estimator is None else self.estimator,
self.random_state,
)
if self.verbose < 2:
self._transformer.show_warnings = False
if self.verbose < 1:
self._transformer.disable_progressbar = True
m = getattr(self._estimator, "n_jobs", None)
if m is not None:
self._estimator.n_jobs = self._threads_to_use
X_t = self._transformer.fit_transform(X, y)
self._estimator.fit(X_t, y)
return self
def fit(self, X, y):
"""Fit an estimator using transformed data from the Catch22 transformer.
Parameters
----------
X : nested pandas DataFrame of shape [n_instances, n_dims]
Nested dataframe with univariate time-series in cells.
y : array-like, shape = [n_instances] The class labels.
Returns
-------
self : object
"""
X, y = check_X_y(X, y)
self.classes_ = class_distribution(np.asarray(y).reshape(-1, 1))[0][0]
self.n_classes = np.unique(y).shape[0]
self._transformer = (TSFreshRelevantFeatureExtractor(
default_fc_parameters=self.default_fc_parameters,
n_jobs=self.n_jobs,
chunksize=self.chunksize,
) if self.relevant_feature_extractor else TSFreshFeatureExtractor(
default_fc_parameters=self.default_fc_parameters,
n_jobs=self.n_jobs,
chunksize=self.chunksize,
))
self._estimator = _clone_estimator(
RandomForestClassifier(n_estimators=200)
if self.estimator is None else self.estimator,
self.random_state,
)
if self.verbose < 2:
self._transformer.show_warnings = False
if self.verbose < 1:
self._transformer.disable_progressbar = True
m = getattr(self._estimator, "n_jobs", None)
if callable(m):
self._estimator.n_jobs = self.n_jobs
X_t = self._transformer.fit_transform(X, y)
self._estimator.fit(X_t, y)
self._is_fitted = True
return self
class FreshPRINCE(BaseClassifier):
"""Fresh Pipeline with RotatIoN forest Classifier.
This classifier simply transforms the input data using the TSFresh [1]_
transformer with comprehensive features and builds a RotationForest estimator using
the transformed data.
Parameters
----------
default_fc_parameters : str, default="comprehensive"
Set of TSFresh features to be extracted, options are "minimal", "efficient" or
"comprehensive".
n_estimators : int, default=200
Number of estimators for the RotationForest ensemble.
verbose : int, default=0
Level of output printed to the console (for information only)
n_jobs : int, default=1
The number of jobs to run in parallel for both `fit` and `predict`.
``-1`` means using all processors.
chunksize : int or None, default=None
Number of series processed in each parallel TSFresh job, should be optimised
for efficient parallelisation.
random_state : int or None, default=None
Seed for random, integer.
Attributes
----------
n_classes_ : int
Number of classes. Extracted from the data.
classes_ : ndarray of shape (n_classes_)
Holds the label for each class.
See Also
--------
TSFreshFeatureExtractor, TSFreshClassifier, RotationForest
References
----------
.. [1] Christ, Maximilian, et al. "Time series feature extraction on basis of
scalable hypothesis tests (tsfresh–a python package)." Neurocomputing 307
(2018): 72-77.
https://www.sciencedirect.com/science/article/pii/S0925231218304843
Examples
--------
>>> from sktime.classification.feature_based import FreshPRINCE
>>> from sktime.contrib.vector_classifiers._rotation_forest import RotationForest
>>> from sktime.datasets import load_unit_test
>>> X_train, y_train = load_unit_test(split="train", return_X_y=True)
>>> X_test, y_test = load_unit_test(split="test", return_X_y=True)
>>> clf = FreshPRINCE(
... default_fc_parameters="minimal",
... n_estimators=10,
... )
>>> clf.fit(X_train, y_train)
FreshPRINCE(...)
>>> y_pred = clf.predict(X_test)
"""
_tags = {
"capability:multivariate": True,
"capability:multithreading": True,
"capability:train_estimate": True,
}
def __init__(
self,
default_fc_parameters="comprehensive",
n_estimators=200,
save_transformed_data=False,
verbose=0,
n_jobs=1,
chunksize=None,
random_state=None,
):
self.default_fc_parameters = default_fc_parameters
self.n_estimators = n_estimators
self.save_transformed_data = save_transformed_data
self.verbose = verbose
self.n_jobs = n_jobs
self.chunksize = chunksize
self.random_state = random_state
self.n_instances_ = 0
self.n_dims_ = 0
self.series_length_ = 0
self.transformed_data_ = []
self._rotf = None
self._tsfresh = None
super(FreshPRINCE, self).__init__()
def _fit(self, X, y):
"""Fit a pipeline on cases (X,y), where y is the target variable.
Parameters
----------
X : 3D np.array of shape = [n_instances, n_dimensions, series_length]
The training data.
y : array-like, shape = [n_instances]
The class labels.
Returns
-------
self :
Reference to self.
Notes
-----
Changes state by creating a fitted model that updates attributes
ending in "_" and sets is_fitted flag to True.
"""
self.n_instances_, self.n_dims_, self.series_length_ = X.shape
self._rotf = RotationForest(
n_estimators=self.n_estimators,
save_transformed_data=self.save_transformed_data,
n_jobs=self._threads_to_use,
random_state=self.random_state,
)
self._tsfresh = TSFreshFeatureExtractor(
default_fc_parameters=self.default_fc_parameters,
n_jobs=self._threads_to_use,
chunksize=self.chunksize,
show_warnings=self.verbose > 1,
disable_progressbar=self.verbose < 1,
)
X_t = self._tsfresh.fit_transform(X, y)
self._rotf.fit(X_t, y)
if self.save_transformed_data:
self.transformed_data_ = X_t
return self
def _predict(self, X):
"""Predict class values of n instances in X.
Parameters
----------
X : 3D np.array of shape = [n_instances, n_dimensions, series_length]
The data to make predictions for.
Returns
-------
y : array-like, shape = [n_instances]
Predicted class labels.
"""
return self._rotf.predict(self._tsfresh.transform(X))
def _predict_proba(self, X):
"""Predict class probabilities for n instances in X.
Parameters
----------
X : 3D np.array of shape = [n_instances, n_dimensions, series_length]
The data to make predict probabilities for.
Returns
-------
y : array-like, shape = [n_instances, n_classes_]
Predicted probabilities using the ordering in classes_.
"""
return self._rotf.predict_proba(self._tsfresh.transform(X))
def _get_train_probs(self, X, y):
self.check_is_fitted()
X, y = check_X_y(X, y, coerce_to_numpy=True)
n_instances, n_dims, series_length = X.shape
if (n_instances != self.n_instances_ or n_dims != self.n_dims_
or series_length != self.series_length_):
raise ValueError(
"n_instances, n_dims, series_length mismatch. X should be "
"the same as the training data used in fit for generating train "
"probabilities.")
if not self.save_transformed_data:
raise ValueError(
"Currently only works with saved transform data from fit.")
return self._rotf._get_train_probs(self.transformed_data_, y)