- Resolved merge conflicts with upstream main in estimator checks, testing data, and register modules

Author: MatthewMiddlehurst

aeon/anomaly_detection/whole_series/__init__.py

@@ -0,0 +1 @@
+"""Whole-series anomaly detection methods."""

aeon/anomaly_detection/whole_series/_outlier_detection.py

@@ -0,0 +1,34 @@
+"""Basic outlier detection classifier."""
+
+from aeon.anomaly_detection 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."""
+
+    _tags = {
+        "X_inner_type": "numpy2D",
+    }
+
+    def __init__(self, estimator, random_state=None):
+        self.estimator = estimator
+        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)
+        return self
+
+    def _predict(self, X):
+        pred = self.estimator_.predict(X)
+        pred[pred == -1] = 0
+        return pred
+
+    def _get_test_params(cls, parameter_set="default"):
+        return {"estimator": IsolationForest()}

aeon/anomaly_detection/whole_series/base.py

@@ -0,0 +1,92 @@
+"""Abstract base class for whole-series/collection anomaly detectors."""
+
+__maintainer__ = ["MatthewMiddlehurst"]
+__all__ = ["BaseCollectionAnomalyDetector"]
+
+from abc import abstractmethod
+from typing import final
+
+import numpy as np
+import pandas as pd
+
+from aeon.base import BaseCollectionEstimator
+
+
+class BaseCollectionAnomalyDetector(BaseCollectionEstimator):
+    """Collection anomaly detector base class."""
+
+    _tags = {
+        "fit_is_empty": False,
+        "requires_y": False,
+    }
+
+    def __init__(self):
+        super().__init__()
+
+    @final
+    def fit(self, X, y=None):
+        """Fit."""
+        if self.get_tag("fit_is_empty"):
+            self.is_fitted = True
+            return self
+
+        if self.get_tag("requires_y"):
+            if y is None:
+                raise ValueError("Tag requires_y is true, but fit called with y=None")
+
+        # reset estimator at the start of fit
+        self.reset()
+
+        X = self._preprocess_collection(X)
+        if y is not None:
+            y = self._check_y(y, self.metadata_["n_cases"])
+
+        self._fit(X, y)
+
+        # this should happen last
+        self.is_fitted = True
+        return self
+
+    @final
+    def predict(self, X):
+        """Predict."""
+        fit_empty = self.get_tag("fit_is_empty")
+        if not fit_empty:
+            self._check_is_fitted()
+
+        X = self._preprocess_collection(X, store_metadata=False)
+        # Check if X has the correct shape seen during fitting
+        self._check_shape(X)
+
+        return self._predict(X)
+
+    @abstractmethod
+    def _fit(self, X, y=None): ...
+
+    @abstractmethod
+    def _predict(self, X): ...
+
+    def _check_y(self, y, n_cases):
+        if not isinstance(y, (pd.Series, np.ndarray)):
+            raise TypeError(
+                f"y must be a np.array or a pd.Series, but found type: {type(y)}"
+            )
+        if isinstance(y, np.ndarray) and y.ndim > 1:
+            raise TypeError(f"y must be 1-dimensional, found {y.ndim} dimensions")
+
+        if not all([x == 0 or x == 1 for x in y]):
+            raise ValueError(
+                "y input must only contain 0 (not anomalous) or 1 (anomalous) values."
+            )
+
+        # Check matching number of labels
+        n_labels = y.shape[0]
+        if n_cases != n_labels:
+            raise ValueError(
+                f"Mismatch in number of cases. Found X = {n_cases} and y = {n_labels}"
+            )
+
+        if isinstance(y, pd.Series):
+            y = pd.Series.to_numpy(y)
+
+        return y

aeon/testing/estimator_checking/_yield_collection_anomaly_detection_checks.py

@@ -1,81 +1,9 @@
 """Tests for all collection anomaly detectors."""
 
-from functools import partial
-
-import numpy as np
-
-from aeon.base._base import _clone_estimator
-from aeon.testing.testing_data import FULL_TEST_DATA_DICT
-from aeon.utils.data_types import COLLECTIONS_DATA_TYPES
-from aeon.utils.validation import get_n_cases
-
 
 def _yield_collection_anomaly_detection_checks(
     estimator_class, estimator_instances, datatypes
 ):
     """Yield all collection anomaly detection checks for an aeon estimator."""
-    # only class required
-    yield partial(
-        check_collection_detector_overrides_and_tags, estimator_class=estimator_class
-    )
-
-    # test class instances
-    for i, estimator in enumerate(estimator_instances):
-        # test all data types
-        for datatype in datatypes[i]:
-            yield partial(
-                check_collection_anomaly_detector_output,
-                estimator=estimator,
-                datatype=datatype,
-            )
-
-
-def check_collection_detector_overrides_and_tags(estimator_class):
-    """Test compliance with the detector base class contract."""
-    # Test valid tag for X_inner_type
-    X_inner_type = estimator_class.get_class_tag(tag_name="X_inner_type")
-    if isinstance(X_inner_type, str):
-        assert X_inner_type in COLLECTIONS_DATA_TYPES
-    else:  # must be a list
-        assert all([t in COLLECTIONS_DATA_TYPES for t in X_inner_type])
-
-    # one of X_inner_types must be capable of storing unequal length
-    if estimator_class.get_class_tag("capability:unequal_length"):
-        valid_unequal_types = ["np-list", "df-list", "pd-multiindex"]
-        if isinstance(X_inner_type, str):
-            assert X_inner_type in valid_unequal_types
-        else:  # must be a list
-            assert any([t in valid_unequal_types for t in X_inner_type])
-
-
-def check_collection_anomaly_detector_output(estimator, datatype):
-    """Test the collection anomaly detector output on valid data."""
-    estimator = _clone_estimator(estimator)
-
-    estimator.fit(
-        FULL_TEST_DATA_DICT[datatype]["train"][0],
-        FULL_TEST_DATA_DICT[datatype]["train"][1],
-    )
-
-    y_pred = estimator.predict(FULL_TEST_DATA_DICT[datatype]["test"][0])
-    assert isinstance(y_pred, np.ndarray)
-    # collections need n_cases predictions
-    assert len(y_pred) == get_n_cases(FULL_TEST_DATA_DICT[datatype]["test"][0])
-
-    ot = estimator.get_tag("anomaly_output_type")
-    if ot == "anomaly_scores":
-        assert np.issubdtype(y_pred.dtype, np.floating) or np.issubdtype(
-            y_pred.dtype, np.integer
-        ), "y_pred must be of floating point or int type"
-        assert not np.array_equal(
-            np.unique(y_pred), [0, 1]
-        ), "y_pred cannot contain only 0s and 1s"
-    elif ot == "binary":
-        assert np.issubdtype(y_pred.dtype, np.integer) or np.issubdtype(
-            y_pred.dtype, np.bool_
-        ), "y_pred must be of int or bool type for binary output"
-        assert all(
-            val in [0, 1] for val in np.unique(y_pred)
-        ), "y_pred must contain only 0s, 1s, True, or False"
-    else:
-        raise ValueError(f"Unknown anomaly output type: {ot}")
+    # nothing currently!
+    return []

aeon/testing/estimator_checking/_yield_estimator_checks.py

@@ -12,8 +12,7 @@
 from sklearn.exceptions import NotFittedError
 
 from aeon.anomaly_detection.base import BaseAnomalyDetector
-from aeon.anomaly_detection.collection.base import BaseCollectionAnomalyDetector
-from aeon.anomaly_detection.series.base import BaseSeriesAnomalyDetector
+from aeon.anomaly_detection.whole_series.base import BaseCollectionAnomalyDetector
 from aeon.base import BaseAeonEstimator
 from aeon.base._base import _clone_estimator
 from aeon.classification import BaseClassifier
@@ -37,6 +36,9 @@
 from aeon.testing.estimator_checking._yield_collection_anomaly_detection_checks import (
     _yield_collection_anomaly_detection_checks,
 )
+from aeon.testing.estimator_checking._yield_collection_transformation_checks import (
+    _yield_collection_transformation_checks,
+)
 from aeon.testing.estimator_checking._yield_early_classification_checks import (
     _yield_early_classification_checks,
 )
@@ -148,13 +150,13 @@ def _yield_all_aeon_checks(
             estimator_class, estimator_instances, datatypes
         )
 
-    if issubclass(estimator_class, BaseSeriesAnomalyDetector):
-        yield from _yield_series_anomaly_detection_checks(
+    if issubclass(estimator_class, BaseCollectionAnomalyDetector):
+        yield from _yield_collection_anomaly_detection_checks(
             estimator_class, estimator_instances, datatypes
         )
 
-    if issubclass(estimator_class, BaseCollectionAnomalyDetector):
-        yield from _yield_collection_anomaly_detection_checks(
+    if issubclass(estimator_class, BaseSimilaritySearch):
+        yield from _yield_similarity_search_checks(
             estimator_class, estimator_instances, datatypes
         )
 

aeon/testing/testing_data.py

@@ -2,8 +2,8 @@
 
 import numpy as np
 
-from aeon.anomaly_detection.collection.base import BaseCollectionAnomalyDetector
-from aeon.anomaly_detection.series.base import BaseSeriesAnomalyDetector
+from aeon.anomaly_detection.base import BaseAnomalyDetector
+from aeon.anomaly_detection.whole_series.base import BaseCollectionAnomalyDetector
 from aeon.base import BaseCollectionEstimator, BaseSeriesEstimator
 from aeon.classification import BaseClassifier
 from aeon.classification.early_classification import BaseEarlyClassifier
@@ -862,8 +862,8 @@ def _get_task_for_estimator(estimator):
         or isinstance(estimator, BaseEarlyClassifier)
         or isinstance(estimator, BaseClusterer)
         or isinstance(estimator, BaseCollectionTransformer)
+        or isinstance(estimator, BaseSimilaritySearch)
         or isinstance(estimator, BaseCollectionAnomalyDetector)
-        or isinstance(estimator, BaseCollectionSimilaritySearch)
     ):
         data_label = "Classification"
     # collection data with continuous target labels

aeon/utils/base/_register.py

@@ -16,8 +16,7 @@
 ]
 
 from aeon.anomaly_detection.base import BaseAnomalyDetector
-from aeon.anomaly_detection.collection.base import BaseCollectionAnomalyDetector
-from aeon.anomaly_detection.series.base import BaseSeriesAnomalyDetector
+from aeon.anomaly_detection.whole_series.base import BaseCollectionAnomalyDetector
 from aeon.base import BaseAeonEstimator, BaseCollectionEstimator, BaseSeriesEstimator
 from aeon.classification.base import BaseClassifier
 from aeon.classification.early_classification import BaseEarlyClassifier
@@ -40,10 +39,7 @@
     "series-estimator": BaseSeriesEstimator,
     "transformer": BaseTransformer,
     "anomaly-detector": BaseAnomalyDetector,
-    "similarity-search": BaseSimilaritySearch,
-    # estimator types
     "collection-anomaly-detector": BaseCollectionAnomalyDetector,
-    "collection-similarity-search": BaseCollectionSimilaritySearch,
     "collection-transformer": BaseCollectionTransformer,
     "classifier": BaseClassifier,
     "clusterer": BaseClusterer,