Add ColumnwiseTransformer (multivariate compositor for series-to-series transformer)

sktime/tests/_config.py

@@ -85,6 +85,7 @@
 from sktime.transformations.series.compose import OptionalPassthrough
 from sktime.transformations.series.outlier_detection import HampelFilter
 from sktime.transformations.series.boxcox import BoxCoxTransformer
+from sktime.transformations.series.multivariate_compositor import MultivariateCompositor
 from sktime.clustering.base.base import BaseCluster
 
 
@@ -276,6 +277,7 @@
     Imputer: {"method": "mean"},
     HampelFilter: {"window_length": 3},
     OptionalPassthrough: {"transformer": BoxCoxTransformer(), "passthrough": True},
+    MultivariateCompositor: {"transformer": BoxCoxTransformer()},
 }
 
 # We use estimator tags in addition to class hierarchies to further distinguish

sktime/transformations/series/multivariate_compositor.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3 -u
+# -*- coding: utf-8 -*-
+# copyright: sktime developers, BSD-3-Clause License (see LICENSE file)
+
+__all__ = ["MultivariateCompositor"]
+__author__ = ["Svea Meyer"]
+
+import pandas as pd
+from sklearn.base import clone
+from sktime.transformations.base import _SeriesToSeriesTransformer
+from sktime.utils.validation.series import check_series
+
+
+class MultivariateCompositor(_SeriesToSeriesTransformer):
+    """
+    Parameters
+    ----------
+    transformer : series-to-series transformer to be applied to each series
+    columns : names of columns that are supposed to be transformed
+    """
+
+    _required_parameters = ["transformer"]
+    _tags = {
+        "multivariate-only": True,
+    }
+
+    def __init__(self, transformer, columns="all"):
+        self.transformer = transformer
+        self.columns = columns
+        self.transformers_ = None
+        super(MultivariateCompositor, self).__init__()
+
+    def fit(self, Z, X=None):
+        """
+        Iterates over columns (series) and applies the fit function of the transformer
+        """
+        if not isinstance(Z, pd.DataFrame):
+            raise ValueError("Z needs to be a multivariate Pandas Series")
+        self._is_fitted = False
+        z = check_series(Z)
+        if self.columns == "all":
+            self.columns = z.columns
+
+        # make sure z contains all columns that the user wants to transform
+        Z_wanted_keys = set(self.columns)
+        Z_new_keys = set(z.columns)
+        difference = Z_wanted_keys.difference(Z_new_keys)
+        if len(difference) != 0:
+            raise ValueError("Missing columns" + str(difference) + "in Z.")
+
+        self.transformers_ = {}
+        for colname in self.columns:
+            transformer = clone(self.transformer)
+            self.transformers_[colname] = transformer
+            self.transformers_[colname].fit(z[colname], X)
+            # self.transformers_[colname].is_fitted = True
+        self._is_fitted = True
+        return self
+
+    def transform(self, Z, X=None):
+        """
+        calls transform on every single transformer (one transformer per series)
+        """
+        if not isinstance(Z, pd.DataFrame):
+            raise ValueError("Z needs to be a multivariate Pandas Series")
+
+        self.check_is_fitted()
+        z = check_series(Z)
+
+        # make copy of z
+        z = z.copy()
+        # make sure z contains all columns that the user wants to transform
+        Z_wanted_keys = set(self.columns)
+        Z_new_keys = set(z.columns)
+        difference = Z_wanted_keys.difference(Z_new_keys)
+        if len(difference) != 0:
+            raise ValueError("Missing columns" + str(difference) + "in Z.")
+        for colname in self.columns:
+            # self.columns : columns that are supposed to be transformed
+            self.transformers_[colname].check_is_fitted()
+            z[colname] = self.transformers_[colname].transform(z[colname], X)
+        return z
+
+    def inverse_transform(self, Z, X=None):
+        """
+        if the base transformer has an inverse-transform this
+        inverse transform is called on every single transformer
+        (one transformer per series)
+        """
+        if not isinstance(Z, pd.DataFrame):
+            raise ValueError("Z needs to be a multivariate Pandas Series")
+
+        if not hasattr(self.transformer, "inverse_transform"):
+            raise NotImplementedError(
+                "this transform does not have an inverse_transform method"
+            )
+        self.check_is_fitted()
+        z = check_series(Z)
+
+        if isinstance(Z, pd.DataFrame):
+            # make copy of z
+            z = z.copy()
+
+            # make sure z contains all columns that the user wants to transform
+            Z_wanted_keys = set(self.columns)
+            Z_new_keys = set(z.columns)
+            difference = Z_wanted_keys.difference(Z_new_keys)
+            if len(difference) != 0:
+                raise ValueError("Missing columns" + str(difference) + "in Z.")
+            for colname in self.columns:
+                # self.columns : columns that are supposed to be transformed
+                self.transformers_[colname].check_is_fitted()
+                z[colname] = self.transformers_[colname].inverse_transform(
+                    z[colname], X
+                )
+            return z
+
+    # todo: add functionality for update

sktime/transformations/tests/test_all_transformers.py

@@ -57,7 +57,7 @@ def check_series_to_primitive_transform_univariate(Estimator, **kwargs):
 
 
 def _check_raises_error(Estimator, **kwargs):
-    with pytest.raises(ValueError, match=r"univariate"):
+    with pytest.raises(ValueError, match=r"variate"):
         if _has_tag(Estimator, "fit-in-transform"):
             # As some estimators have an empty fit method, we here check if
             # they raise the appropriate error in transform rather than fit.
@@ -79,12 +79,15 @@ def check_series_to_primitive_transform_multivariate(Estimator):
 
 def check_series_to_series_transform_univariate(Estimator):
     n_timepoints = 15
-    out = _construct_fit_transform(
-        Estimator,
-        n_timepoints=n_timepoints,
-        add_nan=_has_tag(Estimator, "handles-missing-data"),
-    )
-    assert isinstance(out, (pd.Series, np.ndarray, pd.DataFrame))
+    if _has_tag(Estimator, "multivariate-only"):
+        _check_raises_error(Estimator, n_timepoints=n_timepoints)
+    else:
+        out = _construct_fit_transform(
+            Estimator,
+            n_timepoints=n_timepoints,
+            add_nan=_has_tag(Estimator, "handles-missing-data"),
+        )
+        assert isinstance(out, (pd.Series, np.ndarray, pd.DataFrame))
 
 
 def check_series_to_series_transform_multivariate(Estimator):
@@ -156,7 +159,10 @@ def check_transform_returns_same_time_index(Estimator):
 
 def check_transform_inverse_transform_equivalent(Estimator):
     estimator = _construct_instance(Estimator)
-    X = _make_args(estimator, "fit")[0]
+    if _has_tag(Estimator, "multivariate-only"):
+        X = _make_args(estimator, "fit", n_columns=3)[0]
+    else:
+        X = _make_args(estimator, "fit")[0]
     Xt = estimator.fit_transform(X)
     Xit = estimator.inverse_transform(Xt)
     _assert_array_almost_equal(X, Xit)