autogluon.timeseries 1.2.1b20250416__py3-none-any.whl → 1.2.1b20250417__py3-none-any.whl

autogluon/timeseries/models/chronos/model.py

@@ -228,7 +228,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         fine_tune_ckpt_path = Path(model.path) / cls.fine_tuned_ckpt_name
         if fine_tune_ckpt_path.exists():
             logger.debug(f"\tFine-tuned checkpoint exists, setting model_path to {fine_tune_ckpt_path}")
-            model.model_path = fine_tune_ckpt_path
+            model.model_path = str(fine_tune_ckpt_path)
 
         return model
 
@@ -249,8 +249,10 @@ class ChronosModel(AbstractTimeSeriesModel):
         """The default configuration of the model used by AutoGluon if the model is one of those
         defined in MODEL_CONFIGS. For now, these are ``autogluon/chronos-t5-*`` family of models.
         """
-        model_name = str(self.model_path).split("/")[-1]
-        return MODEL_CONFIGS.get(model_name, {})
+        for k in MODEL_CONFIGS:
+            if k in self.model_path:
+                return MODEL_CONFIGS[k]
+        return {}
 
     @property
     def min_num_gpus(self) -> int:
@@ -314,28 +316,38 @@ class ChronosModel(AbstractTimeSeriesModel):
 
         return torch.cuda.is_available() and torch.cuda.get_device_capability()[0] >= 8
 
-    def _get_model_params(self) -> dict:
+    def get_hyperparameters(self) -> dict:
         """Gets params that are passed to the inner model."""
-        init_args = super()._get_model_params().copy()
-
-        init_args.setdefault("batch_size", self.default_batch_size)
-        init_args.setdefault("num_samples", self.default_num_samples)
-        init_args.setdefault("device", None)
-        # if the model requires a GPU, set the torch dtype to bfloat16
-        init_args.setdefault("torch_dtype", self.default_torch_dtype)
-        init_args.setdefault("data_loader_num_workers", 0)
-        init_args.setdefault("context_length", None)
-        init_args.setdefault("optimization_strategy", None)
-        init_args.setdefault("fine_tune", False)
-        init_args.setdefault("keep_transformers_logs", False)
-        init_args.setdefault("fine_tune_lr", 1e-5)
-        init_args.setdefault("fine_tune_steps", 1000)
-        init_args.setdefault("fine_tune_batch_size", 32)
-        init_args.setdefault("eval_during_fine_tune", False)
-        init_args.setdefault("fine_tune_eval_max_items", 256)
-        init_args.setdefault("fine_tune_shuffle_buffer_size", 10_000)
+        init_args = super().get_hyperparameters()
 
         eval_during_fine_tune = init_args["eval_during_fine_tune"]
+        fine_tune_trainer_kwargs = self._get_fine_tune_trainer_kwargs(init_args, eval_during_fine_tune)
+        user_fine_tune_trainer_kwargs = init_args.get("fine_tune_trainer_kwargs", {})
+        fine_tune_trainer_kwargs.update(user_fine_tune_trainer_kwargs)
+        init_args["fine_tune_trainer_kwargs"] = fine_tune_trainer_kwargs
+
+        return init_args.copy()
+
+    def _get_default_hyperparameters(self) -> Dict:
+        return {
+            "batch_size": self.default_batch_size,
+            "num_samples": self.default_num_samples,
+            "device": None,
+            "torch_dtype": self.default_torch_dtype,
+            "data_loader_num_workers": 0,
+            "context_length": None,
+            "optimization_strategy": None,
+            "fine_tune": False,
+            "keep_transformers_logs": False,
+            "fine_tune_lr": 1e-5,
+            "fine_tune_steps": 1000,
+            "fine_tune_batch_size": 32,
+            "eval_during_fine_tune": False,
+            "fine_tune_eval_max_items": 256,
+            "fine_tune_shuffle_buffer_size": 10_000,
+        }
+
+    def _get_fine_tune_trainer_kwargs(self, init_args, eval_during_fine_tune: bool):
         output_dir = Path(self.path) / "transformers_logs"
         fine_tune_trainer_kwargs = dict(
             output_dir=str(output_dir),
@@ -364,12 +376,8 @@ class ChronosModel(AbstractTimeSeriesModel):
             load_best_model_at_end=True if eval_during_fine_tune else False,
             metric_for_best_model="eval_loss" if eval_during_fine_tune else None,
         )
