[ENH] Refactor to set forecast_ in fit and to require y in predict (#2927)

* require y in predict

* forecast_

* remove calls to predict

* doc examples

* regression forecaster rework

* other tests

* docstrings

* refactor forecasting checks

* test

* test

* regression notebook

* test_ets

* Revert "test_ets"

This reverts commit 827a12a.

* Revert "regression notebook"

This reverts commit 2797802.

* ets

* notebook

* naive testing

Author: TonyBagnall

aeon/forecasting/_ets.py

@@ -84,9 +84,7 @@ class ETSForecaster(BaseForecaster):
     ...     error_type='additive', trend_type='multiplicative',
     ...     seasonality_type='multiplicative', seasonal_period=4
     ... )
-    >>> forecaster.fit(y)
-    ETSForecaster(...)
-    >>> forecaster.predict()
+    >>> forecaster.forecast(y)
     366.90200486015596
     """
 
@@ -195,9 +193,21 @@ def _get_int(x):
             self._gamma,
             self.phi,
         )
+        self.forecast_ = _predict(
+            self._trend_type,
+            self._seasonality_type,
+            self.level_,
+            self.trend_,
+            self.seasonality_,
+            self.phi,
+            self.horizon,
+            self.n_timepoints_,
+            self._seasonal_period,
+        )
+
         return self
 
-    def _predict(self, y=None, exog=None):
+    def _predict(self, y, exog=None):
         """
         Predict the next horizon steps ahead.
 
@@ -214,18 +224,7 @@ def _predict(self, y=None, exog=None):
         float
             single prediction self.horizon steps ahead of y.
         """
-        fitted_value = _predict(
-            self._trend_type,
-            self._seasonality_type,
-            self.level_,
-            self.trend_,
-            self.seasonality_,
-            self.phi,
-            self.horizon,
-            self.n_timepoints_,
-            self._seasonal_period,
-        )
-        return fitted_value
+        return self.forecast_
 
     def _initialise(self, data):
         """

aeon/forecasting/_naive.py

@@ -41,39 +41,33 @@ def _fit(self, y, exog=None):
         y_squeezed = y.squeeze()
 
         if self.strategy == "last":
-            self._fitted_scalar_value = y_squeezed[-1]
+            self.forecast_ = y_squeezed[-1]
         elif self.strategy == "mean":
-            self._fitted_scalar_value = np.mean(y_squeezed)
+            self.forecast_ = np.mean(y_squeezed)
         elif self.strategy == "seasonal_last":
-            self._fitted_last_season = y_squeezed[-self.seasonal_period :]
+            season = y_squeezed[-self.seasonal_period :]
+            idx = (self.horizon - 1) % self.seasonal_period
+            self.forecast_ = season[idx]
         else:
             raise ValueError(
                 f"Unknown strategy: {self.strategy}. "
                 "Valid strategies are 'last', 'mean', 'seasonal_last'."
             )
         return self
 
-    def _predict(self, y=None, exog=None):
-        if y is None:
-            if self.strategy == "last" or self.strategy == "mean":
-                return self._fitted_scalar_value
+    def _predict(self, y, exog=None):
+        y_squeezed = y.squeeze()
 
-            # For "seasonal_last" strategy
-            prediction_index = (self.horizon - 1) % self.seasonal_period
-            return self._fitted_last_season[prediction_index]
+        if self.strategy == "last":
+            return y_squeezed[-1]
+        elif self.strategy == "mean":
+            return np.mean(y_squeezed)
+        elif self.strategy == "seasonal_last":
+            period = y_squeezed[-self.seasonal_period :]
+            idx = (self.horizon - 1) % self.seasonal_period
+            return period[idx]
         else:
-            y_squeezed = y.squeeze()
-
-            if self.strategy == "last":
-                return y_squeezed[-1]
-            elif self.strategy == "mean":
-                return np.mean(y_squeezed)
-            elif self.strategy == "seasonal_last":
-                period = y_squeezed[-self.seasonal_period :]
-                idx = (self.horizon - 1) % self.seasonal_period
-                return period[idx]
-            else:
-                raise ValueError(
-                    f"Unknown strategy: {self.strategy}. "
-                    "Valid strategies are 'last', 'mean', 'seasonal_last'."
-                )
+            raise ValueError(
+                f"Unknown strategy: {self.strategy}. "
+                "Valid strategies are 'last', 'mean', 'seasonal_last'."
+            )

