Add baseline multiseries regressor

docs/source/release_notes.rst

@@ -3,6 +3,7 @@ Release Notes
 **Future Releases**
     * Enhancements
         * Updated regression metrics to handle multioutput dataframes as well as single output series :pr:`4233`
+        * Added baseline regressor for multiseries time series problems :pr:`4246`
         * Added stacking and unstacking utility functions to work with multiseries data :pr:`4250`
     * Fixes
         * Added support for pandas 2 :pr:`4216`

evalml/pipelines/components/__init__.py

@@ -21,6 +21,7 @@
     DecisionTreeClassifier,
     DecisionTreeRegressor,
     TimeSeriesBaselineEstimator,
+    MultiseriesTimeSeriesBaselineRegressor,
     KNeighborsClassifier,
     ProphetRegressor,
     SVMClassifier,

evalml/pipelines/components/component_base.py

@@ -31,6 +31,7 @@ class ComponentBase(ABC, metaclass=ComponentBaseMeta):
     # Referring to the pandas nullable dtypes; not just woodwork logical types
     _integer_nullable_incompatibilities = []
     _boolean_nullable_incompatibilities = []
+    is_multiseries = False
 
     def __init__(self, parameters=None, component_obj=None, random_seed=0, **kwargs):
         """Base class for all components.

evalml/pipelines/components/estimators/__init__.py

@@ -25,6 +25,7 @@
     ExtraTreesRegressor,
     BaselineRegressor,
     TimeSeriesBaselineEstimator,
+    MultiseriesTimeSeriesBaselineRegressor,
     DecisionTreeRegressor,
     SVMRegressor,
     ExponentialSmoothingRegressor,

evalml/pipelines/components/estimators/regressors/__init__.py

@@ -29,6 +29,9 @@
 from evalml.pipelines.components.estimators.regressors.time_series_baseline_estimator import (
     TimeSeriesBaselineEstimator,
 )
+from evalml.pipelines.components.estimators.regressors.multiseries_time_series_baseline_regressor import (
+    MultiseriesTimeSeriesBaselineRegressor,
+)
 from evalml.pipelines.components.estimators.regressors.prophet_regressor import (
     ProphetRegressor,
 )

evalml/pipelines/components/estimators/regressors/multiseries_time_series_baseline_regressor.py

@@ -0,0 +1,112 @@
+"""Time series estimator that predicts using the naive forecasting approach."""
+import numpy as np
+import pandas as pd
+
+from evalml.model_family import ModelFamily
+from evalml.pipelines.components.estimators import Estimator
+from evalml.problem_types import ProblemTypes
+from evalml.utils import infer_feature_types
+
+
+class MultiseriesTimeSeriesBaselineRegressor(Estimator):
+    """Multiseries time series regressor that predicts using the naive forecasting approach.
+
+    This is useful as a simple baseline estimator for multiseries time series problems.
+
+    Args:
+        gap (int): Gap between prediction date and target date and must be a positive integer. If gap is 0, target date will be shifted ahead by 1 time period. Defaults to 1.
+        forecast_horizon (int): Number of time steps the model is expected to predict.
+        random_seed (int): Seed for the random number generator. Defaults to 0.
+    """
+
+    name = "Multiseries Time Series Baseline Regressor"
+    hyperparameter_ranges = {}
+    """{}"""
+    model_family = ModelFamily.BASELINE
+    """ModelFamily.BASELINE"""
+    is_multiseries = True
+    supported_problem_types = [
+        ProblemTypes.TIME_SERIES_REGRESSION,
+    ]
+    """[
+        ProblemTypes.TIME_SERIES_REGRESSION,
+    ]"""
+
+    def __init__(self, gap=1, forecast_horizon=1, random_seed=0, **kwargs):
+        self._prediction_value = None
+        self.start_delay = forecast_horizon + gap
+        self._num_features = None
+
+        if gap < 0:
+            raise ValueError(
+                f"gap value must be a positive integer. {gap} was provided.",
+            )
+
+        parameters = {"gap": gap, "forecast_horizon": forecast_horizon}
+        parameters.update(kwargs)
+        super().__init__(
+            parameters=parameters,
+            component_obj=None,
+            random_seed=random_seed,
+        )
+
+    def fit(self, X, y=None):
+        """Fits multiseries time series baseline regressor to data.
+
+        Args:
+            X (pd.DataFrame): The input training data of shape [n_samples, n_features].
+            y (pd.Series): The target training data of length [n_samples].
+
+        Returns:
+            self
+
+        Raises:
+            ValueError: If input y is None.
+        """
+        if y is None:
+            raise ValueError(
+                "Cannot train Multiseries Time Series Baseline Regressor if y is None",
+            )
+        if isinstance(y, pd.Series):
+            raise ValueError(
+                "y must be a DataFrame with multiple columns for Multiseries Time Series Baseline Regressor",
+            )
+        self._target_column_names = list(y.columns)
+        self._num_features = X.shape[1]
+
+        return self
+
+    def predict(self, X):
+        """Make predictions using fitted multiseries time series baseline regressor.
+
+        Args:
+            X (pd.DataFrame): Data of shape [n_samples, n_features].
+
+        Returns:
+            pd.Series: Predicted values.
+
+        Raises:
+            ValueError: If the lagged columns are not present in X.
+        """
+        X = infer_feature_types(X)
+        feature_names = [
+            f"{col}_delay_{self.start_delay}" for col in self._target_column_names
+        ]
+        if not set(feature_names).issubset(set(X.columns)):
+            raise ValueError(
+                "Multiseries Time Series Baseline Regressor is meant to be used in a pipeline with "
+                "a Time Series Featurizer",
+            )
+        return X.ww[feature_names]
+
+    @property
+    def feature_importance(self):
+        """Returns importance associated with each feature.
+
+        Since baseline estimators do not use input features to calculate predictions, returns an array of zeroes.
+
+        Returns:
+            np.ndarray (float): An array of zeroes.
+        """
+        importance = np.array([0] * self._num_features)
+        return importance

evalml/pipelines/components/transformers/preprocessing/time_series_featurizer.py

@@ -124,12 +124,15 @@ def fit(self, X, y=None):
         """
         if self.time_index is None:
             raise ValueError("time_index cannot be None!")
