autogluon.timeseries 1.2.1b20250304__py3-none-any.whl → 1.2.1b20250306__py3-none-any.whl

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -5,7 +5,7 @@ import logging
 import os
 import re
 import time
-from contextlib import nullcontext
+from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
 import pandas as pd
@@ -14,35 +14,21 @@ 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.common.utils.distribute_utils import DistributedContext
-from autogluon.common.utils.log_utils import DuplicateFilter
 from autogluon.common.utils.resource_utils import get_resource_manager
-from autogluon.common.utils.try_import import try_import_ray
 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.hpo.constants import CUSTOM_BACKEND, RAY_BACKEND
-from autogluon.core.hpo.exceptions import EmptySearchSpace
-from autogluon.core.hpo.executors import HpoExecutor, HpoExecutorFactory, RayHpoExecutor
 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.regressor import CovariateRegressor
-from autogluon.timeseries.transforms import (
-    CovariateScaler,
-    LocalTargetScaler,
-    get_covariate_scaler_from_name,
-    get_target_scaler_from_name,
-)
+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.warning_filters import disable_stdout, warning_filter
 
-from .model_trial import model_trial, skip_hpo
+from .tunable import TimeSeriesTunable
 
 logger = logging.getLogger(__name__)
-dup_filter = DuplicateFilter()
-logger.addFilter(dup_filter)
 
 
 # TODO: refactor and move to util. We do not need to use "params_aux" in time series
@@ -120,9 +106,9 @@ def check_and_split_hyperparameters(
     return params, params_aux
 
 
-# TODO: refactor. remove params_aux, etc. make class inherit from ABC, make overrides and abstract
-# methods clear, change name to TimeSeriesModel, et al.
-class AbstractTimeSeriesModel(ModelBase):
+# 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.
 
     Parameters
@@ -212,19 +198,16 @@ class AbstractTimeSeriesModel(ModelBase):
         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.target_scaler: Optional[LocalTargetScaler] = None
-        self.covariate_scaler: Optional[CovariateScaler] = None
-        self.covariate_regressor: Optional[CovariateRegressor] = None
-
-        # TODO: remove the variables below
-        self.model = None
 
-        self._is_initialized = False
-        self._user_params, self._user_params_aux = check_and_split_hyperparameters(hyperparameters)
+        self.params: Dict[str, Any] = {}
+        self.params_aux: Dict[str, Any] = {}
+        self._init_params_aux()
+        self._init_params()
+        self._is_initialized = True
 
-        self.params = {}
-        self.params_aux = {}
+        # TODO: remove the variables below
         self.nondefault_params: List[str] = []
 
         self.fit_time: Optional[float] = None  # Time taken to fit in seconds (Training data)
@@ -234,6 +217,11 @@ class AbstractTimeSeriesModel(ModelBase):
         )
         self.val_score: Optional[float] = None  # Score with eval_metric (Validation data)
 
+        self.target_scaler: Optional[TargetScaler]
+        self.covariate_scaler: Optional[CovariateScaler]
+        self.covariate_regressor: Optional[CovariateRegressor]
+        self._initialize_transforms_and_regressor()
+
     def __repr__(self) -> str:
         return self.name
 
@@ -263,9 +251,7 @@ class AbstractTimeSeriesModel(ModelBase):
         self._oof_predictions = None
 
         file_path = os.path.join(path, self.model_file_name)
-        _model = self.model
         save_pkl.save(path=file_path, object=self, verbose=verbose)
-        self.model = _model
 
         self._oof_predictions = oof_predictions
         return path
@@ -310,21 +296,6 @@ class AbstractTimeSeriesModel(ModelBase):
             self._oof_predictions = self.load_oof_predictions(self.path)
         return self._oof_predictions
 
-    def _get_default_auxiliary_params(self) -> dict:
-        return 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,
-        )
-
-    # TODO: remove
-    @classmethod
-    def _get_default_ag_args(cls) -> dict:
-        return {}
-
     def _init_params(self):
         """Initializes model hyperparameters"""
         hyperparameters = self._user_params
@@ -342,26 +313,35 @@ class AbstractTimeSeriesModel(ModelBase):
         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 {}
