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

.all-contributorsrc

@@ -1040,7 +1040,8 @@
       "avatar_url": "https://avatars.githubusercontent.com/u/46671894?v=4",
       "profile": "https://github.com/SveaMeyer13",
       "contributions": [
-        "doc"
+        "doc",
+        "code"
       ]
     },
     {

docs/source/api_reference/transformations.rst

@@ -269,6 +269,7 @@ Composition
     :template: class.rst
 
     OptionalPassthrough
+    ColumnwiseTransformer
 
 Theta
 ~~~~~

sktime/tests/_config.py

@@ -91,9 +91,11 @@
 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.compose import ColumnwiseTransformer
 from sktime.dists_kernels.compose_tab_to_panel import AggrDist
 from sktime.dists_kernels.scipy_dist import ScipyDist
 
+
 # The following estimators currently do not pass all unit tests
 # What do they fail? ShapeDTW fails on 3d_numpy_input test, not set up for that
 EXCLUDE_ESTIMATORS = [
@@ -314,6 +316,7 @@
     Imputer: {"method": "mean"},
     HampelFilter: {"window_length": 3},
     OptionalPassthrough: {"transformer": BoxCoxTransformer(), "passthrough": True},
+    ColumnwiseTransformer: {"transformer": Detrender()},
     AggrDist: {"transformer": ScipyDist()},
     PyODAnnotator: {"estimator": ANOMALY_DETECTOR},
 }

sktime/transformations/series/compose.py

@@ -2,9 +2,10 @@
 # -*- coding: utf-8 -*-
 # copyright: sktime developers, BSD-3-Clause License (see LICENSE file)
 
-__author__ = ["Martin Walter"]
-__all__ = ["OptionalPassthrough"]
+__author__ = ["Martin Walter", "Svea Meyer"]
+__all__ = ["OptionalPassthrough", "ColumnwiseTransformer"]
 
+import pandas as pd
 from sktime.transformations.base import _SeriesToSeriesTransformer
 from sktime.utils.validation.series import check_series
 
@@ -96,3 +97,210 @@ def inverse_transform(self, Z, X=None):
         if not self.passthrough:
             z = self.transformer_.inverse_transform(z, X=None)
         return z
+
+
+class ColumnwiseTransformer(_SeriesToSeriesTransformer):
+    """
+    Applies a transformer for univariate series
+    columnwise to multivariate series.
+
+    Parameters
+    ----------
+    transformer : Estimator
+        scikit-learn-like or sktime-like transformer to fit and apply to series
+    columns : list of str
+            Names of columns that are supposed to be transformed
+
+     Attributes
+    ----------
+    transformers_ : dict of {str : transformer}
+        Maps columns to transformers
+
+    Example
+    -------
+    >>> from sktime.datasets import base
+    >>> from sktime.transformations.series.detrend import Detrender
+    >>> from sktime.transformations.series.compose import ColumnwiseTransformer
+
+    >>> y, X = base.load_longley()
+    >>> transformer = ColumnwiseTransformer(Detrender())
+    >>> yt = transformer.fit_transform(X)
+    """
+
+    _required_parameters = ["transformer"]
+
+    def __init__(self, transformer, columns=None):
+        self.transformer = transformer
+        self.columns = columns
+
+        # check that columns are None or list of strings
+        if columns is not None:
+            if not isinstance(columns, list) and all(
+                isinstance(s, str) for s in columns
+            ):
+                raise ValueError("Columns need to be a list of strings or None.")
+
+        self.columns_ = columns
+        self.transformers_ = None
+        super(ColumnwiseTransformer, self).__init__()
+
+    def fit(self, Z, X=None):
+        """
+        Iterates over columns (series) and applies
+        the fit function of the transformer.
+
+        Parameters
+        ----------
+        Z : pd.Series, pd.DataFrame
+
+        Returns
+        -------
+        self : an instance of self
+
+        """
+        z = check_series(Z, allow_numpy=False)
+        self._is_fitted = False
+
+        # univariate case
+        if isinstance(z, pd.Series):
+            z = z.to_frame()
+
+        if self.columns_ is None:
+            self.columns_ = z.columns
+
+        # make sure z contains all columns that the user wants to transform
+        self._check_columns(z)
+
+        self.transformers_ = {}
+        for colname in self.columns_:
+            transformer = clone(self.transformer)
+            self.transformers_[colname] = transformer
+            self.transformers_[colname].fit(z[colname], X)
+        self._is_fitted = True
+        return self
+
+    def transform(self, Z, X=None):
+        """Transform data.
+        Returns a transformed version of Z by iterating over specified
+        columns and applying the univariate series transformer to them.
+
+        Parameters
+        ----------
+        Z : pd.Series, pd.DataFrame
+
+        Returns
+        -------
+        Z : pd.Series, pd.DataFrame
+            Transformed time series(es).
+        """
+        self.check_is_fitted()
+        z = check_series(Z)
+        is_series = False
+
+        # univariate case
+        if isinstance(z, pd.Series):
+            is_series = True
+            name_of_z = z.name
+            z = z.to_frame()
+
+        # make copy of z
+        z = z.copy()
+
+        # make sure z contains all columns that the user wants to transform
+        self._check_columns(z)
+        for colname in self.columns_:
+            # self.columns_ : columns that are supposed to be transformed
+            z[colname] = self.transformers_[colname].transform(z[colname], X)
+
+        # make z a series again in univariate case
+        if is_series:
+            z = self._revert_to_series(name_of_z, z)
+        return z
+
+    @if_delegate_has_method(delegate="transformer")
+    def inverse_transform(self, Z, X=None):
+        """
+        Inverse-transform data.
+
+        Returns an inverse-transformed version of Z by iterating over specified
+        columns and applying the univariate series transformer to them.
+        Only works if self.transformer has an inverse-transform method.
+
+        Parameters
+        ----------
+        Z : pd.Series, pd.DataFrame
+
+        Returns
+        -------
+        Z : pd.Series, pd.DataFrame
+            Inverse-transformed time series(es).
+        """
+        self.check_is_fitted()
+        z = check_series(Z)
+
+        is_series = False
+        # univariate case
+        if isinstance(z, pd.Series):
+            name_of_z = z.name
+            z = z.to_frame()
+            is_series = True
+
+        # make copy of z
+        z = z.copy()
+
+        # make sure z contains all columns that the user wants to transform
+        self._check_columns(z)
+
+        for colname in self.columns_:
+            # self.columns_ : columns that are supposed to be transformed
+            z[colname] = self.transformers_[colname].inverse_transform(z[colname], X)
+        # make z a series again in univariate case
+        if is_series:
+            z = self._revert_to_series(name_of_z, z)
+        return z
+
+    @if_delegate_has_method(delegate="transformer")
+    def update(self, Z, X=None, update_params=True):
+        """
+        Update the parameters of the estimator with new data
+        by iterating over specified columns.
+        Only works if self.transformer has an update method.
+
+        Parameters
+        ----------
+        Z : pd.Series
+            New time series
+        update_params : bool, optional (default=True)
+
+        Returns
+        -------
+        self : an instance of self
+        """
+        z = check_series(Z)
+
+        # univariate case
+        if isinstance(z, pd.Series):
+            z = z.to_frame()
+
+        # make sure z contains all columns that the user wants to transform
+        self._check_columns(z)
+        for colname in self.columns_:
+            # self.columns_ : columns that are supposed to be transformed
+            self.transformers_[colname].update(z[colname], X)
+        return self
+
+    def _check_columns(self, z):
+        # 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.")
+
+    def _revert_to_series(self, name_of_z, z):
+        if name_of_z is not None:
+            z = z[name_of_z]
+        else:
+            z = z[0]
+            z.name = None
+        return z