-        self.statistically_significant_lags = self._find_significant_lags(
-            y,
-            conf_level=self.conf_level,
-            start_delay=self.start_delay,
-            max_delay=self.max_delay,
-        )
+        if isinstance(y, pd.DataFrame):
+            self.statistically_significant_lags = [self.start_delay]
+        else:
+            self.statistically_significant_lags = self._find_significant_lags(
+                y,
+                conf_level=self.conf_level,
+                start_delay=self.start_delay,
+                max_delay=self.max_delay,
+            )
         return self
 
     @staticmethod
@@ -215,6 +218,22 @@ def _compute_rolling_transforms(self, X, y, original_features):
         )
         return data
 
+    def _delay_df(
+        self,
+        data,
+        cols_to_delay,
+        categorical_columns=None,
+        X_categorical=None,
+    ):
+        lagged_features = {}
+        for col_name in cols_to_delay:
+            col = data[col_name]
+            if categorical_columns and col_name in categorical_columns:
+                col = X_categorical[col_name]
+            for t in self.statistically_significant_lags:
+                lagged_features[f"{col_name}_delay_{t}"] = col.shift(t)
+        return lagged_features
+
     def _compute_delays(self, X_ww, y):
         """Computes the delayed features for numeric/categorical features in X and y.
 
@@ -234,33 +253,28 @@ def _compute_delays(self, X_ww, y):
             ).columns,
         )
         categorical_columns = self._get_categorical_columns(X_ww)
-        cols_derived_from_categoricals = []
         lagged_features = {}
         if self.delay_features and len(X_ww) > 0:
             X_categorical = self._encode_X_while_preserving_index(
                 X_ww[categorical_columns],
             )
-            for col_name in cols_to_delay:
-                col = X_ww[col_name]
-                if col_name in categorical_columns:
-                    col = X_categorical[col_name]
-                for t in self.statistically_significant_lags:
-                    feature_name = f"{col_name}_delay_{t}"
-                    lagged_features[f"{col_name}_delay_{t}"] = col.shift(t)
-                    if col_name in categorical_columns:
-                        cols_derived_from_categoricals.append(feature_name)
+            lagged_features.update(
+                self._delay_df(X_ww, cols_to_delay, categorical_columns, X_categorical),
+            )
         # Handle cases where the target was passed in
         if self.delay_target and y is not None:
-            if type(y.ww.logical_type) == logical_types.Categorical:
-                y = self._encode_y_while_preserving_index(y)
-            for t in self.statistically_significant_lags:
-                lagged_features[self.target_colname_prefix.format(t)] = y.shift(t)
+            if isinstance(y, pd.DataFrame):
+                lagged_features.update(self._delay_df(y, y.columns))
+            else:
+                if type(y.ww.logical_type) == logical_types.Categorical:
+                    y = self._encode_y_while_preserving_index(y)
+                for t in self.statistically_significant_lags:
+                    lagged_features[self.target_colname_prefix.format(t)] = y.shift(t)
         # Features created from categorical columns should no longer be categorical
-        lagged_features = pd.DataFrame(lagged_features)
+        lagged_features = pd.DataFrame(lagged_features, index=X_ww.index)
         lagged_features.ww.init(
             logical_types={col: "Double" for col in lagged_features.columns},
         )
-        lagged_features.index = X_ww.index
         return ww.concat_columns([X_ww, lagged_features])
 
     def transform(self, X, y=None):

evalml/tests/component_tests/test_components.py

@@ -40,6 +40,7 @@
     LinearDiscriminantAnalysis,
     LinearRegressor,
     LogisticRegressionClassifier,
+    MultiseriesTimeSeriesBaselineRegressor,
     NaturalLanguageFeaturizer,
     OneHotEncoder,
     Oversampler,
@@ -1015,9 +1016,9 @@ def test_components_can_be_used_for_partial_dependence_fast_mode():
     # Expected number is hardcoded so that this test will fail when new components are added
     # It should be len(all_native_components) - num_invalid_for_pd_fast_mode
     if ProphetRegressor not in all_native_components:
-        expected_num_valid_for_pd_fast_mode = 63
-    else:
         expected_num_valid_for_pd_fast_mode = 64
+    else:
+        expected_num_valid_for_pd_fast_mode = 65
     assert num_valid_for_pd_fast_mode == expected_num_valid_for_pd_fast_mode
 
 
@@ -1210,6 +1211,7 @@ def test_all_estimators_check_fit(
             StackedEnsembleClassifier,
             StackedEnsembleRegressor,
             TimeSeriesBaselineEstimator,
+            MultiseriesTimeSeriesBaselineRegressor,
             VowpalWabbitBinaryClassifier,
             VowpalWabbitMulticlassClassifier,
             VowpalWabbitRegressor,
@@ -1367,6 +1369,9 @@ def test_serialization(
     else:
         X, y = X_y_binary
 
+    if component_class.is_multiseries:
+        y = pd.DataFrame({"target_a": y, "target_b": y})
+
     component.fit(X, y)
 
     for pickle_protocol in range(cloudpickle.DEFAULT_PROTOCOL + 1):
@@ -1740,6 +1745,9 @@ def test_estimator_fit_respects_custom_indices(
     X = pd.DataFrame(X)
     y = pd.Series(y)
 
+    if estimator_class.is_multiseries:
+        y = pd.DataFrame({"target_a": y, "target_b": y})
+
     if use_custom_index and ts_problem:
         X.index = pd.date_range("2020-10-01", periods=40)
         y.index = pd.date_range("2020-10-01", periods=40)
@@ -1915,7 +1923,10 @@ def test_components_support_nullable_types(
     component is added that has nullable type incompatibilities, this should fail."""
     cannot_handle_boolean_target = [CatBoostRegressor]
 
