autogluon.timeseries 1.0.1b20240304__py3-none-any.whl → 1.4.1b20251210__py3-none-any.whl

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -1,110 +1,110 @@
+import copy
 import logging
 import os
 import re
 import time
-from contextlib import nullcontext
-from typing import Any, Dict, List, Optional, Union
+from abc import ABC, abstractmethod
+from typing import Any, Sequence
+
+import pandas as pd
+from typing_extensions import Self
 
 from autogluon.common import space
 from autogluon.common.loaders import load_pkl
 from autogluon.common.savers import save_pkl
-from autogluon.core.hpo.exceptions import EmptySearchSpace
-from autogluon.core.hpo.executors import HpoExecutor, RayHpoExecutor
-from autogluon.core.models import AbstractModel
+from autogluon.common.utils.resource_utils import get_resource_manager
+from autogluon.common.utils.utils import setup_outputdir
+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
 from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_metric
+from autogluon.timeseries.models.registry import ModelRegistry
+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.warning_filters import disable_stdout, warning_filter
+from autogluon.timeseries.utils.forecast import make_future_data_frame
 
-from .model_trial import model_trial, skip_hpo
+from .tunable import TimeSeriesTunable
 
 logger = logging.getLogger(__name__)
 
 
-class AbstractTimeSeriesModel(AbstractModel):
-    """Abstract class for all `Model` objects in autogluon.timeseries.
+class TimeSeriesModelBase(ModelBase, ABC):
+    """Abstract base class for all `Model` objects in autogluon.timeseries, including both
+    forecasting models and forecast combination/ensemble models.
 
     Parameters
     ----------
-    path : str, default = None
+    path
         Directory location to store all outputs.
         If None, a new unique time-stamped directory is chosen.
-    freq: str
+    freq
         Frequency string (cf. gluonts frequency strings) describing the frequency
-        of the time series data. For example, "H" for hourly or "D" for daily data.
-    prediction_length: int
+        of the time series data. For example, "h" for hourly or "D" for daily data.
+    prediction_length
         Length of the prediction horizon, i.e., the number of time steps the model
         is fit to forecast.
-    name : str, default = None
+    name
         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
         A mapping of different covariate types known to autogluon.timeseries to column names
         in the data set.
-    eval_metric : Union[str, TimeSeriesScorer], default = "WQL"
+    eval_metric
         Metric by which predictions will be ultimately evaluated on future test data. This only impacts
         ``model.score()``, as eval_metric is not used during training. Available metrics can be found in
         ``autogluon.timeseries.metrics``.
