autogluon.timeseries 1.2.1b20250424__py3-none-any.whl → 1.2.1b20250426__py3-none-any.whl

autogluon/timeseries/dataset/ts_dataframe.py

@@ -8,12 +8,12 @@ from collections.abc import Iterable
 from itertools import islice
 from pathlib import Path
 from pprint import pformat
-from typing import TYPE_CHECKING, Any, List, Optional, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any, List, Optional, Tuple, Type, Union, overload
 
 import pandas as pd
 from joblib.parallel import Parallel, delayed
 from pandas.core.internals import ArrayManager, BlockManager  # type: ignore
-from typing_extensions import Self, overload
+from typing_extensions import Self
 
 from autogluon.common.loaders import load_pd
 
@@ -1044,8 +1044,15 @@ class TimeSeriesDataFrame(pd.DataFrame):
         """Convert `TimeSeriesDataFrame` to a `pandas.DataFrame`"""
         return pd.DataFrame(self)
 
+    # inline typing stubs for various overridden methods
     if TYPE_CHECKING:
 
+        def query(  # type: ignore
+            self, expr: str, *, inplace: bool = False, **kwargs
+        ) -> Self: ...
+
+        def reindex(*args, **kwargs) -> Self: ...  # type: ignore
+
         @overload
         def __new__(cls, data: pd.DataFrame, static_features: Optional[pd.DataFrame] = None) -> Self: ...  # type: ignore
 

autogluon/timeseries/learner.py

@@ -29,15 +29,13 @@ class TimeSeriesLearner(AbstractLearner):
         known_covariates_names: Optional[List[str]] = None,
         trainer_type: Type[TimeSeriesTrainer] = TimeSeriesTrainer,
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
-        eval_metric_seasonal_period: Optional[int] = None,
         prediction_length: int = 1,
         cache_predictions: bool = True,
         ensemble_model_type: Optional[Type] = None,
         **kwargs,
     ):
         super().__init__(path_context=path_context)
-        self.eval_metric: TimeSeriesScorer = check_get_evaluation_metric(eval_metric)
-        self.eval_metric_seasonal_period = eval_metric_seasonal_period
+        self.eval_metric = check_get_evaluation_metric(eval_metric, prediction_length=prediction_length)
         self.trainer_type = trainer_type
         self.target = target
         self.known_covariates_names = [] if known_covariates_names is None else known_covariates_names
@@ -82,7 +80,6 @@ class TimeSeriesLearner(AbstractLearner):
                 path=self.model_context,
                 prediction_length=self.prediction_length,
                 eval_metric=self.eval_metric,
-                eval_metric_seasonal_period=self.eval_metric_seasonal_period,
                 target=self.target,
                 quantile_levels=self.quantile_levels,
                 verbosity=kwargs.get("verbosity", 2),

autogluon/timeseries/metrics/__init__.py

@@ -1,5 +1,7 @@
 from pprint import pformat
-from typing import Type, Union
+from typing import Any, Dict, Optional, Sequence, Type, Union
+
+import numpy as np
 
 from .abstract import TimeSeriesScorer
 from .point import MAE, MAPE, MASE, MSE, RMSE, RMSLE, RMSSE, SMAPE, WAPE, WCD
