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

autogluon/timeseries/models/autogluon_tabular/transforms.py

@@ -1,4 +1,4 @@
-from typing import Literal, Optional, Union
+from typing import Literal, Union
 
 import numpy as np
 import pandas as pd
@@ -13,29 +13,32 @@ from autogluon.timeseries.dataset.ts_dataframe import (
     TIMESTAMP,
     TimeSeriesDataFrame,
 )
-from autogluon.timeseries.transforms.target_scaler import LocalTargetScaler, get_target_scaler
+from autogluon.timeseries.transforms.target_scaler import TargetScaler, get_target_scaler
 
 from .utils import MLF_ITEMID, MLF_TIMESTAMP
 
 
 class MLForecastScaler(BaseTargetTransform):
-    def __init__(self, scaler_type: Literal["standard", "robust", "min_max", "mean_abs"]):
+    def __init__(self, scaler_type: Literal["standard", "min_max", "mean_abs", "robust"]):
         # For backward compatibility
-        self.scaler_type = scaler_type
-        self.ag_scaler: Optional[LocalTargetScaler] = None
+        self.scaler_type: Literal["standard", "min_max", "mean_abs", "robust"] = scaler_type
+        self.ag_scaler: TargetScaler
 
     def _df_to_tsdf(self, df: pd.DataFrame) -> TimeSeriesDataFrame:
-        return df.rename(columns={self.id_col: ITEMID, self.time_col: TIMESTAMP}).set_index([ITEMID, TIMESTAMP])
+        return TimeSeriesDataFrame(
+            df.rename(columns={self.id_col: ITEMID, self.time_col: TIMESTAMP}).set_index([ITEMID, TIMESTAMP])
+        )
 
     def _tsdf_to_df(self, ts_df: TimeSeriesDataFrame) -> pd.DataFrame:
         return pd.DataFrame(ts_df).reset_index().rename(columns={ITEMID: self.id_col, TIMESTAMP: self.time_col})
 
-    def fit_transform(self, df: pd.DataFrame) -> pd.DataFrame:
+    def fit_transform(self, df: pd.DataFrame) -> pd.DataFrame:  # type: ignore
         self.ag_scaler = get_target_scaler(name=self.scaler_type, target=self.target_col)
-        transformed = self.ag_scaler.fit_transform(self._df_to_tsdf(df)).reset_index()
+        transformed = self.ag_scaler.fit_transform(self._df_to_tsdf(df))
         return self._tsdf_to_df(transformed)
 
-    def inverse_transform(self, df: pd.DataFrame) -> pd.DataFrame:
+    def inverse_transform(self, df: pd.DataFrame) -> pd.DataFrame:  # type: ignore
+        assert self.ag_scaler is not None
         transformed = self.ag_scaler.inverse_transform(self._df_to_tsdf(df))
         return self._tsdf_to_df(transformed)
 
@@ -46,7 +49,9 @@ def apply_inverse_transform(
 ) -> pd.DataFrame:
     """Apply inverse transformation to a dataframe, converting to GroupedArray if necessary"""
     if isinstance(transform, BaseTargetTransform):
-        return transform.inverse_transform(df=df)
+        inverse_transformed = transform.inverse_transform(df=df)
+        assert isinstance(inverse_transformed, pd.DataFrame)
+        return inverse_transformed
     elif isinstance(transform, _BaseGroupedArrayTargetTransform):
         indptr = np.concatenate([[0], df[MLF_ITEMID].value_counts().cumsum()])
         assignment = {}

autogluon/timeseries/models/ensemble/greedy.py

@@ -28,7 +28,6 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         random_state: Optional[np.random.RandomState] = None,
         prediction_length: int = 1,
         target: str = "target",
-        eval_metric_seasonal_period: int = 1,
         **kwargs,
     ):
         super().__init__(
@@ -43,7 +42,6 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         )
         self.prediction_length = prediction_length
         self.target = target
-        self.eval_metric_seasonal_period = eval_metric_seasonal_period
         self.metric: TimeSeriesScorer
 
         self.dummy_pred_per_window = []