-    eval_metric_seasonal_period : int, optional
-        Seasonal period used to compute some evaluation metrics such as mean absolute scaled error (MASE). Defaults to
-        ``None``, in which case the seasonal period is computed based on the data frequency.
-    hyperparameters : dict, default = None
+    hyperparameters
         Hyperparameters that will be used by the model (can be search spaces instead of fixed values).
         If None, model defaults are used. This is identical to passing an empty dictionary.
     """
 
+    model_file_name = "model.pkl"
+    model_info_name = "info.pkl"
     _oof_filename = "oof.pkl"
 
-    # TODO: refactor "pruned" methods after AbstractModel is refactored
-    predict_proba = None
-    score_with_y_pred_proba = None
-    disk_usage = None  # disk / memory size
-    estimate_memory_usage = None
-    reduce_memory_size = None
-    compute_feature_importance = None  # feature processing and importance
-    get_features = None
-    _apply_conformalization = None
-    _apply_temperature_scaling = None
-    _predict_proba = None
-    _convert_proba_to_unified_form = None
-    _compute_permutation_importance = None
-    _estimate_memory_usage = None
-    _preprocess = None
-    _preprocess_nonadaptive = None
-    _preprocess_set_features = None
+    # TODO: For which models should we override this parameter?
+    _covariate_regressor_fit_time_fraction: float = 0.5
+    default_max_time_limit_ratio: float = 0.9
+
+    _supports_known_covariates: bool = False
+    _supports_past_covariates: bool = False
+    _supports_static_features: bool = False
 
     def __init__(
         self,
-        freq: Optional[str] = None,
+        path: str | None = None,
+        name: str | None = None,
+        hyperparameters: dict[str, Any] | None = None,
+        freq: str | None = None,
         prediction_length: int = 1,
-        path: Optional[str] = None,
-        name: Optional[str] = None,
-        metadata: Optional[CovariateMetadata] = None,
-        eval_metric: Union[str, TimeSeriesScorer, None] = None,
-        eval_metric_seasonal_period: Optional[int] = None,
-        hyperparameters: Dict[str, Union[int, float, str, space.Space]] = None,
-        **kwargs,
+        covariate_metadata: CovariateMetadata | None = 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: str | TimeSeriesScorer | None = None,
     ):
-        name = name or re.sub(r"Model$", "", self.__class__.__name__)
-        super().__init__(
-            path=path,
-            name=name,
-            problem_type=None,
-            eval_metric=None,
-            hyperparameters=hyperparameters,
-        )
-        self.eval_metric: TimeSeriesScorer = check_get_evaluation_metric(eval_metric)
-        self.eval_metric_seasonal_period = eval_metric_seasonal_period
-        self.stopping_metric = None
-        self.problem_type = "timeseries"
-        self.conformalize = False
-        self.target: str = kwargs.get("target", "target")
-        self.metadata = metadata or CovariateMetadata()
-
-        self.freq: str = freq
+        self.name = name or re.sub(r"Model$", "", self.__class__.__name__)
+
+        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.
+            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}")
+
+        self.path = os.path.join(self.path_root, self.name)
+
+        self.eval_metric = check_get_evaluation_metric(eval_metric, prediction_length=prediction_length)
+        self.target: str = target
+        self.covariate_metadata = covariate_metadata or CovariateMetadata()
+
+        self.freq: str | None = freq
         self.prediction_length: int = prediction_length
-        self.quantile_levels = kwargs.get("quantile_levels", [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
+        self.quantile_levels: list[float] = list(quantile_levels)
 
         if not all(0 < q < 1 for q in self.quantile_levels):
             raise ValueError("Invalid quantile_levels specified. Quantiles must be between 0 and 1 (exclusive).")
@@ -117,76 +117,151 @@ class AbstractTimeSeriesModel(AbstractModel):
         else:
             self.must_drop_median = False
 
-        self._oof_predictions: Optional[List[TimeSeriesDataFrame]] = None
+        self._oof_predictions: list[TimeSeriesDataFrame] | None = None
+
+        # user provided hyperparameters and extra arguments that are used during model training
+        self._hyperparameters, self._extra_ag_args = self._check_and_split_hyperparameters(hyperparameters)
+
+        # Time taken to fit in seconds (Training data)
+        self.fit_time: float | None = None
+        # Time taken to predict in seconds, for a single prediction horizon on validation data
+        self.predict_time: float | None = None
+        # Time taken to predict 1 row of data in seconds (with batch size `predict_1_batch_size`)
+        self.predict_1_time: float | None = None
+        # Useful for ensembles, additional prediction time excluding base models. None for base models.
+        self.predict_time_marginal: float | None = None
+        # Score with eval_metric on validation data
+        self.val_score: float | None = None
 
     def __repr__(self) -> str:
         return self.name
 
-    def save(self, path: str = None, verbose=True) -> str:
+    def rename(self, name: str) -> None:
+        if self.name is not None and len(self.name) > 0:
+            self.path = os.path.join(os.path.dirname(self.path), name)
+        else:
+            self.path = os.path.join(self.path, name)
+        self.name = name
+
+    def set_contexts(self, path_context):
+        self.path = path_context
+        self.path_root = self.path.rsplit(self.name, 1)[0]
+
+    def cache_oof_predictions(self, predictions: TimeSeriesDataFrame | list[TimeSeriesDataFrame]) -> None:
+        if isinstance(predictions, TimeSeriesDataFrame):
+            predictions = [predictions]
+        self._oof_predictions = predictions
+
+    @classmethod
+    def _check_and_split_hyperparameters(
+        cls, hyperparameters: dict[str, Any] | None = 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
+            The model hyperparameters dictionary provided to the model constructor.
+
+        Returns
+        -------
+        hyperparameters
+            Native model hyperparameters that are passed into the "inner model" AutoGluon wraps
+        extra_ag_args
+            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: str | None = None, verbose: bool = True) -> str:
+        if path is None:
+            path = self.path
+
         # Save self._oof_predictions as a separate file, not model attribute
         if self._oof_predictions is not None:
             save_pkl.save(
-                path=os.path.join(self.path, "utils", self._oof_filename),
+                path=os.path.join(path, "utils", self._oof_filename),
                 object=self._oof_predictions,
                 verbose=verbose,
             )
         oof_predictions = self._oof_predictions
         self._oof_predictions = None
-        save_path = super().save(path=path, verbose=verbose)
+
+        file_path = os.path.join(path, self.model_file_name)
+        save_pkl.save(path=file_path, object=self, verbose=verbose)
+
         self._oof_predictions = oof_predictions
-        return save_path
+        return path
 
     @classmethod
-    def load(
-        cls, path: str, reset_paths: bool = True, load_oof: bool = False, verbose: bool = True
-    ) -> "AbstractTimeSeriesModel":
-        model = super().load(path=path, reset_paths=reset_paths, verbose=verbose)
+    def load(cls, path: str, reset_paths: bool = True, load_oof: bool = False, verbose: bool = True) -> Self:
+        file_path = os.path.join(path, cls.model_file_name)
+        model = load_pkl.load(path=file_path, verbose=verbose)
+        if reset_paths:
+            model.set_contexts(path)
         if load_oof and model._oof_predictions is None:
             model._oof_predictions = cls.load_oof_predictions(path=path, verbose=verbose)
         return model
 
     @classmethod
-    def load_oof_predictions(cls, path: str, verbose: bool = True) -> List[TimeSeriesDataFrame]:
+    def load_oof_predictions(cls, path: str, verbose: bool = True) -> list[TimeSeriesDataFrame]:
         """Load the cached OOF predictions from disk."""
         return load_pkl.load(path=os.path.join(path, "utils", cls._oof_filename), verbose=verbose)
 
+    @property
+    def supports_known_covariates(self) -> bool:
+        return (
+            self.get_hyperparameters().get("covariate_regressor") is not None
+            or self.__class__._supports_known_covariates
+        )
+
+    @property
+    def supports_past_covariates(self) -> bool:
+        return self.__class__._supports_past_covariates
+
+    @property
+    def supports_static_features(self) -> bool:
+        return (
+            self.get_hyperparameters().get("covariate_regressor") is not None
+            or self.__class__._supports_static_features
+        )
+
     def get_oof_predictions(self):
         if self._oof_predictions is None:
             self._oof_predictions = self.load_oof_predictions(self.path)
         return self._oof_predictions
 
-    def _initialize(self, **kwargs) -> None:
-        self._init_params_aux()
-        self._init_params()
+    def _get_default_hyperparameters(self) -> dict:
+        return {}
 
-    def _compute_fit_metadata(self, val_data: TimeSeriesDataFrame = None, **kwargs):
-        fit_metadata = dict(
-            val_in_fit=val_data is not None,
-        )
-        return fit_metadata
+    def get_hyperparameters(self) -> dict:
+        """Get dictionary of hyperparameters that will be passed to the "inner model" that AutoGluon wraps."""
+        return {**self._get_default_hyperparameters(), **self._hyperparameters}
 
-    def _validate_fit_memory_usage(self, **kwargs):
-        # memory usage handling not implemented for timeseries models
-        pass
-
-    def get_params(self) -> dict:
-        params = super().get_params()
-        params.update(
-            dict(
-                freq=self.freq,
-                prediction_length=self.prediction_length,
-                quantile_levels=self.quantile_levels,
-                metadata=self.metadata,
-                target=self.target,
-            )
-        )
-        return params
+    def get_hyperparameter(self, key: str) -> Any:
+        """Get a single hyperparameter value for the "inner model"."""
+        return self.get_hyperparameters()[key]
 
     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__,
@@ -197,53 +272,278 @@ class AbstractTimeSeriesModel(AbstractModel):
             "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
 
-    def fit(self, **kwargs) -> "AbstractTimeSeriesModel":
+    @classmethod
+    def load_info(cls, path: str, load_model_if_required: bool = True) -> dict:
+        # TODO: remove?
+        load_path = os.path.join(path, cls.model_info_name)
+        try:
+            return load_pkl.load(path=load_path)
+        except:
+            if load_model_if_required:
+                model = cls.load(path=path, reset_paths=True)
+                return model.get_info()
+            else:
+                raise
+
+    def _is_gpu_available(self) -> bool:
+        return False
+
+    @staticmethod
+    def _get_system_resources() -> dict[str, Any]:
+        resource_manager = get_resource_manager()
+        system_num_cpus = resource_manager.get_cpu_count()
+        system_num_gpus = resource_manager.get_gpu_count()
+        return {
+            "num_cpus": system_num_cpus,
+            "num_gpus": system_num_gpus,
+        }
+
+    def _get_model_base(self) -> Self:
+        return self
+
+    def persist(self) -> Self:
+        """Ask the model to persist its assets in memory, i.e., to predict with low latency. In practice
+        this is used for pretrained models that have to lazy-load model parameters to device memory at
+        prediction time.
+        """
+        return self
+
+    def _more_tags(self) -> dict:
+        """Encode model properties using tags, similar to sklearn & autogluon.tabular.
+
+        For more details, see `autogluon.core.models.abstract.AbstractModel._get_tags()` and
+        https://scikit-learn.org/stable/_sources/developers/develop.rst.txt.
+
+        List of currently supported tags:
+        - allow_nan: Can the model handle data with missing values represented by np.nan?
+        - can_refit_full: Does it make sense to retrain the model without validation data?
+            See `autogluon.core.models.abstract._tags._DEFAULT_TAGS` for more details.
+        - can_use_train_data: Can the model use train_data if it's provided to model.fit()?
+        - can_use_val_data: Can the model use val_data if it's provided to model.fit()?
+        """
+        return {
+            "allow_nan": False,
+            "can_refit_full": False,
+            "can_use_train_data": True,
+            "can_use_val_data": False,
+        }
+
+    def get_params(self) -> dict:
+        """Get the constructor parameters required for cloning this model object"""
+        # We only use the user-provided hyperparameters for cloning. We cannot use the output of get_hyperparameters()
+        # since it may contain search spaces that won't be converted to concrete values during HPO
+        hyperparameters = self._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 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) -> Self:
+        """After calling this function, returned model should be able to be fit without `val_data`."""
+        params = copy.deepcopy(self.get_params())
+
+        # Remove 0.5 from quantile_levels so that the cloned model sets its must_drop_median correctly
+        if self.must_drop_median:
+            params["quantile_levels"].remove(0.5)
+
+        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
+
+
+class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=ModelRegistry):
+    """Abstract base class for all time series models that take historical data as input and
+    make predictions for the forecast horizon.
+    """
+
+    ag_priority: int = 0
+
+    def __init__(
+        self,
+        path: str | None = None,
+        name: str | None = None,
+        hyperparameters: dict[str, Any] | None = None,
+        freq: str | None = None,
+        prediction_length: int = 1,
+        covariate_metadata: CovariateMetadata | None = 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: str | TimeSeriesScorer | None = None,
+    ):
+        # TODO: make freq a required argument in AbstractTimeSeriesModel
+        super().__init__(
+            path=path,
+            name=name,
+            hyperparameters=hyperparameters,
+            freq=freq,
+            prediction_length=prediction_length,
+            covariate_metadata=covariate_metadata,
+            target=target,
+            quantile_levels=quantile_levels,
+            eval_metric=eval_metric,
+        )
+        self.target_scaler: TargetScaler | None
+        self.covariate_scaler: CovariateScaler | None
+        self.covariate_regressor: CovariateRegressor | None
+
+    def _initialize_transforms_and_regressor(self) -> None:
+        self.target_scaler = get_target_scaler(self.get_hyperparameters().get("target_scaler"), target=self.target)
+        self.covariate_scaler = get_covariate_scaler(
+            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_hyperparameters().get("covariate_regressor"),
+            target=self.target,
+            covariate_metadata=self.covariate_metadata,
+        )
+
+    @property
+    def allowed_hyperparameters(self) -> list[str]:
+        """List of hyperparameters allowed by the model."""
+        return ["target_scaler", "covariate_regressor", "covariate_scaler"]
+
+    def fit(
+        self,
+        train_data: TimeSeriesDataFrame,
+        val_data: TimeSeriesDataFrame | None = None,
+        time_limit: float | None = None,
+        verbosity: int = 2,
+        **kwargs,
+    ) -> Self:
         """Fit timeseries model.
 
         Models should not override the `fit` method, but instead override the `_fit` method which
         has the same arguments.
 
