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

autogluon/timeseries/dataset/ts_dataframe.py

@@ -8,11 +8,12 @@ from collections.abc import Iterable
 from itertools import islice
 from pathlib import Path
 from pprint import pformat
-from typing import Any, List, Optional, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any, List, Optional, Tuple, Type, Union
 
 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 autogluon.common.loaders import load_pd
 
@@ -490,7 +491,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
                 except ValueError:
                     inferred_freq = None
                 else:
-                    inferred_freq = candidate_freq
+                    inferred_freq = candidate_freq.freqstr
             return inferred_freq
 
         freq_for_each_item = index_df.groupby(ITEMID, sort=False).agg(get_freq)[TIMESTAMP]
@@ -1029,7 +1030,11 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
         # Resampling time for 1 item < overhead time for a single parallel job. Therefore, we group items into chunks
         # so that the speedup from parallelization isn't dominated by the communication costs.
-        chunks = split_into_chunks(pd.DataFrame(self).groupby(level=ITEMID, sort=False), chunk_size)
+        df = pd.DataFrame(self)
+        # Make sure that timestamp index has dtype 'datetime64[ns]', otherwise index may contain NaT values.
+        # See https://github.com/autogluon/autogluon/issues/4917
+        df.index = df.index.set_levels(df.index.levels[1].astype("datetime64[ns]"), level=TIMESTAMP)
+        chunks = split_into_chunks(df.groupby(level=ITEMID, sort=False), chunk_size)
         resampled_chunks = Parallel(n_jobs=num_cpus)(delayed(resample_chunk)(chunk) for chunk in chunks)
         resampled_df = TimeSeriesDataFrame(pd.concat(resampled_chunks))
         resampled_df.static_features = self.static_features
@@ -1038,3 +1043,13 @@ class TimeSeriesDataFrame(pd.DataFrame):
     def to_data_frame(self) -> pd.DataFrame:
         """Convert `TimeSeriesDataFrame` to a `pandas.DataFrame`"""
         return pd.DataFrame(self)
+
+    if TYPE_CHECKING:
+
+        @overload
+        def __new__(cls, data: pd.DataFrame, static_features: Optional[pd.DataFrame] = None) -> Self: ...  # type: ignore
+
+        @overload
+        def __getitem__(self, items: List[str]) -> Self: ...  # type: ignore
+        @overload
+        def __getitem__(self, item: str) -> pd.Series: ...  # type: ignore

autogluon/timeseries/learner.py

@@ -3,7 +3,6 @@ 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
@@ -31,7 +30,6 @@ 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,
@@ -40,7 +38,6 @@ 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
@@ -86,7 +83,6 @@ 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,8 +1,5 @@
 from pprint import pformat
-from typing import Optional, Type, Union, overload
-
-import numpy as np
-import numpy.typing as npt
+from typing import Type, Union
 
 from .abstract import TimeSeriesScorer
 from .point import MAE, MAPE, MASE, MSE, RMSE, RMSLE, RMSSE, SMAPE, WAPE, WCD
@@ -78,29 +75,3 @@ 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,7 +69,6 @@ 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
@@ -93,8 +92,6 @@ class TimeSeriesScorer:
                     data_future=data_future,
                     predictions=predictions,
                     target=target,
-                    prediction_length=prediction_length,
-                    horizon_weight=horizon_weight,
                     **kwargs,
                 )
         finally:
@@ -108,8 +105,6 @@ 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.
@@ -126,11 +121,6 @@ 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,20 +38,10 @@ class RMSE(TimeSeriesScorer):
     equivalent_tabular_regression_metric = "root_mean_squared_error"
 
     def compute_metric(
-        self,
-        data_future: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        target: str = "target",
-        prediction_length: int = 1,
-        horizon_weight: Optional[np.ndarray] = None,
-        **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()
-        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))
+        return np.sqrt(self._safemean((y_true - y_pred) ** 2))
 
 
 class MSE(TimeSeriesScorer):
@@ -79,20 +69,10 @@ class MSE(TimeSeriesScorer):
     equivalent_tabular_regression_metric = "mean_squared_error"
 
     def compute_metric(
-        self,
-        data_future: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        target: str = "target",
-        prediction_length: int = 1,
-        horizon_weight: Optional[np.ndarray] = None,
-        **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()
-        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)
+        return self._safemean((y_true - y_pred) ** 2)
 
 
 class MAE(TimeSeriesScorer):
@@ -118,20 +98,10 @@ class MAE(TimeSeriesScorer):
     equivalent_tabular_regression_metric = "mean_absolute_error"
 
     def compute_metric(
-        self,
-        data_future: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        target: str = "target",
-        prediction_length: int = 1,
-        horizon_weight: Optional[np.ndarray] = None,
-        **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()
-        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)
+        return self._safemean((y_true - y_pred).abs())
 
 
 class WAPE(TimeSeriesScorer):
@@ -149,7 +119,6 @@ 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
     ----------
@@ -160,21 +129,10 @@ class WAPE(TimeSeriesScorer):
     equivalent_tabular_regression_metric = "mean_absolute_error"
 
     def compute_metric(
-        self,
-        data_future: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        target: str = "target",
-        prediction_length: int = 1,
-        horizon_weight: Optional[np.ndarray] = None,
-        **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()
-        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))
+        return (y_true - y_pred).abs().sum() / y_true.abs().sum()
 
 
 class SMAPE(TimeSeriesScorer):