aeon/forecasting/_regression.py

@@ -70,9 +70,10 @@ def _fit(self, y, exog=None):
             self.regressor_ = LinearRegression()
         else:
             self.regressor_ = self.regressor
-
+        self._n_exog = 0
         # Combine y and exog for windowing
         if exog is not None:
+            self._n_exog = exog.shape[0]
             if exog.ndim == 1:
                 exog = exog.reshape(1, -1)
             if exog.shape[1] != y.shape[1]:
@@ -96,16 +97,18 @@ def _fit(self, y, exog=None):
         X = X[:, :, :].reshape(X.shape[0], -1)
 
         # Ignore the final horizon values for X
-        X = X[: -self.horizon]
+        X_train = X[: -self.horizon]
 
         # Extract y_train from the original series
         y_train = y.squeeze()[self.window + self.horizon - 1 :]
 
-        self.last_ = combined_data[:, -self.window :]
-        self.regressor_.fit(X=X, y=y_train)
+        self.regressor_.fit(X=X_train, y=y_train)
+
+        last = X[[-1]]
+        self.forecast_ = self.regressor_.predict(last)[0]
         return self
 
-    def _predict(self, y=None, exog=None):
+    def _predict(self, y, exog=None):
         """
         Predict the next horizon steps ahead.
 
@@ -122,26 +125,52 @@ def _predict(self, y=None, exog=None):
         float
             single prediction self.horizon steps ahead of y.
         """
-        if y is None:
-            # Flatten the last window to be compatible with sklearn regressors
-            last_window_flat = self.last_.reshape(1, -1)
-            return self.regressor_.predict(last_window_flat)[0]
-
+        y = y[:, -self.window :]
+        y = y.squeeze()
+        # Test data compliant for regression based
+        if len(y) < self.window:
+            raise ValueError(
+                f" Series passed in predict length = {len(y)} but this "
+                f"RegressionForecaster was trained on window length = "
+                f"{self.window}"
+            )
         # Combine y and exog for prediction
         if exog is not None:
+            if exog.shape[0] != self._n_exog:
+                raise ValueError(
+                    f" Forecaster passed {exog.shape[0]} exogenous variables in "
+                    f"predict but this RegressionForecaster was trained on"
+                    f" {self._n_exog} variables in fit"
+                )
+
             if exog.ndim == 1:
                 exog = exog.reshape(1, -1)
-            if exog.shape[1] != y.shape[1]:
-                raise ValueError("y and exog must have the same number of time points.")
+            if exog.shape[1] < self.window:
+                raise ValueError(
+                    f" Exogenous variables passed in predict of length = {len(y)} but "
+                    f"this RegressionForecaster was trained on window length = "
+                    f"{self.window}"
+                )
+
+            exog = exog[:, -self.window :]
             combined_data = np.vstack([y, exog])
         else:
+            if self._n_exog > 0:
+                raise ValueError(
+                    f" predict passed no exogenous variables, but this "
+                    f"RegressionForecaster was trained on {self._n_exog} exog in fit"
+                )
             combined_data = y
 
         # Extract the last window and flatten for prediction
-        last_window = combined_data[:, -self.window :]
-        last_window_flat = last_window.reshape(1, -1)
+        last_window = combined_data.reshape(1, -1)
+
+        return self.regressor_.predict(last_window)[0]
 
-        return self.regressor_.predict(last_window_flat)[0]
+    def _forecast(self, y, exog=None):
+        """Forecast values for time series X."""
+        self.fit(y, exog)
+        return self.forecast_
 
     @classmethod
     def _get_test_params(cls, parameter_set: str = "default"):

aeon/forecasting/base.py

@@ -96,14 +96,13 @@ def fit(self, y, exog=None):
     def _fit(self, y, exog=None): ...
 
     @final
-    def predict(self, y=None, exog=None):
+    def predict(self, y, exog=None):
         """Predict the next horizon steps ahead.
 
         Parameters
         ----------
-        y : np.ndarray, default = None
-            A time series to predict the next horizon value for. If None,
-            predict the next horizon value after series seen in fit.
+        y : np.ndarray
+            A time series to predict the next horizon value for.
         exog : np.ndarray, default =None
             Optional exogenous time series data assumed to be aligned with y.
 
@@ -113,28 +112,25 @@ def predict(self, y=None, exog=None):
             single prediction self.horizon steps ahead of y.
         """
         self._check_is_fitted()