-        Other Parameters
-        ----------------
-        train_data : TimeSeriesDataFrame
+        Parameters
+        ----------
+        train_data
             The training data provided in the library's `autogluon.timeseries.dataset.TimeSeriesDataFrame`
             format.
-        val_data : TimeSeriesDataFrame, optional
+        val_data
             The validation data set in the same format as training data.
-        time_limit : float, default = None
+        time_limit
             Time limit in seconds to adhere to when fitting model.
             Ideally, model should early stop during fit to avoid going over the time limit if specified.
-        num_cpus : int, default = 'auto'
+        num_cpus
             How many CPUs to use during fit.
             This is counted in virtual cores, not in physical cores.
             If 'auto', model decides.
-        num_gpus : int, default = 'auto'
+        num_gpus
             How many GPUs to use during fit.
             If 'auto', model decides.
-        verbosity : int, default = 2
+        verbosity
             Verbosity levels range from 0 to 4 and control how much information is printed.
             Higher levels correspond to more detailed print statements (you can set verbosity = 0 to suppress warnings).
-        **kwargs :
+        **kwargs
             Any additional fit arguments a model supports.
 
         Returns
         -------
-        model: AbstractTimeSeriesModel
+        model
             The fitted model object
         """
-        return super().fit(**kwargs)
+        start_time = time.monotonic()
+        self._initialize_transforms_and_regressor()
+
+        if self.target_scaler is not None:
+            train_data = self.target_scaler.fit_transform(train_data)
+
+        if self.covariate_scaler is not None:
+            train_data = self.covariate_scaler.fit_transform(train_data)
+
+        if self.covariate_regressor is not None:
+            covariate_regressor_time_limit = (
+                self._covariate_regressor_fit_time_fraction * time_limit if time_limit is not None else None
+            )
+            self.covariate_regressor.fit(
+                train_data,
+                time_limit=covariate_regressor_time_limit,
+                verbosity=verbosity - 1,
+            )
 
+        if self._get_tags()["can_use_train_data"]:
+            if self.covariate_regressor is not None:
+                train_data = self.covariate_regressor.transform(train_data)
+            train_data, _ = self.preprocess(train_data, is_train=True)
+
+        if self._get_tags()["can_use_val_data"] and val_data is not None:
+            if self.target_scaler is not None:
+                val_data = self.target_scaler.transform(val_data)
+            if self.covariate_scaler is not None:
+                val_data = self.covariate_scaler.transform(val_data)
+            if self.covariate_regressor is not None:
+                val_data = self.covariate_regressor.transform(val_data)
+            val_data, _ = self.preprocess(val_data, is_train=False)
+
+        if time_limit is not None:
+            time_limit = time_limit - (time.monotonic() - start_time)
+            time_limit = self._preprocess_time_limit(time_limit=time_limit)
+            if time_limit <= 0:
+                logger.warning(
+                    f"\tWarning: Model has no time left to train, skipping model... (Time Left = {time_limit:.1f}s)"
+                )
+                raise TimeLimitExceeded
+
+        self._fit(
+            train_data=train_data,
+            val_data=val_data,
+            time_limit=time_limit,
+            verbosity=verbosity,
+            **(self._get_system_resources() | kwargs),
+        )
+
+        return self
+
+    @abstractmethod
     def _fit(
         self,
         train_data: TimeSeriesDataFrame,
-        val_data: Optional[TimeSeriesDataFrame] = None,
-        time_limit: Optional[int] = None,
-        num_cpus: Optional[int] = None,
-        num_gpus: Optional[int] = None,
+        val_data: TimeSeriesDataFrame | None = None,
+        time_limit: float | None = None,
+        num_cpus: int | None = None,
+        num_gpus: int | None = None,
         verbosity: int = 2,
         **kwargs,
     ) -> None:
@@ -251,21 +551,36 @@ class AbstractTimeSeriesModel(AbstractModel):
         the model training logic, `fit` additionally implements other logic such as keeping
         track of the time limit, etc.
         """