@@ -79,6 +77,10 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         self.scorer_per_window = []
         self.data_future_per_window = []
 
+        seasonal_period = self.metric.seasonal_period
+        if seasonal_period is None:
+            seasonal_period = get_seasonality(labels[0].freq)
+
         for window_idx, data in enumerate(labels):
             dummy_pred = copy.deepcopy(predictions[0][window_idx])
             # This should never happen; sanity check to make sure that all predictions have the same index
@@ -90,7 +92,7 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
             # Split the observed time series once to avoid repeated computations inside the evaluator
             data_past = data.slice_by_timestep(None, -self.prediction_length)
             data_future = data.slice_by_timestep(-self.prediction_length, None)
-            scorer.save_past_metrics(data_past, target=self.target, seasonal_period=self.eval_metric_seasonal_period)
+            scorer.save_past_metrics(data_past, target=self.target, seasonal_period=seasonal_period)
             self.scorer_per_window.append(scorer)
             self.data_future_per_window.append(data_future)
 
@@ -122,7 +124,9 @@ 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,
             )
             total_score += metric.sign * metric_value
         avg_score = total_score / len(self.data_future_per_window)
@@ -162,14 +166,11 @@ class GreedyEnsemble(AbstractWeightedTimeSeriesEnsembleModel):
         model_scores: Optional[Dict[str, float]] = None,
         time_limit: Optional[float] = None,
     ):
