autogluon.timeseries 1.2.1b20250305__py3-none-any.whl → 1.2.1b20250307__py3-none-any.whl

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -6,7 +6,6 @@ import os
 import re
 import time
 from abc import ABC, abstractmethod
-from contextlib import nullcontext
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
 import pandas as pd
@@ -15,15 +14,9 @@ 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
@@ -32,13 +25,10 @@ from autogluon.timeseries.regressor import CovariateRegressor, get_covariate_reg
 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
@@ -117,8 +107,8 @@ def check_and_split_hyperparameters(
 
 
 # TODO: refactor. remove params_aux, etc. make overrides and abstract
-# methods clear, change name to TimeSeriesModel, et al.
-class AbstractTimeSeriesModel(ModelBase, ABC):
+# methods clear, et al.
+class TimeSeriesModelBase(ModelBase, ABC):
     """Abstract class for all `Model` objects in autogluon.timeseries.
 
     Parameters
@@ -400,6 +390,175 @@ class AbstractTimeSeriesModel(ModelBase, ABC):
             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,
@@ -492,28 +651,6 @@ class AbstractTimeSeriesModel(ModelBase, ABC):
 
         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,
@@ -540,14 +677,9 @@ class AbstractTimeSeriesModel(ModelBase, ABC):
                 "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 predict(  # type: ignore
         self,
-        data: Union[TimeSeriesDataFrame, Dict[str, Optional[TimeSeriesDataFrame]]],
+        data: TimeSeriesDataFrame,
         known_covariates: Optional[TimeSeriesDataFrame] = None,
         **kwargs,
     ) -> TimeSeriesDataFrame:
@@ -630,197 +762,27 @@ class AbstractTimeSeriesModel(ModelBase, ABC):
         """Private method for `predict`. See `predict` for documentation of arguments."""
         pass
 
-    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 _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
-        )
-
-        # 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,  # type: ignore
-                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
@@ -828,93 +790,3 @@ class AbstractTimeSeriesModel(ModelBase, ABC):
         """
         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."""
-        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,
-        }

autogluon/timeseries/models/abstract/tunable.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import logging
+import os
+import time
+from abc import ABC, abstractmethod
+from contextlib import nullcontext
+from typing import Any, Dict, Optional, Tuple, Union
+
+from typing_extensions import Self
+
+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.try_import import try_import_ray
+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 Tunable
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
+from autogluon.timeseries.utils.warning_filters import disable_stdout, warning_filter
+
+from .model_trial import model_trial, skip_hpo
+
+logger = logging.getLogger(__name__)
+dup_filter = DuplicateFilter()
+logger.addFilter(dup_filter)
+
+
+class TimeSeriesTunable(Tunable, ABC):
+    @abstractmethod
+    def __init__(self) -> None:
+        self.name: str
+        self.path: str
+        self.path_root: str
+
+    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
+        )
+
+        # 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,
+        )
+
+        minimum_resources = self.get_minimum_resources(is_gpu_available=self._is_gpu_available())
+        hpo_context = disable_stdout if isinstance(hpo_executor, RayHpoExecutor) else nullcontext
+
+        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,  # type: ignore
+                adapter_type="timeseries",
+            )
+
+            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,
+            )
+
+        return hpo_models, analysis
+
+    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_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
+
+    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 estimate_memory_usage(self, *args, **kwargs) -> float | None:
+        """Return the estimated memory usage of the model. None if memory usage cannot be
+        estimated.
+        """
+        return None
+
+    def get_minimum_resources(self, is_gpu_available: bool = False) -> Dict[str, Union[int, float]]:
+        return {
+            "num_cpus": 1,
+        }
+
+    def _save_with_data(
+        self, train_data: TimeSeriesDataFrame, val_data: Optional[TimeSeriesDataFrame]
+    ) -> Tuple[str, str]:
+        self.path = os.path.abspath(self.path)
+        self.path_root = self.path.rsplit(self.name, 1)[0]
+
+        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
+
+    @abstractmethod
+    def _get_model_base(self) -> Self:
+        pass
+
+    @abstractmethod
+    def _is_gpu_available(self) -> bool:
+        pass
+
+    @abstractmethod
+    def _get_search_space(self) -> Dict[str, Any]:
+        pass
+
+    @abstractmethod
+    def get_params(self) -> dict:
+        """Return a clean copy of constructor parameters that can be used to
+        clone the current model.
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def _get_system_resources() -> Dict[str, Any]:
+        pass

autogluon/timeseries/models/ensemble/greedy_ensemble.py

@@ -101,7 +101,9 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
 class TimeSeriesGreedyEnsemble(AbstractTimeSeriesEnsembleModel):
     """Constructs a weighted ensemble using the greedy Ensemble Selection algorithm."""
 
-    def __init__(self, name: str, ensemble_size: int = 100, **kwargs):
+    def __init__(self, name: Optional[str] = None, ensemble_size: int = 100, **kwargs):
+        if name is None:
+            name = "WeightedEnsemble"
         super().__init__(name=name, **kwargs)
         self.ensemble_size = ensemble_size
         self.model_to_weight: Dict[str, float] = {}
@@ -144,7 +146,7 @@ class TimeSeriesGreedyEnsemble(AbstractTimeSeriesEnsembleModel):
         return np.array(list(self.model_to_weight.values()), dtype=np.float64)
 
     def predict(self, data: Dict[str, Optional[TimeSeriesDataFrame]], **kwargs) -> TimeSeriesDataFrame:
-        if set(data.keys()) != set(self.model_names):
+        if not set(self.model_names).issubset(set(data.keys())):
             raise ValueError(
                 f"Set of models given for prediction in {self.name} differ from those provided during initialization."
             )

autogluon/timeseries/models/presets.py

@@ -235,9 +235,6 @@ def get_preset_models(
                     "is present in `excluded_model_types` and will be removed."
                 )
                 continue
-            if "mxnet" in model.lower():
-                logger.info(f"\tMXNet model '{model}' given in `hyperparameters` is deprecated and won't be trained. ")
-                continue
             model_type = MODEL_TYPES[model]
         elif isinstance(model, type):
             if not issubclass(model, AbstractTimeSeriesModel):

autogluon/timeseries/version.py

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

{autogluon.timeseries-1.2.1b20250305.dist-info → autogluon.timeseries-1.2.1b20250307.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.2.1b20250305
+Version: 1.2.1b20250307
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -55,9 +55,9 @@ Requires-Dist: fugue>=0.9.0
 Requires-Dist: tqdm<5,>=4.38
 Requires-Dist: orjson~=3.9
 Requires-Dist: tensorboard<3,>=2.9
-Requires-Dist: autogluon.core[raytune]==1.2.1b20250305
-Requires-Dist: autogluon.common==1.2.1b20250305
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250305
+Requires-Dist: autogluon.core[raytune]==1.2.1b20250307
+Requires-Dist: autogluon.common==1.2.1b20250307
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250307
 Provides-Extra: all
 Provides-Extra: chronos-onnx
 Requires-Dist: optimum[onnxruntime]<1.20,>=1.17; extra == "chronos-onnx"

{autogluon.timeseries-1.2.1b20250305.dist-info → autogluon.timeseries-1.2.1b20250307.dist-info}/RECORD

@@ -1,4 +1,4 @@
-autogluon.timeseries-1.2.1b20250305-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.2.1b20250307-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
 autogluon/timeseries/__init__.py,sha256=_CrLLc1fkjen7UzWoO0Os8WZoHOgvZbHKy46I8v_4k4,304
 autogluon/timeseries/evaluator.py,sha256=l642tYfTHsl8WVIq_vV6qhgAFVFr9UuZD7gLra3A_Kc,250
 autogluon/timeseries/learner.py,sha256=PDAHFlos6q5JukwRE86tKoH0zxYf3nLzy7qfD_a5NYY,13849
@@ -6,7 +6,7 @@ autogluon/timeseries/predictor.py,sha256=DgKNvDfduVyauR7MXQZk04JyT3fc5erXAGVp3XO
 autogluon/timeseries/regressor.py,sha256=3MlTpP-M1ayTZ52UQDK0wIMMFUijPep-iEyftlDdKPg,11804
 autogluon/timeseries/splitter.py,sha256=yzPca9p2bWV-_VJAptUyyzQsxu-uixAdpMoGQtDzMD4,3205
 autogluon/timeseries/trainer.py,sha256=L9FT5qERcqlWTgH9IgE6QsO0aBNj2nivRKF2Oy4UJOk,57250
-autogluon/timeseries/version.py,sha256=hjp__CpU1tLt2wGIEfd4tVSKrES_x0vHTkZdLuoYGnE,91
+autogluon/timeseries/version.py,sha256=c5NUbrqeXmY6g27wyrvskoLAD4GR6pJJiY4KIluKRt0,91
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
 autogluon/timeseries/configs/presets_configs.py,sha256=cLat8ecLlWrI-SC5KLBDCX2SbVXaucemy2pjxJAtSY0,2543
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
@@ -17,10 +17,11 @@ autogluon/timeseries/metrics/point.py,sha256=g7L8jVUKc5YVjETZ-B7syK9nZswfKxLFlkN
 autogluon/timeseries/metrics/quantile.py,sha256=eemdLbo3y2wstnVkuA-f55YXywctUmSW1EhIW4BsoH4,3965
 autogluon/timeseries/metrics/utils.py,sha256=HuDe1BNe8yJU4f_DKM913nNrUueoRaw6zhxm1-S20s0,910
 autogluon/timeseries/models/__init__.py,sha256=MYD9JJ-wUDE5B6jW6E6LU2eXQ6vflfQBvqQJkdzJa3A,1189
-autogluon/timeseries/models/presets.py,sha256=GezDk-p591Mlhm5UTIjKKJqQE2mnWw9rdsDYKen4zJo,12478
+autogluon/timeseries/models/presets.py,sha256=qfpxoT3G3FEM2_P41nBfTXGNuLZTneCXAVa15guW5do,12292
 autogluon/timeseries/models/abstract/__init__.py,sha256=wvDsQAZIV0N3AwBeMaGItoQ82trEfnT-nol2AAOIxBg,102
-autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=ouQJu75JydLOzWAroHWHzLhaRgkeOXOu0d5F1dh_4Yc,40598
+autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=XlLZQjt0LRRZGcCzqKVXSpuiFTwUOoDdhNm63igdIdE,34836
 autogluon/timeseries/models/abstract/model_trial.py,sha256=ENPg_7nsdxIvaNM0o0UShZ3x8jFlRmwRc5m0fGPC0TM,3720
+autogluon/timeseries/models/abstract/tunable.py,sha256=SFl4vjkb6BfFFaRPVdftnnLYlIyCThutLHxiiAlV6tY,7168
 autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=r9i6jWcyeLHYClkcMSKRVsfrkBUMxpDrTATNTBc_qgQ,136
 autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=HGuV6_63TnBK9RqVD-VUTbbBuxQG9lmKxo5kLQLTlug,33016
 autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=CVvNun8DKH7UQGyXU-iO2xmvBIHRQElw72gIrZ7QjkU,2504
@@ -34,7 +35,7 @@ autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=2MJuik-YFgON
 autogluon/timeseries/models/chronos/pipeline/utils.py,sha256=dtDX5Pyu95bGv7qmqgfUc1iYowWPY84dnGN0uyqyHyQ,13131
 autogluon/timeseries/models/ensemble/__init__.py,sha256=kFr11Gmt7lQJu9Rr8HuIPphQN5l1TsoorfbJm_O3a_s,128
 autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py,sha256=LzL64JASiwkLsuFxGToXJGRItcMxq5_Ig2QP5Zm7SHw,3537
-autogluon/timeseries/models/ensemble/greedy_ensemble.py,sha256=UPEmNx-RSuqCXS7V093NEid_AwwEigM6AXMcZtof8vg,7230
+autogluon/timeseries/models/ensemble/greedy_ensemble.py,sha256=v5A2xv4d_QynA1GWD7iqmn-VVEFpD88Oiswyp72yBCc,7321
 autogluon/timeseries/models/gluonts/__init__.py,sha256=asC1PTj4j9xMbilvk1IT1julnpeoKbv5ZNuAR6-DFgA,361
 autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=brf2lIMHH4a_AETwyOcOBVPWqWhLxr8iolJ3Z5AR8MA,30621
 autogluon/timeseries/models/gluonts/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -58,11 +59,11 @@ autogluon/timeseries/utils/datetime/base.py,sha256=3NdsH3NDq4cVAOSoy3XpaNixyNlbj
 autogluon/timeseries/utils/datetime/lags.py,sha256=gQDk5_zmsY5DUWDUpSaCKYkQ9nHKKY-LsywJQRAoYSk,5988
 autogluon/timeseries/utils/datetime/seasonality.py,sha256=YK_2k8hvYIMW-sJPnjGWRtCnvIOthwA2hATB3nwVoD4,834
 autogluon/timeseries/utils/datetime/time_features.py,sha256=MjLi3zQ00uWWJtXH9oGX2GJkTbvjdSiuabSa4kcVuxE,2672
-autogluon.timeseries-1.2.1b20250305.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.2.1b20250305.dist-info/METADATA,sha256=yPmePcrpFvseKU8tl3A7y22PYvTf5SfD_2lAahDWfU8,12684
-autogluon.timeseries-1.2.1b20250305.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.2.1b20250305.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.timeseries-1.2.1b20250305.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250305.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250305.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.2.1b20250305.dist-info/RECORD,,
+autogluon.timeseries-1.2.1b20250307.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.2.1b20250307.dist-info/METADATA,sha256=Ws9N44bzdHBksRKp4Zwq0bPj3tq7UisxMJnfRey8Za0,12684
+autogluon.timeseries-1.2.1b20250307.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.2.1b20250307.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.timeseries-1.2.1b20250307.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.2.1b20250307.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.2.1b20250307.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.2.1b20250307.dist-info/RECORD,,