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 @@
  """
  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 @@
  )
  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 @@
  ).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 @@
  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",