-        # TODO: Make the models respect `num_cpus` and `num_gpus` parameters
-        raise NotImplementedError
+        pass
 
+    # 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."
             )
 
+    def _log_unused_hyperparameters(self, extra_allowed_hyperparameters: list[str] | None = None) -> None:
+        """Log a warning if unused hyperparameters were provided to the model."""
+        allowed_hyperparameters = self.allowed_hyperparameters
+        if extra_allowed_hyperparameters is not None:
+            allowed_hyperparameters = allowed_hyperparameters + extra_allowed_hyperparameters
+
+        unused_hyperparameters = [key for key in self.get_hyperparameters() if key not in allowed_hyperparameters]
+        if len(unused_hyperparameters) > 0:
+            logger.warning(
+                f"{self.name} ignores following hyperparameters: {unused_hyperparameters}. "
+                f"See the documentation for {self.name} for the list of supported hyperparameters."
+            )
+
     def predict(
         self,
-        data: Union[TimeSeriesDataFrame, Dict[str, TimeSeriesDataFrame]],
-        known_covariates: Optional[TimeSeriesDataFrame] = None,
+        data: TimeSeriesDataFrame,
+        known_covariates: TimeSeriesDataFrame | None = None,
         **kwargs,
     ) -> TimeSeriesDataFrame:
         """Given a dataset, predict the next `self.prediction_length` time steps.
@@ -277,55 +592,123 @@ class AbstractTimeSeriesModel(AbstractModel):
 
         Parameters
         ----------
-        data: Union[TimeSeriesDataFrame, Dict[str, TimeSeriesDataFrame]]
+        data
             The dataset where each time series is the "context" for predictions. For ensemble models that depend on
             the predictions of other models, this method may accept a dictionary of previous models' predictions.
-        known_covariates : Optional[TimeSeriesDataFrame]
+        known_covariates
             A TimeSeriesDataFrame containing the values of the known covariates during the forecast horizon.
 
         Returns
         -------
-        predictions: TimeSeriesDataFrame
-            pandas data frames with a timestamp index, where each input item from the input
+        predictions
+            pandas dataframes with a timestamp index, where each input item from the input
             data is given as a separate forecast item in the dictionary, keyed by the `item_id`s
             of input items.
         """
