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

autogluon/timeseries/learner.py

@@ -12,7 +12,7 @@ from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
 from autogluon.timeseries.splitter import AbstractWindowSplitter
 from autogluon.timeseries.trainer import TimeSeriesTrainer
 from autogluon.timeseries.utils.features import TimeSeriesFeatureGenerator
-from autogluon.timeseries.utils.forecast import get_forecast_horizon_index_ts_dataframe
+from autogluon.timeseries.utils.forecast import make_future_data_frame
 
 logger = logging.getLogger(__name__)
 
@@ -88,7 +88,7 @@ class TimeSeriesLearner(AbstractLearner):
                 verbosity=kwargs.get("verbosity", 2),
                 skip_model_selection=kwargs.get("skip_model_selection", False),
                 enable_ensemble=kwargs.get("enable_ensemble", True),
-                metadata=self.feature_generator.covariate_metadata,
+                covariate_metadata=self.feature_generator.covariate_metadata,
                 val_splitter=val_splitter,
                 refit_every_n_windows=refit_every_n_windows,
                 cache_predictions=self.cache_predictions,
@@ -148,15 +148,17 @@ class TimeSeriesLearner(AbstractLearner):
                 f"known_covariates are missing information for the following item_ids: {reprlib.repr(missing_item_ids.to_list())}."
             )
 
-        forecast_index = get_forecast_horizon_index_ts_dataframe(
-            data, prediction_length=self.prediction_length, freq=self.freq
+        forecast_index = pd.MultiIndex.from_frame(
+            make_future_data_frame(data, prediction_length=self.prediction_length, freq=self.freq)
         )
         try:
             known_covariates = known_covariates.loc[forecast_index]  # type: ignore
         except KeyError:
             raise ValueError(
-                f"known_covariates should include the values for prediction_length={self.prediction_length} "
-                "many time steps into the future."
+                "`known_covariates` should include the `item_id` and `timestamp` values covering the forecast horizon "
+                "(i.e., the next `prediction_length` time steps following the end of each time series in the input "
+                "data). Use `TimeSeriesPredictor.make_future_data_frame` to generate the required `item_id` and "
+                "`timestamp` combinations for the `known_covariates`."
             )
         return known_covariates
 

autogluon/timeseries/metrics/abstract.py

@@ -140,7 +140,7 @@ class TimeSeriesScorer:
     ) -> None:
         """Compute auxiliary metrics on past data (before forecast horizon), if the chosen metric requires it.
 
-        This method should only be implemented by metrics that rely on historic (in-sample) data, such as Mean Absolute
+        This method should only be implemented by metrics that rely on historical (in-sample) data, such as Mean Absolute
         Scaled Error (MASE) https://en.wikipedia.org/wiki/Mean_absolute_scaled_error.
 
         We keep this method separate from :meth:`compute_metric` to avoid redundant computations when fitting ensemble.

autogluon/timeseries/metrics/point.py

@@ -196,13 +196,13 @@ class MAPE(TimeSeriesScorer):
 class MASE(TimeSeriesScorer):
     r"""Mean absolute scaled error.
 
-    Normalizes the absolute error for each time series by the historic seasonal error of this time series.
+    Normalizes the absolute error for each time series by the historical seasonal error of this time series.
 
     .. math::
 
         \operatorname{MASE} = \frac{1}{N} \frac{1}{H} \sum_{i=1}^{N} \frac{1}{a_i} \sum_{t=T+1}^{T+H} |y_{i,t} - f_{i,t}|
 
-    where :math:`a_i` is the historic absolute seasonal error defined as
+    where :math:`a_i` is the historical absolute seasonal error defined as
 
     .. math::
 