-        user_fine_tune_trainer_kwargs = init_args.get("fine_tune_trainer_kwargs", {})
-        fine_tune_trainer_kwargs.update(user_fine_tune_trainer_kwargs)
 
-        init_args["fine_tune_trainer_kwargs"] = fine_tune_trainer_kwargs
-
-        return init_args
+        return fine_tune_trainer_kwargs
 
     def _validate_and_assign_attributes(self, model_params: dict):
         # we validate the params here because their values are concrete,
@@ -432,8 +440,7 @@ class ChronosModel(AbstractTimeSeriesModel):
                 transformers_logger.setLevel(logging.ERROR if verbosity <= 3 else logging.INFO)
 
         self._check_fit_params()
-
-        model_params = self._get_model_params()
+        model_params = self.get_hyperparameters()
         self._validate_and_assign_attributes(model_params)
         do_fine_tune = model_params["fine_tune"]
 
@@ -655,7 +662,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         return TimeSeriesDataFrame(df)
 
     def _more_tags(self) -> Dict:
-        do_fine_tune = self._get_model_params()["fine_tune"]
+        do_fine_tune = self.get_hyperparameters()["fine_tune"]
         return {
             "allow_nan": True,
             "can_use_train_data": do_fine_tune,

autogluon/timeseries/models/gluonts/abstract_gluonts.py

@@ -245,9 +245,9 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
     def _get_hpo_backend(self):
         return RAY_BACKEND
 
-    def _deferred_init_params_aux(self, dataset: TimeSeriesDataFrame) -> None:
-        """Update GluonTS specific parameters with information available only at training time."""
-        model_params = self._get_model_params()
+    def _deferred_init_hyperparameters(self, dataset: TimeSeriesDataFrame) -> None:
+        """Update GluonTS specific hyperparameters with information available only at training time."""
+        model_params = self.get_hyperparameters()
         disable_static_features = model_params.get("disable_static_features", False)
         if not disable_static_features:
             self.num_feat_static_cat = len(self.metadata.static_features_cat)
@@ -301,7 +301,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
 
         self.negative_data = (dataset[self.target] < 0).any()
 
-    def _get_default_params(self):
+    def _get_default_hyperparameters(self):
         """Gets default parameters for GluonTS estimator initialization that are available after
         AbstractTimeSeriesModel initialization (i.e., before deferred initialization). Models may
         override this method to update default parameters.
@@ -319,7 +319,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             "covariate_scaler": "global",
         }
 
-    def _get_model_params(self) -> dict:
+    def get_hyperparameters(self) -> dict:
         """Gets params that are passed to the inner model."""
         # for backward compatibility with the old GluonTS MXNet API
         parameter_name_aliases = {
@@ -327,7 +327,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             "learning_rate": "lr",
         }
 
-        init_args = super()._get_model_params()
+        init_args = super().get_hyperparameters()
         for alias, actual in parameter_name_aliases.items():
             if alias in init_args:
                 if actual in init_args:
@@ -335,12 +335,12 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
                 else:
                     init_args[actual] = init_args.pop(alias)
 
-        return self._get_default_params() | init_args
+        return self._get_default_hyperparameters() | init_args
 
     def _get_estimator_init_args(self) -> Dict[str, Any]:
-        """Get GluonTS specific constructor arguments for estimator objects, an alias to `self._get_model_params`
+        """Get GluonTS specific constructor arguments for estimator objects, an alias to `self.get_hyperparameters`
         for better readability."""
-        return self._get_model_params()
+        return self.get_hyperparameters()
 
     def _get_estimator_class(self) -> Type[GluonTSEstimator]:
         raise NotImplementedError
@@ -517,7 +517,7 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             time_limit=time_limit,
             early_stopping_patience=None if val_data is None else init_args["early_stopping_patience"],
         )
