wrappers

Author: MatthewMiddlehurst

aeon/anomaly_detection/whole_series/_classification.py

@@ -0,0 +1,65 @@
+"""Adapter to use classification algorithms for collection anomaly detection."""
+
+__maintainer__ = []
+
+
+from sklearn.base import ClassifierMixin
+from sklearn.ensemble import RandomForestClassifier
+
+from aeon.anomaly_detection.whole_series.base import BaseCollectionAnomalyDetector
+from aeon.base._base import _clone_estimator
+from aeon.classification.feature_based import SummaryClassifier
+
+
+class ClassificationAdapter(BaseCollectionAnomalyDetector):
+    """
+    Basic classifier adapter for collection anomaly detection.
+
+    This class wraps a classification algorithm to be used as an anomaly detector.
+    Anomaly labels are required for training.
+
+    Parameters
+    ----------
+    classifier : aeon classifier or ClassifierMixin
+        The classification algorithm to be adapted.
+    random_state : int, RandomState instance or None, default=None
+        If `int`, random_state is the seed used by the random number generator;
+        If `RandomState` instance, random_state is the random number generator;
+        If `None`, the random number generator is the `RandomState` instance used
+        by `np.random`.
+    """
+
+    _tags = {
+        "X_inner_type": "numpy2D",
+        "requires_y": True,
+    }
+
+    def __init__(self, classifier, random_state=None):
+        self.classifier = classifier
+        self.random_state = random_state
+
+        super().__init__()
+
+    def _fit(self, X, y=None):
+        if not isinstance(self.classifier, ClassifierMixin):
+            raise ValueError(
+                "The estimator must be an aeon classification algorithm "
+                "or class that implements the ClassifierMixin interface."
+            )
+
+        self.classifier_ = _clone_estimator(
+            self.classifier, random_state=self.random_state
+        )
+        self.classifier_.fit(X, y)
+        return self
+
+    def _predict(self, X):
+        return self.classifier_.predict(X)
+
+    @classmethod
+    def _get_test_params(cls, parameter_set="default"):
+        return {
+            "estimator": SummaryClassifier(
+                estimator=RandomForestClassifier(n_estimators=5)
+            )
+        }

aeon/anomaly_detection/whole_series/_outlier_detection.py

@@ -1,33 +1,55 @@
-"""Basic outlier detection classifier."""
+"""Adapter to use outlier detection algorithms for collection anomaly detection."""
 
+__maintainer__ = []
+
+from sklearn.base import OutlierMixin
 from sklearn.ensemble import IsolationForest
 
 from aeon.anomaly_detection.whole_series.base import BaseCollectionAnomalyDetector
 from aeon.base._base import _clone_estimator
 
 
-class OutlierDetectionClassifier(BaseCollectionAnomalyDetector):
-    """Basic outlier detection classifier."""
+class OutlierDetectionAdapter(BaseCollectionAnomalyDetector):
+    """
+    Basic outlier detection adapter for collection anomaly detection.
+
+    This class wraps an sklearn outlier detection algorithm to be used as an anomaly
+    detector.
+
+    Parameters
+    ----------
+    detector : OutlierMixin
+        The outlier detection algorithm to be adapted.
+    random_state : int, RandomState instance or None, default=None
+        If `int`, random_state is the seed used by the random number generator;
+        If `RandomState` instance, random_state is the random number generator;
+        If `None`, the random number generator is the `RandomState` instance used
+        by `np.random`.
+    """
 
     _tags = {
         "X_inner_type": "numpy2D",
     }
 
-    def __init__(self, estimator, random_state=None):
-        self.estimator = estimator
+    def __init__(self, detector, random_state=None):
+        self.detector = detector
         self.random_state = random_state
 
         super().__init__()
 
     def _fit(self, X, y=None):
-        self.estimator_ = _clone_estimator(
-            self.estimator, random_state=self.random_state
-        )
-        self.estimator_.fit(X, y)
+        if not isinstance(self.detector, OutlierMixin):
+            raise ValueError(
+                "The estimator must be an outlier detection algorithm "
+                "that implements the OutlierMixin interface."
+            )
+
+        self.detector_ = _clone_estimator(self.detector, random_state=self.random_state)
+        self.detector_.fit(X, y)
         return self
 
     def _predict(self, X):
-        pred = self.estimator_.predict(X)
+        pred = self.detector_.predict(X)
         pred[pred == -1] = 0
         return pred