+        if self.target_scaler is not None:
+            data = self.target_scaler.fit_transform(data)
+        if self.covariate_scaler is not None:
+            data = self.covariate_scaler.fit_transform(data)
+            known_covariates = self.covariate_scaler.transform_known_covariates(known_covariates)
+        if self.covariate_regressor is not None:
+            data = self.covariate_regressor.fit_transform(data)
+
+        data, known_covariates = self.preprocess(data, known_covariates, is_train=False)
+
+        # FIXME: Set self.covariate_regressor=None so to avoid copying it across processes during _predict
+        # FIXME: The clean solution is to convert all methods executed in parallel to @classmethod
+        covariate_regressor = self.covariate_regressor
+        self.covariate_regressor = None
         predictions = self._predict(data=data, known_covariates=known_covariates, **kwargs)
-        logger.debug(f"Predicting with model {self.name}")
-        # "0.5" might be missing from the quantiles if self is a wrapper (MultiWindowBacktestingModel or ensemble)
+        self.covariate_regressor = covariate_regressor
+
+        # Ensure that 'mean' is the leading column. Trailing columns might not match quantile_levels if self is
+        # a MultiWindowBacktestingModel and base_model.must_drop_median=True
+        column_order = pd.Index(["mean"] + [col for col in predictions.columns if col != "mean"])
+        if not predictions.columns.equals(column_order):
+            predictions = predictions.reindex(columns=column_order)
+
+        # "0.5" might be missing from the quantiles if self is a MultiWindowBacktestingModel
         if "0.5" in predictions.columns:
             if self.eval_metric.optimized_by_median:
                 predictions["mean"] = predictions["0.5"]
             if self.must_drop_median:
                 predictions = predictions.drop("0.5", axis=1)