-        self.params_aux = {**self._get_default_auxiliary_params(), **hyperparameters_aux}
-
-    def initialize(self) -> None:
-        if not self._is_initialized:
-            self._init_params_aux()
-            self._init_params()
-            self._initialize_transforms()
-            self._is_initialized = True
-
-    def _initialize_transforms(self) -> None:
-        self.target_scaler = self._create_target_scaler()
-        self.covariate_scaler = self._create_covariate_scaler()
-        self.covariate_regressor = self._create_covariate_regressor()
+        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.covariate_scaler = get_covariate_scaler(
+            self._get_model_params().get("covariate_scaler"),
+            covariate_metadata=self.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"),
+            target=self.target,
+            covariate_metadata=self.metadata,
+        )
 
     def _get_model_params(self) -> dict:
         return self.params.copy()
 
     def get_params(self) -> dict:
-        # TODO: do not extract to AbstractModel if this is only used for getting a
-        # prototype of the object for HPO.
         hyperparameters = self._user_params.copy()
         if self._user_params_aux:
             hyperparameters[AG_ARGS_FIT] = self._user_params_aux.copy()
@@ -378,19 +358,6 @@ class AbstractTimeSeriesModel(ModelBase):
             target=self.target,
         )
 
-    @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 get_info(self) -> dict:
         """
         Returns a dictionary of numerous fields describing the model.
@@ -410,6 +377,188 @@ class AbstractTimeSeriesModel(ModelBase):
         }
         return info
 
+    @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
+
+    @property
+    def allowed_hyperparameters(self) -> List[str]:
+        """List of hyperparameters allowed by the model."""
+        return ["target_scaler", "covariate_regressor"]
+
+    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(
+            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:  # type: ignore
+        """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
+        models always return higher-is-better type scores.
+
+        Parameters
+        ----------
+        data: TimeSeriesDataFrame
+            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
+            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
+        )
+        predictions = self.predict(past_data, known_covariates=known_covariates)
+        return self._score_with_predictions(data=data, predictions=predictions, metric=metric)
+
+    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
+        )
+        predict_start_time = time.time()
+        oof_predictions = self.predict(past_data, known_covariates=known_covariates, **predict_kwargs)
+        self._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 _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 preprocess(  # type: ignore
+        self,
+        data: TimeSeriesDataFrame,
+        known_covariates: Optional[TimeSeriesDataFrame] = None,
+        is_train: bool = False,
+        **kwargs,
+    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
+        """Method that implements model-specific preprocessing logic."""
+        return data, known_covariates
+
+    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 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.
+
+        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,
+        }
+
+
+class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
     def fit(  # type: ignore
         self,
         train_data: TimeSeriesDataFrame,
@@ -452,7 +601,6 @@ class AbstractTimeSeriesModel(ModelBase):
             The fitted model object
         """
         start_time = time.monotonic()
-        self.initialize()
 
         if self.target_scaler is not None:
             train_data = self.target_scaler.fit_transform(train_data)
@@ -503,28 +651,7 @@ class AbstractTimeSeriesModel(ModelBase):
 
         return self
 
-    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"]
-
-        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
-
+    @abstractmethod
     def _fit(  # type: ignore
         self,
         train_data: TimeSeriesDataFrame,
@@ -539,8 +666,7 @@ class AbstractTimeSeriesModel(ModelBase):
         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: perform this check inside fit() ?
     def _check_fit_params(self):
@@ -551,65 +677,9 @@ class AbstractTimeSeriesModel(ModelBase):
                 "as hyperparameters when initializing or use `hyperparameter_tune` instead."
             )
 
-    @property
-    def allowed_hyperparameters(self) -> List[str]:
-        """List of hyperparameters allowed by the model."""
-        return ["target_scaler", "covariate_regressor"]
-
-    def _create_target_scaler(self) -> Optional[LocalTargetScaler]:
-        """Create a LocalTargetScaler object based on the value of the `target_scaler` hyperparameter."""
-        # TODO: Add support for custom target transforms (e.g., Box-Cox, log1p, ...)
-        target_scaler_type = self._get_model_params().get("target_scaler")
-        if target_scaler_type is not None:
-            return get_target_scaler_from_name(target_scaler_type, target=self.target)
-        else:
-            return None
-
-    def _create_covariate_scaler(self) -> Optional[CovariateScaler]:
-        """Create a CovariateScaler object based on the value of the `covariate_scaler` hyperparameter."""
-        covariate_scaler_type = self._get_model_params().get("covariate_scaler")
-        if covariate_scaler_type is not None:
-            return get_covariate_scaler_from_name(
-                covariate_scaler_type,
-                metadata=self.metadata,
-                use_static_features=self.supports_static_features,
-                use_known_covariates=self.supports_known_covariates,
-                use_past_covariates=self.supports_past_covariates,
-            )
-        else:
-            return None
-
-    def _create_covariate_regressor(self) -> Optional[CovariateRegressor]:
-        """Create a CovariateRegressor object based on the value of the `covariate_regressor` hyperparameter."""
-        covariate_regressor = self._get_model_params().get("covariate_regressor")
-        if covariate_regressor is not None:
-            if len(self.metadata.known_covariates + self.metadata.static_features) == 0:
-                logger.info(
-                    "\tSkipping covariate_regressor since the dataset contains no covariates or static features."
-                )
-                return None
-            else:
-                if isinstance(covariate_regressor, str):
-                    return CovariateRegressor(covariate_regressor, target=self.target, metadata=self.metadata)
-                elif isinstance(covariate_regressor, dict):
-                    return CovariateRegressor(**covariate_regressor, target=self.target, metadata=self.metadata)
-                elif isinstance(covariate_regressor, CovariateRegressor):
-                    logger.warning(
-                        "\tUsing a custom covariate_regressor is experimental functionality that may break in the future!"
-                    )
-                    covariate_regressor.target = self.target
-                    covariate_regressor.metadata = self.metadata
-                    return covariate_regressor
-                else:
-                    raise ValueError(
-                        f"Invalid value for covariate_regressor {covariate_regressor} of type {type(covariate_regressor)}"
-                    )
-        else:
-            return None
-
     def predict(  # type: ignore
         self,
-        data: Union[TimeSeriesDataFrame, Dict[str, Optional[TimeSeriesDataFrame]]],
+        data: TimeSeriesDataFrame,
         known_covariates: Optional[TimeSeriesDataFrame] = None,
         **kwargs,
     ) -> TimeSeriesDataFrame:
@@ -682,6 +752,7 @@ class AbstractTimeSeriesModel(ModelBase):
         """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)
 
