autogluon.timeseries 0.8.3b20231024__py3-none-any.whl → 0.8.3b20231027__py3-none-any.whl

autogluon/timeseries/metrics/point.py

@@ -0,0 +1,156 @@
+import logging
+from typing import Optional
+
+import numpy as np
+import pandas as pd
+
+from autogluon.timeseries import TimeSeriesDataFrame
+from autogluon.timeseries.dataset.ts_dataframe import ITEMID
+
+from .abstract import TimeSeriesScorer
+from .utils import _in_sample_abs_seasonal_error, _in_sample_squared_seasonal_error
+
+logger = logging.getLogger(__name__)
+
+
+class RMSE(TimeSeriesScorer):
+    """Root mean squared error."""
+
+    equivalent_tabular_regression_metric = "root_mean_squared_error"
+
+    def compute_metric(
+        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+    ) -> float:
+        y_true, y_pred = self._get_point_forecast_score_inputs(data_future, predictions, target=target)
+        return np.sqrt(self._safemean((y_true - y_pred) ** 2))
+
+
+class MSE(TimeSeriesScorer):
+    """Mean squared error."""
+
+    equivalent_tabular_regression_metric = "mean_squared_error"
+
+    def compute_metric(
+        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+    ) -> float:
+        y_true, y_pred = self._get_point_forecast_score_inputs(data_future, predictions, target=target)
+        return self._safemean((y_true - y_pred) ** 2)
+
+
+class MAE(TimeSeriesScorer):
+    """Mean absolute error."""
+
+    optimized_by_median = True
+    equivalent_tabular_regression_metric = "mean_absolute_error"
+
+    def compute_metric(
+        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+    ) -> float:
+        y_true, y_pred = self._get_point_forecast_score_inputs(data_future, predictions, target=target)
+        return self._safemean((y_true - y_pred).abs())
+
+
+class WAPE(TimeSeriesScorer):
+    """Weighted absolute percentage error."""
+
+    optimized_by_median = True
+    equivalent_tabular_regression_metric = "mean_absolute_error"
+
+    def compute_metric(
+        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+    ) -> float:
+        y_true, y_pred = self._get_point_forecast_score_inputs(data_future, predictions, target=target)
+        return (y_true - y_pred).abs().sum() / y_true.abs().sum()
+
+
+class sMAPE(TimeSeriesScorer):
+    """Symmetric mean absolute percentage error."""
+
+    optimized_by_median = True
+    equivalent_tabular_regression_metric = "symmetric_mean_absolute_percentage_error"
+
+    def compute_metric(
+        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+    ) -> float:
+        y_true, y_pred = self._get_point_forecast_score_inputs(data_future, predictions, target=target)
+        return self._safemean(2 * ((y_true - y_pred).abs() / (y_true.abs() + y_pred.abs())))
+
+
+class MAPE(TimeSeriesScorer):
+    """Mean Absolute Percentage Error."""
+
+    optimized_by_median = True
+    equivalent_tabular_regression_metric = "mean_absolute_percentage_error"
+
+    def compute_metric(
+        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+    ) -> float:
+        y_true, y_pred = self._get_point_forecast_score_inputs(data_future, predictions, target=target)
+        return self._safemean((y_true - y_pred).abs() / y_true.abs())
+
+
+class MASE(TimeSeriesScorer):
+    """Mean absolute scaled error."""
+
+    optimized_by_median = True
+    equivalent_tabular_regression_metric = "mean_absolute_error"
+
+    def __init__(self):
+        self._past_abs_seasonal_error: Optional[pd.Series] = None
+
+    def save_past_metrics(
+        self,
+        data_past: TimeSeriesDataFrame,
+        target: str = "target",
+        seasonal_period: int = 1,
+        **kwargs,
+    ) -> None:
+        self._past_abs_seasonal_error = _in_sample_abs_seasonal_error(
+            y_past=data_past[target], seasonal_period=seasonal_period
+        )
+
+    def clear_past_metrics(self) -> None:
+        self._past_abs_seasonal_error = None
+
+    def compute_metric(
+        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+    ) -> float:
+        y_true, y_pred = self._get_point_forecast_score_inputs(data_future, predictions, target=target)
+        if self._past_abs_seasonal_error is None:
+            raise AssertionError("Call `save_past_metrics` before `compute_metric`")
+
+        mae_per_item = (y_true - y_pred).abs().groupby(level=ITEMID, sort=False).mean()
+        return self._safemean(mae_per_item / self._past_abs_seasonal_error)
+
+
+class RMSSE(TimeSeriesScorer):
+    """Root mean squared scaled error."""
+
+    equivalent_tabular_regression_metric = "root_mean_squared_error"
+
+    def __init__(self):
+        self._past_squared_seasonal_error: Optional[pd.Series] = None
+
+    def save_past_metrics(
+        self,
+        data_past: TimeSeriesDataFrame,
+        target: str = "target",
+        seasonal_period: int = 1,
+        **kwargs,
+    ) -> None:
+        self._past_squared_seasonal_error = _in_sample_squared_seasonal_error(
+            y_past=data_past[target], seasonal_period=seasonal_period
+        )
+
+    def clear_past_metrics(self) -> None:
+        self._past_squared_seasonal_error = None
+
+    def compute_metric(
+        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+    ) -> float:
+        y_true, y_pred = self._get_point_forecast_score_inputs(data_future, predictions, target=target)
+        if self._past_squared_seasonal_error is None:
+            raise AssertionError("Call `save_past_metrics` before `compute_metric`")
+
+        mse_per_item = (y_true - y_pred).pow(2.0).groupby(level=ITEMID, sort=False).mean()
+        return np.sqrt(self._safemean(mse_per_item / self._past_squared_seasonal_error))