+
+        if self.covariate_regressor is not None:
+            if known_covariates is None:
+                known_covariates = TimeSeriesDataFrame.from_data_frame(
+                    pd.DataFrame(index=self.get_forecast_horizon_index(data), dtype="float32")
+                )
+
+            predictions = self.covariate_regressor.inverse_transform(
+                predictions,
+                known_covariates=known_covariates,
+                static_features=data.static_features,
+            )
+
+        if self.target_scaler is not None:
+            predictions = self.target_scaler.inverse_transform(predictions)
         return predictions
 
+    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 pd.MultiIndex.from_frame(
+            make_future_data_frame(data, prediction_length=self.prediction_length, freq=self.freq)
+        )
+
+    @abstractmethod
     def _predict(
         self,
-        data: Union[TimeSeriesDataFrame, Dict[str, TimeSeriesDataFrame]],
-        known_covariates: Optional[TimeSeriesDataFrame] = None,
+        data: TimeSeriesDataFrame,
+        known_covariates: TimeSeriesDataFrame | None = None,
         **kwargs,
     ) -> TimeSeriesDataFrame:
         """Private method for `predict`. See `predict` for documentation of arguments."""
-        raise NotImplementedError
+        pass
+
+    def _preprocess_time_limit(self, time_limit: float) -> float:
+        original_time_limit = 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
+
+        if max_time_limit is not None:
+            time_limit = min(time_limit, max_time_limit)
+
+        if original_time_limit != time_limit:
+            time_limit_og_str = f"{original_time_limit:.2f}s" if original_time_limit is not None else "None"
+            time_limit_str = f"{time_limit:.2f}s" if time_limit is not None else "None"
+            logger.debug(
+                f"\tTime limit adjusted due to model hyperparameters: "
+                f"{time_limit_og_str} -> {time_limit_str} "
+                f"(ag.max_time_limit={max_time_limit}, "
+                f"ag.max_time_limit_ratio={max_time_limit_ratio}"
+            )
+
+        return time_limit
+
+    def _get_search_space(self):
+        """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._hyperparameters.copy()
+        return params
 
     def _score_with_predictions(
         self,
         data: TimeSeriesDataFrame,
         predictions: TimeSeriesDataFrame,
-        metric: Optional[str] = None,
     ) -> float:
         """Compute the score measuring how well the predictions align with the data."""
-        eval_metric = self.eval_metric if metric is None else check_get_evaluation_metric(metric)
-        return eval_metric.score(
+        return self.eval_metric.score(
             data=data,
             predictions=predictions,
-            prediction_length=self.prediction_length,
             target=self.target,
-            seasonal_period=self.eval_metric_seasonal_period,
         )
 
-    def score(self, data: TimeSeriesDataFrame, metric: Optional[str] = None) -> float:
+    def score(self, data: TimeSeriesDataFrame) -> float:
         """Return the evaluation scores for given metric and dataset. The last
         `self.prediction_length` time steps of each time series in the input data set
         will be held out and used for computing the evaluation score. Time series