-        self._deferred_init_params_aux(train_data)
+        self._deferred_init_hyperparameters(train_data)
 
         estimator = self._get_estimator()
         with warning_filter(), disable_root_logger(), gluonts.core.settings.let(gluonts_env, use_tqdm=False):

autogluon/timeseries/models/gluonts/torch/models.py

@@ -208,8 +208,8 @@ class TemporalFusionTransformerModel(AbstractGluonTSModel):
 
         return TemporalFusionTransformerEstimator
 
-    def _get_default_params(self):
-        return super()._get_default_params() | {
+    def _get_default_hyperparameters(self):
+        return super()._get_default_hyperparameters() | {
             "context_length": min(512, max(64, 2 * self.prediction_length)),
         }
 
@@ -281,8 +281,8 @@ class DLinearModel(AbstractGluonTSModel):
         If True, ``lightning_logs`` directory will NOT be removed after the model finished training.
     """
 
-    def _get_default_params(self):
-        return super()._get_default_params() | {
+    def _get_default_hyperparameters(self):
+        return super()._get_default_hyperparameters() | {
             "context_length": 96,
         }
 
@@ -346,8 +346,8 @@ class PatchTSTModel(AbstractGluonTSModel):
 
         return PatchTSTEstimator
 
-    def _get_default_params(self):
-        return super()._get_default_params() | {"context_length": 96, "patch_len": 16}
+    def _get_default_hyperparameters(self):
+        return super()._get_default_hyperparameters() | {"context_length": 96, "patch_len": 16}
 
     def _get_estimator_init_args(self) -> Dict[str, Any]:
         init_kwargs = super()._get_estimator_init_args()
@@ -515,8 +515,8 @@ class TiDEModel(AbstractGluonTSModel):
 
         return TiDEEstimator
 
-    def _get_default_params(self):
-        return super()._get_default_params() | {
+    def _get_default_hyperparameters(self):
+        return super()._get_default_hyperparameters() | {
             "context_length": min(512, max(64, 2 * self.prediction_length)),
             "encoder_hidden_dim": 64,
             "decoder_hidden_dim": 64,

autogluon/timeseries/models/local/abstract_local_model.py

@@ -112,7 +112,7 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
             raise TimeLimitExceeded
 
         # Initialize parameters passed to each local model
-        raw_local_model_args = self._get_model_params().copy()
+        raw_local_model_args = self.get_hyperparameters().copy()
 
         unused_local_model_args = []
         local_model_args = {}

autogluon/timeseries/models/local/naive.py

@@ -85,7 +85,7 @@ class SeasonalNaiveModel(AbstractLocalModel):
 
 
 class AverageModel(AbstractLocalModel):
-    """Baseline model that sets the forecast equal to the historic average or quantile.
+    """Baseline model that sets the forecast equal to the historical average or quantile.
 
     Other Parameters
     ----------------
@@ -117,7 +117,7 @@ class AverageModel(AbstractLocalModel):
 
 
 class SeasonalAverageModel(AbstractLocalModel):
-    """Baseline model that sets the forecast equal to the historic average or quantile in the same season.
+    """Baseline model that sets the forecast equal to the historical average or quantile in the same season.
 
     Other Parameters
     ----------------

autogluon/timeseries/models/multi_window/multi_window_model.py

@@ -212,9 +212,6 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
         if store_predict_time:
             assert self.predict_time is not None
 
-    def get_user_params(self) -> dict:
-        return self.model_base.get_user_params()
-
     def _get_search_space(self):
         return self.model_base._get_search_space()
 

autogluon/timeseries/predictor.py

@@ -27,6 +27,7 @@ from autogluon.timeseries.learner import TimeSeriesLearner
 from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_metric
 from autogluon.timeseries.splitter import ExpandingWindowSplitter
 from autogluon.timeseries.trainer import TimeSeriesTrainer
+from autogluon.timeseries.utils.forecast import make_future_data_frame
 
 logger = logging.getLogger("autogluon.timeseries")
 
@@ -305,11 +306,11 @@ class TimeSeriesPredictor:
         return df
 
     def _check_data_for_evaluation(self, data: TimeSeriesDataFrame, name: str = "data") -> None:
-        """Make sure that provided evaluation data includes both historic and future time series values."""
+        """Make sure that provided evaluation data includes both historical and future time series values."""
         if data.num_timesteps_per_item().min() <= self.prediction_length:
             raise ValueError(
                 f"Cannot reserve last prediction_length={self.prediction_length} time steps for evaluation in some "
-                f"time series in {name}. Please make sure that {name} includes both historic and future data, and that"
+                f"time series in {name}. Please make sure that {name} includes both historical and future data, and that"
                 f"all time series have length > prediction_length (at least {self.prediction_length + 1})"
             )
 
@@ -441,9 +442,8 @@ class TimeSeriesPredictor:
 
                 data.static_features["store_id"] = data.static_features["store_id"].astype("category")
 
-            If provided data is a path or a pandas.DataFrame, AutoGluon will attempt to automatically convert it to a
-            ``TimeSeriesDataFrame``.
-
+            If provided data is a `pandas.DataFrame`, AutoGluon will attempt to convert it to a `TimeSeriesDataFrame`.
+            If a `str` or a `Path` is provided, AutoGluon will attempt to load this file.
         tuning_data : Union[TimeSeriesDataFrame, pd.DataFrame, Path, str], optional
             Data reserved for model selection and hyperparameter tuning, rather than training individual models. Also
             used to compute the validation scores. Note that only the last ``prediction_length`` time steps of each
@@ -455,16 +455,10 @@ class TimeSeriesPredictor:
             Leaving this argument empty and letting AutoGluon automatically generate the validation set from
             ``train_data`` is a good default.
 
-            If ``known_covariates_names`` were specified when creating the predictor, ``tuning_data`` must also include
-            the columns listed in ``known_covariates_names`` with the covariates values aligned with the target time
-            series.
-
-            If ``train_data`` has past covariates or static features, ``tuning_data`` must have also include them (with
-            same columns names and dtypes).
-
-            If provided data is a path or a pandas.DataFrame, AutoGluon will attempt to automatically convert it to a
-            ``TimeSeriesDataFrame``.
+            The names and dtypes of columns and static features in ``tuning_data`` must match the ``train_data``.
 
+            If provided data is a `pandas.DataFrame`, AutoGluon will attempt to convert it to a `TimeSeriesDataFrame`.
+            If a `str` or a `Path` is provided, AutoGluon will attempt to load this file.
         time_limit : int, optional
             Approximately how long :meth:`~autogluon.timeseries.TimeSeriesPredictor.fit` will run (wall-clock time in
             seconds). If not specified, :meth:`~autogluon.timeseries.TimeSeriesPredictor.fit` will run until all models
@@ -775,23 +769,23 @@ class TimeSeriesPredictor:
         Parameters
         ----------
         data : Union[TimeSeriesDataFrame, pd.DataFrame, Path, str]
-            Time series data to forecast with.
-
-            If ``known_covariates_names`` were specified when creating the predictor, ``data`` must include the columns
-            listed in ``known_covariates_names`` with the covariates values aligned with the target time series.
+            Historical time series data for which the forecast needs to be made.
 
-            If ``train_data`` used to train the predictor contained past covariates or static features, then ``data``
-            must also include them (with same column names and dtypes).
+            The names and dtypes of columns and static features in ``data`` must match the ``train_data`` used to train
+            the predictor.
 
-            If provided data is an instance of pandas DataFrame, AutoGluon will attempt to automatically convert it
-            to a ``TimeSeriesDataFrame``.
+            If provided data is a `pandas.DataFrame`, AutoGluon will attempt to convert it to a `TimeSeriesDataFrame`.
+            If a `str` or a `Path` is provided, AutoGluon will attempt to load this file.
         known_covariates : Union[TimeSeriesDataFrame, pd.DataFrame, Path, str], optional
             If ``known_covariates_names`` were specified when creating the predictor, it is necessary to provide the
-            values of the known covariates for each time series during the forecast horizon. That is:
+            values of the known covariates for each time series during the forecast horizon. Specifically:
 
-            - The columns must include all columns listed in ``known_covariates_names``
-            - The ``item_id`` index must include all item ids present in ``data``
-            - The ``timestamp`` index must include the values for ``prediction_length`` many time steps into the future from the end of each time series in ``data``
+            - Must contain all columns listed in ``known_covariates_names``.
+            - Must include all ``item_id`` values present in the input ``data``.
+            - Must include ``timestamp`` values for the full forecast horizon (i.e., ``prediction_length`` time steps) following the end of each series in the input ``data``.
+
+            You can use :meth:`autogluon.timeseries.TimeSeriesPredictor.make_future_data_frame` to generate a template
+            containing the required ``item_id`` and ``timestamp`` combinations for the `known_covariates` data frame.
 
             See example below.
         model : str, optional
@@ -872,17 +866,14 @@ class TimeSeriesPredictor:
             The data to evaluate the best model on. The last ``prediction_length`` time steps of each time series in
             ``data`` will be held out for prediction and forecast accuracy will be calculated on these time steps.
 
-            Must include both historic and future data (i.e., length of all time series in ``data`` must be at least
+            Must include both historical and future data (i.e., length of all time series in ``data`` must be at least
             ``prediction_length + 1``).
 
-            If ``known_covariates_names`` were specified when creating the predictor, ``data`` must include the columns
-            listed in ``known_covariates_names`` with the covariates values aligned with the target time series.
-
-            If ``train_data`` used to train the predictor contained past covariates or static features, then ``data``
-            must also include them (with same column names and dtypes).
+            The names and dtypes of columns and static features in ``data`` must match the ``train_data`` used to train
+            the predictor.
 
-            If provided data is an instance of pandas DataFrame, AutoGluon will attempt to automatically convert it
-            to a ``TimeSeriesDataFrame``.
+            If provided data is a `pandas.DataFrame`, AutoGluon will attempt to convert it to a `TimeSeriesDataFrame`.
+            If a `str` or a `Path` is provided, AutoGluon will attempt to load this file.
         model : str, optional
             Name of the model that you would like to evaluate. By default, the best model during training
             (with highest validation score) will be used.
@@ -948,15 +939,11 @@ class TimeSeriesPredictor:
             item, will be held out for prediction and forecast accuracy will be calculated on these time steps.
             More accurate feature importances will be obtained from new data that was held-out during ``fit()``.
 
-            If ``known_covariates_names`` were specified when creating the predictor, ``data`` must include the columns
-            listed in ``known_covariates_names`` with the covariates values aligned with the target time series.
-            This data must contain the label column with the same column name as specified during ``fit()``.
-
-            If ``train_data`` used to train the predictor contained past covariates or static features, then ``data``
-            must also include them (with same column names and dtypes).
+            The names and dtypes of columns and static features in ``data`` must match the ``train_data`` used to train
+            the predictor.
 
-            If provided data is an instance of pandas DataFrame, AutoGluon will attempt to automatically convert it
-            to a ``TimeSeriesDataFrame``. If str or Path is passed, ``data`` will be loaded using the str value as the file path.
+            If provided data is a `pandas.DataFrame`, AutoGluon will attempt to convert it to a `TimeSeriesDataFrame`.
+            If a `str` or a `Path` is provided, AutoGluon will attempt to load this file.
 
             If ``data`` is not provided, then validation (tuning) data provided during training (or the held out data used for
             validation if ``tuning_data`` was not explicitly provided ``fit()``) will be used.
@@ -1228,18 +1215,14 @@ class TimeSeriesPredictor:
         Parameters
         ----------
         data : Union[TimeSeriesDataFrame, pd.DataFrame, Path, str], optional
-            dataset used for additional evaluation. Must include both historic and future data (i.e., length of all
+            dataset used for additional evaluation. Must include both historical and future data (i.e., length of all
             time series in ``data`` must be at least ``prediction_length + 1``).
 
-            If ``known_covariates_names`` were specified when creating the predictor, ``data`` must include the columns
-            listed in ``known_covariates_names`` with the covariates values aligned with the target time series.
-
-            If ``train_data`` used to train the predictor contained past covariates or static features, then ``data``
-            must also include them (with same column names and dtypes).
-
-            If provided data is a path or a pandas.DataFrame, AutoGluon will attempt to automatically convert it to a
-            ``TimeSeriesDataFrame``.
+            The names and dtypes of columns and static features in ``data`` must match the ``train_data`` used to train
+            the predictor.
 
+            If provided data is a `pandas.DataFrame`, AutoGluon will attempt to convert it to a `TimeSeriesDataFrame`.
+            If a `str` or a `Path` is provided, AutoGluon will attempt to load this file.
         extra_info : bool, default = False
             If True, the leaderboard will contain an additional column `hyperparameters` with the hyperparameters used
             by each model during training. An empty dictionary `{}` means that the model was trained with default
@@ -1288,6 +1271,44 @@ class TimeSeriesPredictor:
                 print(leaderboard)
         return leaderboard
 
+    def make_future_data_frame(self, data: Union[TimeSeriesDataFrame, pd.DataFrame, Path, str]) -> pd.DataFrame:
+        """Generate a data frame with the `item_id` and `timestamp` values corresponding to the forecast horizon.
+
+        Parameters
+        ----------
+        data : Union[TimeSeriesDataFrame, pd.DataFrame, Path, str]
+            Historical time series data.
+
+        Returns
+        -------
+        forecast_horizon : pd.DataFrame
+            Data frame with columns `item_id` and `timestamp` corresponding to the forecast horizon. For each item ID
+            in `data`, `forecast_horizon` will contain the timestamps for the next `prediction_length` time steps,
+            following the end of each series in the input data.
+
+        Examples
+        --------
+        >>> print(data)
+                            target
+        item_id timestamp
+        A       2024-01-01       0
+                2024-01-02       1
+                2024-01-03       2
+        B       2024-04-07       3
+                2024-04-08       4
+        >>> predictor = TimeSeriesPredictor(prediction_length=2, freq="D")
+        >>> print(predictor.make_future_data_frame(data))
+          item_id  timestamp
+        0       A 2024-01-04
+        0       A 2024-01-05
+        1       B 2024-04-09
+        1       B 2024-04-10
+        """
+        if self.freq is None:
+            raise ValueError("Please fit the predictor before calling `make_future_data_frame`")
+        data = self._check_and_prepare_data_frame(data)
+        return make_future_data_frame(data, prediction_length=self.prediction_length, freq=self.freq)
+
     def fit_summary(self, verbosity: int = 1) -> Dict[str, Any]:
         """Output summary of information about models produced during
         :meth:`~autogluon.timeseries.TimeSeriesPredictor.fit`.
@@ -1323,7 +1344,7 @@ class TimeSeriesPredictor:
         model_hyperparams = {}
         for model_name in self.model_names():
             model_obj = self._trainer.load_model(model_name)
-            model_hyperparams[model_name] = model_obj.params
+            model_hyperparams[model_name] = model_obj.get_hyperparameters()
 
         results["model_hyperparams"] = model_hyperparams
         results["leaderboard"] = self._learner.leaderboard()
@@ -1400,11 +1421,6 @@ class TimeSeriesPredictor:
                 )
         return refit_full_dict
 