+    @abstractmethod
     def _predict(
         self,
         data: Union[TimeSeriesDataFrame, Dict[str, TimeSeriesDataFrame]],
@@ -689,203 +760,29 @@ class AbstractTimeSeriesModel(ModelBase):
         **kwargs,
     ) -> TimeSeriesDataFrame:
         """Private method for `predict`. See `predict` for documentation of arguments."""
-        raise NotImplementedError
-
-    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(
-            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:  # type: ignore
-        """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
-        models always return higher-is-better type scores.
-
-        Parameters
-        ----------
-        data: TimeSeriesDataFrame
-            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
-            The computed forecast evaluation score on the last `self.prediction_length`
-            time steps of each time series.
-        """
-        # TODO: align method signature in the new AbstractModel
-
-        past_data, known_covariates = data.get_model_inputs_for_scoring(
-            prediction_length=self.prediction_length, known_covariates_names=self.metadata.known_covariates
-        )
-        predictions = self.predict(past_data, known_covariates=known_covariates)
-        return self._score_with_predictions(data=data, predictions=predictions, metric=metric)
-
-    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
-        )
-        predict_start_time = time.time()
-        oof_predictions = self.predict(past_data, known_covariates=known_covariates, **predict_kwargs)
-        self._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
-
-    @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 hyperparameter_tune(
-        self,
-        train_data: TimeSeriesDataFrame,
-        val_data: Optional[TimeSeriesDataFrame],
-        val_splitter: Any = None,
-        default_num_trials: Optional[int] = 1,
-        refit_every_n_windows: Optional[int] = 1,
-        hyperparameter_tune_kwargs: Union[str, dict] = "auto",
-        time_limit: Optional[float] = None,
-    ) -> Tuple[Dict[str, Any], Any]:
-        hpo_executor = self._get_default_hpo_executor()
-        hpo_executor.initialize(
-            hyperparameter_tune_kwargs, default_num_trials=default_num_trials, time_limit=time_limit
-        )
+        pass
 