@@ -22,7 +24,7 @@ __all__ = [
 
 DEFAULT_METRIC_NAME = "WQL"
 
-AVAILABLE_METRICS = {
+AVAILABLE_METRICS: Dict[str, Type[TimeSeriesScorer]] = {
     "MASE": MASE,
     "MAPE": MAPE,
     "SMAPE": SMAPE,
@@ -42,33 +44,59 @@ DEPRECATED_METRICS = {
 }
 
 # Experimental metrics that are not yet user facing
-EXPERIMENTAL_METRICS = {
+EXPERIMENTAL_METRICS: Dict[str, Type[TimeSeriesScorer]] = {
     "WCD": WCD,
 }
 
 
 def check_get_evaluation_metric(
-    eval_metric: Union[str, TimeSeriesScorer, Type[TimeSeriesScorer], None] = None
+    eval_metric: Union[str, TimeSeriesScorer, Type[TimeSeriesScorer], None],
+    prediction_length: int,
+    seasonal_period: Optional[int] = None,
+    horizon_weight: Optional[Sequence[float] | np.ndarray] = None,
 ) -> TimeSeriesScorer:
+    """Factory method for TimeSeriesScorer objects.
+
+    Returns
+    -------
+    scorer :
+        A `TimeSeriesScorer` object based on the provided `eval_metric`.
+
+        `scorer.prediction_length` is always set to the `prediction_length` provided to this method.
+
+        If `seasonal_period` is not `None`, then `scorer.seasonal_period` is set to this value. Otherwise the original
+        value of `seasonal_period` is kept.
+
+        If `horizon_weight` is not `None`, then `scorer.horizon_weight` is set to this value. Otherwise the original
+        value of `horizon_weight` is kept.
+    """
     scorer: TimeSeriesScorer
+    metric_kwargs: Dict[str, Any] = dict(
+        prediction_length=prediction_length, seasonal_period=seasonal_period, horizon_weight=horizon_weight
+    )
     if isinstance(eval_metric, TimeSeriesScorer):
         scorer = eval_metric
+        scorer.prediction_length = prediction_length
+        if seasonal_period is not None:
+            scorer.seasonal_period = seasonal_period
+        if horizon_weight is not None:
+            scorer.horizon_weight = scorer.check_get_horizon_weight(horizon_weight, prediction_length=prediction_length)
     elif isinstance(eval_metric, type) and issubclass(eval_metric, TimeSeriesScorer):
         # e.g., user passed `eval_metric=CustomMetric` instead of `eval_metric=CustomMetric()`
-        scorer = eval_metric()
+        scorer = eval_metric(**metric_kwargs)
     elif isinstance(eval_metric, str):
         metric_name = DEPRECATED_METRICS.get(eval_metric, eval_metric).upper()
         if metric_name in AVAILABLE_METRICS:
-            scorer = AVAILABLE_METRICS[metric_name]()
+            scorer = AVAILABLE_METRICS[metric_name](**metric_kwargs)
         elif metric_name in EXPERIMENTAL_METRICS:
-            scorer = EXPERIMENTAL_METRICS[metric_name]()
+            scorer = EXPERIMENTAL_METRICS[metric_name](**metric_kwargs)
         else:
             raise ValueError(
                 f"Time series metric {eval_metric} not supported. Available metrics are:\n"
                 f"{pformat(sorted(AVAILABLE_METRICS.keys()))}"
             )
     elif eval_metric is None:
-        scorer = AVAILABLE_METRICS[DEFAULT_METRIC_NAME]()
+        scorer = AVAILABLE_METRICS[DEFAULT_METRIC_NAME](**metric_kwargs)
     else:
         raise ValueError(
             f"eval_metric must be of type str, TimeSeriesScorer or None "

autogluon/timeseries/metrics/abstract.py

@@ -1,6 +1,8 @@
-from typing import Optional, Tuple, Union
+import warnings
+from typing import Optional, Sequence, Tuple, Union, overload
 
 import numpy as np
+import numpy.typing as npt
 import pandas as pd
 
 from autogluon.timeseries import TimeSeriesDataFrame
@@ -15,6 +17,18 @@ class TimeSeriesScorer:
 
     Follows the design of ``autogluon.core.metrics.Scorer``.
 
+    Parameters
+    ----------
+    prediction_length : int, default = 1
+        The length of the forecast horizon. The predictions provided to the `TimeSeriesScorer` are expected to contain
+        a forecast for this many time steps for each time series.
+    seasonal_period : int or None, default = None
+        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.
+    horizon_weight : Sequence[float], np.ndarray or None, default = None
+        Weight assigned to each time step in the forecast horizon when computing the metric. If provided, the
+        `horizon_weight` will be stored as a numpy array of shape `[1, prediction_length]`.
+
     Attributes
     ----------
     greater_is_better_internal : bool, default = False
@@ -40,6 +54,18 @@ class TimeSeriesScorer:
     needs_quantile: bool = False
     equivalent_tabular_regression_metric: Optional[str] = None
 
+    def __init__(
+        self,
+        prediction_length: int = 1,
+        seasonal_period: Optional[int] = None,
+        horizon_weight: Optional[Sequence[float]] = None,
+    ):
+        self.prediction_length = int(prediction_length)
+        if self.prediction_length < 1:
+            raise ValueError(f"prediction_length must be >= 1 (received {prediction_length})")
+        self.seasonal_period = seasonal_period
+        self.horizon_weight = self.check_get_horizon_weight(horizon_weight, prediction_length=prediction_length)
+
     @property
     def sign(self) -> int:
         return 1 if self.greater_is_better_internal else -1
@@ -66,18 +92,25 @@ class TimeSeriesScorer:
         self,
         data: TimeSeriesDataFrame,
         predictions: TimeSeriesDataFrame,
-        prediction_length: int = 1,
         target: str = "target",
-        seasonal_period: Optional[int] = None,
         **kwargs,
     ) -> float:
-        seasonal_period = get_seasonality(data.freq) if seasonal_period is None else seasonal_period
+        seasonal_period = get_seasonality(data.freq) if self.seasonal_period is None else self.seasonal_period
+
+        if "prediction_length" in kwargs:
+            warnings.warn(
+                "Passing `prediction_length` to `TimeSeriesScorer.__call__` is deprecated and will be removed in v2.0. "
+                "Please set the `eval_metric.prediction_length` attribute instead.",
+                category=FutureWarning,
+            )
+            self.prediction_length = kwargs["prediction_length"]
+            self.horizon_weight = self.check_get_horizon_weight(self.horizon_weight, self.prediction_length)
 
-        data_past = data.slice_by_timestep(None, -prediction_length)
-        data_future = data.slice_by_timestep(-prediction_length, None)
+        data_past = data.slice_by_timestep(None, -self.prediction_length)
+        data_future = data.slice_by_timestep(-self.prediction_length, None)
 
         assert not predictions.isna().any().any(), "Predictions contain NaN values."
-        assert (predictions.num_timesteps_per_item() == prediction_length).all()
+        assert (predictions.num_timesteps_per_item() == self.prediction_length).all()
         assert data_future.index.equals(predictions.index), "Prediction and data indices do not match."
 
         try:
@@ -200,3 +233,40 @@ class TimeSeriesScorer:
         q_pred = pd.DataFrame(predictions[quantile_columns])
         quantile_levels = np.array(quantile_columns, dtype=float)
         return y_true, q_pred, quantile_levels
+
+    @overload
+    @staticmethod
+    def check_get_horizon_weight(horizon_weight: None, prediction_length: int) -> None: ...
+    @overload
+    @staticmethod
+    def check_get_horizon_weight(
+        horizon_weight: Sequence[float] | np.ndarray, prediction_length: int
+    ) -> npt.NDArray[np.float64]: ...
+
+    @staticmethod
+    def check_get_horizon_weight(
+        horizon_weight: Sequence[float] | np.ndarray | None, prediction_length: int
+    ) -> Optional[npt.NDArray[np.float64]]:
+        """Convert horizon_weight to a non-negative numpy array that sums up to prediction_length.
+        Raises an exception if horizon_weight has an invalid shape or contains invalid values.
+
+        Returns
+        -------
+        horizon_weight:
+            None if the input is None, otherwise a numpy array of shape [1, prediction_length].
+        """
+        if horizon_weight is None:
+            return None
+        horizon_weight_np = np.ravel(horizon_weight).astype(np.float64)
+        if horizon_weight_np.shape != (prediction_length,):
+            raise ValueError(
+                f"horizon_weight must have length equal to {prediction_length=} (got {len(horizon_weight)=})"
+            )
+        if not (horizon_weight_np >= 0).all():
+            raise ValueError(f"All values in horizon_weight must be >= 0 (got {horizon_weight})")
+        if not horizon_weight_np.sum() > 0:
+            raise ValueError(f"At least some values in horizon_weight must be > 0 (got {horizon_weight})")
+        if not np.isfinite(horizon_weight_np).all():
+            raise ValueError(f"All horizon_weight values must be finite (got {horizon_weight})")
+        horizon_weight_np = horizon_weight_np * prediction_length / horizon_weight_np.sum()
+        return horizon_weight_np.reshape([1, prediction_length])

autogluon/timeseries/metrics/point.py

@@ -1,6 +1,6 @@
 import logging
 import warnings
-from typing import Optional
+from typing import Optional, Sequence
 
 import numpy as np
 import pandas as pd
@@ -38,10 +38,18 @@ class RMSE(TimeSeriesScorer):
     equivalent_tabular_regression_metric = "root_mean_squared_error"
 
     def compute_metric(
-        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+        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))
+        y_true, y_pred = y_true.to_numpy(), y_pred.to_numpy()
+        errors = ((y_true - y_pred) ** 2).reshape([-1, self.prediction_length])
+        if self.horizon_weight is not None:
+            errors *= self.horizon_weight
+        return np.sqrt(self._safemean(errors))
 
 
 class MSE(TimeSeriesScorer):
@@ -69,10 +77,18 @@ class MSE(TimeSeriesScorer):
     equivalent_tabular_regression_metric = "mean_squared_error"
 
     def compute_metric(
-        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+        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)
+        y_true, y_pred = y_true.to_numpy(), y_pred.to_numpy()
+        errors = ((y_true - y_pred) ** 2).reshape([-1, self.prediction_length])
+        if self.horizon_weight is not None:
+            errors *= self.horizon_weight
+        return self._safemean(errors)
 
 
 class MAE(TimeSeriesScorer):
@@ -98,10 +114,18 @@ class MAE(TimeSeriesScorer):
     equivalent_tabular_regression_metric = "mean_absolute_error"
 
     def compute_metric(
-        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+        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, y_pred = y_true.to_numpy(), y_pred.to_numpy()
+        errors = np.abs(y_true - y_pred).reshape([-1, self.prediction_length])
+        if self.horizon_weight is not None:
+            errors *= self.horizon_weight
+        return self._safemean(errors)
 
 
 class WAPE(TimeSeriesScorer):
@@ -119,6 +143,7 @@ class WAPE(TimeSeriesScorer):
     - not sensitive to outliers
     - prefers models that accurately estimate the median
 
+    If `self.horizon_weight` is provided, both the errors and the target time series in the denominator will be re-weighted.
 
     References
     ----------
@@ -129,10 +154,19 @@ class WAPE(TimeSeriesScorer):
     equivalent_tabular_regression_metric = "mean_absolute_error"
 
     def compute_metric(
-        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+        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()
+        y_true, y_pred = y_true.to_numpy(), y_pred.to_numpy()
+        errors = np.abs(y_true - y_pred).reshape([-1, self.prediction_length])
+        if self.horizon_weight is not None:
+            errors *= self.horizon_weight
+            y_true = y_true.reshape([-1, self.prediction_length]) * self.horizon_weight
+        return np.nansum(errors) / np.nansum(np.abs(y_true))
 
 
 class SMAPE(TimeSeriesScorer):
@@ -158,10 +192,18 @@ class SMAPE(TimeSeriesScorer):
     equivalent_tabular_regression_metric = "symmetric_mean_absolute_percentage_error"
 
     def compute_metric(
-        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+        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())))
+        y_true, y_pred = y_true.to_numpy(), y_pred.to_numpy()
+        errors = (np.abs(y_true - y_pred) / (np.abs(y_true) + np.abs(y_pred))).reshape([-1, self.prediction_length])
+        if self.horizon_weight is not None:
+            errors *= self.horizon_weight
+        return 2 * self._safemean(errors)
 
 
 class MAPE(TimeSeriesScorer):
@@ -187,10 +229,18 @@ class MAPE(TimeSeriesScorer):
     equivalent_tabular_regression_metric = "mean_absolute_percentage_error"
 
     def compute_metric(
-        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+        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())
+        y_true, y_pred = y_true.to_numpy(), y_pred.to_numpy()
+        errors = (np.abs(y_true - y_pred) / np.abs(y_true)).reshape([-1, self.prediction_length])
+        if self.horizon_weight is not None:
+            errors *= self.horizon_weight
+        return self._safemean(errors)
 
 
 class MASE(TimeSeriesScorer):
@@ -226,7 +276,15 @@ class MASE(TimeSeriesScorer):
     optimized_by_median = True
     equivalent_tabular_regression_metric = "mean_absolute_error"
 
-    def __init__(self):
+    def __init__(
+        self,
+        prediction_length: int = 1,
+        seasonal_period: Optional[int] = None,
+        horizon_weight: Optional[Sequence[float]] = None,
+    ):
+        super().__init__(
+            prediction_length=prediction_length, seasonal_period=seasonal_period, horizon_weight=horizon_weight
+        )
         self._past_abs_seasonal_error: Optional[pd.Series] = None
 
     def save_past_metrics(
@@ -240,16 +298,22 @@ class MASE(TimeSeriesScorer):
         self._past_abs_seasonal_error = None
 
     def compute_metric(
-        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+        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`")
 
-        num_items = len(self._past_abs_seasonal_error)
-        # Reshape abs errors into [num_items, prediction_length] to normalize per item without groupby
-        abs_errors = np.abs(y_true.to_numpy() - y_pred.to_numpy()).reshape([num_items, -1])
-        return self._safemean(abs_errors / self._past_abs_seasonal_error.values[:, None])
+        y_true, y_pred = self._get_point_forecast_score_inputs(data_future, predictions, target=target)
+        y_true, y_pred = y_true.to_numpy(), y_pred.to_numpy()
+
+        errors = np.abs(y_true - y_pred).reshape([-1, self.prediction_length])
+        if self.horizon_weight is not None:
+            errors *= self.horizon_weight
+        return self._safemean(errors / self._past_abs_seasonal_error.to_numpy()[:, None])
 
 
 class RMSSE(TimeSeriesScorer):
@@ -286,7 +350,15 @@ class RMSSE(TimeSeriesScorer):
 
     equivalent_tabular_regression_metric = "root_mean_squared_error"
 
-    def __init__(self):
+    def __init__(
+        self,
+        prediction_length: int = 1,
+        seasonal_period: Optional[int] = None,
+        horizon_weight: Optional[Sequence[float]] = None,
+    ):
+        super().__init__(
+            prediction_length=prediction_length, seasonal_period=seasonal_period, horizon_weight=horizon_weight
+        )
         self._past_squared_seasonal_error: Optional[pd.Series] = None
 
     def save_past_metrics(
@@ -300,16 +372,21 @@ class RMSSE(TimeSeriesScorer):
         self._past_squared_seasonal_error = None
 
     def compute_metric(
-        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+        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`")
 
-        num_items = len(self._past_squared_seasonal_error)
-        # Reshape squared errors into [num_items, prediction_length] to normalize per item without groupby
-        squared_errors = ((y_true.to_numpy() - y_pred.to_numpy()) ** 2.0).reshape([num_items, -1])
-        return np.sqrt(self._safemean(squared_errors / self._past_squared_seasonal_error.values[:, None]))
+        y_true, y_pred = self._get_point_forecast_score_inputs(data_future, predictions, target=target)
+        y_true, y_pred = y_true.to_numpy(), y_pred.to_numpy()
+        errors = ((y_true - y_pred) ** 2).reshape([-1, self.prediction_length])
+        if self.horizon_weight is not None:
+            errors *= self.horizon_weight
+        return np.sqrt(self._safemean(errors / self._past_squared_seasonal_error.to_numpy()[:, None]))
 
 
 class RMSLE(TimeSeriesScorer):
@@ -336,20 +413,26 @@ class RMSLE(TimeSeriesScorer):
     """
 
     def compute_metric(
-        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+        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)
+        y_true, y_pred = y_true.to_numpy(), y_pred.to_numpy()
         y_pred = np.clip(y_pred, a_min=0.0, a_max=None)
 
-        return np.sqrt(np.power(np.log1p(y_pred) - np.log1p(y_true), 2).mean())
+        errors = np.power(np.log1p(y_pred) - np.log1p(y_true), 2).reshape([-1, self.prediction_length])
+        if self.horizon_weight is not None:
+            errors *= self.horizon_weight
+        return np.sqrt(self._safemean(errors))
 
     def __call__(
         self,
         data: TimeSeriesDataFrame,
         predictions: TimeSeriesDataFrame,
-        prediction_length: int = 1,
         target: str = "target",
-        seasonal_period: Optional[int] = None,
         **kwargs,
     ) -> float:
         if (data[target] < 0).any():
@@ -357,9 +440,7 @@ class RMSLE(TimeSeriesScorer):
         return super().__call__(
             data=data,
             predictions=predictions,
-            prediction_length=prediction_length,
             target=target,
-            seasonal_period=seasonal_period,
             **kwargs,
         )
 
@@ -382,35 +463,43 @@ class WCD(TimeSeriesScorer):
     Parameters
     ----------
     alpha : float, default = 0.5
-        Values > 0.5 correspond put a stronger penalty on underpredictions (when cumulative forecast is below the
+        Values > 0.5 put a stronger penalty on underpredictions (when cumulative forecast is below the
         cumulative actual value). Values < 0.5 put a stronger penalty on overpredictions.
     """
 
-    def __init__(self, alpha: float = 0.5):
+    def __init__(
+        self,
+        alpha: float = 0.5,
+        prediction_length: int = 1,
+        seasonal_period: Optional[int] = None,
+        horizon_weight: Optional[Sequence[float]] = None,
+    ):
+        super().__init__(
+            prediction_length=prediction_length, seasonal_period=seasonal_period, horizon_weight=horizon_weight
+        )
         assert 0 < alpha < 1, "alpha must be in (0, 1)"
         self.alpha = alpha
-        self.num_items: Optional[int] = None
         warnings.warn(
             f"{self.name} is an experimental metric. Its behavior may change in the future version of AutoGluon."
         )
 
-    def save_past_metrics(
-        self, data_past: TimeSeriesDataFrame, target: str = "target", seasonal_period: int = 1, **kwargs
-    ) -> None:
-        self.num_items = data_past.num_items
-
     def _fast_cumsum(self, y: np.ndarray) -> np.ndarray:
-        """Compute the cumulative sum for each consecutive `prediction_length` items in the array."""
-        assert self.num_items is not None, "Make sure to call `save_past_metrics` before `compute_metric`"
-        y = y.reshape(self.num_items, -1)
+        """Compute the cumulative sum for each consecutive `self.prediction_length` items in the array."""
+        y = y.reshape(-1, self.prediction_length)
         return np.nancumsum(y, axis=1).ravel()
 
     def compute_metric(
-        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+        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)
         cumsum_true = self._fast_cumsum(y_true.to_numpy())
         cumsum_pred = self._fast_cumsum(y_pred.to_numpy())
         diffs = cumsum_pred - cumsum_true
-        error = diffs * np.where(diffs < 0, -self.alpha, (1 - self.alpha))
-        return 2 * self._safemean(error)
+        errors = (diffs * np.where(diffs < 0, -self.alpha, (1 - self.alpha))).reshape([-1, self.prediction_length])
+        if self.horizon_weight is not None:
+            errors *= self.horizon_weight
+        return 2 * self._safemean(errors)