@@ -333,169 +716,46 @@ class AbstractTimeSeriesModel(AbstractModel):
 
         Parameters
         ----------
-        data: TimeSeriesDataFrame
+        data
             Dataset used for scoring.
-        metric: str
-            String identifier of evaluation metric to use, from one of
-            `autogluon.timeseries.utils.metric_utils.AVAILABLE_METRICS`.
-
-        Other Parameters
-        ----------------
-        num_samples: int
-            Number of samples to use for making evaluation predictions if the probabilistic
-            forecasts are generated by forward sampling from the fitted model.
 
         Returns
         -------
-        score: float
+        score
             The computed forecast evaluation score on the last `self.prediction_length`
             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_real
+            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)
+        return self._score_with_predictions(data=data, predictions=predictions)
 
     def score_and_cache_oof(
         self,
         val_data: TimeSeriesDataFrame,
         store_val_score: bool = False,
         store_predict_time: bool = False,
+        **predict_kwargs,
     ) -> 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_real
+            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)
-        self._oof_predictions = [oof_predictions]
+        oof_predictions = self.predict(past_data, known_covariates=known_covariates, **predict_kwargs)
+        self.cache_oof_predictions(oof_predictions)
         if store_predict_time:
             self.predict_time = time.time() - predict_start_time
         if store_val_score:
             self.val_score = self._score_with_predictions(val_data, oof_predictions)
 