-    def __dir__(self) -> List[str]:
-        # This hides method from IPython autocomplete, but not VSCode autocomplete
-        deprecated = ["score", "get_model_best", "get_model_names"]
-        return [d for d in super().__dir__() if d not in deprecated]
-
     def _simulation_artifact(self, test_data: TimeSeriesDataFrame) -> dict:
         """[Advanced] Computes and returns the necessary information to perform offline ensemble simulation."""
 
@@ -1463,7 +1479,7 @@ class TimeSeriesPredictor:
         point_forecast_column: Optional[str] = None,
         matplotlib_rc_params: Optional[dict] = None,
     ):
-        """Plot historic time series values and the forecasts.
+        """Plot historical time series values and the forecasts.
 
         Parameters
         ----------

autogluon/timeseries/trainer.py

@@ -434,7 +434,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
                     "When `skip_model_selection=True`, only a single model must be provided via `hyperparameters` "
                     f"but {len(models)} models were given"
                 )
-            if contains_searchspace(models[0].get_user_params()):
+            if contains_searchspace(models[0].get_hyperparameters()):
                 raise ValueError(
                     "When `skip_model_selection=True`, model configuration should contain no search spaces."
                 )
@@ -462,7 +462,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
             if random_seed is not None:
                 seed_everything(random_seed + i)
 