autogluon/timeseries/metrics/quantile.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+from autogluon.timeseries import TimeSeriesDataFrame
+
+from .abstract import TimeSeriesScorer
+
+
+class WQL(TimeSeriesScorer):
+    """Weighted quantile loss.
+
+    Also known as weighted pinball loss.
+    """
+
+    needs_quantile = True
+
+    def compute_metric(
+        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+    ) -> float:
+        y_true, q_pred, quantile_levels = self._get_quantile_forecast_score_inputs(data_future, predictions, target)
+        values_true = y_true.values[:, None]  # shape [N, 1]
+        values_pred = q_pred.values  # shape [N, len(quantile_levels)]
+
+        return 2 * np.mean(
+            np.abs((values_true - values_pred) * ((values_true <= values_pred) - quantile_levels)).sum(axis=0)
+            / np.abs(values_true).sum()
+        )

autogluon/timeseries/metrics/utils.py

@@ -0,0 +1,18 @@
+import pandas as pd
+
+from autogluon.timeseries.dataset.ts_dataframe import ITEMID
+
+
+def _get_seasonal_diffs(*, y_past: pd.Series, seasonal_period: int = 1) -> pd.Series:
+    return y_past.groupby(level=ITEMID, sort=False).diff(seasonal_period).abs()
+
+
+def _in_sample_abs_seasonal_error(*, y_past: pd.Series, seasonal_period: int = 1) -> pd.Series:
+    """Compute seasonal naive forecast error (predict value from seasonal_period steps ago) for each time series."""
+    seasonal_diffs = _get_seasonal_diffs(y_past=y_past, seasonal_period=seasonal_period)
+    return seasonal_diffs.groupby(level=ITEMID, sort=False).mean().fillna(1.0)
+
+
+def _in_sample_squared_seasonal_error(*, y_past: pd.Series, seasonal_period: int = 1) -> pd.Series:
+    seasonal_diffs = _get_seasonal_diffs(y_past=y_past, seasonal_period=seasonal_period)
+    return seasonal_diffs.pow(2.0).groupby(level=ITEMID, sort=False).mean().fillna(1.0)

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -11,7 +11,7 @@ from autogluon.core.hpo.exceptions import EmptySearchSpace
 from autogluon.core.hpo.executors import HpoExecutor
 from autogluon.core.models import AbstractModel
 from autogluon.timeseries.dataset import TimeSeriesDataFrame
-from autogluon.timeseries.evaluator import TimeSeriesEvaluator
+from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_metric
 from autogluon.timeseries.utils.features import CovariateMetadata
 
 from .model_trial import model_trial, skip_hpo