@@ -255,13 +255,13 @@ class MASE(TimeSeriesScorer):
 class RMSSE(TimeSeriesScorer):
     r"""Root mean squared scaled error.
 
-    Normalizes the absolute error for each time series by the historic seasonal error of this time series.
+    Normalizes the absolute error for each time series by the historical seasonal error of this time series.
 
     .. math::
 
         \operatorname{RMSSE} = \sqrt{\frac{1}{N} \frac{1}{H} \sum_{i=1}^{N} \frac{1}{s_i} \sum_{t=T+1}^{T+H} (y_{i,t} - f_{i,t})^2}
 
-    where :math:`s_i` is the historic squared seasonal error defined as
+    where :math:`s_i` is the historical squared seasonal error defined as
 
     .. math::
 

autogluon/timeseries/metrics/quantile.py

@@ -51,13 +51,13 @@ class SQL(TimeSeriesScorer):
 
     Also known as scaled pinball loss.
 
-    Normalizes the quantile loss for each time series by the historic seasonal error of this time series.
+    Normalizes the quantile loss for each time series by the historical seasonal error of this time series.
 
     .. math::
 
         \operatorname{SQL} = \frac{1}{N} \frac{1}{H} \sum_{i=1}^{N} \frac{1}{a_i} \sum_{t=T+1}^{T+H} \sum_{q}  \rho_q(y_{i,t}, f^q_{i,t})
 
-    where :math:`a_i` is the historic absolute seasonal error defined as
+    where :math:`a_i` is the historical absolute seasonal error defined as
 
     .. math::
 

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -16,7 +16,7 @@ from autogluon.common.loaders import load_pkl
 from autogluon.common.savers import save_pkl
 from autogluon.common.utils.resource_utils import get_resource_manager
 from autogluon.common.utils.utils import setup_outputdir
-from autogluon.core.constants import AG_ARG_PREFIX, AG_ARGS_FIT, REFIT_FULL_SUFFIX
+from autogluon.core.constants import AG_ARGS_FIT, REFIT_FULL_SUFFIX
 from autogluon.core.models import ModelBase
 from autogluon.core.utils.exceptions import TimeLimitExceeded
 from autogluon.timeseries.dataset import TimeSeriesDataFrame
@@ -24,90 +24,13 @@ from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_
 from autogluon.timeseries.regressor import CovariateRegressor, get_covariate_regressor
 from autogluon.timeseries.transforms import CovariateScaler, TargetScaler, get_covariate_scaler, get_target_scaler
 from autogluon.timeseries.utils.features import CovariateMetadata
-from autogluon.timeseries.utils.forecast import get_forecast_horizon_index_ts_dataframe
+from autogluon.timeseries.utils.forecast import make_future_data_frame
 
 from .tunable import TimeSeriesTunable
 
 logger = logging.getLogger(__name__)
 
 
-# TODO: refactor and move to util. We do not need to use "params_aux" in time series
-def check_and_split_hyperparameters(
-    params: Optional[Dict[str, Any]] = None,
-    ag_args_fit: str = AG_ARGS_FIT,
-    ag_arg_prefix: str = AG_ARG_PREFIX,
-) -> Tuple[Dict[str, Any], Dict[str, Any]]:
-    """
-    Given the user-specified hyperparameters, split into `params` and `params_aux`.
-
-    Parameters
-    ----------
-    params : Optional[Dict[str, Any]], default = None
-        The model hyperparameters dictionary
-    ag_args_fit : str, default = "ag_args_fit"
-        The params key to look for that contains params_aux.
-        If the key is present, the value is used for params_aux and popped from params.
-        If no such key is found, then initialize params_aux as an empty dictionary.
-    ag_arg_prefix : str, default = "ag."
-        The key prefix to look for that indicates a parameter is intended for params_aux.
-        If None, this logic is skipped.
-        If a key starts with this prefix, it is popped from params and added to params_aux with the prefix removed.
-        For example:
-            input:  params={'ag.foo': 2, 'abc': 7}, params_aux={'bar': 3}, and ag_arg_prefix='.ag',
-            output: params={'abc': 7}, params_aux={'bar': 3, 'foo': 2}
-        In cases where the key is specified multiple times, the value of the key with the prefix will always take priority.
-        A warning will be logged if a key is present multiple times.
-        For example, given the most complex scenario:
-            input:  params={'ag.foo': 1, 'foo': 2, 'ag_args_fit': {'ag.foo': 3, 'foo': 4}}
-            output: params={'foo': 2}, params_aux={'foo': 1}
-
-    Returns
-    -------
-    params, params_aux : (Dict[str, Any], Dict[str, Any])
-        params will contain the native model hyperparameters
-        params_aux will contain special auxiliary hyperparameters
-    """
-    params = copy.deepcopy(params) if params is not None else dict()
-    assert isinstance(params, dict), f"Invalid dtype of params! Expected dict, but got {type(params)}"
-    for k in params.keys():
-        if not isinstance(k, str):
-            logger.warning(
-                f"Warning: Specified hyperparameter key is not of type str: {k} (type={type(k)}). "
-                f"There might be a bug in your configuration."
-            )
-
-    params_aux = params.pop(ag_args_fit, dict())
-    if params_aux is None:
-        params_aux = dict()
-    assert isinstance(params_aux, dict), f"Invalid dtype of params_aux! Expected dict, but got {type(params_aux)}"
-    if ag_arg_prefix is not None:
-        param_aux_keys = list(params_aux.keys())
-        for k in param_aux_keys:
-            if isinstance(k, str) and k.startswith(ag_arg_prefix):
-                k_no_prefix = k[len(ag_arg_prefix) :]
-                if k_no_prefix in params_aux:
-                    logger.warning(
-                        f'Warning: hyperparameter "{k}" is present '
-                        f'in `ag_args_fit` as both "{k}" and "{k_no_prefix}". '
-                        f'Will use "{k}" and ignore "{k_no_prefix}".'
-                    )
-                params_aux[k_no_prefix] = params_aux.pop(k)
-        param_keys = list(params.keys())
-        for k in param_keys:
-            if isinstance(k, str) and k.startswith(ag_arg_prefix):
-                k_no_prefix = k[len(ag_arg_prefix) :]
-                if k_no_prefix in params_aux:
-                    logger.warning(
-                        f'Warning: hyperparameter "{k}" is present '
-                        f"in both `ag_args_fit` and `hyperparameters`. "
-                        f"Will use `hyperparameters` value."
-                    )
-                params_aux[k_no_prefix] = params.pop(k)
-    return params, params_aux
-
-
-# TODO: refactor. remove params_aux, etc. make overrides and abstract
-# methods clear, et al.
 class TimeSeriesModelBase(ModelBase, ABC):
     """Abstract class for all `Model` objects in autogluon.timeseries.
 
