New estimators and interval dilation (#10)

* new estimators and interval dilation

* exclude install for scikit-fda py version

Author: MatthewMiddlehurst

pyproject.toml

@@ -48,6 +48,8 @@ extras = [
     "pyfftw>=0.12.0,<0.14.0",
     "statsmodels>=0.12.1,<0.14.0",
     "wildboar>=1.1.0,<1.2.0",
+    "scikit-fda>=0.7.0,<0.9.0 ; python_version <= '3.10'",
+    "stumpy>=1.6.0,<1.12.0"
 ]
 unstable_extras = [
     "mrsqm>=0.0.1,<0.1.0 ; platform_system == 'Darwin'",  # requires gcc and fftw to be installed for Windows and some other OS (see http://www.fftw.org/index.html)

tsml/distance_based/__init__.py

@@ -3,6 +3,8 @@
 
 __all__ = [
     "ProximityForestClassifier",
+    "MPDistClassifier",
 ]
 
+from tsml.distance_based._mpdist import MPDistClassifier
 from tsml.distance_based._pf import ProximityForestClassifier

tsml/distance_based/_mpdist.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+""""""
+
+__author__ = ["TonyBagnall", "patrickzib", "MatthewMiddlehurst"]
+__all__ = ["MPDistClassifier"]
+
+import numpy as np
+import stumpy
+from sklearn.base import ClassifierMixin
+from sklearn.metrics import pairwise
+from sklearn.utils.multiclass import check_classification_targets
+from sklearn.utils.validation import check_is_fitted
+
+from tsml.base import BaseTimeSeriesEstimator
+from tsml.utils.validation import check_n_jobs
+
+
+class MPDistClassifier(ClassifierMixin, BaseTimeSeriesEstimator):
+    """MPDist 1-NN classifier-adaptor."""
+
+    def __init__(self, window=10, n_jobs=1):
+        self.window = window
+        self.n_jobs = n_jobs
+
+        super(MPDistClassifier, self).__init__()
+
+    def fit(self, X, y):
+        X, y = self._validate_data(X=X, y=y, ensure_min_samples=2)
+        X = self._convert_X(X)
+
+        check_classification_targets(y)
+
+        self.n_instances_, self.series_length_ = X.shape
+        self.classes_ = np.unique(y)
+        self.n_classes_ = self.classes_.shape[0]
+        self.class_dictionary_ = {}
+        for index, class_val in enumerate(self.classes_):
+            self.class_dictionary_[class_val] = index
+
+        if self.n_classes_ == 1:
+            return self
+
+        self._n_jobs = check_n_jobs(self.n_jobs)
+
+        self._X_train = X.astype(np.float64)
+        self._y_train = y
+
+        return self
+
+    def predict(self, X) -> np.ndarray:
+        check_is_fitted(self)
+
+        # treat case of single class seen in fit
+        if self.n_classes_ == 1:
+            return np.repeat(list(self.class_dictionary_.keys()), X.shape[0], axis=0)
+
+        X = self._validate_data(X=X, reset=False)
+        X = self._convert_X(X)
+
+        window = (
+            self.window if self.window >= 1 else int(self.window * self.series_length_)
+        )
+
+        distance_matrix = pairwise.pairwise_distances(
+            X.astype(np.float64),
+            self._X_train,
+            metric=(lambda x, y: stumpy.mpdist(x, y, window)),
+            n_jobs=self._n_jobs,
+        )
+
+        return self._y_train[np.argmin(distance_matrix, axis=1)]
+
+    def _more_tags(self):
+        return {
+            "X_types": ["2darray"],
+            "optional_dependency": True,
+        }
+
+    @classmethod
+    def get_test_params(cls, parameter_set="default"):
+        """Return testing parameter settings for the estimator.
+
+        Parameters
+        ----------
+        parameter_set : str, default="default"
+            Name of the set of test parameters to return, for use in tests. If no
+            special parameters are defined for a value, will return `"default"` set.
+            For classifiers, a "default" set of parameters should be provided for
+            general testing, and a "results_comparison" set for comparing against
+            previously recorded results if the general set does not produce suitable
+            probabilities to compare against.
+
+        Returns
+        -------
+        params : dict or list of dict, default={}
+            Parameters to create testing instances of the class.
+            Each dict are parameters to construct an "interesting" test instance, i.e.,
+            `MyClass(**params)` or `MyClass(**params[i])` creates a valid test instance.
+            `create_test_instance` uses the first (or only) dictionary in `params`.
+        """
+
+        return {
+            "window": 0.8,
+        }

tsml/distance_based/_pf.py

@@ -20,33 +20,29 @@ def __init__(
         pivot_sample="label",
         metric_sample="weighted",
         metric_factories="default",
-        oob_score=False,
         max_depth=None,
         min_samples_split=2,
         min_samples_leaf=1,
         min_impurity_decrease=0,
         criterion="entropy",
         bootstrap=True,
-        warm_start=False,
+        oob_score=False,
         n_jobs=None,
-        class_weight=None,
         random_state=None,
     ):
         self.n_estimators = n_estimators
         self.n_pivot = n_pivot
         self.pivot_sample = pivot_sample
         self.metric_sample = metric_sample
         self.metric_factories = metric_factories
-        self.oob_score = oob_score
         self.max_depth = max_depth
         self.min_samples_split = min_samples_split
         self.min_samples_leaf = min_samples_leaf
         self.min_impurity_decrease = min_impurity_decrease
         self.criterion = criterion
         self.bootstrap = bootstrap
-        self.warm_start = warm_start
+        self.oob_score = oob_score
         self.n_jobs = n_jobs
-        self.class_weight = class_weight
         self.random_state = random_state
 
         _check_optional_dependency("wildboar", "wildboar", self)
@@ -65,8 +61,8 @@ def fit(self, X, y):
         self.classes_ = np.unique(y)
         self.n_classes_ = self.classes_.shape[0]
         self.class_dictionary_ = {}
-        for index, classVal in enumerate(self.classes_):
-            self.class_dictionary_[classVal] = index
+        for index, class_val in enumerate(self.classes_):
+            self.class_dictionary_[class_val] = index
 
         if self.n_classes_ == 1:
             return self
@@ -91,9 +87,7 @@ def fit(self, X, y):
             min_impurity_decrease=self.min_impurity_decrease,
             criterion=self.criterion,
             bootstrap=self.bootstrap,
-            warm_start=self.warm_start,
             n_jobs=self.n_jobs,
-            class_weight=self.class_weight,
             random_state=self.random_state,
         )
         self.clf_.fit(X, y)
@@ -115,7 +109,7 @@ def predict(self, X) -> np.ndarray:
 
         return self.clf_.predict(X)
 
-    def _predict_proba(self, X) -> np.ndarray:
+    def predict_proba(self, X) -> np.ndarray:
         check_is_fitted(self)
 
         # treat case of single class seen in fit
@@ -129,3 +123,30 @@ def _predict_proba(self, X) -> np.ndarray:
             X = np.reshape(X, (X.shape[0], X.shape[2]))
 
         return self.clf_.predict_proba(X)
+
+    @classmethod
+    def get_test_params(cls, parameter_set="default"):
+        """Return testing parameter settings for the estimator.
+
+        Parameters
+        ----------
+        parameter_set : str, default="default"
+            Name of the set of test parameters to return, for use in tests. If no
+            special parameters are defined for a value, will return `"default"` set.
+            For classifiers, a "default" set of parameters should be provided for
+            general testing, and a "results_comparison" set for comparing against
+            previously recorded results if the general set does not produce suitable
+            probabilities to compare against.
+
+        Returns
+        -------
+        params : dict or list of dict, default={}
+            Parameters to create testing instances of the class.
+            Each dict are parameters to construct an "interesting" test instance, i.e.,
+            `MyClass(**params)` or `MyClass(**params[i])` creates a valid test instance.
+            `create_test_instance` uses the first (or only) dictionary in `params`.
+        """
+
+        return {
+            "n_estimators": 2,
+        }

tsml/dummy/_dummy.py

@@ -107,8 +107,8 @@ def fit(self, X, y):
         if self.validate:
             self.n_classes_ = self.classes_.shape[0]
             self.class_dictionary_ = {}
-            for index, classVal in enumerate(self.classes_):
-                self.class_dictionary_[classVal] = index
+            for index, class_val in enumerate(self.classes_):
+                self.class_dictionary_[class_val] = index
 
             if self.n_classes_ == 1:
                 return self

tsml/feature_based/__init__.py

@@ -4,6 +4,9 @@
 __all__ = [
     "Catch22Classifier",
     "Catch22Regressor",
+    "FPCAClassifier",
+    "FPCARegressor",
 ]
 
 from tsml.feature_based._catch22 import Catch22Classifier, Catch22Regressor
+from tsml.feature_based._fpca import FPCAClassifier, FPCARegressor

tsml/feature_based/_catch22.py

@@ -137,9 +137,7 @@ def fit(self, X, y):
         Changes state by creating a fitted model that updates attributes
         ending in "_" and sets is_fitted flag to True.
         """
-        X, y = self._validate_data(
-            X=X, y=y, ensure_min_samples=2, ensure_min_series_length=3
-        )
+        X, y = self._validate_data(X=X, y=y, ensure_min_samples=2)
         X = self._convert_X(X)
 
         check_classification_targets(y)
@@ -148,8 +146,8 @@ def fit(self, X, y):
         self.classes_ = np.unique(y)
         self.n_classes_ = self.classes_.shape[0]
         self.class_dictionary_ = {}
-        for index, classVal in enumerate(self.classes_):
-            self.class_dictionary_[classVal] = index
+        for index, class_val in enumerate(self.classes_):
+            self.class_dictionary_[class_val] = index
 
         if self.n_classes_ == 1:
             return self