@@ -40,16 +40,13 @@ class AbstractTimeSeriesModel(AbstractModel):
     metadata: CovariateMetadata
         A mapping of different covariate types known to autogluon.timeseries to column names
         in the data set.
-    eval_metric : str, default
-        Metric by which predictions will be ultimately evaluated on test data.
-        This only impacts `model.score()`, as eval_metric is not used during training.
-        Available metrics can be found in `autogluon.timeseries.utils.metric_utils.AVAILABLE_METRICS`, and
-        detailed documentation can be found in `gluonts.evaluation.Evaluator`. By default, `WQL`
-        will be used.
+    eval_metric : Union[str, TimeSeriesScorer], default = "WQL"
+        Metric by which predictions will be ultimately evaluated on future test data. This only impacts
+        ``model.score()``, as eval_metric is not used during training. Available metrics can be found in
+        ``autogluon.timeseries.metrics``.
     eval_metric_seasonal_period : int, optional
-        Seasonal period used to compute the mean absolute scaled error (MASE) evaluation metric. This parameter is only
-        used if ``eval_metric="MASE"`. See https://en.wikipedia.org/wiki/Mean_absolute_scaled_error for more details.
-        Defaults to ``None``, in which case the seasonal period is computed based on the data frequency.
+        Seasonal period used to compute some evaluation metrics such as mean absolute scaled error (MASE). Defaults to
+        ``None``, in which case the seasonal period is computed based on the data frequency.
     hyperparameters : dict, default = None
         Hyperparameters that will be used by the model (can be search spaces instead of fixed values).
         If None, model defaults are used. This is identical to passing an empty dictionary.
@@ -82,7 +79,7 @@ class AbstractTimeSeriesModel(AbstractModel):
         path: Optional[str] = None,
         name: Optional[str] = None,
         metadata: Optional[CovariateMetadata] = None,
-        eval_metric: Optional[str] = None,
+        eval_metric: Union[str, TimeSeriesScorer, None] = None,
         eval_metric_seasonal_period: Optional[int] = None,
         hyperparameters: Dict[str, Union[int, float, str, space.Space]] = None,
         **kwargs,
@@ -95,7 +92,7 @@ class AbstractTimeSeriesModel(AbstractModel):
             eval_metric=None,
             hyperparameters=hyperparameters,
         )
-        self.eval_metric: str = TimeSeriesEvaluator.check_get_evaluation_metric(eval_metric)
+        self.eval_metric: TimeSeriesScorer = check_get_evaluation_metric(eval_metric)
         self.eval_metric_seasonal_period = eval_metric_seasonal_period
         self.stopping_metric = None
         self.problem_type = "timeseries"
@@ -106,6 +103,18 @@ class AbstractTimeSeriesModel(AbstractModel):
         self.freq: str = freq
         self.prediction_length: int = prediction_length
         self.quantile_levels = kwargs.get("quantile_levels", [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
+
+        if not all(0 < q < 1 for q in self.quantile_levels):
+            raise ValueError("Invalid quantile_levels specified. Quantiles must be between 0 and 1 (exclusive).")
+
+        # We ensure that P50 forecast is always among the "raw" predictions generated by _predict.
+        # We remove P50 from the final predictions if P50 wasn't present among the specified quantile_levels.
+        if 0.5 not in self.quantile_levels:
+            self.must_drop_median = True
+            self.quantile_levels = sorted(set([0.5] + self.quantile_levels))
+        else:
+            self.must_drop_median = False
+
         self._oof_predictions: Optional[List[TimeSeriesDataFrame]] = None
 
     def __repr__(self) -> str:
@@ -256,22 +265,6 @@ class AbstractTimeSeriesModel(AbstractModel):
                 "as hyperparameters when initializing or use `hyperparameter_tune` instead."
             )
 
-    def _check_predict_inputs(
-        self,
-        data: TimeSeriesDataFrame,
-        quantile_levels: Optional[List[float]] = None,
-        **kwargs,  # noqa: F841
-    ):
-        logger.debug(f"Predicting with time series model {self.name}")
-        logger.debug(
-            f"\tProvided data for prediction with {len(data)} rows, {data.num_items} items. "
-            f"Average time series length is {len(data) / data.num_items:.1f}."
-        )
-
-        quantiles = quantile_levels or self.quantile_levels
-        if not all(0 < q < 1 for q in quantiles):
-            raise ValueError("Invalid quantile value specified. Quantiles must be between 0 and 1 (exclusive).")
-
     def predict(
         self,
         data: Union[TimeSeriesDataFrame, Dict[str, TimeSeriesDataFrame]],
@@ -293,13 +286,6 @@ class AbstractTimeSeriesModel(AbstractModel):
         known_covariates : Optional[TimeSeriesDataFrame]
             A TimeSeriesDataFrame containing the values of the known covariates during the forecast horizon.
 
-        Other Parameters
-        ----------------
-        quantile_levels
-            Quantiles of probabilistic forecasts, if probabilistic forecasts are implemented by the
-            corresponding subclass. If None, `self.quantile_levels` will be used instead,
-            if provided during initialization.
-
         Returns
         -------
         predictions: TimeSeriesDataFrame
@@ -307,6 +293,22 @@ class AbstractTimeSeriesModel(AbstractModel):
             data is given as a separate forecast item in the dictionary, keyed by the `item_id`s
             of input items.
         """
+        predictions = self._predict(data=data, known_covariates=known_covariates, **kwargs)
+        # "0.5" might be missing from the quantiles if self is a wrapper (MultiWindowBacktestingModel or ensemble)
+        if "0.5" in predictions.columns:
+            if self.eval_metric.optimized_by_median:
+                predictions["mean"] = predictions["0.5"]
+            if self.must_drop_median:
+                predictions = predictions.drop("0.5", axis=1)
+        return predictions
+
+    def _predict(
+        self,
+        data: Union[TimeSeriesDataFrame, Dict[str, TimeSeriesDataFrame]],
+        known_covariates: Optional[TimeSeriesDataFrame] = None,
+        **kwargs,
+    ) -> TimeSeriesDataFrame:
+        """Private method for `predict`. See `predict` for documentation of arguments."""
         raise NotImplementedError
 
     def _score_with_predictions(
@@ -316,14 +318,14 @@ class AbstractTimeSeriesModel(AbstractModel):
         metric: Optional[str] = None,
     ) -> float:
         """Compute the score measuring how well the predictions align with the data."""
-        eval_metric = self.eval_metric if metric is None else metric
-        evaluator = TimeSeriesEvaluator(
-            eval_metric=eval_metric,
-            eval_metric_seasonal_period=self.eval_metric_seasonal_period,
+        eval_metric = self.eval_metric if metric is None else check_get_evaluation_metric(metric)
+        return eval_metric.score(
+            data=data,
+            predictions=predictions,
             prediction_length=self.prediction_length,
-            target_column=self.target,
+            target=self.target,
+            seasonal_period=self.eval_metric_seasonal_period,
         )
-        return evaluator(data, predictions) * evaluator.coefficient
 
     def score(self, data: TimeSeriesDataFrame, metric: Optional[str] = None) -> float:
         """Return the evaluation scores for given metric and dataset. The last

autogluon/timeseries/models/abstract/model_trial.py

@@ -80,7 +80,7 @@ def fit_and_save_model(model, fit_kwargs, train_data, val_data, eval_metric, tim
     model.score_and_cache_oof(val_data, store_val_score=True, store_predict_time=True)
 
     logger.debug(f"\tHyperparameter tune run: {model.name}")
-    logger.debug(f"\t\t{model.val_score:<7.4f}".ljust(15) + f"= Validation score ({eval_metric})")
+    logger.debug(f"\t\t{model.val_score:<7.4f}".ljust(15) + f"= Validation score ({eval_metric.name_with_sign})")
     logger.debug(f"\t\t{model.fit_time:<7.3f} s".ljust(15) + "= Training runtime")
     logger.debug(f"\t\t{model.predict_time:<7.3f} s".ljust(15) + "= Training runtime")
     model.save()

autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -174,7 +174,8 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
             data = data.query("item_id in @items_to_keep")
 
         mlforecast_df = self._to_mlforecast_df(data, data.static_features)
-        df = self._mlf.preprocess(mlforecast_df, dropna=False)
+        # Unless we set static_features=[], MLForecast interprets all known covariates as static features
+        df = self._mlf.preprocess(mlforecast_df, dropna=False, static_features=[])
         # df.query results in 2x memory saving compared to df.dropna(subset="y")
         df = df.query("y.notnull()")
 
@@ -251,7 +252,6 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
                 "path": os.path.join(self.path, "tabular_predictor"),
                 "verbosity": verbosity - 2,
                 "label": MLF_TARGET,
-                "eval_metric": self.TIMESERIES_METRIC_TO_TABULAR_METRIC[self.eval_metric],
                 **self._get_extra_tabular_init_kwargs(),
             },
             predictor_fit_kwargs={
@@ -279,14 +279,6 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         else:
             return pd.Series(1.0, index=item_ids)
 
-    def predict(
-        self,
-        data: TimeSeriesDataFrame,
-        known_covariates: Optional[TimeSeriesDataFrame] = None,
-        **kwargs,
-    ) -> TimeSeriesDataFrame:
-        raise NotImplementedError
-
 
 class DirectTabularModel(AbstractMLForecastModel):
     """Predict all future time series values simultaneously using TabularPredictor from AutoGluon-Tabular.
@@ -333,28 +325,9 @@ class DirectTabularModel(AbstractMLForecastModel):
         end of each time series).
     """
 
-    TIMESERIES_METRIC_TO_TABULAR_METRIC = {
-        "MAPE": "mean_absolute_percentage_error",
-        "sMAPE": "symmetric_mean_absolute_percentage_error",
-        "WQL": "pinball_loss",
-        "MASE": "mean_absolute_error",
-        "WAPE": "mean_absolute_error",
-        "MSE": "mean_squared_error",
-        "RMSE": "root_mean_squared_error",
-        "RMSSE": "root_mean_squared_error",
-    }
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        if 0.5 not in self.quantile_levels:
-            self.must_drop_median = True
-            self.quantile_levels = sorted(set([0.5] + self.quantile_levels))
-        else:
-            self.must_drop_median = False
-
     @property
     def is_quantile_model(self) -> bool:
-        return self.eval_metric == "WQL"
+        return self.eval_metric.needs_quantile
 
     def _get_model_params(self) -> dict:
         model_params = super()._get_model_params()
@@ -379,7 +352,7 @@ class DirectTabularModel(AbstractMLForecastModel):
         else:
             return super()._compute_residuals_std(val_df=val_df)
 
-    def predict(
+    def _predict(
         self,
         data: TimeSeriesDataFrame,
         known_covariates: Optional[TimeSeriesDataFrame] = None,
@@ -394,7 +367,7 @@ class DirectTabularModel(AbstractMLForecastModel):
         data_future[self.target] = float("inf")
         data_extended = pd.concat([data, data_future])
         mlforecast_df = self._to_mlforecast_df(data_extended, data.static_features)
-        df = self._mlf.preprocess(mlforecast_df, dropna=False)
+        df = self._mlf.preprocess(mlforecast_df, dropna=False, static_features=[])
         df = df.groupby(MLF_ITEMID, sort=False).tail(self.prediction_length)
         df = df.replace(float("inf"), float("nan"))
 
@@ -404,14 +377,12 @@ class DirectTabularModel(AbstractMLForecastModel):
 
         if hasattr(self._mlf.ts, "target_transforms"):
             # Ensure that transforms are fitted only on past data
-            self._mlf.preprocess(self._to_mlforecast_df(data, None))
+            self._mlf.preprocess(self._to_mlforecast_df(data, None), static_features=[])
             for tfm in self._mlf.ts.target_transforms[::-1]:
                 predictions = tfm.inverse_transform(predictions)
         predictions = predictions.rename(columns={MLF_ITEMID: ITEMID, MLF_TIMESTAMP: TIMESTAMP}).set_index(
             [ITEMID, TIMESTAMP]
         )
-        if self.must_drop_median:
-            predictions = predictions.drop("0.5", axis=1)
         return TimeSeriesDataFrame(predictions)
 
     def _postprocess_predictions(self, predictions: np.ndarray) -> pd.DataFrame:
@@ -429,9 +400,16 @@ class DirectTabularModel(AbstractMLForecastModel):
 
     def _get_extra_tabular_init_kwargs(self) -> dict:
         if self.is_quantile_model:
-            return {"problem_type": ag.constants.QUANTILE, "quantile_levels": self.quantile_levels}
+            return {
+                "problem_type": ag.constants.QUANTILE,
+                "quantile_levels": self.quantile_levels,
+                "eval_metric": "pinball_loss",
+            }
         else:
-            return {"problem_type": ag.constants.REGRESSION}
+            return {
+                "problem_type": ag.constants.REGRESSION,
+                "eval_metric": self.eval_metric.equivalent_tabular_regression_metric or "mean_absolute_error",
+            }
 
 
 class RecursiveTabularModel(AbstractMLForecastModel):
@@ -475,24 +453,13 @@ class RecursiveTabularModel(AbstractMLForecastModel):
         end of each time series).
     """
 
-    TIMESERIES_METRIC_TO_TABULAR_METRIC = {
-        "MAPE": "mean_absolute_percentage_error",
-        "sMAPE": "symmetric_mean_absolute_percentage_error",
-        "WQL": "mean_absolute_error",
-        "MASE": "mean_absolute_error",
-        "WAPE": "mean_absolute_error",
-        "MSE": "mean_squared_error",
-        "RMSE": "root_mean_squared_error",
-        "RMSSE": "root_mean_squared_error",
-    }
-
     def _get_model_params(self) -> dict:
         model_params = super()._get_model_params()
         model_params.setdefault("scaler", "standard")
         model_params.setdefault("differences", [get_seasonality(self.freq)])
         return model_params
 
-    def predict(
+    def _predict(
         self,
         data: TimeSeriesDataFrame,
         known_covariates: Optional[TimeSeriesDataFrame] = None,
@@ -501,15 +468,18 @@ class RecursiveTabularModel(AbstractMLForecastModel):
         from scipy.stats import norm
 
         new_df = self._to_mlforecast_df(data, data.static_features)
-        if known_covariates is not None:
-            dynamic_dfs = [self._to_mlforecast_df(known_covariates, data.static_features, include_target=False)]
-        else:
-            dynamic_dfs = None
+        if known_covariates is None:
+            future_index = get_forecast_horizon_index_ts_dataframe(data, self.prediction_length)
+            known_covariates = pd.DataFrame(columns=[self.target], index=future_index, dtype="float32")
+        X_df = self._to_mlforecast_df(known_covariates, data.static_features, include_target=False)
+        # If both covariates & static features are missing, set X_df = None to avoid exception from MLForecast
+        if len(X_df.columns.difference([MLF_ITEMID, MLF_TIMESTAMP])) == 0:
+            X_df = None
         with warning_filter():
             raw_predictions = self._mlf.predict(
                 h=self.prediction_length,
                 new_df=new_df,
-                dynamic_dfs=dynamic_dfs,
+                X_df=X_df,
             )
         predictions = raw_predictions.rename(columns={MLF_ITEMID: ITEMID, MLF_TIMESTAMP: TIMESTAMP})
 
@@ -526,4 +496,7 @@ class RecursiveTabularModel(AbstractMLForecastModel):
         return TimeSeriesDataFrame(predictions).reindex(data.item_ids, level=ITEMID)
 
     def _get_extra_tabular_init_kwargs(self) -> dict:
-        return {"problem_type": ag.constants.REGRESSION}
+        return {
+            "problem_type": ag.constants.REGRESSION,
+            "eval_metric": self.eval_metric.equivalent_tabular_regression_metric or "mean_absolute_error",
+        }

autogluon/timeseries/models/ensemble/greedy_ensemble.py

@@ -7,8 +7,9 @@ import numpy as np
 import autogluon.core as ag
 from autogluon.core.models.greedy_ensemble.ensemble_selection import EnsembleSelection
 from autogluon.timeseries import TimeSeriesDataFrame
-from autogluon.timeseries.evaluator import TimeSeriesEvaluator
+from autogluon.timeseries.metrics import TimeSeriesScorer
 from autogluon.timeseries.models.ensemble import AbstractTimeSeriesEnsembleModel
+from autogluon.timeseries.utils.datetime import get_seasonality
 
 logger = logging.getLogger(__name__)
 
@@ -17,12 +18,15 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
     def __init__(
         self,
         ensemble_size: int,
-        metric: TimeSeriesEvaluator,
+        metric: TimeSeriesScorer,
         problem_type: str = ag.constants.QUANTILE,
         sorted_initialization: bool = False,
         bagging: bool = False,
         tie_breaker: str = "random",
         random_state: np.random.RandomState = None,
+        prediction_length: int = 1,
+        target: str = "target",
+        eval_metric_seasonal_period: Optional[int] = None,
         **kwargs,
     ):
         super().__init__(
@@ -35,6 +39,9 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
             random_state=random_state,
             **kwargs,
         )
+        self.prediction_length = prediction_length
+        self.target = target
+        self.eval_metric_seasonal_period = eval_metric_seasonal_period
 
     def _fit(
         self,
@@ -47,7 +54,7 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         stacked_predictions = [np.stack(preds) for preds in predictions]
 
         self.dummy_pred_per_window = []
-        self.evaluator_per_window = []
+        self.scorer_per_window = []
         self.data_future_per_window = []
 
         for window_idx, data in enumerate(labels):
@@ -57,12 +64,12 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
 
             self.dummy_pred_per_window.append(dummy_pred)
 
-            evaluator = copy.deepcopy(self.metric)
+            scorer = copy.deepcopy(self.metric)
             # Split the observed time series once to avoid repeated computations inside the evaluator
-            data_past = data.slice_by_timestep(None, -self.metric.prediction_length)
-            data_future = data.slice_by_timestep(-self.metric.prediction_length, None)
-            evaluator.save_past_metrics(data_past)
-            self.evaluator_per_window.append(evaluator)
+            data_past = data.slice_by_timestep(None, -self.prediction_length)
+            data_future = data.slice_by_timestep(-self.prediction_length, None)
+            scorer.save_past_metrics(data_past, target=self.target, seasonal_period=self.eval_metric_seasonal_period)
+            self.scorer_per_window.append(scorer)
             self.data_future_per_window.append(data_future)
 
         super()._fit(
@@ -80,8 +87,11 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         for window_idx, data_future in enumerate(self.data_future_per_window):
             dummy_pred = self.dummy_pred_per_window[window_idx]
             dummy_pred[list(dummy_pred.columns)] = y_pred_proba[window_idx]
-            evaluator = self.evaluator_per_window[window_idx]
-            total_score += evaluator.score_with_saved_past_metrics(data_future, dummy_pred) * metric.coefficient
+            # We use scorer.compute_metric instead of scorer.score to avoid repeated calls to scorer.save_past_metrics
+            metric_value = self.scorer_per_window[window_idx].compute_metric(
+                data_future, dummy_pred, target=self.target
+            )
+            total_score += metric.sign * metric_value
         avg_score = total_score / len(self.data_future_per_window)
         # score: higher is better, regret: lower is better, so we flip the sign
         return -avg_score
@@ -102,13 +112,15 @@ class TimeSeriesGreedyEnsemble(AbstractTimeSeriesEnsembleModel):
         time_limit: Optional[int] = None,
         **kwargs,
     ):
-        evaluator = TimeSeriesEvaluator(
-            eval_metric=self.eval_metric,
-            eval_metric_seasonal_period=self.eval_metric_seasonal_period,
+        if self.eval_metric_seasonal_period is None:
+            self.eval_metric_seasonal_period = get_seasonality(self.freq)
+        ensemble_selection = TimeSeriesEnsembleSelection(
+            ensemble_size=self.ensemble_size,
+            metric=self.eval_metric,
             prediction_length=self.prediction_length,
-            target_column=self.target,
+            target=self.target,
+            eval_metric_seasonal_period=self.eval_metric_seasonal_period,
         )
-        ensemble_selection = TimeSeriesEnsembleSelection(ensemble_size=self.ensemble_size, metric=evaluator)
         ensemble_selection.fit(
             predictions=list(predictions_per_window.values()),
             labels=data_per_window,