-        if y is not None:
-            self._check_X(y, self.axis)
-            y = self._convert_y(y, self.axis)
+        self._check_X(y, self.axis)
+        y = self._convert_y(y, self.axis)
         if exog is not None:
             exog = self._convert_y(exog, self.axis)
-
         return self._predict(y, exog)
 
     @abstractmethod
-    def _predict(self, y=None, exog=None): ...
+    def _predict(self, y, exog=None): ...
 
     @final
     def forecast(self, y, exog=None):
-        """Forecast the next horizon steps ahead.
+        """Forecast the next horizon steps ahead of ``y``.
 
-        By default this is simply fit followed by predict.
+        By default this is simply fit followed by returning forecast_.
 
         Parameters
         ----------
-        y : np.ndarray, default = None
-            A time series to predict the next horizon value for. If None,
-            predict the next horizon value after series seen in fit.
+        y : np.ndarray
+            A time series to predict the next horizon value for.
         exog : np.ndarray, default =None
             Optional exogenous time series data assumed to be aligned with y.
 
@@ -150,9 +146,9 @@ def forecast(self, y, exog=None):
         return self._forecast(y, exog)
 
     def _forecast(self, y, exog=None):
-        """Forecast values for time series X."""
+        """Forecast horizon steps ahead for time series ``y``."""
         self.fit(y, exog)
-        return self._predict(y, exog)
+        return self.forecast_
 
     @final
     def direct_forecast(self, y, prediction_horizon, exog=None):
@@ -174,7 +170,10 @@ def direct_forecast(self, y, prediction_horizon, exog=None):
             The number of future time steps to forecast.
         exog : np.ndarray, default =None
             Optional exogenous time series data assumed to be aligned with y.
-        predictions : np.ndarray
+
+        Returns
+        -------
+        np.ndarray
             An array of shape `(prediction_horizon,)` containing the forecasts for
             each horizon.
 
@@ -210,15 +209,15 @@ def direct_forecast(self, y, prediction_horizon, exog=None):
 
     def iterative_forecast(self, y, prediction_horizon):
         """
-        Forecast ``prediction_horizon`` prediction using a single model from `y`.
+        Forecast ``prediction_horizon`` prediction using a single model fit on `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.
+        recursive or iterated). This involves a single model fit on ``y`` which is then
+        used to make ``prediction_horizon`` ahead forecasts 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.
@@ -227,7 +226,7 @@ def iterative_forecast(self, y, prediction_horizon):
 
         Returns
         -------
-        predictions : np.ndarray
+        np.ndarray
             An array of shape `(prediction_horizon,)` containing the forecasts for
             each horizon.
 

aeon/forecasting/tests/test_base.py

@@ -4,15 +4,15 @@
 import pandas as pd
 import pytest
 
-from aeon.forecasting import NaiveForecaster, RegressionForecaster
+from aeon.forecasting import BaseForecaster, NaiveForecaster, RegressionForecaster
 
 
 def test_base_forecaster():
     """Test base forecaster functionality."""
     f = NaiveForecaster()
     y = np.random.rand(50)
     f.fit(y)
-    p1 = f.predict()
+    p1 = f.predict(y)
     assert p1 == y[-1]
     p2 = f.forecast(y)
     p3 = f._forecast(y)
@@ -54,8 +54,8 @@ def test_direct_forecast():
         assert p == preds[i]
 
 
-def test_recursive_forecast():
-    """Test recursive forecasting."""
+def test_iterative_forecast():
+    """Test iterative forecasting."""
     y = np.random.rand(50)
     f = RegressionForecaster(window=4)
     preds = f.iterative_forecast(y, prediction_horizon=10)
@@ -79,3 +79,21 @@ def test_direct_forecast_with_exog():
     # Check that predictions are different from when no exog is used
     preds_no_exog = f.direct_forecast(y, prediction_horizon=10)
     assert not np.array_equal(preds, preds_no_exog)
+
+
+def test_fit_is_empty():
+    """Test empty fit."""
+
+    class _EmptyFit(BaseForecaster):
+        _tags = {"fit_is_empty": True}
+
+        def _fit(self, y):
+            return self
+
+        def _predict(self, y):
+            return 0
+
+    dummy = _EmptyFit(horizon=1, axis=1)
+    y = np.arange(50)
+    dummy.fit(y)
+    assert dummy.is_fitted