-        if self.eval_metric_seasonal_period is None:
-            self.eval_metric_seasonal_period = get_seasonality(self.freq)
         ensemble_selection = TimeSeriesEnsembleSelection(
             ensemble_size=self.get_hyperparameters()["ensemble_size"],
             metric=self.eval_metric,
             prediction_length=self.prediction_length,
             target=self.target,
-            eval_metric_seasonal_period=self.eval_metric_seasonal_period,
         )
         ensemble_selection.fit(
             predictions=list(predictions_per_window.values()),

autogluon/timeseries/models/local/abstract_local_model.py

@@ -10,6 +10,7 @@ from scipy.stats import norm
 
 from autogluon.core.utils.exceptions import TimeLimitExceeded
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
+from autogluon.timeseries.metrics import TimeSeriesScorer
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
 from autogluon.timeseries.utils.datetime import get_seasonality
 from autogluon.timeseries.utils.warning_filters import warning_filter
@@ -30,8 +31,6 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
     ----------
     allowed_local_model_args : List[str]
         Argument that can be passed to the underlying local model.
-    default_n_jobs : Union[int, float]
-        Default number of CPU cores used to train models. If float, this fraction of CPU cores will be used.
     default_max_ts_length : Optional[int]
         If not None, only the last ``max_ts_length`` time steps of each time series will be used to train the model.
         This significantly speeds up fitting and usually leads to no change in accuracy.
@@ -41,7 +40,6 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
     """
 
     allowed_local_model_args: List[str] = []
-    default_n_jobs: Union[int, float] = AG_DEFAULT_N_JOBS
     default_max_ts_length: Optional[int] = 2500
     default_max_time_limit_ratio = 1.0
     init_time_in_seconds: int = 0
@@ -52,26 +50,10 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         prediction_length: int = 1,
         path: Optional[str] = None,
         name: Optional[str] = None,
-        eval_metric: str = None,
-        hyperparameters: Dict[str, Any] = None,
+        eval_metric: Union[str, TimeSeriesScorer, None] = None,
+        hyperparameters: Optional[Dict[str, Any]] = None,
         **kwargs,  # noqa
     ):
-        if hyperparameters is None:
-            hyperparameters = {}
-        else:
-            hyperparameters = hyperparameters.copy()
-        # TODO: Replace with 'num_cpus' argument passed to fit (after predictor API is changed)
-        n_jobs = hyperparameters.pop("n_jobs", self.default_n_jobs)
-        if isinstance(n_jobs, float) and 0 < n_jobs <= 1:
-            self.n_jobs = max(int(cpu_count() * n_jobs), 1)
-        elif isinstance(n_jobs, int):
-            self.n_jobs = n_jobs
-        else:
-            raise ValueError(f"n_jobs must be a float between 0 and 1 or an integer (received n_jobs = {n_jobs})")
-        # Default values, potentially overridden inside _fit()
-        self.use_fallback_model = hyperparameters.pop("use_fallback_model", True)
-        self.max_ts_length = hyperparameters.pop("max_ts_length", self.default_max_ts_length)
-
         super().__init__(
             path=path,
             freq=freq,
@@ -82,9 +64,9 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
             **kwargs,
         )
 
-        self._local_model_args: Dict[str, Any] = None
-        self._seasonal_period: Optional[int] = None
-        self._dummy_forecast: Optional[pd.DataFrame] = None
+        self._local_model_args: Dict[str, Any]
+        self._seasonal_period: int
+        self._dummy_forecast: pd.DataFrame
 
     @property
     def allowed_hyperparameters(self) -> List[str]:
@@ -105,19 +87,32 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
             data = data.fill_missing_values()
         return data, known_covariates
 
+    def _get_default_hyperparameters(self) -> dict:
+        return {
+            "n_jobs": AG_DEFAULT_N_JOBS,
+            "use_fallback_model": True,
+            "max_ts_length": self.default_max_ts_length,
+        }
+
+    @staticmethod
+    def _compute_n_jobs(n_jobs: Union[int, float]) -> int:
+        if isinstance(n_jobs, float) and 0 < n_jobs <= 1:
+            return max(int(cpu_count() * n_jobs), 1)
+        elif isinstance(n_jobs, int):
+            return n_jobs
+        else:
+            raise ValueError(f"n_jobs must be a float between 0 and 1 or an integer (received n_jobs = {n_jobs})")
+
     def _fit(self, train_data: TimeSeriesDataFrame, time_limit: Optional[int] = None, **kwargs):
         self._check_fit_params()
 
         if time_limit is not None and time_limit < self.init_time_in_seconds:
             raise TimeLimitExceeded
 
-        # Initialize parameters passed to each local model
-        raw_local_model_args = self.get_hyperparameters().copy()
-
         unused_local_model_args = []
         local_model_args = {}
         # TODO: Move filtering logic to AbstractTimeSeriesModel
-        for key, value in raw_local_model_args.items():
+        for key, value in self.get_hyperparameters().items():
             if key in self.allowed_local_model_args:
                 local_model_args[key] = value
             elif key in self.allowed_hyperparameters:
@@ -151,9 +146,11 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         return local_model_args
 
     def _predict(self, data: TimeSeriesDataFrame, **kwargs) -> TimeSeriesDataFrame:
-        if self.max_ts_length is not None:
-            logger.debug(f"Shortening all time series to at most {self.max_ts_length}")
-            data = data.groupby(level=ITEMID, sort=False).tail(self.max_ts_length)
+        model_params = self.get_hyperparameters()
+        max_ts_length = model_params["max_ts_length"]
+        if max_ts_length is not None:
+            logger.debug(f"Shortening all time series to at most {max_ts_length}")
+            data = data.groupby(level=ITEMID, sort=False).tail(max_ts_length)
 
         df = pd.DataFrame(data).reset_index(level=ITEMID)
         all_series = (ts for _, ts in df.groupby(by=ITEMID, as_index=False, sort=False)[self.target])
@@ -161,15 +158,20 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         # timeout ensures that no individual job takes longer than time_limit
         # TODO: a job started late may still exceed time_limit - how to prevent that?
         time_limit = kwargs.get("time_limit")
-        timeout = None if self.n_jobs == 1 else time_limit
+        # TODO: Take into account num_cpus once the TimeSeriesPredictor API is updated
+        n_jobs = self._compute_n_jobs(model_params["n_jobs"])
+        timeout = None if n_jobs == 1 else time_limit
         # end_time ensures that no new jobs are started after time_limit is exceeded
         end_time = None if time_limit is None else time.time() + time_limit
-        executor = Parallel(self.n_jobs, timeout=timeout)
+        executor = Parallel(n_jobs=n_jobs, timeout=timeout)
 
         try:
             with warning_filter():
                 predictions_with_flags = executor(
-                    delayed(self._predict_wrapper)(ts, end_time=end_time) for ts in all_series
+                    delayed(self._predict_wrapper)(
+                        ts, use_fallback_model=model_params["use_fallback_model"], end_time=end_time
+                    )
+                    for ts in all_series
                 )
         except TimeoutError:
             raise TimeLimitExceeded
@@ -185,7 +187,12 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         predictions_df.index = self.get_forecast_horizon_index(data)
         return TimeSeriesDataFrame(predictions_df)
 
-    def _predict_wrapper(self, time_series: pd.Series, end_time: Optional[float] = None) -> Tuple[pd.DataFrame, bool]:
+    def _predict_wrapper(
+        self,
+        time_series: pd.Series,
+        use_fallback_model: bool,
+        end_time: Optional[float] = None,
+    ) -> Tuple[pd.DataFrame, bool]:
         if end_time is not None and time.time() >= end_time:
             raise TimeLimitExceeded
 
@@ -201,7 +208,7 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
                 if not np.isfinite(result.values).all():
                     raise RuntimeError("Forecast contains NaN or Inf values.")
             except Exception:
-                if self.use_fallback_model:
+                if use_fallback_model:
                     result = seasonal_naive_forecast(
                         target=time_series.values.ravel(),
                         prediction_length=self.prediction_length,

autogluon/timeseries/models/multi_window/multi_window_model.py

@@ -215,7 +215,7 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
     def _get_search_space(self):
         return self.model_base._get_search_space()
 
-    def _initialize_transforms_and_regressor(self, **kwargs) -> None:
+    def _initialize_transforms_and_regressor(self) -> None:
         # Do not initialize the target_scaler and covariate_regressor in the multi window model!
         self.target_scaler = None
         self.covariate_scaler = None

autogluon/timeseries/models/presets.py

@@ -183,7 +183,6 @@ def get_preset_models(
     prediction_length: int,
     path: str,
     eval_metric: Union[str, TimeSeriesScorer],
-    eval_metric_seasonal_period: Optional[int],
     hyperparameters: Union[str, Dict, None],
     hyperparameter_tune: bool,
     covariate_metadata: CovariateMetadata,
@@ -260,7 +259,6 @@ def get_preset_models(
                 freq=freq,
                 prediction_length=prediction_length,
                 eval_metric=eval_metric,
-                eval_metric_seasonal_period=eval_metric_seasonal_period,
                 covariate_metadata=covariate_metadata,
                 hyperparameters=model_hps,
                 **kwargs,

autogluon/timeseries/predictor.py

@@ -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
@@ -107,7 +115,7 @@ class TimeSeriesPredictor:
         List of increasing decimals that specifies which quantiles should be estimated when making distributional
         forecasts. Defaults to ``[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]``.
     path : str or pathlib.Path, optional
-        Path to the directory where models and intermediate outputs will be saved. Defaults to a timestamped folder
+        Path to the local directory where models and intermediate outputs will be saved. Defaults to a timestamped folder
         ``AutogluonModels/ag-[TIMESTAMP]`` that will be created in the working directory.
     verbosity : int, default = 2
         Verbosity levels range from 0 to 4 and control how much information is printed to stdout. Higher levels
@@ -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: Optional[List[float]] = None,
         path: Optional[Union[str, Path]] = None,
         verbosity: int = 2,
         log_to_file: bool = True,
@@ -156,6 +165,11 @@ class TimeSeriesPredictor:
         self.verbosity = verbosity
         set_logger_verbosity(self.verbosity, logger=logger)
         self.path = setup_outputdir(path)
+        if self.path.lower().startswith("s3://"):
+            logger.warning(
+                "Warning: S3 paths are not supported for the `path` argument in TimeSeriesPredictor. "
+                "Use a local path and upload the trained predictor to S3 manually if needed"
+            )
         self._setup_log_to_file(log_to_file=log_to_file, log_file_path=log_file_path)
 
         self.cache_predictions = cache_predictions
@@ -187,15 +201,18 @@ class TimeSeriesPredictor:
             if std_freq != str(self.freq):
                 logger.info(f"Frequency '{self.freq}' stored as '{std_freq}'")
             self.freq = std_freq
-        self.eval_metric = check_get_evaluation_metric(eval_metric)
-        self.eval_metric_seasonal_period = eval_metric_seasonal_period
+        self.eval_metric: TimeSeriesScorer = check_get_evaluation_metric(
+            eval_metric,
+            prediction_length=prediction_length,
+            seasonal_period=eval_metric_seasonal_period,
+            horizon_weight=horizon_weight,
+        )
         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)
         self._learner: TimeSeriesLearner = self._learner_type(
             path_context=self.path,
-            eval_metric=eval_metric,
-            eval_metric_seasonal_period=eval_metric_seasonal_period,
+            eval_metric=self.eval_metric,
             target=self.target,
             known_covariates_names=self.known_covariates_names,
             prediction_length=self.prediction_length,
@@ -395,12 +412,12 @@ class TimeSeriesPredictor:
                 f"\tRemoving {len(too_short_items)} short time series from train_data. Only series with length "
                 f">= {min_length} will be used for training."
             )
-            train_data = train_data.query("item_id not in @too_short_items")  # type: ignore
+            train_data = train_data.query("item_id not in @too_short_items")
 
         all_nan_items = train_data.item_ids[train_data[self.target].isna().groupby(ITEMID, sort=False).all()]
         if len(all_nan_items) > 0:
             logger.info(f"\tRemoving {len(all_nan_items)} time series consisting of only NaN values from train_data.")
-            train_data = train_data.query("item_id not in @all_nan_items")  # type: ignore
+            train_data = train_data.query("item_id not in @all_nan_items")
 
         if len(too_short_items) or len(all_nan_items):
             logger.info(f"\tAfter filtering, train_data has {self._get_dataset_stats(train_data)}")
@@ -494,33 +511,22 @@ class TimeSeriesPredictor:
 
             Available presets:
 
-            - ``"fast_training"``: fit simple statistical models (``ETS``, ``Theta``, ``Naive``, ``SeasonalNaive``) + fast tree-based models ``RecursiveTabular``
-              and ``DirectTabular``. These models are fast to train but may not be very accurate.
-            - ``"medium_quality"``: all models mentioned above + deep learning model ``TemporalFusionTransformer`` + Chronos-Bolt (small). Produces good forecasts with reasonable training time.
-            - ``"high_quality"``: All ML models available in AutoGluon + additional statistical models (``NPTS``, ``AutoETS``,
-              ``DynamicOptimizedTheta``). Much more accurate than ``medium_quality``, but takes longer to train.
+            - ``"fast_training"``: Simple statistical and tree-based ML models. These models are fast to train but may not be very accurate.
+            - ``"medium_quality"``: Same models as above, plus deep learning models ``TemporalFusionTransformer`` and Chronos-Bolt (small). Produces good forecasts with reasonable training time.
+            - ``"high_quality"``: A mix of multiple DL, ML and statistical forecasting models available in AutoGluon that offers the best forecast accuracy. Much more accurate than ``medium_quality``, but takes longer to train.
             - ``"best_quality"``: Same models as in ``"high_quality"``, but performs validation with multiple backtests. Usually better than ``high_quality``, but takes even longer to train.
 
-            Available presets with the new, faster `Chronos-Bolt <https://github.com/amazon-science/chronos-forecasting>`_ model:
+            Available presets with the `Chronos-Bolt <https://github.com/amazon-science/chronos-forecasting>`_ model:
 
             - ``"bolt_{model_size}"``: where model size is one of ``tiny,mini,small,base``. Uses the Chronos-Bolt pretrained model for zero-shot forecasting.
               See the documentation for ``ChronosModel`` or see `Hugging Face <https://huggingface.co/collections/amazon/chronos-models-65f1791d630a8d57cb718444>`_ for more information.
 
-            Available presets with the original `Chronos <https://github.com/amazon-science/chronos-forecasting>`_ model.
-            Note that as of v1.2 we recommend using the new, faster Chronos-Bolt models instead of the original Chronos models.
+            Exact definitions of these presets can be found in the source code
+            [`1 <https://github.com/autogluon/autogluon/blob/stable/timeseries/src/autogluon/timeseries/configs/presets_configs.py>`_,
+            `2 <https://github.com/autogluon/autogluon/blob/stable/timeseries/src/autogluon/timeseries/models/presets.py>`_].
 
-            - ``"chronos_{model_size}"``: where model size is one of ``tiny,mini,small,base,large``. Uses the Chronos pretrained model for zero-shot forecasting.
-              See the documentation for ``ChronosModel`` or see `Hugging Face <https://huggingface.co/collections/amazon/chronos-models-65f1791d630a8d57cb718444>`_ for more information.
-              Note that a GPU is required for model sizes ``small``, ``base`` and ``large``.
-            - ``"chronos"``: alias for ``"chronos_small"``.
-            - ``"chronos_ensemble"``: builds an ensemble of seasonal naive, tree-based and deep learning models with fast inference
-              and ``"chronos_small"``.
-            - ``"chronos_large_ensemble"``: builds an ensemble of seasonal naive, tree-based and deep learning models
-              with fast inference and ``"chronos_large"``.
-
-            Details for these presets can be found in ``autogluon/timeseries/configs/presets_configs.py``. If not
-            provided, user-provided values for ``hyperparameters`` and ``hyperparameter_tune_kwargs`` will be used
-            (defaulting to their default values specified below).
+            If no `presets` are selected, user-provided values for `hyperparameters` will be used (defaulting to their
+            default values specified below).
         hyperparameters : str or dict, optional
             Determines what models are trained and what hyperparameters are used by each model.
 
@@ -684,7 +690,8 @@ class TimeSeriesPredictor:
             target=self.target,
             known_covariates_names=self.known_covariates_names,
             eval_metric=self.eval_metric,
-            eval_metric_seasonal_period=self.eval_metric_seasonal_period,
+            eval_metric_seasonal_period=self.eval_metric.seasonal_period,
+            horizon_weight=self.eval_metric.horizon_weight,
             quantile_levels=self.quantile_levels,
             freq=self.freq,
             time_limit=time_limit,
@@ -1500,7 +1507,8 @@ class TimeSeriesPredictor:
             target=self.target,
             prediction_length=self.prediction_length,
             eval_metric=self.eval_metric.name,
-            eval_metric_seasonal_period=self.eval_metric_seasonal_period,
+            eval_metric_seasonal_period=self.eval_metric.seasonal_period,
+            horizon_weight=self.eval_metric.horizon_weight,
             quantile_levels=self.quantile_levels,
         )
         return simulation_dict

autogluon/timeseries/trainer.py

@@ -46,7 +46,6 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         path: str,
         prediction_length: int = 1,
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
-        eval_metric_seasonal_period: Optional[int] = None,
         save_data: bool = True,
         skip_model_selection: bool = False,
         enable_ensemble: bool = True,
@@ -86,8 +85,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         #: self.refit_single_full() and self.refit_full().
         self.model_refit_map = {}
 
-        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)
         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"
@@ -577,7 +575,6 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         ensemble = self.ensemble_model_type(
             name=self._get_ensemble_model_name(),
             eval_metric=self.eval_metric,
-            eval_metric_seasonal_period=self.eval_metric_seasonal_period,
             target=self.target,
             prediction_length=self.prediction_length,
             path=self.path,
@@ -791,6 +788,17 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
             raise ValueError(f"Model {model_name} failed to predict. Please check the model's logs.")
         return predictions
 
+    def _get_eval_metric(self, metric: Union[str, TimeSeriesScorer, None]) -> TimeSeriesScorer:
+        if metric is None:
+            return self.eval_metric
+        else:
+            return check_get_evaluation_metric(
+                metric,
+                prediction_length=self.prediction_length,
+                seasonal_period=self.eval_metric.seasonal_period,
+                horizon_weight=self.eval_metric.horizon_weight,
+            )
+
     def _score_with_predictions(
         self,
         data: TimeSeriesDataFrame,
@@ -798,13 +806,11 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         metric: Union[str, TimeSeriesScorer, None] = None,
     ) -> float:
         """Compute the score measuring how well the predictions align with the data."""
-        eval_metric = self.eval_metric if metric is None else check_get_evaluation_metric(metric)
-        return eval_metric.score(
+        return self._get_eval_metric(metric).score(
             data=data,
             predictions=predictions,
             prediction_length=self.prediction_length,
             target=self.target,
-            seasonal_period=self.eval_metric_seasonal_period,
         )
 
     def score(
@@ -814,7 +820,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         metric: Union[str, TimeSeriesScorer, None] = None,
         use_cache: bool = True,
     ) -> float:
-        eval_metric = self.eval_metric if metric is None else check_get_evaluation_metric(metric)
+        eval_metric = self._get_eval_metric(metric)
         scores_dict = self.evaluate(data=data, model=model, metrics=[eval_metric], use_cache=use_cache)
         return scores_dict[eval_metric.name]
 
@@ -833,7 +839,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         metrics_ = [metrics] if not isinstance(metrics, list) else metrics
         scores_dict = {}
         for metric in metrics_:
-            eval_metric = self.eval_metric if metric is None else check_get_evaluation_metric(metric)
+            eval_metric = self._get_eval_metric(metric)
             scores_dict[eval_metric.name] = self._score_with_predictions(
                 data=data, predictions=predictions, metric=eval_metric
             )
@@ -855,7 +861,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         confidence_level: float = 0.99,
     ) -> pd.DataFrame:
         assert method in ["naive", "permutation"], f"Invalid feature importance method {method}."
-        metric = check_get_evaluation_metric(metric) if metric is not None else self.eval_metric
+        eval_metric = self._get_eval_metric(metric)
 
         logger.info("Computing feature importance")
 
@@ -902,11 +908,13 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         for n in range(num_iterations):
             if subsample_size < data.num_items:
                 item_ids_sampled = data.item_ids.to_series().sample(subsample_size)  # noqa
-                data_sample: TimeSeriesDataFrame = data.query("item_id in @item_ids_sampled")  # type: ignore
+                data_sample: TimeSeriesDataFrame = data.query("item_id in @item_ids_sampled")
             else:
                 data_sample = data
 
-            base_score = self.evaluate(data=data_sample, model=model, metrics=metric, use_cache=False)[metric.name]
+            base_score = self.evaluate(data=data_sample, model=model, metrics=eval_metric, use_cache=False)[
+                eval_metric.name
+            ]
 
             for feature in features:
                 # override importance for unused features
@@ -914,9 +922,9 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
                     continue
                 else:
                     data_sample_replaced = importance_transform.transform(data_sample, feature_name=feature)
-                    score = self.evaluate(data=data_sample_replaced, model=model, metrics=metric, use_cache=False)[
-                        metric.name
-                    ]
+                    score = self.evaluate(
+                        data=data_sample_replaced, model=model, metrics=eval_metric, use_cache=False
+                    )[eval_metric.name]
 
                     importance = base_score - score
                     if relative_scores:
@@ -1266,7 +1274,6 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         return get_preset_models(
             path=self.path,
             eval_metric=self.eval_metric,
-            eval_metric_seasonal_period=self.eval_metric_seasonal_period,
             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.1b20250424"
+__version__ = "1.2.1b20250426"
 __lite__ = False

{autogluon.timeseries-1.2.1b20250424.dist-info → autogluon.timeseries-1.2.1b20250426.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.2.1b20250424
+Version: 1.2.1b20250426
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -55,10 +55,10 @@ 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.1b20250424
-Requires-Dist: autogluon.common==1.2.1b20250424
-Requires-Dist: autogluon.features==1.2.1b20250424
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250424
+Requires-Dist: autogluon.core[raytune]==1.2.1b20250426
+Requires-Dist: autogluon.common==1.2.1b20250426
+Requires-Dist: autogluon.features==1.2.1b20250426
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250426
 Provides-Extra: all
 Provides-Extra: chronos-onnx
 Requires-Dist: optimum[onnxruntime]<1.23,>=1.17; extra == "chronos-onnx"