-            if contains_searchspace(model.get_user_params()):
+            if contains_searchspace(model.get_hyperparameters()):
                 fit_log_message = f"Hyperparameter tuning model {model.name}. "
                 if time_left is not None:
                     fit_log_message += (
@@ -629,7 +629,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
                 if isinstance(model, MultiWindowBacktestingModel):
                     model = model.most_recent_model
                     assert model is not None
-                model_info[model_name]["hyperparameters"] = model.params
+                model_info[model_name]["hyperparameters"] = model.get_hyperparameters()
 
         if extra_metrics is None:
             extra_metrics = []

autogluon/timeseries/utils/forecast.py

@@ -4,6 +4,7 @@ from typing import Optional
 import numpy as np
 import pandas as pd
 
+from autogluon.common.utils.deprecated_utils import Deprecated
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TIMESTAMP, TimeSeriesDataFrame
 
 
@@ -18,20 +19,24 @@ def get_forecast_horizon_index_single_time_series(
     return pd.date_range(start=start_ts, periods=prediction_length, freq=freq, name=TIMESTAMP)
 
 
-# TODO: Deprecate this method, add this functionality to `TimeSeriesPredictor`
-def get_forecast_horizon_index_ts_dataframe(
+@Deprecated(
+    min_version_to_warn="1.3", min_version_to_error="2.0", new="TimeSeriesPredictor.forecast_horizon_data_frame"
+)
+def get_forecast_horizon_index_ts_dataframe(*args, **kwargs) -> pd.MultiIndex:
+    return pd.MultiIndex.from_frame(make_future_data_frame(*args, **kwargs))
+
+
+def make_future_data_frame(
     ts_dataframe: TimeSeriesDataFrame,
     prediction_length: int,
     freq: Optional[str] = None,
-) -> pd.MultiIndex:
+) -> pd.DataFrame:
     """For each item in the dataframe, get timestamps for the next `prediction_length` time steps into the future.
 
-    Returns a pandas.MultiIndex, where
-    - level 0 ("item_id") contains the same item_ids as the input ts_dataframe.
-    - level 1 ("timestamp") contains the next prediction_length time steps starting from the end of each time series.
+    Returns a pandas.DataFrame, with columns "item_id" and "timestamp" corresponding to the forecast horizon.
     """
     last = ts_dataframe.reset_index()[[ITEMID, TIMESTAMP]].groupby(by=ITEMID, sort=False, as_index=False).last()
-    item_ids = np.repeat(last[ITEMID], prediction_length)
+    item_ids = np.repeat(last[ITEMID].to_numpy(), prediction_length)
 
     if freq is None:
         freq = ts_dataframe.freq
@@ -41,4 +46,4 @@ def get_forecast_horizon_index_ts_dataframe(
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", category=pd.errors.PerformanceWarning)
         timestamps = np.dstack([last_ts + step * offset for step in range(1, prediction_length + 1)]).ravel()  # type: ignore[operator]
-    return pd.MultiIndex.from_arrays([item_ids, timestamps], names=[ITEMID, TIMESTAMP])
+    return pd.DataFrame({ITEMID: item_ids, TIMESTAMP: timestamps})

autogluon/timeseries/version.py

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

{autogluon.timeseries-1.2.1b20250416.dist-info → autogluon.timeseries-1.2.1b20250417.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.2.1b20250416
+Version: 1.2.1b20250417
 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.1b20250416
-Requires-Dist: autogluon.common==1.2.1b20250416
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250416
+Requires-Dist: autogluon.core[raytune]==1.2.1b20250417
+Requires-Dist: autogluon.common==1.2.1b20250417
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250417
 Provides-Extra: all
 Provides-Extra: chronos-onnx
 Requires-Dist: optimum[onnxruntime]<1.23,>=1.17; extra == "chronos-onnx"