autogluon.timeseries 1.2.1b20250416__py3-none-any.whl → 1.2.1b20250418__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,26 +245,26 @@ 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)
-            self.num_feat_static_real = len(self.metadata.static_features_real)
+            self.num_feat_static_cat = len(self.covariate_metadata.static_features_cat)
+            self.num_feat_static_real = len(self.covariate_metadata.static_features_real)
             if self.num_feat_static_cat > 0:
                 assert dataset.static_features is not None, (
                     "Static features must be provided if num_feat_static_cat > 0"
                 )
-                feat_static_cat = dataset.static_features[self.metadata.static_features_cat]
+                feat_static_cat = dataset.static_features[self.covariate_metadata.static_features_cat]
                 self.feat_static_cat_cardinality = feat_static_cat.nunique().tolist()
 
         disable_known_covariates = model_params.get("disable_known_covariates", False)
         if not disable_known_covariates and self.supports_known_covariates:
-            self.num_feat_dynamic_cat = len(self.metadata.known_covariates_cat)
-            self.num_feat_dynamic_real = len(self.metadata.known_covariates_real)
+            self.num_feat_dynamic_cat = len(self.covariate_metadata.known_covariates_cat)
+            self.num_feat_dynamic_real = len(self.covariate_metadata.known_covariates_real)
             if self.num_feat_dynamic_cat > 0:
-                feat_dynamic_cat = dataset[self.metadata.known_covariates_cat]
+                feat_dynamic_cat = dataset[self.covariate_metadata.known_covariates_cat]
                 if self.supports_cat_covariates:
                     self.feat_dynamic_cat_cardinality = feat_dynamic_cat.nunique().tolist()
                 else:
@@ -280,10 +280,10 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
 
         disable_past_covariates = model_params.get("disable_past_covariates", False)
         if not disable_past_covariates and self.supports_past_covariates:
-            self.num_past_feat_dynamic_cat = len(self.metadata.past_covariates_cat)
-            self.num_past_feat_dynamic_real = len(self.metadata.past_covariates_real)
+            self.num_past_feat_dynamic_cat = len(self.covariate_metadata.past_covariates_cat)
+            self.num_past_feat_dynamic_real = len(self.covariate_metadata.past_covariates_real)
             if self.num_past_feat_dynamic_cat > 0:
-                past_feat_dynamic_cat = dataset[self.metadata.past_covariates_cat]
+                past_feat_dynamic_cat = dataset[self.covariate_metadata.past_covariates_cat]
                 if self.supports_cat_covariates:
                     self.past_feat_dynamic_cat_cardinality = past_feat_dynamic_cat.nunique().tolist()
                 else:
@@ -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
@@ -400,7 +400,9 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
                 assert time_series_df.static_features is not None, (
                     "Static features must be provided if num_feat_static_cat > 0"
                 )
-                feat_static_cat = time_series_df.static_features[self.metadata.static_features_cat].to_numpy()
+                feat_static_cat = time_series_df.static_features[
+                    self.covariate_metadata.static_features_cat
+                ].to_numpy()
             else:
                 feat_static_cat = None
 
@@ -408,7 +410,9 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
                 assert time_series_df.static_features is not None, (
                     "Static features must be provided if num_feat_static_real > 0"
                 )
-                feat_static_real = time_series_df.static_features[self.metadata.static_features_real].to_numpy()
+                feat_static_real = time_series_df.static_features[
+                    self.covariate_metadata.static_features_real
+                ].to_numpy()
             else:
                 feat_static_real = None
 
@@ -418,31 +422,31 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
             if known_covariates is not None:
                 known_covariates = pd.DataFrame(known_covariates)  # type: ignore
             if self.num_feat_dynamic_cat > 0:
-                feat_dynamic_cat = df[self.metadata.known_covariates_cat].to_numpy()
+                feat_dynamic_cat = df[self.covariate_metadata.known_covariates_cat].to_numpy()
                 if known_covariates is not None:
                     feat_dynamic_cat = np.concatenate(
-                        [feat_dynamic_cat, known_covariates[self.metadata.known_covariates_cat].to_numpy()]
+                        [feat_dynamic_cat, known_covariates[self.covariate_metadata.known_covariates_cat].to_numpy()]
                     )
                     assert len(feat_dynamic_cat) == expected_known_covariates_len
             else:
                 feat_dynamic_cat = None
 
             if self.num_feat_dynamic_real > 0:
-                feat_dynamic_real = df[self.metadata.known_covariates_real].to_numpy()
+                feat_dynamic_real = df[self.covariate_metadata.known_covariates_real].to_numpy()
                 # Append future values of known covariates
                 if known_covariates is not None:
                     feat_dynamic_real = np.concatenate(
-                        [feat_dynamic_real, known_covariates[self.metadata.known_covariates_real].to_numpy()]
+                        [feat_dynamic_real, known_covariates[self.covariate_metadata.known_covariates_real].to_numpy()]
                     )
                     assert len(feat_dynamic_real) == expected_known_covariates_len
                 # Categorical covariates are one-hot-encoded as real
                 if self._ohe_generator_known is not None:
                     feat_dynamic_cat_ohe: np.ndarray = self._ohe_generator_known.transform(
-                        df[self.metadata.known_covariates_cat]
+                        df[self.covariate_metadata.known_covariates_cat]
                     )  # type: ignore
                     if known_covariates is not None:
                         future_dynamic_cat_ohe: np.ndarray = self._ohe_generator_known.transform(  # type: ignore
-                            known_covariates[self.metadata.known_covariates_cat]
+                            known_covariates[self.covariate_metadata.known_covariates_cat]
                         )
                         feat_dynamic_cat_ohe = np.concatenate([feat_dynamic_cat_ohe, future_dynamic_cat_ohe])
                         assert len(feat_dynamic_cat_ohe) == expected_known_covariates_len
@@ -451,15 +455,15 @@ class AbstractGluonTSModel(AbstractTimeSeriesModel):
                 feat_dynamic_real = None
 
             if self.num_past_feat_dynamic_cat > 0:
-                past_feat_dynamic_cat = df[self.metadata.past_covariates_cat].to_numpy()
+                past_feat_dynamic_cat = df[self.covariate_metadata.past_covariates_cat].to_numpy()
             else:
                 past_feat_dynamic_cat = None
 
             if self.num_past_feat_dynamic_real > 0:
-                past_feat_dynamic_real = df[self.metadata.past_covariates_real].to_numpy()
+                past_feat_dynamic_real = df[self.covariate_metadata.past_covariates_real].to_numpy()
                 if self._ohe_generator_past is not None:
                     past_feat_dynamic_cat_ohe: np.ndarray = self._ohe_generator_past.transform(  # type: ignore
-                        df[self.metadata.past_covariates_cat]
+                        df[self.covariate_metadata.past_covariates_cat]
                     )
                     past_feat_dynamic_real = np.concatenate(
                         [past_feat_dynamic_real, past_feat_dynamic_cat_ohe], axis=1
@@ -517,7 +521,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/models/presets.py

@@ -186,7 +186,7 @@ def get_preset_models(
     eval_metric_seasonal_period: Optional[int],
     hyperparameters: Union[str, Dict, None],
     hyperparameter_tune: bool,
-    metadata: CovariateMetadata,
+    covariate_metadata: CovariateMetadata,
     all_assigned_names: List[str],
     excluded_model_types: Optional[List[str]],
     multi_window: bool = False,
@@ -261,7 +261,7 @@ def get_preset_models(
                 prediction_length=prediction_length,
                 eval_metric=eval_metric,
                 eval_metric_seasonal_period=eval_metric_seasonal_period,
-                metadata=metadata,
+                covariate_metadata=covariate_metadata,
                 hyperparameters=model_hps,
                 **kwargs,
             )

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."""
 
@@ -1428,7 +1444,8 @@ class TimeSeriesPredictor:
         }
 
         past_data, known_covariates = test_data.get_model_inputs_for_scoring(
-            prediction_length=self.prediction_length, known_covariates_names=trainer.metadata.known_covariates
+            prediction_length=self.prediction_length,
+            known_covariates_names=trainer.covariate_metadata.known_covariates,
         )
         pred_proba_dict_test, _ = trainer.get_model_pred_dict(
             base_model_names, data=past_data, known_covariates=known_covariates
@@ -1463,7 +1480,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
         ----------