autogluon.timeseries 1.2.1b20250420__py3-none-any.whl → 1.2.1b20250422__py3-none-any.whl

autogluon/timeseries/learner.py

@@ -3,6 +3,7 @@ import reprlib
 import time
 from typing import Any, Dict, List, Literal, Optional, Type, Union
 
+import numpy as np
 import pandas as pd
 
 from autogluon.core.learner import AbstractLearner
@@ -30,6 +31,7 @@ class TimeSeriesLearner(AbstractLearner):
         trainer_type: Type[TimeSeriesTrainer] = TimeSeriesTrainer,
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
         eval_metric_seasonal_period: Optional[int] = None,
+        horizon_weight: Optional[np.ndarray] = None,
         prediction_length: int = 1,
         cache_predictions: bool = True,
         ensemble_model_type: Optional[Type] = None,
@@ -38,6 +40,7 @@ class TimeSeriesLearner(AbstractLearner):
         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.horizon_weight = horizon_weight
         self.trainer_type = trainer_type
         self.target = target
         self.known_covariates_names = [] if known_covariates_names is None else known_covariates_names
@@ -83,6 +86,7 @@ class TimeSeriesLearner(AbstractLearner):
                 prediction_length=self.prediction_length,
                 eval_metric=self.eval_metric,
                 eval_metric_seasonal_period=self.eval_metric_seasonal_period,
+                horizon_weight=self.horizon_weight,
                 target=self.target,
                 quantile_levels=self.quantile_levels,
                 verbosity=kwargs.get("verbosity", 2),

autogluon/timeseries/metrics/__init__.py

@@ -1,5 +1,8 @@
 from pprint import pformat
-from typing import Type, Union
+from typing import Optional, Type, Union, overload
+
+import numpy as np
+import numpy.typing as npt
 
 from .abstract import TimeSeriesScorer
 from .point import MAE, MAPE, MASE, MSE, RMSE, RMSLE, RMSSE, SMAPE, WAPE, WCD
@@ -75,3 +78,29 @@ def check_get_evaluation_metric(
             f"(received eval_metric = {eval_metric} of type {type(eval_metric)})"
         )
     return scorer
+
+@overload
+def check_get_horizon_weight(horizon_weight: None, prediction_length: int) -> None: ...
+@overload
+def check_get_horizon_weight(horizon_weight: list[float], prediction_length: int) -> np.ndarray: ...
+
+def check_get_horizon_weight(horizon_weight: list[float] | None, prediction_length: int) -> Optional[np.ndarray]:
+    """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.
+    """
+    if horizon_weight is None:
+        return None
+    horizon_weight_np = np.array(list(horizon_weight), dtype=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

autogluon/timeseries/metrics/abstract.py

@@ -69,6 +69,7 @@ class TimeSeriesScorer:
         prediction_length: int = 1,
         target: str = "target",
         seasonal_period: Optional[int] = None,
+        horizon_weight: Optional[np.ndarray] = None,
         **kwargs,
     ) -> float:
         seasonal_period = get_seasonality(data.freq) if seasonal_period is None else seasonal_period
@@ -92,6 +93,8 @@ class TimeSeriesScorer:
                     data_future=data_future,
                     predictions=predictions,
                     target=target,
+                    prediction_length=prediction_length,
+                    horizon_weight=horizon_weight,
                     **kwargs,
                 )
         finally:
@@ -105,6 +108,8 @@ class TimeSeriesScorer:
         data_future: TimeSeriesDataFrame,
         predictions: TimeSeriesDataFrame,
         target: str = "target",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
         **kwargs,
     ) -> float:
         """Internal method that computes the metric for given forecast & actual data.
@@ -121,6 +126,11 @@ class TimeSeriesScorer:
             columns corresponding to each of the quantile levels. Must have the same index as ``data_future``.
         target : str, default = "target"
             Name of the column in ``data_future`` that contains the target time series.
+        prediction_length : int, default = 1
+            Length of the forecast horizon in time steps.
+        horizon_weight : np.ndarray, optional
+            Weight assigned to each time step in the forecast horizon when computing the metric. If provided, this list
+            must contain `prediction_length` non-negative values, with `sum(horizon_weight) = prediction_length`.
 
         Returns
         -------

autogluon/timeseries/metrics/point.py

@@ -38,10 +38,20 @@ 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",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
+        **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, prediction_length])
+        if horizon_weight is not None:
+            errors *= horizon_weight.reshape([1, prediction_length])
+        return np.sqrt(self._safemean(errors))
 
 
 class MSE(TimeSeriesScorer):
@@ -69,10 +79,20 @@ 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",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
+        **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, prediction_length])
+        if horizon_weight is not None:
+            errors *= horizon_weight.reshape([1, prediction_length])
+        return self._safemean(errors)
 
 
 class MAE(TimeSeriesScorer):
@@ -98,10 +118,20 @@ 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",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
+        **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, prediction_length])
+        if horizon_weight is not None:
+            errors *= horizon_weight.reshape([1, prediction_length])
+        return self._safemean(errors)
 
 
 class WAPE(TimeSeriesScorer):
@@ -119,6 +149,7 @@ class WAPE(TimeSeriesScorer):
     - not sensitive to outliers
     - prefers models that accurately estimate the median
 
+    If `horizon_weight` is provided, both the errors and the target time series in the denominator will be re-weighted.
 
     References
     ----------
@@ -129,10 +160,21 @@ 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",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
+        **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, prediction_length])
+        if horizon_weight is not None:
+            errors *= horizon_weight.reshape([1, prediction_length])
+            y_true = y_true.reshape([-1, prediction_length]) * horizon_weight.reshape([1, prediction_length])
+        return np.nansum(errors) / np.nansum(np.abs(y_true))
 
 
 class SMAPE(TimeSeriesScorer):
@@ -158,10 +200,20 @@ 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",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
+        **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, prediction_length])
+        if horizon_weight is not None:
+            errors *= horizon_weight.reshape([1, prediction_length])
+        return 2 * self._safemean(errors)
 
 
 class MAPE(TimeSeriesScorer):
@@ -187,10 +239,20 @@ 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",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
+        **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, prediction_length])
+        if horizon_weight is not None:
+            errors *= horizon_weight.reshape([1, prediction_length])
+        return self._safemean(errors)
 
 
 class MASE(TimeSeriesScorer):
@@ -240,16 +302,24 @@ 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",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
+        **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, prediction_length])
+        if horizon_weight is not None:
+            errors *= horizon_weight.reshape([1, prediction_length])
+        return self._safemean(errors / self._past_abs_seasonal_error.to_numpy()[:, None])
 
 
 class RMSSE(TimeSeriesScorer):
@@ -300,16 +370,23 @@ 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",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
+        **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, prediction_length])
+        if horizon_weight is not None:
+            errors *= horizon_weight.reshape([1, prediction_length])
+        return np.sqrt(self._safemean(errors / self._past_squared_seasonal_error.to_numpy()[:, None]))
 
 
 class RMSLE(TimeSeriesScorer):
@@ -336,12 +413,22 @@ 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",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
+        **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, prediction_length])
+        if horizon_weight is not None:
+            errors *= horizon_weight.reshape([1, prediction_length])
+        return np.sqrt(self._safemean(errors))
 
     def __call__(
         self,
@@ -350,6 +437,7 @@ class RMSLE(TimeSeriesScorer):
         prediction_length: int = 1,
         target: str = "target",
         seasonal_period: Optional[int] = None,
+        horizon_weight: Optional[np.ndarray] = None,
         **kwargs,
     ) -> float:
         if (data[target] < 0).any():
@@ -360,6 +448,7 @@ class RMSLE(TimeSeriesScorer):
             prediction_length=prediction_length,
             target=target,
             seasonal_period=seasonal_period,
+            horizon_weight=horizon_weight,
             **kwargs,
         )
 
@@ -382,35 +471,36 @@ 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):
         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:
+    def _fast_cumsum(self, y: np.ndarray, prediction_length: int) -> 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)
+        y = y.reshape(-1, 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",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
+        **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())
+        cumsum_true = self._fast_cumsum(y_true.to_numpy(), prediction_length=prediction_length)
+        cumsum_pred = self._fast_cumsum(y_pred.to_numpy(), prediction_length=prediction_length)
         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, prediction_length])
+        if horizon_weight is not None:
+            errors *= horizon_weight.reshape([1, prediction_length])
+        return 2 * self._safemean(errors)

autogluon/timeseries/metrics/quantile.py

@@ -25,6 +25,7 @@ class WQL(TimeSeriesScorer):
     - scale-dependent (time series with large absolute value contribute more to the loss)
     - equivalent to WAPE if ``quantile_levels = [0.5]``
 
+    If `horizon_weight` is provided, both the errors and the target time series in the denominator will be re-weighted.
 
     References
     ----------
@@ -34,16 +35,27 @@ class WQL(TimeSeriesScorer):
     needs_quantile = True
 
     def compute_metric(
-        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+        self,
+        data_future: TimeSeriesDataFrame,
+        predictions: TimeSeriesDataFrame,
+        target: str = "target",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
+        **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)]
+        y_true = y_true.to_numpy()[:, None]  # shape [N, 1]
+        q_pred = q_pred.to_numpy()  # shape [N, len(quantile_levels)]
 
-        return 2 * np.mean(
-            np.nansum(np.abs((values_true - values_pred) * ((values_true <= values_pred) - quantile_levels)), axis=0)
-            / np.nansum(np.abs(values_true))
+        errors = (
+            np.abs((q_pred - y_true) * ((y_true <= q_pred) - quantile_levels))
+            .mean(axis=1)
+            .reshape([-1, prediction_length])
         )
+        if horizon_weight is not None:
+            errors *= horizon_weight.reshape([1, prediction_length])
+            y_true = y_true.reshape([-1, prediction_length]) * horizon_weight.reshape([1, prediction_length])
+        return 2 * np.nansum(errors) / np.nansum(np.abs(y_true))
 
 
 class SQL(TimeSeriesScorer):
@@ -93,17 +105,26 @@ class SQL(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",
+        prediction_length: int = 1,
+        horizon_weight: Optional[np.ndarray] = None,
+        **kwargs,
     ) -> float:
         if self._past_abs_seasonal_error is None:
             raise AssertionError("Call `save_past_metrics` before `compute_metric`")
 
         y_true, q_pred, quantile_levels = self._get_quantile_forecast_score_inputs(data_future, predictions, target)
-        q_pred = q_pred.values
-        values_true = y_true.values[:, None]  # shape [N, 1]
-
-        ql = np.abs((q_pred - values_true) * ((values_true <= q_pred) - quantile_levels)).mean(axis=1)
-        num_items = len(self._past_abs_seasonal_error)
-        # Reshape quantile losses values into [num_items, prediction_length] to normalize per item without groupby
-        quantile_losses = ql.reshape([num_items, -1])
-        return 2 * self._safemean(quantile_losses / self._past_abs_seasonal_error.values[:, None])
+        q_pred = q_pred.to_numpy()
+        y_true = y_true.to_numpy()[:, None]  # shape [N, 1]
+
+        errors = (
+            np.abs((q_pred - y_true) * ((y_true <= q_pred) - quantile_levels))
+            .mean(axis=1)
+            .reshape([-1, prediction_length])
+        )
+        if horizon_weight is not None:
+            errors *= horizon_weight.reshape([1, prediction_length])
+        return 2 * self._safemean(errors / self._past_abs_seasonal_error.to_numpy()[:, None])

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -8,6 +8,7 @@ import time
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
+import numpy as np
 import pandas as pd
 from typing_extensions import Self
 
@@ -59,6 +60,9 @@ class TimeSeriesModelBase(ModelBase, ABC):
     eval_metric_seasonal_period : int, optional
         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 : np.ndarray, optional
+        Weight assigned to each time step in the forecast horizon when computing the metric. If provided, this list
+        must contain `prediction_length` non-negative values, with `sum(horizon_weight) = prediction_length`.
     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.
@@ -88,6 +92,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         quantile_levels: Sequence[float] = (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9),
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
         eval_metric_seasonal_period: Optional[int] = None,
+        horizon_weight: Optional[np.ndarray] = None,
     ):
         self.name = name or re.sub(r"Model$", "", self.__class__.__name__)
 
@@ -104,6 +109,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
 
         self.eval_metric: TimeSeriesScorer = check_get_evaluation_metric(eval_metric)
         self.eval_metric_seasonal_period = eval_metric_seasonal_period
+        self.horizon_weight = horizon_weight
         self.target: str = target
         self.covariate_metadata = covariate_metadata or CovariateMetadata()
 
@@ -322,6 +328,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
             prediction_length=self.prediction_length,
             target=self.target,
             seasonal_period=self.eval_metric_seasonal_period,
+            horizon_weight=self.horizon_weight,
         )
 
     def score(self, data: TimeSeriesDataFrame, metric: Optional[str] = None) -> float:  # type: ignore

autogluon/timeseries/models/ensemble/greedy_ensemble.py

@@ -28,6 +28,7 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         prediction_length: int = 1,
         target: str = "target",
         eval_metric_seasonal_period: Optional[int] = None,
+        horizon_weight: Optional[np.ndarray] = None,
         **kwargs,
     ):
         super().__init__(
@@ -43,6 +44,7 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         self.prediction_length = prediction_length
         self.target = target
         self.eval_metric_seasonal_period = eval_metric_seasonal_period
+        self.horizon_weight = horizon_weight
 
     def _fit(
         self,
@@ -90,7 +92,11 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
             dummy_pred[list(dummy_pred.columns)] = y_pred_proba[window_idx]
             # 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
+                data_future,
+                dummy_pred,
+                target=self.target,
+                prediction_length=self.prediction_length,
+                horizon_weight=self.horizon_weight,
             )
             total_score += metric.sign * metric_value
         avg_score = total_score / len(self.data_future_per_window)
@@ -123,6 +129,7 @@ class TimeSeriesGreedyEnsemble(AbstractTimeSeriesEnsembleModel):
             prediction_length=self.prediction_length,
             target=self.target,
             eval_metric_seasonal_period=self.eval_metric_seasonal_period,
+            horizon_weight=self.horizon_weight,
         )
         ensemble_selection.fit(
             predictions=list(predictions_per_window.values()),

autogluon/timeseries/models/presets.py

@@ -4,6 +4,8 @@ import re
 from collections import defaultdict
 from typing import Any, Dict, List, Optional, Type, Union
 
+import numpy as np
+
 from autogluon.common import space
 from autogluon.core import constants
 from autogluon.timeseries.metrics import TimeSeriesScorer
@@ -184,6 +186,7 @@ def get_preset_models(
     path: str,
     eval_metric: Union[str, TimeSeriesScorer],
     eval_metric_seasonal_period: Optional[int],
+    horizon_weight: Optional[np.ndarray],
     hyperparameters: Union[str, Dict, None],
     hyperparameter_tune: bool,
     covariate_metadata: CovariateMetadata,
@@ -262,6 +265,7 @@ def get_preset_models(
                 eval_metric=eval_metric,
                 eval_metric_seasonal_period=eval_metric_seasonal_period,
                 covariate_metadata=covariate_metadata,
+                horizon_weight=horizon_weight,
                 hyperparameters=model_hps,
                 **kwargs,
             )

autogluon/timeseries/predictor.py

@@ -24,7 +24,7 @@ from autogluon.timeseries import __version__ as current_ag_version
 from autogluon.timeseries.configs import TIMESERIES_PRESETS_CONFIGS
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
 from autogluon.timeseries.learner import TimeSeriesLearner
-from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_metric
+from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_metric, check_get_horizon_weight
 from autogluon.timeseries.splitter import ExpandingWindowSplitter
 from autogluon.timeseries.trainer import TimeSeriesTrainer
 from autogluon.timeseries.utils.forecast import make_future_data_frame
@@ -93,6 +93,14 @@ class TimeSeriesPredictor:
     eval_metric_seasonal_period : int, optional
         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 : List[float], optional
+        Weight assigned to each time step in the forecast horizon when computing the `eval_metric`. If provided, this
+        must be a list with `prediction_length` non-negative values, where at least some values are greater than zero.
+        AutoGluon will automatically normalize the weights so that they sum up to `prediction_length`. By default, all
+        time steps in the forecast horizon have the same weight, which is equivalent to setting `horizon_weight = [1] * prediction_length`.
+
+        This parameter only affects model selection and ensemble construction; it has no effect on the loss function of
+        the individual forecasting models.
     known_covariates_names: List[str], optional
         Names of the covariates that are known in advance for all time steps in the forecast horizon. These are also
         known as dynamic features, exogenous variables, additional regressors or related time series. Examples of such
@@ -144,6 +152,7 @@ class TimeSeriesPredictor:
         freq: Optional[str] = None,
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
         eval_metric_seasonal_period: Optional[int] = None,
+        horizon_weight: list[float] | None = None,
         path: Optional[Union[str, Path]] = None,
         verbosity: int = 2,
         log_to_file: bool = True,
@@ -189,6 +198,7 @@ class TimeSeriesPredictor:
             self.freq = std_freq
         self.eval_metric = check_get_evaluation_metric(eval_metric)
         self.eval_metric_seasonal_period = eval_metric_seasonal_period
+        self.horizon_weight = check_get_horizon_weight(horizon_weight, prediction_length=self.prediction_length)
         if quantile_levels is None:
             quantile_levels = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
         self.quantile_levels = sorted(quantile_levels)
@@ -196,6 +206,7 @@ class TimeSeriesPredictor:
             path_context=self.path,
             eval_metric=eval_metric,
             eval_metric_seasonal_period=eval_metric_seasonal_period,
+            horizon_weight=self.horizon_weight,
             target=self.target,
             known_covariates_names=self.known_covariates_names,
             prediction_length=self.prediction_length,

autogluon/timeseries/trainer.py

@@ -47,6 +47,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
         prediction_length: int = 1,
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
         eval_metric_seasonal_period: Optional[int] = None,
+        horizon_weight: Optional[np.ndarray] = None,
         save_data: bool = True,
         skip_model_selection: bool = False,
         enable_ensemble: bool = True,
@@ -88,6 +89,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
 
         self.eval_metric: TimeSeriesScorer = check_get_evaluation_metric(eval_metric)
         self.eval_metric_seasonal_period = eval_metric_seasonal_period
+        self.horizon_weight = horizon_weight
         if val_splitter is None:
             val_splitter = ExpandingWindowSplitter(prediction_length=self.prediction_length)
         assert isinstance(val_splitter, AbstractWindowSplitter), "val_splitter must be of type AbstractWindowSplitter"
@@ -571,6 +573,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
             name=self._get_ensemble_model_name(),
             eval_metric=self.eval_metric,
             eval_metric_seasonal_period=self.eval_metric_seasonal_period,
+            horizon_weight=self.horizon_weight,
             target=self.target,
             prediction_length=self.prediction_length,
             path=self.path,
@@ -793,6 +796,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
             prediction_length=self.prediction_length,
             target=self.target,
             seasonal_period=self.eval_metric_seasonal_period,
+            horizon_weight=self.horizon_weight,
         )
 
     def score(
@@ -1254,6 +1258,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
             path=self.path,
             eval_metric=self.eval_metric,
             eval_metric_seasonal_period=self.eval_metric_seasonal_period,
+            horizon_weight=self.horizon_weight,
             prediction_length=self.prediction_length,
             freq=freq,
             hyperparameters=hyperparameters,

autogluon/timeseries/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.2.1b20250420"
+__version__ = "1.2.1b20250422"
 __lite__ = False

{autogluon.timeseries-1.2.1b20250420.dist-info → autogluon.timeseries-1.2.1b20250422.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.2.1b20250420
+Version: 1.2.1b20250422
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -55,9 +55,9 @@ Requires-Dist: fugue>=0.9.0
 Requires-Dist: tqdm<5,>=4.38
 Requires-Dist: orjson~=3.9
 Requires-Dist: tensorboard<3,>=2.9
-Requires-Dist: autogluon.core[raytune]==1.2.1b20250420
-Requires-Dist: autogluon.common==1.2.1b20250420
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250420
+Requires-Dist: autogluon.core[raytune]==1.2.1b20250422
+Requires-Dist: autogluon.common==1.2.1b20250422
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250422
 Provides-Extra: all
 Provides-Extra: chronos-onnx
 Requires-Dist: optimum[onnxruntime]<1.23,>=1.17; extra == "chronos-onnx"

{autogluon.timeseries-1.2.1b20250420.dist-info → autogluon.timeseries-1.2.1b20250422.dist-info}/RECORD

@@ -1,25 +1,25 @@
-autogluon.timeseries-1.2.1b20250420-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.2.1b20250422-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
 autogluon/timeseries/__init__.py,sha256=_CrLLc1fkjen7UzWoO0Os8WZoHOgvZbHKy46I8v_4k4,304
 autogluon/timeseries/evaluator.py,sha256=l642tYfTHsl8WVIq_vV6qhgAFVFr9UuZD7gLra3A_Kc,250
-autogluon/timeseries/learner.py,sha256=7dqSHKCIX2osjv9cmWWLwaGvdrPvla0HTnsR75bdenY,14112
-autogluon/timeseries/predictor.py,sha256=eklp1Qils6f4vIex8KhLD6nVsUQwZ6Jt9UKkTsSyErM,85739
+autogluon/timeseries/learner.py,sha256=F3RhHCFc4EB3QmKSaYV9WH7vvoN5T8HoneSdraNJ_2Q,14281
+autogluon/timeseries/predictor.py,sha256=Fvf1C2Eap61DIc6a5aYcbSOOqKdzroU83MgWpqfhM-k,86680
 autogluon/timeseries/regressor.py,sha256=xw5VPrXS-NQ_Ts4ppDjoNV0TdqUYjW4VINUtb_BZdiI,11868
 autogluon/timeseries/splitter.py,sha256=yzPca9p2bWV-_VJAptUyyzQsxu-uixAdpMoGQtDzMD4,3205
-autogluon/timeseries/trainer.py,sha256=LHLaLvzOLjjwFHfKifydp5NOCLLv2nv2BJLerbeNWuU,57700
-autogluon/timeseries/version.py,sha256=JeRMGQ1tQl_wapzgVTNXyANKEqo0z7JdlDeM0AwnHcw,91
+autogluon/timeseries/trainer.py,sha256=R_u7a90PyB9apSMknEGMwpcMRXvepuNnn0NAACw5sSg,57942
+autogluon/timeseries/version.py,sha256=CZZ1almZ8IwUvIs8IcJ7fdkqLQwq9WIQ8u_uKA5X8YU,91
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
 autogluon/timeseries/configs/presets_configs.py,sha256=cLat8ecLlWrI-SC5KLBDCX2SbVXaucemy2pjxJAtSY0,2543
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
 autogluon/timeseries/dataset/ts_dataframe.py,sha256=SodnGhEA2V-hnfYHuAkH8rK4hQlLH8K5Tb6dsGapvPM,47161
-autogluon/timeseries/metrics/__init__.py,sha256=dJCrZ2cHwqhqNctwQjwG-FHgGUmzIFT-D0z72f4RAVM,2104
-autogluon/timeseries/metrics/abstract.py,sha256=CHUZB6xt9oF9yijSOjgGtjLuKo2X0mT6dQDuwg4ZzpU,8192
-autogluon/timeseries/metrics/point.py,sha256=2nlieQcPBCI9hXMT3v0Oe802ykZDuzvEtDpunzt0IVA,15785
-autogluon/timeseries/metrics/quantile.py,sha256=wvFeDMvRf1mFurhvVr_7g13Kg-hKIRoW4y9t2no_e7A,3969
+autogluon/timeseries/metrics/__init__.py,sha256=IWEG1X0NP_WbBwgLO7iC9TAoKZD7v-G6rrzqgWqhx08,3552
+autogluon/timeseries/metrics/abstract.py,sha256=nrnFZpBJo6f7zg5fbqJoLubTZyQdj3_rh-Z8D5qfxAk,8825
+autogluon/timeseries/metrics/point.py,sha256=yHs5ivgINO8WlhkhERVBFyP-hgk2tjBSJsOF7OszYgk,18814
+autogluon/timeseries/metrics/quantile.py,sha256=s2N70vdVgMVJpaFNBCbOfmvYVKZMlSyqfyy75WLpzZY,4552
 autogluon/timeseries/metrics/utils.py,sha256=HuDe1BNe8yJU4f_DKM913nNrUueoRaw6zhxm1-S20s0,910
 autogluon/timeseries/models/__init__.py,sha256=MYD9JJ-wUDE5B6jW6E6LU2eXQ6vflfQBvqQJkdzJa3A,1189
-autogluon/timeseries/models/presets.py,sha256=BdSTW91-flgqhVNuZIvqEf7wUj1iB6BPger4tJaoAZQ,12322
+autogluon/timeseries/models/presets.py,sha256=k5V2GgH5xFEqDrHBhfnLph61ASq_B1elcPLPurvFo0U,12431
 autogluon/timeseries/models/abstract/__init__.py,sha256=wvDsQAZIV0N3AwBeMaGItoQ82trEfnT-nol2AAOIxBg,102
-autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=gGairH3JX5rMEWhSj6VYy6zu7isZ04IaIj4lDXaTc1E,30814
+autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=UeSgldAHam7hI0J8jY4ALJLwZNC3_hRjo8NdK1UesyA,31247
 autogluon/timeseries/models/abstract/model_trial.py,sha256=ENPg_7nsdxIvaNM0o0UShZ3x8jFlRmwRc5m0fGPC0TM,3720
 autogluon/timeseries/models/abstract/tunable.py,sha256=SFl4vjkb6BfFFaRPVdftnnLYlIyCThutLHxiiAlV6tY,7168
 autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=r9i6jWcyeLHYClkcMSKRVsfrkBUMxpDrTATNTBc_qgQ,136
@@ -35,7 +35,7 @@ autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=kNIDesojKB3r
 autogluon/timeseries/models/chronos/pipeline/utils.py,sha256=dtDX5Pyu95bGv7qmqgfUc1iYowWPY84dnGN0uyqyHyQ,13131
 autogluon/timeseries/models/ensemble/__init__.py,sha256=kFr11Gmt7lQJu9Rr8HuIPphQN5l1TsoorfbJm_O3a_s,128
 autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py,sha256=LzL64JASiwkLsuFxGToXJGRItcMxq5_Ig2QP5Zm7SHw,3537
-autogluon/timeseries/models/ensemble/greedy_ensemble.py,sha256=v5A2xv4d_QynA1GWD7iqmn-VVEFpD88Oiswyp72yBCc,7321
+autogluon/timeseries/models/ensemble/greedy_ensemble.py,sha256=S9ghBwfSUGT0fvHZl5HHcOPmaBnQE2ZQR0lLrC5TXsE,7610
 autogluon/timeseries/models/gluonts/__init__.py,sha256=asC1PTj4j9xMbilvk1IT1julnpeoKbv5ZNuAR6-DFgA,361
 autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=35T8rty6sPGiaSFNpiVNmeseo1_qpn664UcWo92W5eI,32906
 autogluon/timeseries/models/gluonts/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -59,11 +59,11 @@ autogluon/timeseries/utils/datetime/base.py,sha256=3NdsH3NDq4cVAOSoy3XpaNixyNlbj
 autogluon/timeseries/utils/datetime/lags.py,sha256=gQDk5_zmsY5DUWDUpSaCKYkQ9nHKKY-LsywJQRAoYSk,5988
 autogluon/timeseries/utils/datetime/seasonality.py,sha256=YK_2k8hvYIMW-sJPnjGWRtCnvIOthwA2hATB3nwVoD4,834
 autogluon/timeseries/utils/datetime/time_features.py,sha256=MjLi3zQ00uWWJtXH9oGX2GJkTbvjdSiuabSa4kcVuxE,2672
-autogluon.timeseries-1.2.1b20250420.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.2.1b20250420.dist-info/METADATA,sha256=rU1Po4zkmiHUBtZTV9IXmOlGXXrtIftFPtaXqdGVrBU,12687
-autogluon.timeseries-1.2.1b20250420.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.2.1b20250420.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.timeseries-1.2.1b20250420.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250420.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250420.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.2.1b20250420.dist-info/RECORD,,
+autogluon.timeseries-1.2.1b20250422.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.2.1b20250422.dist-info/METADATA,sha256=4UirSdHj-jRgjGXA8AAVHrCVhTECV4Za_K6-yidbEJc,12687
+autogluon.timeseries-1.2.1b20250422.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.2.1b20250422.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.timeseries-1.2.1b20250422.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.2.1b20250422.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.2.1b20250422.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.2.1b20250422.dist-info/RECORD,,