-    if component_class == TimeSeriesBaselineEstimator:
+    if (
+        component_class == TimeSeriesBaselineEstimator
+        or component_class == MultiseriesTimeSeriesBaselineRegressor
+    ):
         pytest.skip(
             "Time Series Baseline Estimator can only be used within a Pipeline.",
         )

evalml/tests/component_tests/test_multiseries_baseline_regressor.py

@@ -0,0 +1,62 @@
+import pandas as pd
+import pytest
+
+from evalml.model_family import ModelFamily
+from evalml.pipelines.components import (
+    MultiseriesTimeSeriesBaselineRegressor,
+    TimeSeriesFeaturizer,
+)
+
+
+def test_multiseries_time_series_baseline_regressor_init():
+    baseline = MultiseriesTimeSeriesBaselineRegressor()
+    assert baseline.model_family == ModelFamily.BASELINE
+    assert baseline.is_multiseries
+    assert baseline.start_delay == 2
+
+    baseline = MultiseriesTimeSeriesBaselineRegressor(gap=2, forecast_horizon=5)
+    assert baseline.start_delay == 7
+
+
+def test_multiseries_time_series_baseline_gap_negative():
+    with pytest.raises(ValueError, match="gap value must be a positive integer."):
+        MultiseriesTimeSeriesBaselineRegressor(gap=-1)
+
+
+def test_multiseries_time_series_baseline_estimator_invalid_y(
+    X_y_multiseries_regression,
+):
+    X, _ = X_y_multiseries_regression
+
+    estimator = MultiseriesTimeSeriesBaselineRegressor(gap=0, forecast_horizon=2)
+
+    with pytest.raises(ValueError, match="if y is None"):
+        estimator.fit(X, None)
+    with pytest.raises(ValueError, match="y must be a DataFrame"):
+        estimator.fit(X, pd.Series(range(100)))
+
+
+def test_multiseries_baseline_no_featurizer(X_y_multiseries_regression):
+    X, y = X_y_multiseries_regression
+
+    estimator = MultiseriesTimeSeriesBaselineRegressor(gap=0, forecast_horizon=2)
+    estimator.fit(X, y)
+
+    with pytest.raises(ValueError, match="is meant to be used in a pipeline with "):
+        estimator.predict(X)
+
+
+def test_multiseries_time_series_baseline_lags(X_y_multiseries_regression):
+    X, y = X_y_multiseries_regression
+
+    feat = TimeSeriesFeaturizer(time_index="index", gap=0, forecast_horizon=2)
+    feat.fit(X, y)
+    X_t = feat.transform(X, y)
+
+    estimator = MultiseriesTimeSeriesBaselineRegressor(gap=0, forecast_horizon=2)
+    estimator.fit(X_t, y)
+
+    pred = estimator.predict(X_t)
+    expected = y.shift(2)
+    expected.columns = [f"{col}_delay_2" for col in expected.columns]
+    pd.testing.assert_frame_equal(pred, expected)