-        self.initialize()
-
-        # we use k_fold=1 to circumvent autogluon.core logic to manage resources during parallelization
-        # of different folds
-        # FIXME: we pass in self which currently does not inherit from AbstractModel
-        hpo_executor.register_resources(self, k_fold=1, **self._get_system_resources())  # type: ignore
-
-        time_start = time.time()
-        logger.debug(f"\tStarting 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)
-
-        train_path, val_path = self._save_with_data(train_data, val_data)
-
-        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=dict(
-                val_splitter=val_splitter,
-                refit_every_n_windows=refit_every_n_windows,
-            ),
-            train_path=train_path,
-            val_path=val_path,
-            hpo_executor=hpo_executor,
-        )
+    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"]
 
-        minimum_resources = self.get_minimum_resources(is_gpu_available=self._is_gpu_available())
-        hpo_context = disable_stdout if isinstance(hpo_executor, RayHpoExecutor) else nullcontext
+        time_limit *= max_time_limit_ratio
 
-        minimum_cpu_per_trial = minimum_resources.get("num_cpus", 1)
-        if not isinstance(minimum_cpu_per_trial, int):
-            logger.warning(
-                f"Minimum number of CPUs per trial for {self.name} is not an integer. "
-                f"Setting to 1. Minimum number of CPUs per trial: {minimum_cpu_per_trial}"
-            )
-            minimum_cpu_per_trial = 1
-
-        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=self.path,
-                minimum_cpu_per_trial=minimum_cpu_per_trial,
-                minimum_gpu_per_trial=minimum_resources.get("num_gpus", 0),
-                model_estimate_memory_usage=None,
-                adapter_type="timeseries",
-            )
+        if max_time_limit is not None:
+            time_limit = min(time_limit, max_time_limit)
 
-            assert self.path_root is not None
-            hpo_models, analysis = hpo_executor.get_hpo_results(
-                model_name=self.name,
-                model_path_root=self.path_root,
-                time_start=time_start,
+        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 hpo_models, analysis
-
-    @property
-    def is_ensemble(self) -> bool:
-        """Return True if the model is an ensemble model or a container of multiple models."""
-        return self._get_model_base() is self
-
-    def _get_default_hpo_executor(self) -> HpoExecutor:
-        backend = (
-            self._get_model_base()._get_hpo_backend()
-        )  # If ensemble, will use the base model to determine backend
-        if backend == RAY_BACKEND:
-            try:
-                try_import_ray()
-            except Exception as e:
-                warning_msg = f"Will use custom hpo logic because ray import failed. Reason: {str(e)}"
-                dup_filter.attach_filter_targets(warning_msg)
-                logger.warning(warning_msg)
-                backend = CUSTOM_BACKEND
-        hpo_executor = HpoExecutorFactory.get_hpo_executor(backend)()  # type: ignore
-        return hpo_executor
-
-    def _get_model_base(self) -> AbstractTimeSeriesModel:
-        return self
-
-    def _get_hpo_backend(self) -> str:
-        """Choose which backend("ray" or "custom") to use for hpo"""
-        if DistributedContext.is_distributed_mode():
-            return RAY_BACKEND
-        return CUSTOM_BACKEND
+        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
@@ -893,100 +790,3 @@ class AbstractTimeSeriesModel(ModelBase):
         """
         params = self.params.copy()
         return params
-
-    def _save_with_data(self, train_data, val_data):
-        self.set_contexts(os.path.abspath(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)
-        return train_path, val_path
-
-    def preprocess(  # type: ignore
-        self,
-        data: TimeSeriesDataFrame,
-        known_covariates: Optional[TimeSeriesDataFrame] = None,
-        is_train: bool = False,
-        **kwargs,
-    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
-        """Method that implements model-specific preprocessing logic."""
-        # TODO: move to new AbstractModel
-        return data, known_covariates
-
-    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 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()
-
-        # TODO: remove
-        # Increase memory limit by 25% to avoid memory restrictions during fit
-        params["hyperparameters"][AG_ARGS_FIT]["max_memory_usage_ratio"] = (
-            params["hyperparameters"][AG_ARGS_FIT].get("max_memory_usage_ratio", 1.0) * 1.25
-        )
-
-        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.
-
-        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,
-        }