[ENH] Add recursive and direct methods to forecasting base class (#2899)

* base class methods

* direct

* recursive

* base

* direct_forecasting

* recursive_forecasting

* recursive_forecasting

* recursive_forecasting

* direct notebook

* direct notebook

* direct notebook

* switch to iterative

* switch to iterative

* iterative

* iterative notebook

* append change

* append change

* fix regression bug

* comment

Author: TonyBagnall

aeon/forecasting/_regression.py

@@ -73,11 +73,11 @@ def _fit(self, y, exog=None):
         X = np.lib.stride_tricks.sliding_window_view(y, window_shape=self.window)
         # Ignore the final horizon values: need to store these for pred with empty y
         X = X[: -self.horizon]
-        # Extract y
-        y = y[self.window + self.horizon - 1 :]
+        # Extract y_train
+        y_train = y[self.window + self.horizon - 1 :]
         self.last_ = y[-self.window :]
         self.last_ = self.last_.reshape(1, -1)
-        self.regressor_.fit(X=X, y=y)
+        self.regressor_.fit(X=X, y=y_train)
         return self
 
     def _predict(self, y=None, exog=None):

aeon/forecasting/base.py

@@ -8,6 +8,7 @@
 __all__ = ["BaseForecaster"]
 
 from abc import abstractmethod
+from typing import final
 
 import numpy as np
 import pandas as pd
@@ -46,6 +47,7 @@ def __init__(self, horizon: int, axis: int):
         self.meta_ = None  # Meta data related to y on the last fit
         super().__init__(axis)
 
+    @final
     def fit(self, y, exog=None):
         """Fit forecaster to series y.
 
@@ -89,6 +91,7 @@ def fit(self, y, exog=None):
     @abstractmethod
     def _fit(self, y, exog=None): ...
 
+    @final
     def predict(self, y=None, exog=None):
         """Predict the next horizon steps ahead.
 
@@ -117,6 +120,7 @@ def predict(self, y=None, exog=None):
     @abstractmethod
     def _predict(self, y=None, exog=None): ...
 
+    @final
     def forecast(self, y, exog=None):
         """Forecast the next horizon steps ahead.
 
@@ -144,6 +148,106 @@ def _forecast(self, y, exog=None):
         self.fit(y, exog)
         return self._predict(y, exog)
 
+    @final
+    def direct_forecast(self, y, prediction_horizon):
+        """
+        Make ``prediction_horizon`` ahead forecasts using a fit for each horizon.
+
+        This is commonly called the direct strategy. The forecaster is trained to
+        predict one ahead, then retrained to fit two ahead etc. Not all forecasters
+        are capable of being used with direct forecasting. The ability to
+        forecast on horizons greater than 1 is indicated by the tag
+        "capability:horizon". If this tag is false this function raises a value
+        error. This method cannot be overridden.
+
+        Parameters
+        ----------
+        y : np.ndarray
+            The time series to make forecasts about.
+        prediction_horizon : int
+            The number of future time steps to forecast.
+
+        predictions : np.ndarray
+            An array of shape `(prediction_horizon,)` containing the forecasts for
+            each horizon.
+
+        Raises
+        ------
+        ValueError
+            if ``"capability:horizon`` is False or `prediction_horizon` less than 1.
+
+        Examples
+        --------
+        >>> from aeon.forecasting import RegressionForecaster
+        >>> y = np.array([1.0, 2.0, 3.0, 4.0, 3.0, 2.0, 1.0, 2.0, 3.0, 4.0])
+        >>> f = RegressionForecaster(window=3)
+        >>> f.direct_forecast(y,2)
+        array([3., 2.])
+        """
+        horizon = self.get_tag("capability:horizon")
+        if not horizon:
+            raise ValueError(
+                "This forecaster cannot be used with the direct strategy "
+                "because it cannot be trained with a horizon > 1."
+            )
+        if prediction_horizon < 1:
+            raise ValueError(
+                "The `prediction_horizon` must be greater than or equal to 1."
+            )
+
+        preds = np.zeros(prediction_horizon)
+        for i in range(0, prediction_horizon):
+            self.horizon = i + 1
+            preds[i] = self.forecast(y)
+        return preds
+
+    def iterative_forecast(self, y, prediction_horizon):
+        """
+        Forecast ``prediction_horizon`` prediction using a single model from `y`.
+
+        This function implements the iterative forecasting strategy (also called
+        recursive or iterated). This involves a single model fit on y which is then
+        used to make ``prediction_horizon`` ahead  using its own predictions as
+        inputs for future forecasts. This is done by taking
+        the prediction at step ``i`` and feeding it back into the model to help
+        predict for step ``i+1``. The basic contract of
+        `iterative_forecast` is that `fit` is only ever called once.
+
+        y : np.ndarray
+            The time series to make forecasts about.
+        prediction_horizon : int
+            The number of future time steps to forecast.
+
+        Returns
+        -------
+        predictions : np.ndarray
+            An array of shape `(prediction_horizon,)` containing the forecasts for
+            each horizon.
+
+        Raises
+        ------
+        ValueError
+            if prediction_horizon` less than 1.
+
+        Examples
+        --------
+        >>> from aeon.forecasting import RegressionForecaster
+        >>> y = np.array([1.0, 2.0, 3.0, 4.0, 3.0, 2.0, 1.0, 2.0, 3.0, 4.0])
+        >>> f = RegressionForecaster(window=3)
+        >>> f.iterative_forecast(y,2)
+        array([3., 2.])
+        """
+        if prediction_horizon < 1:
+            raise ValueError(
+                "The `prediction_horizon` must be greater than or equal to 1."
+            )
+        preds = np.zeros(prediction_horizon)
+        self.fit(y)
+        for i in range(0, prediction_horizon):
+            preds[i] = self.predict(y)
+            y = np.append(y, preds[i])
+        return preds
+
     def _convert_y(self, y: VALID_SERIES_INNER_TYPES, axis: int):
         """Convert y to self.get_tag("y_inner_type")."""
         if axis > 1 or axis < 0:

aeon/forecasting/tests/test_base.py

@@ -4,7 +4,7 @@
 import pandas as pd
 import pytest
 
-from aeon.forecasting import NaiveForecaster
+from aeon.forecasting import NaiveForecaster, RegressionForecaster
 
 
 def test_base_forecaster():
@@ -39,3 +39,29 @@ def test_convert_y():
     f.set_tags(**{"y_inner_type": "pd.Series"})
     with pytest.raises(ValueError, match="Unsupported inner type"):
         f._convert_y(y, axis=1)
+
+
+def test_direct_forecast():
+    """Test direct forecasting."""
+    y = np.random.rand(50)
+    f = RegressionForecaster(window=10)
+    # Direct should be the same as setting horizon manually.
+    preds = f.direct_forecast(y, prediction_horizon=10)
+    assert isinstance(preds, np.ndarray) and len(preds) == 10
+    for i in range(0, 10):
+        f = RegressionForecaster(window=10, horizon=i + 1)
+        p = f.forecast(y)
+        assert p == preds[i]
+
+
+def test_recursive_forecast():
+    """Test recursive forecasting."""
+    y = np.random.rand(50)
+    f = RegressionForecaster(window=4)
+    preds = f.iterative_forecast(y, prediction_horizon=10)
+    assert isinstance(preds, np.ndarray) and len(preds) == 10
+    f.fit(y)
+    for i in range(0, 10):
+        p = f.predict(y)
+        assert p == preds[i]
+        y = np.append(y, p)