evalml/tests/component_tests/test_time_series_featurizer.py

@@ -981,3 +981,18 @@ def test_delay_feature_transformer_works_for_non_numeric_ordinal_categories(ts_d
     output.fit(X, y)
     X_t = output.transform(X, y)
     assert set(X_t["cats_delay_1"].value_counts().to_dict().keys()) == {2.0, 0.0, 1.0}
+
+
+def test_featurizer_y_dataframe(X_y_multiseries_regression):
+    X, y = X_y_multiseries_regression
+    X.index = pd.date_range("2021-01-01", periods=X.shape[0])
+
+    featurizer = TimeSeriesFeaturizer(time_index="index", gap=1, forecast_horizon=5)
+    featurizer.fit(X, y)
+
+    assert featurizer.statistically_significant_lags == [6]
+
+    expected_y_cols = [f"y_{i}_delay_6" for i in range(y.shape[1])]
+    X_t = featurizer.transform(X, y)
+    for expected_y_col in expected_y_cols:
+        assert expected_y_col in X_t.columns

evalml/tests/component_tests/test_utils.py

@@ -75,6 +75,7 @@
         "Target Imputer",
         "Natural Language Featurizer",
         "Time Series Baseline Estimator",
+        "Multiseries Time Series Baseline Regressor",
         "Time Series Imputer",
         "Time Series Regularizer",
         "URL Featurizer",