[ENH] New transformation based pipeline classifiers

sktime/classification/feature_based/__init__.py

@@ -3,15 +3,23 @@
 __all__ = [
     "Catch22Classifier",
     "MatrixProfileClassifier",
+    "RandomIntervalClassifier",
     "SignatureClassifier",
+    "SummaryClassifier",
     "TSFreshClassifier",
+    "FreshPRINCE",
 ]
 
 from sktime.classification.feature_based._catch22_classifier import Catch22Classifier
+from sktime.classification.feature_based._fresh_prince import FreshPRINCE
 from sktime.classification.feature_based._matrix_profile_classifier import (
     MatrixProfileClassifier,
 )
+from sktime.classification.feature_based._random_interval_classifier import (
+    RandomIntervalClassifier,
+)
 from sktime.classification.feature_based._signature_classifier import (
     SignatureClassifier,
 )
+from sktime.classification.feature_based._summary_classifier import SummaryClassifier
 from sktime.classification.feature_based._tsfresh_classifier import TSFreshClassifier

sktime/classification/feature_based/_catch22_classifier.py

@@ -26,6 +26,8 @@ class Catch22Classifier(BaseClassifier):
     outlier_norm : bool, default=False
         Normalise each series during the two outlier catch22 features, which can take a
         while to process for large values
+    replace_nans : bool, default=True
+        Replace NaN or inf values from the catch22 transform with 0.
     estimator : sklearn classifier, default=None
         An sklearn estimator to be built using the transformed data. Defaults to a
         Random Forest with 200 trees.
@@ -83,11 +85,13 @@ class Catch22Classifier(BaseClassifier):
     def __init__(
         self,
         outlier_norm=False,
+        replace_nans=True,
         estimator=None,
         n_jobs=1,
         random_state=None,
     ):
         self.outlier_norm = outlier_norm
+        self.replace_nans = replace_nans
         self.estimator = estimator
 
         self.n_jobs = n_jobs
@@ -118,7 +122,9 @@ def _fit(self, X, y):
         Changes state by creating a fitted model that updates attributes
         ending in "_" and sets is_fitted flag to True.
         """
-        self._transformer = Catch22(outlier_norm=self.outlier_norm)
+        self._transformer = Catch22(
+            outlier_norm=self.outlier_norm, replace_nans=self.replace_nans
+        )
 
         self._estimator = _clone_estimator(
             RandomForestClassifier(n_estimators=200)
@@ -132,7 +138,7 @@ def _fit(self, X, y):
             self._estimator.n_jobs = self._threads_to_use
 
         X_t = self._transformer.fit_transform(X, y)
-        X_t = np.nan_to_num(X_t, False, 0, 0, 0)
+
         self._estimator.fit(X_t, y)
 
         return self
@@ -150,9 +156,7 @@ def _predict(self, X):
         y : array-like, shape = [n_instances]
             Predicted class labels.
         """
-        X_t = self._transformer.transform(X)
-        X_t = np.nan_to_num(X_t, False, 0, 0, 0)
-        return self._estimator.predict(X_t)
+        return self._estimator.predict(self._transformer.transform(X))
 
     def _predict_proba(self, X):
         """Predict class probabilities for n instances in X.
@@ -167,15 +171,12 @@ def _predict_proba(self, X):
         y : array-like, shape = [n_instances, n_classes_]
             Predicted probabilities using the ordering in classes_.
         """
-        X_t = self._transformer.transform(X)
-        X_t = np.nan_to_num(X_t, False, 0, 0, 0)
-
         m = getattr(self._estimator, "predict_proba", None)
         if callable(m):
-            return self._estimator.predict_proba(X_t)
+            return self._estimator.predict_proba(self._transformer.transform(X))
         else:
             dists = np.zeros((X.shape[0], self.n_classes_))
-            preds = self._estimator.predict(X_t)
+            preds = self._estimator.predict(self._transformer.transform(X))
             for i in range(0, X.shape[0]):
                 dists[i, self._class_dictionary[preds[i]]] = 1
             return dists

sktime/classification/feature_based/_fresh_prince.py

@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+"""FreshPRINCE Classifier.
+
+Pipeline classifier using the full set of TSFresh features and a RotationForest
+classifier.
+"""
+
+__author__ = ["MatthewMiddlehurst"]
+__all__ = ["FreshPRINCE"]
+
+
+from sktime.classification.base import BaseClassifier
+from sktime.contrib.vector_classifiers._rotation_forest import RotationForest
+from sktime.transformations.panel.tsfresh import TSFreshFeatureExtractor
+from sktime.utils.validation.panel import check_X_y
+
+
+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)