@@ -200,20 +158,10 @@ class SMAPE(TimeSeriesScorer):
     equivalent_tabular_regression_metric = "symmetric_mean_absolute_percentage_error"
 
     def compute_metric(
-        self,
-        data_future: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        target: str = "target",
-        prediction_length: int = 1,
-        horizon_weight: Optional[np.ndarray] = None,
-        **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()
-        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)
+        return self._safemean(2 * ((y_true - y_pred).abs() / (y_true.abs() + y_pred.abs())))
 
 
 class MAPE(TimeSeriesScorer):
@@ -239,20 +187,10 @@ class MAPE(TimeSeriesScorer):
     equivalent_tabular_regression_metric = "mean_absolute_percentage_error"
 
     def compute_metric(
-        self,
-        data_future: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        target: str = "target",
-        prediction_length: int = 1,
-        horizon_weight: Optional[np.ndarray] = None,
-        **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()
-        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)
+        return self._safemean((y_true - y_pred).abs() / y_true.abs())
 
 
 class MASE(TimeSeriesScorer):
@@ -302,24 +240,16 @@ class MASE(TimeSeriesScorer):
         self._past_abs_seasonal_error = None
 
     def compute_metric(
-        self,
-        data_future: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        target: str = "target",
-        prediction_length: int = 1,
-        horizon_weight: Optional[np.ndarray] = None,
-        **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`")
 
-        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])
+        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])
 
 
 class RMSSE(TimeSeriesScorer):
@@ -370,23 +300,16 @@ class RMSSE(TimeSeriesScorer):
         self._past_squared_seasonal_error = None
 
     def compute_metric(
-        self,
-        data_future: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        target: str = "target",
-        prediction_length: int = 1,
-        horizon_weight: Optional[np.ndarray] = None,
-        **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`")
 
-        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]))
+        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]))
 
 
 class RMSLE(TimeSeriesScorer):
@@ -413,22 +336,12 @@ class RMSLE(TimeSeriesScorer):
     """
 
     def compute_metric(
-        self,
-        data_future: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        target: str = "target",
-        prediction_length: int = 1,
-        horizon_weight: Optional[np.ndarray] = None,
-        **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)
 
-        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))
+        return np.sqrt(np.power(np.log1p(y_pred) - np.log1p(y_true), 2).mean())
 
     def __call__(
         self,
@@ -437,7 +350,6 @@ 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():
@@ -448,7 +360,6 @@ class RMSLE(TimeSeriesScorer):
             prediction_length=prediction_length,
             target=target,
             seasonal_period=seasonal_period,
-            horizon_weight=horizon_weight,
             **kwargs,
         )
 
@@ -471,36 +382,35 @@ class WCD(TimeSeriesScorer):
     Parameters
     ----------
     alpha : float, default = 0.5
-        Values > 0.5 put a stronger penalty on underpredictions (when cumulative forecast is below the
+        Values > 0.5 correspond 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 _fast_cumsum(self, y: np.ndarray, prediction_length: int) -> np.ndarray:
+    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."""
-        y = y.reshape(-1, prediction_length)
+        assert self.num_items is not None, "Make sure to call `save_past_metrics` before `compute_metric`"
+        y = y.reshape(self.num_items, -1)
         return np.nancumsum(y, axis=1).ravel()
 
     def compute_metric(
-        self,
-        data_future: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        target: str = "target",
-        prediction_length: int = 1,
-        horizon_weight: Optional[np.ndarray] = None,
-        **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(), prediction_length=prediction_length)
-        cumsum_pred = self._fast_cumsum(y_pred.to_numpy(), prediction_length=prediction_length)
+        cumsum_true = self._fast_cumsum(y_true.to_numpy())
+        cumsum_pred = self._fast_cumsum(y_pred.to_numpy())
         diffs = cumsum_pred - cumsum_true
-        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)
+        error = diffs * np.where(diffs < 0, -self.alpha, (1 - self.alpha))
+        return 2 * self._safemean(error)

autogluon/timeseries/metrics/quantile.py

@@ -25,7 +25,6 @@ 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
     ----------
@@ -35,27 +34,16 @@ class WQL(TimeSeriesScorer):
     needs_quantile = True
 
     def compute_metric(
-        self,
-        data_future: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        target: str = "target",
-        prediction_length: int = 1,
-        horizon_weight: Optional[np.ndarray] = None,
-        **kwargs,
+        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)
-        y_true = y_true.to_numpy()[:, None]  # shape [N, 1]
-        q_pred = q_pred.to_numpy()  # shape [N, len(quantile_levels)]
+        values_true = y_true.values[:, None]  # shape [N, 1]
+        values_pred = q_pred.values  # shape [N, len(quantile_levels)]
 
-        errors = (
-            np.abs((q_pred - y_true) * ((y_true <= q_pred) - quantile_levels))
-            .mean(axis=1)
-            .reshape([-1, prediction_length])
+        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))
         )
-        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):
@@ -105,26 +93,17 @@ class SQL(TimeSeriesScorer):
         self._past_abs_seasonal_error = None
 
     def compute_metric(
-        self,
-        data_future: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        target: str = "target",
-        prediction_length: int = 1,
-        horizon_weight: Optional[np.ndarray] = None,
-        **kwargs,
+        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **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.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])
+        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])

autogluon/timeseries/models/abstract/__init__.py

@@ -1,3 +1,3 @@
-from .abstract_timeseries_model import AbstractTimeSeriesModel
+from .abstract_timeseries_model import AbstractTimeSeriesModel, TimeSeriesModelBase
 
-__all__ = ["AbstractTimeSeriesModel"]
+__all__ = ["AbstractTimeSeriesModel", "TimeSeriesModelBase"]