From 02f4dfb8bf3d4e8eb844eb3578c61fd3d88fd5c7 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 5 Aug 2024 11:39:45 +0100 Subject: [PATCH 1/6] [MNT] Bump crs-k/stale-branches in the github-actions group (#1909) Bumps the github-actions group with 1 update: [crs-k/stale-branches](https://github.com/crs-k/stale-branches). Updates `crs-k/stale-branches` from 5.0.2 to 6.0.1 - [Release notes](https://github.com/crs-k/stale-branches/releases) - [Commits](https://github.com/crs-k/stale-branches/compare/v5.0.2...v6.0.1) --- updated-dependencies: - dependency-name: crs-k/stale-branches dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- .github/workflows/periodic_github_maintenace.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/periodic_github_maintenace.yml b/.github/workflows/periodic_github_maintenace.yml index e004d224e0..82faa51cce 100644 --- a/.github/workflows/periodic_github_maintenace.yml +++ b/.github/workflows/periodic_github_maintenace.yml @@ -23,7 +23,7 @@ jobs: private-key: ${{ secrets.PR_APP_KEY }} - name: Stale Branches - uses: crs-k/stale-branches@v5.0.2 + uses: crs-k/stale-branches@v6.0.1 with: repo-token: ${{ steps.app-token.outputs.token }} days-before-stale: 140 From 7eb8e76dc3cf95903e30c3516018f00dae487246 Mon Sep 17 00:00:00 2001 From: "aeon-actions-bot[bot]" <148872591+aeon-actions-bot[bot]@users.noreply.github.com> Date: Mon, 5 Aug 2024 11:40:08 +0100 Subject: [PATCH 2/6] Automated `pre-commit` hook update (#1907) Co-authored-by: MatthewMiddlehurst <25731235+MatthewMiddlehurst@users.noreply.github.com> --- .pre-commit-config.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index e5991439bd..f9c420ff7b 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -29,7 +29,7 @@ repos: args: [ "--create", "--python-folders", "aeon" ] - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.5.5 + rev: v0.5.6 hooks: - id: ruff args: [ "--fix"] @@ -48,14 +48,14 @@ repos: args: [ "--profile=black", "--multi-line=3" ] - repo: https://github.com/pycqa/flake8 - rev: 7.1.0 + rev: 7.1.1 hooks: - id: flake8 additional_dependencies: [ flake8-bugbear, flake8-print, Flake8-pyproject ] args: [ "--max-line-length=88", "--extend-ignore=E203" ] - repo: https://github.com/psf/black - rev: 24.4.2 + rev: 24.8.0 hooks: - id: black language_version: python3 From f30fff0add07e5133232534857efe4d294ff45b9 Mon Sep 17 00:00:00 2001 From: Matthew Middlehurst Date: Mon, 5 Aug 2024 11:58:03 +0100 Subject: [PATCH 3/6] [MNT] Fix sporadic PF breakage and `matplotlib` version bound (#1906) * fixes * Update pyproject.toml --- .../distance_based/tests/test_proximity_forest.py | 4 ++-- pyproject.toml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/aeon/classification/distance_based/tests/test_proximity_forest.py b/aeon/classification/distance_based/tests/test_proximity_forest.py index 9575177327..a107938000 100644 --- a/aeon/classification/distance_based/tests/test_proximity_forest.py +++ b/aeon/classification/distance_based/tests/test_proximity_forest.py @@ -11,7 +11,7 @@ def test_univariate(): """Test that the function gives appropriate error message.""" X, y = load_unit_test() X_multivariate = X.reshape((-1, 2, 12)) - clf = ProximityForest(n_trees=5, random_state=42, n_jobs=-1) + clf = ProximityForest(n_trees=5) with pytest.raises(ValueError): clf.fit(X_multivariate, y) @@ -20,7 +20,7 @@ def test_proximity_forest(): """Test the fit method of ProximityTree.""" X_train, y_train = load_unit_test() X_test, y_test = load_unit_test(split="test") - clf = ProximityForest(n_trees=5, n_splitters=3, max_depth=4) + clf = ProximityForest(n_trees=5, n_splitters=3, max_depth=4, random_state=42) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) score = accuracy_score(y_test, y_pred) diff --git a/pyproject.toml b/pyproject.toml index 768a2d173f..8726769bb0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -64,7 +64,7 @@ all_extras = [ "imbalanced-learn", "keras-self-attention", "kotsu>=0.3.1", - "matplotlib>=3.3.2", + "matplotlib>=3.3.2,<3.9.0", "pmdarima>=1.8.0", "prophet>=1.1.0", "pydot>=2.0.0", From 44bd0c974cdb8291ab2a080c2a0ea93cf5512720 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 5 Aug 2024 12:58:32 +0200 Subject: [PATCH 4/6] [DEP] Remove FeatureSelection transformer (#1890) * remove Theta * remove * API --- aeon/transformations/feature_selection.py | 223 ------------------ .../tests/test_feature_selection.py | 90 ------- docs/api_reference/transformations.rst | 14 -- 3 files changed, 327 deletions(-) delete mode 100644 aeon/transformations/feature_selection.py delete mode 100644 aeon/transformations/tests/test_feature_selection.py diff --git a/aeon/transformations/feature_selection.py b/aeon/transformations/feature_selection.py deleted file mode 100644 index f71b246a7d..0000000000 --- a/aeon/transformations/feature_selection.py +++ /dev/null @@ -1,223 +0,0 @@ -"""Implements feature selection algorithms.""" - -__maintainer__ = [] -__all__ = ["FeatureSelection"] - -import math - -import pandas as pd -from deprecated.sphinx import deprecated - -from aeon.transformations.base import BaseTransformer -from aeon.utils.validation.forecasting import check_regressor - - -# TODO: remove in v0.11.0 -@deprecated( - version="0.10.0", - reason="DateTimeFeatures will be removed in version 0.11.0.", - category=FutureWarning, -) -class FeatureSelection(BaseTransformer): - """ - Select exogenous features. - - Transformer to enable tuneable feauture selection of exogenous data. The - FeatureSelection implements multiple methods to select features (columns). - In case X is a pd.Series, then it is just passed through, unless method="none", - then None is returned in transform(). - - Parameters - ---------- - method : str - The method of how to select the features. Implemeted methods are: - * "feature-importances": Use feature_importances_ of the regressor (meta-model) - to select n_columns with highest importance values. - Requires parameter n_columns. - * "random": Randomly select n_columns features. Requires parameter n_columns. - * "columns": Select features by given names. - * "none": Remove all columns by setting Z to None. - * "all": Select all given features. - n_columns : int, default = None - Number of feautres (columns) to select. n_columns must be <= - number of X columns. Some methods require n_columns to be given. - regressor : sklearn-like regressor, default=None - Used as meta-model for the method "feature-importances". The given - regressor must have an attribute "feature_importances_". If None, - then a GradientBoostingRegressor(max_depth=5) is used. - random_state : int, RandomState instance or None, default=None - Used to set random_state of the default regressor and to - set random.seed() if method="random". - columns : list of str - A list of columns to select. If columns is given. - - Attributes - ---------- - columns_ : list of str - List of columns that have been selected as features. - regressor_ : sklearn-like regressor - Fitted regressor (meta-model). - n_columns_: int - Derived from number of features if n_columns is None, then - n_columns_ is calculated as int(math.ceil(Z.shape[1] / 2)). So taking - half of given features only as default. - feature_importances_ : dict or None - A dictionary with column name as key and feature imporatnce value as value. - The dict is sorted descending on value. This attribute is a dict if - method="feature-importances", else None. - - Examples - -------- - >>> from aeon.transformations.feature_selection import FeatureSelection - >>> from aeon.datasets import load_longley - >>> y, X = load_longley() - >>> transformer = FeatureSelection(method="feature-importances", n_columns=3) - >>> X_hat = transformer.fit_transform(X, y) - """ - - _tags = { - "input_data_type": "Series", - # what is the abstract type of X: Series, or Panel - "output_data_type": "Series", - # what abstract type is returned: Primitives, Series, Panel - "instancewise": True, - "X_inner_type": ["pd.DataFrame", "pd.Series"], - "y_inner_type": "pd.DataFrame", - "fit_is_empty": False, - "transform-returns-same-time-index": True, - "skip-inverse-transform": True, - "capability:multivariate": True, - } - - def __init__( - self, - method="feature-importances", - n_columns=None, - regressor=None, - random_state=None, - columns=None, - ): - self.n_columns = n_columns - self.method = method - self.regressor = regressor - self.random_state = random_state - self.columns = columns - - super().__init__() - - def _fit(self, X, y=None): - """Fit transformer to X and y. - - private _fit containing the core logic, called from fit - - Parameters - ---------- - X : pd.Series or pd.DataFrame - Data to fit transform to - y : pd.DataFrame, default=None - Additional data, e.g., labels for transformation - - Returns - ------- - self: a fitted instance of the estimator - """ - self.n_columns_ = self.n_columns - self.feature_importances_ = None - - if self.method == "none": - self.set_tags(**{"output_data_type": "Primitives"}) - - # multivariate X - if not isinstance(X, pd.Series): - if self.method == "feature-importances": - self.regressor_ = check_regressor( - regressor=self.regressor, random_state=self.random_state - ) - self._check_n_columns(X) - # fit regressor with X as exog data and y as endog data (target) - self.regressor_.fit(X=X, y=y) - if not hasattr(self.regressor_, "feature_importances_"): - raise ValueError( - """The given regressor must have an - attribute feature_importances_ after fitting.""" - ) - # create dict with columns name (key) and feauter importance (value) - d = dict(zip(X.columns, self.regressor_.feature_importances_)) - # sort d descending - d = {k: d[k] for k in sorted(d, key=d.get, reverse=True)} - self.feature_importances_ = d - self.columns_ = list(d.keys())[: self.n_columns_] - elif self.method == "random": - self._check_n_columns(X) - self.columns_ = list( - X.sample( - n=self.n_columns_, random_state=self.random_state, axis=1 - ).columns - ) - elif self.method == "columns": - if self.columns is None: - raise AttributeError("Parameter columns must be given.") - self.columns_ = self.columns - elif self.method == "none": - self.columns_ = None - elif self.method == "all": - self.columns_ = list(X.columns) - else: - raise ValueError("Incorrect method given. Try another method.") - return self - - def _transform(self, X, y=None): - """Transform X and return a transformed version. - - private _transform containing the core logic, called from transform - - Parameters - ---------- - X : pd.Series or pd.DataFrame - Data to be transformed - y : ignored argument for interface compatibility - Additional data, e.g., labels for transformation - - Returns - ------- - Xt : pd.Series or pd.DataFrame, same type as X - transformed version of X - """ - # multivariate case - if not isinstance(X, pd.Series): - if self.method == "none": - Xt = None - else: - Xt = X[self.columns_] - # univariate case - else: - if self.method == "none": - Xt = None - else: - Xt = X - return Xt - - def _check_n_columns(self, Z): - if not isinstance(self.n_columns_, int): - self.n_columns_ = int(math.ceil(Z.shape[1] / 2)) - - @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. - - - 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 {"method": "all"} diff --git a/aeon/transformations/tests/test_feature_selection.py b/aeon/transformations/tests/test_feature_selection.py deleted file mode 100644 index 74065091d9..0000000000 --- a/aeon/transformations/tests/test_feature_selection.py +++ /dev/null @@ -1,90 +0,0 @@ -"""Test FeatureSelection transformer.""" - -__maintainer__ = [] -__all__ = [] - -import math - -import pandas as pd -import pytest -from pandas.testing import assert_frame_equal -from sklearn.tree import DecisionTreeRegressor - -from aeon.datasets import load_longley -from aeon.forecasting.model_selection import temporal_train_test_split -from aeon.transformations.feature_selection import FeatureSelection - -y, X = load_longley() -y_train, y_test, X_train, X_test = temporal_train_test_split(y, X, test_size=3) - - -@pytest.mark.parametrize( - "method", ["feature-importances", "random", "columns", "none", "all"] -) -@pytest.mark.parametrize("n_columns", [None, 2]) -@pytest.mark.parametrize("random_state", [1, 3]) -def test_feature_selection(method, n_columns, random_state): - columns = ["GNP", "UNEMP"] if method == "columns" else None - transformer = FeatureSelection( - method=method, columns=columns, n_columns=n_columns, random_state=random_state - ) - transformer.fit(X=X_train, y=y_train) - X_hat = transformer.transform(X=X_test, y=y_test) - if method != "none": - assert isinstance(X_hat, pd.DataFrame) - else: - assert X_hat is None - - if method == "feature-importances": - if n_columns is None: - n_columns = int(math.ceil(X_train.shape[1] / 2)) - else: - assert X_hat.shape[1] == n_columns - assert isinstance(transformer.feature_importances_, dict) - assert len(transformer.feature_importances_) == X_train.shape[1] - assert isinstance(transformer.feature_importances_, dict) - # test custom regressor - transformer_f1 = FeatureSelection( - method=method, regressor=DecisionTreeRegressor() - ) - transformer_f1.fit(X=X_train, y=y_train) - _ = transformer_f1.transform(X=X_test, y=y_test) - transformer_f2 = FeatureSelection(method=method) - transformer_f2.fit(X=X_train, y=y_train) - _ = transformer_f2.transform(X=X_test, y=y_test) - - assert ( - transformer_f1.feature_importances_ != transformer_f2.feature_importances_ - ) - - if method == "random": - if n_columns is None: - n_columns = int(math.ceil(X_train.shape[1] / 2)) - else: - assert X_hat.shape[1] == n_columns - # test random state - transformer_rand1 = FeatureSelection( - method=method, random_state=random_state - ) - transformer_rand1.fit(X_train) - X_hat_rand1 = transformer_rand1.transform(X_test) - - transformer_rand2 = FeatureSelection(method=method, random_state=3) - transformer_rand2.fit(X_train) - X_hat_rand2 = transformer_rand2.transform(X_test) - - if random_state == 3: - assert_frame_equal(X_hat_rand1, X_hat_rand2) - if random_state != 3: - with pytest.raises(AssertionError): - assert_frame_equal(X_hat_rand1, X_hat_rand2) - if method == "columns": - if columns is None: - assert X_hat.shape[1] == X_train.shape[1] - else: - assert X_hat.shape[1] == len(columns) - for c in columns: - assert c in X_hat.columns - - -test_feature_selection("random", 2, None) diff --git a/docs/api_reference/transformations.rst b/docs/api_reference/transformations.rst index 10ead8c943..b38db9bd14 100644 --- a/docs/api_reference/transformations.rst +++ b/docs/api_reference/transformations.rst @@ -242,20 +242,6 @@ These transformers create a series based on a sequence of sliding windows. HOG1DTransformer - -FeatureSelection -~~~~~~~~~~~~~~~~ - -These transformers select features in `X` based on `y`. - -.. currentmodule:: aeon.transformations.feature_selection - -.. autosummary:: - :toctree: auto_generated/ - :template: class.rst - - FeatureSelection - .. currentmodule:: aeon.transformations.collection.channel_selection .. autosummary:: From 1f7a11425b753fd011fa097867a1afe9bd2ce7df Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 5 Aug 2024 13:16:25 +0200 Subject: [PATCH 5/6] [DEP] Remove FunctionTransformer (#1891) * remove Theta * remove FunctionTransform * API --- .../tests/test_base_interval_forest.py | 2 +- aeon/transformations/func_transform.py | 190 ------------------ docs/api_reference/transformations.rst | 11 - 3 files changed, 1 insertion(+), 202 deletions(-) delete mode 100644 aeon/transformations/func_transform.py diff --git a/aeon/base/estimator/interval_based/tests/test_base_interval_forest.py b/aeon/base/estimator/interval_based/tests/test_base_interval_forest.py index a11c3c52b1..63b5b4e96b 100644 --- a/aeon/base/estimator/interval_based/tests/test_base_interval_forest.py +++ b/aeon/base/estimator/interval_based/tests/test_base_interval_forest.py @@ -3,6 +3,7 @@ import numpy as np import pytest from sklearn.pipeline import make_pipeline +from sklearn.preprocessing import FunctionTransformer from sklearn.tree import DecisionTreeClassifier from aeon.base._base import _clone_estimator @@ -14,7 +15,6 @@ Catch22, SevenNumberSummaryTransformer, ) -from aeon.transformations.func_transform import FunctionTransformer from aeon.utils.numba.stats import row_mean, row_numba_min diff --git a/aeon/transformations/func_transform.py b/aeon/transformations/func_transform.py deleted file mode 100644 index 79a987275a..0000000000 --- a/aeon/transformations/func_transform.py +++ /dev/null @@ -1,190 +0,0 @@ -"""Implements FunctionTransformer, a class to create custom transformers.""" - -__maintainer__ = [] -__all__ = ["FunctionTransformer"] - -import numpy as np -from deprecated.sphinx import deprecated - -from aeon.transformations.base import BaseTransformer - - -def _identity(X): - """Return X.""" - return X - - -# TODO: remove in v0.11.0 -@deprecated( - version="0.10.0", - reason="FourierFeatures will be removed in version 0.11.0.", - category=FutureWarning, -) -class FunctionTransformer(BaseTransformer): - r""" - Constructs a transformer from an arbitrary callable. - - A FunctionTransformer forwards its y (and optionally X) arguments to a - user-defined function or function object and returns the result of this - function. This is useful for stateless transformations such as taking the - log of frequencies, doing custom scaling, etc. - - Note: If a lambda is used as the function, then the resulting - transformer will not be pickleable. - - Parameters - ---------- - func : callable (X: X_type, **kwargs) -> X_type, default=identity (return X) - The callable to use for the transformation. This will be passed - the same arguments as transform, with args and kwargs forwarded. - If func is None, then func will be the identity function. - inverse_func : callable (X: X_type, **kwargs) -> X_type, default=identity - The callable to use for the inverse transformation. This will be - passed the same arguments as inverse transform, with args and - kwargs forwarded. If inverse_func is None, then inverse_func - will be the identity function. - check_inverse : bool, default=True - Whether to check that or ``func`` followed by ``inverse_func`` leads to - the original inputs. It can be used for a sanity check, raising a - warning when the condition is not fulfilled. - kw_args : dict, default=None - Dictionary of additional keyword arguments to pass to func. - inv_kw_args : dict, default=None - Dictionary of additional keyword arguments to pass to inverse_func. - X_type : str, one of "pd.DataFrame, pd.Series, np.ndarray", or list thereof - Default = ["pd.DataFrame", "pd.Series", "np.ndarray"] - list of types that func is assumed to allow for X (see signature above) - if X passed to transform/inverse_transform is not on the list, - it will be converted to the first list element before passed to funcs - - - Examples - -------- - >>> import numpy as np - >>> from aeon.transformations.func_transform import FunctionTransformer - >>> transformer = FunctionTransformer(np.log1p, np.expm1) - >>> X = np.array([[0, 1], [2, 3]]) - >>> transformer.fit_transform(X) - array([[0. , 0.69314718], - [1.09861229, 1.38629436]]) - """ - - _tags = { - "input_data_type": "Series", - # what is the abstract type of X: Series, or Panel - "output_data_type": "Series", - # what abstract type is returned: Primitives, Series, Panel - "instancewise": True, # is this an instance-wise transform? - "X_inner_type": ["pd.DataFrame", "pd.Series", "np.ndarray"], - "y_inner_type": "None", - "fit_is_empty": True, - "capability:missing_values": True, - "capability:inverse_transform": True, - } - - def __init__( - self, - func=None, - inverse_func=None, - *, - check_inverse=True, - kw_args=None, - inv_kw_args=None, - X_type=None, - ): - self.func = func - self.inverse_func = inverse_func - self.check_inverse = check_inverse - self.kw_args = kw_args - self.inv_kw_args = inv_kw_args - self.X_type = X_type - super().__init__() - - if X_type is not None: - self.set_tags(X_inner_type=X_type) - - def _check_inverse_transform(self, Z): - """Check that func and inverse_func are each other's inverse.""" - Z_round_trip = self.inverse_func(self.func(Z)) - if not np.allclose(Z_round_trip, Z, equal_nan=True): - raise UserWarning( - "The provided functions are not strictly" - " inverse of each other. If you are sure you" - " want to proceed regardless, set" - " 'check_inverse=False'." - ) - - def _transform(self, X, y=None): - """Transform X and return a transformed version. - - private _transform containing the core logic, called from transform - - Parameters - ---------- - X : pd.Series or pd.DataFrame or 1D/2D np.ndarray - Data to be transformed - y : ignored argument for interface compatibility - Additional data, e.g., labels for transformation - - Returns - ------- - Xt : pd.Series or pd.DataFrame or 1D/2D np.ndarray, same type as X - transformed version of X - """ - if self.check_inverse and not (self.func is None or self.inverse_func is None): - self._check_inverse_transform(X) - - Xt = self._apply_function(X, func=self.func, kw_args=self.kw_args) - return Xt - - def _inverse_transform(self, X, y=None): - """Inverse transform X and return an inverse transformed version. - - core logic - - Parameters - ---------- - X : pd.Series or pd.DataFrame or 1D/2D np.ndarray - Data to be transformed - y : ignored argument for interface compatibility - Additional data, e.g., labels for transformation - - Returns - ------- - Xt : pd.Series or pd.DataFrame or 1D/2D np.ndarray, same type as X - inverse transformed version of X - """ - Xt = self._apply_function(X, func=self.inverse_func, kw_args=self.inv_kw_args) - return Xt - - def _apply_function(self, Z, func=None, kw_args=None): - if func is None: - func = _identity - return func(Z, **(kw_args if kw_args else {})) - - @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. - - - 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` - """ - # default params, identity transform - params1 = {} - - # log-transformer, with exp inverse - params2 = {"func": np.expm1, "inverse_func": np.log1p} - - return [params1, params2] diff --git a/docs/api_reference/transformations.rst b/docs/api_reference/transformations.rst index b38db9bd14..a1b614a6b5 100644 --- a/docs/api_reference/transformations.rst +++ b/docs/api_reference/transformations.rst @@ -43,17 +43,6 @@ Transformations are categorized as follows: Composition ----------- -Pipeline building -~~~~~~~~~~~~~~~~~ - -.. currentmodule:: aeon.transformations.func_transform - -.. autosummary:: - :toctree: auto_generated/ - :template: class.rst - - FunctionTransformer - Sklearn and pandas adapters ~~~~~~~~~~~~~~~~~~~~~~~~~~~ From f3143201c33c44b2765bc17dc336895d16495a90 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 5 Aug 2024 13:16:49 +0200 Subject: [PATCH 6/6] [DEP] Remove update in BaseCollectionTransformer (#1894) * remove Theta * deprecate update --- aeon/transformations/collection/base.py | 75 ------------------------- 1 file changed, 75 deletions(-) diff --git a/aeon/transformations/collection/base.py b/aeon/transformations/collection/base.py index a69f642ca9..a2e6a36b7e 100644 --- a/aeon/transformations/collection/base.py +++ b/aeon/transformations/collection/base.py @@ -29,7 +29,6 @@ class name: BaseCollectionTransformer import numpy as np import pandas as pd -from deprecated.sphinx import deprecated from aeon.base import BaseCollectionEstimator from aeon.transformations.base import BaseTransformer @@ -273,80 +272,6 @@ def inverse_transform(self, X, y=None): return Xt - # TODO: remove in v0.11.0 - @deprecated( - version="0.10.0", - reason="The update method will be removed in version 0.11.0.", - category=FutureWarning, - ) - @final - def update(self, X, y=None, update_params=True): - """Update transformer with X, optionally y. - - State required: - Requires state to be "fitted". - - Accesses in self: - _is_fitted : must be True - fitted model attributes (ending in "_") : must be set, accessed by _update - - Writes to self: - _X : set to be X, if remember_data tag is True, potentially used in _update - fitted model attributes (ending in "_") : only if update_params=True - type and nature of update are dependent on estimator - - Parameters - ---------- - X : np.ndarray or list - Input data, any number of channels, equal length series of shape ``( - n_cases, n_channels, n_timepoints)`` - or list of numpy arrays (any number of channels, unequal length series) - of shape ``[n_cases]``, 2D np.array ``(n_channels, n_timepoints_i)``, - where ``n_timepoints_i`` is length of series ``i``. Other types are - allowed and converted into one of the above. - - Different estimators have different capabilities to handle different - types of input. If `self.get_tag("capability:multivariate")`` is False, - they cannot handle multivariate series. If ``self.get_tag( - "capability:unequal_length")`` is False, they cannot handle unequal - length input. In both situations, a ``ValueError`` is raised if X has a - characteristic that the estimator does not have the capability to handle. - Data to fit transform to, of valid collection type. - y : np.ndarray, default=None - 1D np.array of float or str, of shape ``(n_cases)`` - class labels - (ground truth) for fitting indices corresponding to instance indices in X. - If None, no labels are used in fitting. - update_params : bool, default=True - whether the model is updated. Yes if true, if false, simply skips call. - argument exists for compatibility with forecasting module. - - Returns - ------- - self : a fitted instance of the estimator - """ - # check whether is fitted - self.check_is_fitted() - - # if requires_y is set, y is required in fit and update - if self.get_tag("requires_y") and y is None: - raise ValueError(f"{self.__class__.__name__} requires `y` in `update`.") - - # check and convert X/y - X_inner = self._preprocess_collection(X, store_metadata=False) - y_inner = y - - # update memory of X, if remember_data exists and is set to True - if self.get_tag("remember_data", tag_value_default=False): - self._X = X_inner - - # skip everything if update_params is False or fit_is_empty is present and True - if not update_params or self.get_tag("fit_is_empty", tag_value_default=False): - return self - - self._update(X=X_inner, y=y_inner) - - return self - def _fit(self, X, y=None): """Fit transformer to X and y.