@@ -126,7 +49,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         Name of the subdirectory inside path where model will be saved.
         The final model directory will be os.path.join(path, name)
         If None, defaults to the model's class name: self.__class__.__name__
-    metadata: CovariateMetadata
+    covariate_metadata: CovariateMetadata
         A mapping of different covariate types known to autogluon.timeseries to column names
         in the data set.
     eval_metric : Union[str, TimeSeriesScorer], default = "WQL"
@@ -160,7 +83,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         hyperparameters: Optional[Dict[str, Any]] = None,
         freq: Optional[str] = None,
         prediction_length: int = 1,
-        metadata: Optional[CovariateMetadata] = None,
+        covariate_metadata: Optional[CovariateMetadata] = None,
         target: str = "target",
         quantile_levels: Sequence[float] = (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9),
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
@@ -171,7 +94,8 @@ class TimeSeriesModelBase(ModelBase, ABC):
         self.path_root = path
         if self.path_root is None:
             path_suffix = self.name
-            # TODO: Would be ideal to not create dir, but still track that it is unique. However, this isn't possible to do without a global list of used dirs or using UUID.
+            # TODO: Would be ideal to not create dir, but still track that it is unique. However, this isn't possible
+            # to do without a global list of used dirs or using UUID.
             path_cur = setup_outputdir(path=None, create_dir=True, path_suffix=path_suffix)
             self.path_root = path_cur.rsplit(self.name, 1)[0]
             logger.log(20, f"Warning: No path was specified for model, defaulting to: {self.path_root}")
@@ -181,7 +105,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
         self.eval_metric: TimeSeriesScorer = check_get_evaluation_metric(eval_metric)
         self.eval_metric_seasonal_period = eval_metric_seasonal_period
         self.target: str = target
-        self.metadata = metadata or CovariateMetadata()
+        self.covariate_metadata = covariate_metadata or CovariateMetadata()
 
         self.freq: Optional[str] = freq
         self.prediction_length: int = prediction_length
@@ -198,22 +122,15 @@ class TimeSeriesModelBase(ModelBase, ABC):
         else:
             self.must_drop_median = False
 
-        self._user_params, self._user_params_aux = check_and_split_hyperparameters(hyperparameters)
         self._oof_predictions: Optional[List[TimeSeriesDataFrame]] = None
 