-    def _get_hpo_train_fn_kwargs(self, **train_fn_kwargs) -> dict:
-        """Update kwargs passed to model_trial depending on the model configuration.
-
-        These kwargs need to be updated, for example, by MultiWindowBacktestingModel.
-        """
-        return train_fn_kwargs
-
-    def _is_gpu_available(self) -> bool:
-        return False
-
-    def hyperparameter_tune(
-        self, hyperparameter_tune_kwargs="auto", hpo_executor: HpoExecutor = None, time_limit: float = None, **kwargs
-    ):
-        if hpo_executor is None:
-            hpo_executor = self._get_default_hpo_executor()
-            default_num_trials = kwargs.pop("default_num_trials", None)
-            hpo_executor.initialize(
-                hyperparameter_tune_kwargs, default_num_trials=default_num_trials, time_limit=time_limit
-            )
-
-        kwargs = self.initialize(time_limit=time_limit, **kwargs)
-
-        self._register_fit_metadata(**kwargs)
-        self._validate_fit_memory_usage(**kwargs)
-
-        kwargs = self._preprocess_fit_resources(
-            parallel_hpo=hpo_executor.executor_type == "ray", silent=True, **kwargs
-        )
-        self.validate_fit_resources(**kwargs)
-
-        # autogluon.core runs a complicated logic to determine the final number of gpus
-        # used in trials, which results in unintended setting of num_gpus=0. We override this
-        # logic here, and set to minimum num_gpus to 1 if it is set to 0 when GPUs are available
-        kwargs["num_gpus"] = 0 if not self._is_gpu_available() else max(kwargs.get("num_gpus", 1), 1)
-
-        # we use k_fold=1 to circumvent autogluon.core logic to manage resources during parallelization
-        # of different folds
-        hpo_executor.register_resources(self, k_fold=1, **kwargs)
-        return self._hyperparameter_tune(hpo_executor=hpo_executor, **kwargs)
-
-    def _hyperparameter_tune(
+    def preprocess(
         self,
-        train_data: TimeSeriesDataFrame,
-        val_data: TimeSeriesDataFrame,
-        hpo_executor: HpoExecutor,
+        data: TimeSeriesDataFrame,
+        known_covariates: TimeSeriesDataFrame | None = None,
+        is_train: bool = False,
         **kwargs,
-    ):
-        time_start = time.time()
-        logger.debug(f"\tStarting AbstractTimeSeriesModel hyperparameter tuning for {self.name}")
-        search_space = self._get_search_space()
-
-        try:
-            hpo_executor.validate_search_space(search_space, self.name)
-        except EmptySearchSpace:
-            return skip_hpo(self, train_data, val_data, time_limit=hpo_executor.time_limit)
-
-        self.set_contexts(os.path.abspath(self.path))
-        directory = self.path
-        dataset_train_filename = "dataset_train.pkl"
-        train_path = os.path.join(self.path, dataset_train_filename)
-        save_pkl.save(path=train_path, object=train_data)
-
-        dataset_val_filename = "dataset_val.pkl"
-        val_path = os.path.join(self.path, dataset_val_filename)
-        save_pkl.save(path=val_path, object=val_data)
-
-        fit_kwargs = dict(
-            val_splitter=kwargs.get("val_splitter"),
-            refit_every_n_windows=kwargs.get("refit_every_n_windows", 1),
-        )
-        train_fn_kwargs = self._get_hpo_train_fn_kwargs(
-            model_cls=self.__class__,
-            init_params=self.get_params(),
-            time_start=time_start,
-            time_limit=hpo_executor.time_limit,
-            fit_kwargs=fit_kwargs,
-            train_path=train_path,
-            val_path=val_path,
-            hpo_executor=hpo_executor,
-        )
-
-        model_estimate_memory_usage = None
-        if self.estimate_memory_usage is not None:
-            model_estimate_memory_usage = self.estimate_memory_usage(**kwargs)
-
-        minimum_resources = self.get_minimum_resources(is_gpu_available=self._is_gpu_available())
-        hpo_context = disable_stdout if isinstance(hpo_executor, RayHpoExecutor) else nullcontext
-        with hpo_context(), warning_filter():  # prevent Ray from outputting its results to stdout with print
-            hpo_executor.execute(
-                model_trial=model_trial,
-                train_fn_kwargs=train_fn_kwargs,
-                directory=directory,
-                minimum_cpu_per_trial=minimum_resources.get("num_cpus", 1),
-                minimum_gpu_per_trial=minimum_resources.get("num_gpus", 0),
-                model_estimate_memory_usage=model_estimate_memory_usage,
-                adapter_type="timeseries",
-            )
-
-            hpo_models, analysis = hpo_executor.get_hpo_results(
-                model_name=self.name,
-                model_path_root=self.path_root,
-                time_start=time_start,
-            )
-
-        return hpo_models, analysis
-
-    def preprocess(self, data: Any, **kwargs) -> Any:
-        return data
-
-    def get_memory_size(self, **kwargs) -> Optional[int]:
-        return None
-
-    def convert_to_refit_full_via_copy(self) -> "AbstractTimeSeriesModel":
-        refit_model = super().convert_to_refit_full_via_copy()
-        refit_model.val_score = None
-        refit_model.predict_time = None
-        return refit_model
-
-    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()
+    ) -> tuple[TimeSeriesDataFrame, TimeSeriesDataFrame | None]:
+        """Method that implements model-specific preprocessing logic."""
+        return data, known_covariates