-        self.params: Dict[str, Any] = {}
-        self.params_aux: Dict[str, Any] = {}
-        self._init_params_aux()
-        self._init_params()
-        self._is_initialized = True
-
-        # TODO: remove the variables below
-        self.nondefault_params: List[str] = []
+        # user provided hyperparameters and extra arguments that are used during model training
+        self._hyperparameters, self._extra_ag_args = self._check_and_split_hyperparameters(hyperparameters)
 
         self.fit_time: Optional[float] = None  # Time taken to fit in seconds (Training data)
         self.predict_time: Optional[float] = None  # Time taken to predict in seconds (Validation data)
         self.predict_1_time: Optional[float] = (
-            None  # Time taken to predict 1 row of data in seconds (with batch size `predict_1_batch_size` in params_aux)
+            None  # Time taken to predict 1 row of data in seconds (with batch size `predict_1_batch_size`)
         )
         self.val_score: Optional[float] = None  # Score with eval_metric (Validation data)
 
@@ -236,6 +153,44 @@ class TimeSeriesModelBase(ModelBase, ABC):
         self.path = path_context
         self.path_root = self.path.rsplit(self.name, 1)[0]
 
+    @classmethod
+    def _check_and_split_hyperparameters(
+        cls, hyperparameters: Optional[Dict[str, Any]] = None
+    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """
+        Given the user-specified hyperparameters, split into `hyperparameters` and `extra_ag_args`, intended
+        to be used during model initialization.
+
+        Parameters
+        ----------
+        hyperparameters : Optional[Dict[str, Any]], default = None
+            The model hyperparameters dictionary provided to the model constructor.
+
+        Returns
+        -------
+        hyperparameters: Dict[str, Any]
+            Native model hyperparameters that are passed into the "inner model" AutoGluon wraps
+        extra_ag_args: Dict[str, Any]
+            Special auxiliary parameters that modify the model training process used by AutoGluon
+        """
+        hyperparameters = copy.deepcopy(hyperparameters) if hyperparameters is not None else dict()
+        assert isinstance(hyperparameters, dict), (
+            f"Invalid dtype for hyperparameters. Expected dict, but got {type(hyperparameters)}"
+        )
+        for k in hyperparameters.keys():
+            if not isinstance(k, str):
+                logger.warning(
+                    f"Warning: Specified hyperparameter key is not of type str: {k} (type={type(k)}). "
+                    f"There might be a bug in your configuration."
+                )
+
+        extra_ag_args = hyperparameters.pop(AG_ARGS_FIT, {})
+        if not isinstance(extra_ag_args, dict):
+            raise ValueError(
+                f"Invalid hyperparameter type for `{AG_ARGS_FIT}`. Expected dict, but got {type(extra_ag_args)}"
+            )
+        return hyperparameters, extra_ag_args
+
     def save(self, path: Optional[str] = None, verbose=True) -> str:
         if path is None:
             path = self.path
@@ -262,9 +217,6 @@ class TimeSeriesModelBase(ModelBase, ABC):
         model = load_pkl.load(path=file_path, verbose=verbose)
         if reset_paths:
             model.set_contexts(path)
-        if hasattr(model, "_compiler"):
-            if model._compiler is not None and not model._compiler.save_in_pkl:
-                model.model = model._compiler.load(path=path)
         if load_oof and model._oof_predictions is None:
             model._oof_predictions = cls.load_oof_predictions(path=path, verbose=verbose)
         return model
@@ -277,7 +229,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
     @property
     def supports_known_covariates(self) -> bool:
         return (
-            self._get_model_params().get("covariate_regressor") is not None
+            self.get_hyperparameters().get("covariate_regressor") is not None
             or self.__class__._supports_known_covariates
         )
 
@@ -288,7 +240,8 @@ class TimeSeriesModelBase(ModelBase, ABC):
     @property
     def supports_static_features(self) -> bool:
         return (
-            self._get_model_params().get("covariate_regressor") is not None or self.__class__._supports_static_features
+            self.get_hyperparameters().get("covariate_regressor") is not None
+            or self.__class__._supports_static_features
         )
 
     def get_oof_predictions(self):
@@ -296,73 +249,32 @@ class TimeSeriesModelBase(ModelBase, ABC):
             self._oof_predictions = self.load_oof_predictions(self.path)
         return self._oof_predictions
 
-    def _init_params(self):
-        """Initializes model hyperparameters"""
-        hyperparameters = self._user_params
-        self.nondefault_params = []
-        if hyperparameters is not None:
-            self.params.update(hyperparameters)
-            # These are hyperparameters that user has specified.
-            self.nondefault_params = list(hyperparameters.keys())[:]
-        self.params_trained = {}
-
-    def _init_params_aux(self):
-        """
-        Initializes auxiliary hyperparameters.
-        These parameters are generally not model specific and can have a wide variety of effects.
-        For documentation on some of the available options and their defaults, refer to `self._get_default_auxiliary_params`.
-        """
-        hyperparameters_aux = self._user_params_aux or {}
-        default_aux_params = dict(
-            # ratio of given time_limit to use during fit(). If time_limit == 10 and max_time_limit_ratio=0.3,
-            # time_limit would be changed to 3.
-            max_time_limit_ratio=self.default_max_time_limit_ratio,
-            # max time_limit value during fit(). If the provided time_limit is greater than this value, it will be
-            # replaced by max_time_limit. Occurs after max_time_limit_ratio is applied.
-            max_time_limit=None,
-        )
-        self.params_aux = {**default_aux_params, **hyperparameters_aux}
-
     def _initialize_transforms_and_regressor(self) -> None:
-        self.target_scaler = get_target_scaler(self._get_model_params().get("target_scaler"), target=self.target)
+        self.target_scaler = get_target_scaler(self.get_hyperparameters().get("target_scaler"), target=self.target)
         self.covariate_scaler = get_covariate_scaler(
-            self._get_model_params().get("covariate_scaler"),
-            covariate_metadata=self.metadata,
+            self.get_hyperparameters().get("covariate_scaler"),
+            covariate_metadata=self.covariate_metadata,
             use_static_features=self.supports_static_features,
             use_known_covariates=self.supports_known_covariates,
             use_past_covariates=self.supports_past_covariates,
         )
         self.covariate_regressor = get_covariate_regressor(
-            self._get_model_params().get("covariate_regressor"),
+            self.get_hyperparameters().get("covariate_regressor"),
             target=self.target,
-            covariate_metadata=self.metadata,
+            covariate_metadata=self.covariate_metadata,
         )
 
-    def _get_model_params(self) -> dict:
-        return self.params.copy()
+    def _get_default_hyperparameters(self) -> dict:
+        return {}
 
-    def get_params(self) -> dict:
-        hyperparameters = self._user_params.copy()
-        if self._user_params_aux:
-            hyperparameters[AG_ARGS_FIT] = self._user_params_aux.copy()
-
-        return dict(
-            path=self.path_root,
-            name=self.name,
-            eval_metric=self.eval_metric,
-            hyperparameters=hyperparameters,
-            freq=self.freq,
-            prediction_length=self.prediction_length,
-            quantile_levels=self.quantile_levels,
-            metadata=self.metadata,
-            target=self.target,
-        )
+    def get_hyperparameters(self) -> dict:
+        """Get hyperparameters that will be passed to the "inner model" that AutoGluon wraps."""
+        return {**self._get_default_hyperparameters(), **self._hyperparameters}
 
     def get_info(self) -> dict:
         """
         Returns a dictionary of numerous fields describing the model.
         """
-        # TODO: Include self.metadata
         info = {
             "name": self.name,
             "model_type": type(self).__name__,
@@ -373,7 +285,8 @@ class TimeSeriesModelBase(ModelBase, ABC):
             "prediction_length": self.prediction_length,
             "quantile_levels": self.quantile_levels,
             "val_score": self.val_score,
-            "hyperparameters": self.params,
+            "hyperparameters": self.get_hyperparameters(),
+            "covariate_metadata": self.covariate_metadata.to_dict(),
         }
         return info
 
@@ -438,7 +351,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
             time steps of each time series.
         """
         past_data, known_covariates = data.get_model_inputs_for_scoring(
-            prediction_length=self.prediction_length, known_covariates_names=self.metadata.known_covariates
+            prediction_length=self.prediction_length, known_covariates_names=self.covariate_metadata.known_covariates
         )
         predictions = self.predict(past_data, known_covariates=known_covariates)
         return self._score_with_predictions(data=data, predictions=predictions, metric=metric)
@@ -452,7 +365,7 @@ class TimeSeriesModelBase(ModelBase, ABC):
     ) -> None:
         """Compute val_score, predict_time and cache out-of-fold (OOF) predictions."""
         past_data, known_covariates = val_data.get_model_inputs_for_scoring(
-            prediction_length=self.prediction_length, known_covariates_names=self.metadata.known_covariates
+            prediction_length=self.prediction_length, known_covariates_names=self.covariate_metadata.known_covariates
         )
         predict_start_time = time.time()
         oof_predictions = self.predict(past_data, known_covariates=known_covariates, **predict_kwargs)
@@ -495,49 +408,6 @@ class TimeSeriesModelBase(ModelBase, ABC):
         """
         return self
 
-    def convert_to_refit_full_via_copy(self) -> Self:
-        # save the model as a new model on disk
-        previous_name = self.name
-        self.rename(self.name + REFIT_FULL_SUFFIX)
-        refit_model_path = self.path
-        self.save(path=self.path, verbose=False)
-
-        self.rename(previous_name)
-
-        refit_model = self.load(path=refit_model_path, verbose=False)
-        refit_model.val_score = None
-        refit_model.predict_time = None
-
-        return refit_model
-
-    def convert_to_refit_full_template(self):
-        """
-        After calling this function, returned model should be able to be fit without X_val, y_val using the iterations trained by the original model.
-
-        Increase max_memory_usage_ratio by 25% to reduce the chance that the refit model will trigger NotEnoughMemoryError and skip training.
-        This can happen without the 25% increase since the refit model generally will use more training data and thus require more memory.
-        """
-        params = copy.deepcopy(self.get_params())
-
-        if "hyperparameters" not in params:
-            params["hyperparameters"] = dict()
-
-        if AG_ARGS_FIT not in params["hyperparameters"]:
-            params["hyperparameters"][AG_ARGS_FIT] = dict()
-
-        params["hyperparameters"].update(self.params_trained)
-        params["name"] = params["name"] + REFIT_FULL_SUFFIX
-        template = self.__class__(**params)
-
-        return template
-
-    def get_user_params(self) -> dict:
-        """Used to access user-specified parameters for the model before initialization."""
-        if self._user_params is None:
-            return {}
-        else:
-            return self._user_params.copy()
-
     def _more_tags(self) -> dict:
         """Encode model properties using tags, similar to sklearn & autogluon.tabular.
 
@@ -668,10 +538,12 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
         """
         pass
 
-    # TODO: perform this check inside fit() ?
+    # TODO: this check cannot be moved inside fit because of the complex way in which
+    # MultiWindowBacktestingModel handles hyperparameter spaces during initialization.
+    # Move inside fit() after refactoring MultiWindowBacktestingModel
     def _check_fit_params(self):
         # gracefully handle hyperparameter specifications if they are provided to fit instead
-        if any(isinstance(v, space.Space) for v in self.params.values()):
+        if any(isinstance(v, space.Space) for v in self.get_hyperparameters().values()):
             raise ValueError(
                 "Hyperparameter spaces provided to `fit`. Please provide concrete values "
                 "as hyperparameters when initializing or use `hyperparameter_tune` instead."
@@ -705,9 +577,6 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
             data is given as a separate forecast item in the dictionary, keyed by the `item_id`s
             of input items.
         """
-        # TODO: the method signature is not aligned with the model interface in general as it allows dict
-        assert isinstance(data, TimeSeriesDataFrame)
-
         if self.target_scaler is not None:
             data = self.target_scaler.fit_transform(data)
         if self.covariate_scaler is not None:
@@ -748,9 +617,59 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
             predictions = self.target_scaler.inverse_transform(predictions)
         return predictions
 
+    def convert_to_refit_full_via_copy(self) -> Self:
+        # save the model as a new model on disk
+        previous_name = self.name
+        self.rename(self.name + REFIT_FULL_SUFFIX)
+        refit_model_path = self.path
+        self.save(path=self.path, verbose=False)
+
+        self.rename(previous_name)
+
+        refit_model = self.load(path=refit_model_path, verbose=False)
+        refit_model.val_score = None
+        refit_model.predict_time = None
+
+        return refit_model
+
+    def convert_to_refit_full_template(self):
+        """After calling this function, returned model should be able to be fit without `val_data`."""
+        params = copy.deepcopy(self.get_params())
+
+        if "hyperparameters" not in params:
+            params["hyperparameters"] = dict()
+
+        if AG_ARGS_FIT not in params["hyperparameters"]:
+            params["hyperparameters"][AG_ARGS_FIT] = dict()
+
+        params["name"] = params["name"] + REFIT_FULL_SUFFIX
+        template = self.__class__(**params)
+
+        return template
+
+    def get_params(self) -> dict:
+        """Get the constructor parameters required for cloning this model object"""
+        hyperparameters = self.get_hyperparameters().copy()
+        if self._extra_ag_args:
+            hyperparameters[AG_ARGS_FIT] = self._extra_ag_args.copy()
+
+        return dict(
+            path=self.path_root,
+            name=self.name,
+            eval_metric=self.eval_metric,
+            hyperparameters=hyperparameters,
+            freq=self.freq,
+            prediction_length=self.prediction_length,
+            quantile_levels=self.quantile_levels,
+            covariate_metadata=self.covariate_metadata,
+            target=self.target,
+        )
+
     def get_forecast_horizon_index(self, data: TimeSeriesDataFrame) -> pd.MultiIndex:
         """For each item in the dataframe, get timestamps for the next `prediction_length` time steps into the future."""
-        return get_forecast_horizon_index_ts_dataframe(data, prediction_length=self.prediction_length, freq=self.freq)
+        return pd.MultiIndex.from_frame(
+            make_future_data_frame(data, prediction_length=self.prediction_length, freq=self.freq)
+        )
 
     @abstractmethod
     def _predict(
@@ -764,8 +683,8 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
 
     def _preprocess_time_limit(self, time_limit: float) -> float:
         original_time_limit = time_limit
-        max_time_limit_ratio = self.params_aux["max_time_limit_ratio"]
-        max_time_limit = self.params_aux["max_time_limit"]
+        max_time_limit_ratio = self._extra_ag_args.get("max_time_limit_ratio", self.default_max_time_limit_ratio)
+        max_time_limit = self._extra_ag_args.get("max_time_limit")
 
         time_limit *= max_time_limit_ratio
 
@@ -788,5 +707,5 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
         """Sets up default search space for HPO. Each hyperparameter which user did not specify is converted from
         default fixed value to default search space.
         """
-        params = self.params.copy()
+        params = self._hyperparameters.copy()
         return params

autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -134,8 +134,8 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
     def _get_extra_tabular_init_kwargs(self) -> dict:
         raise NotImplementedError
 
-    def _get_model_params(self) -> dict:
-        model_params = super()._get_model_params().copy()
+    def get_hyperparameters(self) -> dict:
+        model_params = super().get_hyperparameters().copy()
         model_params.setdefault("max_num_items", 20_000)
         model_params.setdefault("max_num_samples", 1_000_000)
         model_params.setdefault("tabular_hyperparameters", {"GBM": {}})
@@ -263,7 +263,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         Each row contains unique_id, ds, y, and (optionally) known covariates & static features.
         """
         # TODO: Add support for past_covariates
-        selected_columns = self.metadata.known_covariates.copy()
+        selected_columns = self.covariate_metadata.known_covariates.copy()
         column_name_mapping = {ITEMID: MLF_ITEMID, TIMESTAMP: MLF_TIMESTAMP}
         if include_target:
             selected_columns += [self.target]
@@ -297,11 +297,11 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         self._check_fit_params()
         fit_start_time = time.time()
         self._train_target_median = train_data[self.target].median()
-        for col in self.metadata.known_covariates_real:
+        for col in self.covariate_metadata.known_covariates_real:
             if not set(train_data[col].unique()) == set([0, 1]):
                 self._non_boolean_real_covariates.append(col)
         # TabularEstimator is passed to MLForecast later to include tuning_data
-        model_params = self._get_model_params()
+        model_params = self.get_hyperparameters()
 
         mlforecast_init_args = self._get_mlforecast_init_args(train_data, model_params)
         self._mlf = MLForecast(models={}, freq=self.freq, **mlforecast_init_args)
@@ -473,8 +473,8 @@ class DirectTabularModel(AbstractMLForecastModel):
     def is_quantile_model(self) -> bool:
         return self.eval_metric.needs_quantile
 
-    def _get_model_params(self) -> dict:
-        model_params = super()._get_model_params()
+    def get_hyperparameters(self) -> dict:
+        model_params = super().get_hyperparameters()
         model_params.setdefault("target_scaler", "mean_abs")
         if "differences" not in model_params or model_params["differences"] is None:
             model_params["differences"] = []
@@ -622,8 +622,8 @@ class RecursiveTabularModel(AbstractMLForecastModel):
         end of each time series).
     """
 
-    def _get_model_params(self) -> dict:
-        model_params = super()._get_model_params()
+    def get_hyperparameters(self) -> dict:
+        model_params = super().get_hyperparameters()
         model_params.setdefault("target_scaler", "standard")
         if "differences" not in model_params or model_params["differences"] is None:
             model_params["differences"] = [get_seasonality(self.freq)]