autogluon.timeseries 1.2.1b20250114__tar.gz → 1.2.1b20250116__tar.gz

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.2.1b20250114
+Version: 1.2.1b20250116
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/setup.py

@@ -32,10 +32,10 @@ install_requires = [
     "accelerate",  # version range defined in `core/_setup_utils.py`
     "gluonts>=0.15.0,<0.17",
     "networkx",  # version range defined in `core/_setup_utils.py`
-    "statsforecast>=1.7.0,<1.8",
-    "mlforecast==0.13.4",
-    "utilsforecast>=0.2.3,<0.2.5",  # to prevent breaking changes that propagate through mlforecast's dependency
-    "coreforecast==0.0.12",  # to prevent breaking changes that propagate through mlforecast's dependency
+    "statsforecast>=1.7.0,<2.0.1",
+    "mlforecast>0.13,<0.14",
+    "utilsforecast>=0.2.3,<0.2.11",  # to prevent breaking changes that propagate through mlforecast's dependency
+    "coreforecast>=0.0.12,<0.0.16",  # to prevent breaking changes that propagate through mlforecast's dependency
     "fugue>=0.9.0",  # prevent dependency clash with omegaconf
     "tqdm",  # version range defined in `core/_setup_utils.py`
     "orjson~=3.9",  # use faster JSON implementation in GluonTS

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/dataset/ts_dataframe.py

@@ -12,7 +12,7 @@ from typing import Any, List, Optional, Tuple, Type, Union
 
 import pandas as pd
 from joblib.parallel import Parallel, delayed
-from pandas.core.internals import ArrayManager, BlockManager
+from pandas.core.internals import ArrayManager, BlockManager  # type: ignore
 
 from autogluon.common.loaders import load_pd
 
@@ -174,7 +174,7 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
             data = self._construct_tsdf_from_iterable_dataset(data, num_cpus=num_cpus)
         else:
             raise ValueError(f"data must be a pd.DataFrame, Iterable, string or Path (received {type(data)}).")
-        super().__init__(data=data, *args, **kwargs)
+        super().__init__(data=data, *args, **kwargs)  # type: ignore
         self._static_features: Optional[pd.DataFrame] = None
         if static_features is not None:
             self.static_features = self._construct_static_features(static_features, id_column=id_column)
@@ -419,10 +419,7 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
     def item_ids(self) -> pd.Index:
         return self.index.unique(level=ITEMID)
 
-    @property
-    def static_features(self):
-        return self._static_features
-
+    @classmethod
     def _construct_static_features(
         cls,
         static_features: Union[pd.DataFrame, str, Path],
@@ -443,6 +440,10 @@ class TimeSeriesDataFrame(pd.DataFrame, TimeSeriesDataFrameDeprecatedMixin):
             static_features.rename(columns={id_column: ITEMID}, inplace=True)
         return static_features
 
+    @property
+    def static_features(self):
+        return self._static_features
+
     @static_features.setter
     def static_features(self, value: Optional[pd.DataFrame]):
         # if the current item index is not a multiindex, then we are dealing with a single

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/metrics/__init__.py

@@ -50,28 +50,28 @@ EXPERIMENTAL_METRICS = {
 def check_get_evaluation_metric(
     eval_metric: Union[str, TimeSeriesScorer, Type[TimeSeriesScorer], None] = None
 ) -> TimeSeriesScorer:
+    scorer: TimeSeriesScorer
     if isinstance(eval_metric, TimeSeriesScorer):
-        eval_metric = eval_metric
+        scorer = eval_metric
     elif isinstance(eval_metric, type) and issubclass(eval_metric, TimeSeriesScorer):
         # e.g., user passed `eval_metric=CustomMetric` instead of `eval_metric=CustomMetric()`
-        eval_metric = eval_metric()
+        scorer = eval_metric()
     elif isinstance(eval_metric, str):
-        eval_metric = DEPRECATED_METRICS.get(eval_metric, eval_metric)
-        metric_name = eval_metric.upper()
+        metric_name = DEPRECATED_METRICS.get(eval_metric, eval_metric).upper()
         if metric_name in AVAILABLE_METRICS:
-            eval_metric = AVAILABLE_METRICS[metric_name]()
+            scorer = AVAILABLE_METRICS[metric_name]()
         elif metric_name in EXPERIMENTAL_METRICS:
-            eval_metric = EXPERIMENTAL_METRICS[metric_name]()
+            scorer = EXPERIMENTAL_METRICS[metric_name]()
         else:
             raise ValueError(
                 f"Time series metric {eval_metric} not supported. Available metrics are:\n"
                 f"{pformat(sorted(AVAILABLE_METRICS.keys()))}"
             )
     elif eval_metric is None:
-        eval_metric = AVAILABLE_METRICS[DEFAULT_METRIC_NAME]()
+        scorer = AVAILABLE_METRICS[DEFAULT_METRIC_NAME]()
     else:
         raise ValueError(
             f"eval_metric must be of type str, TimeSeriesScorer or None "
             f"(received eval_metric = {eval_metric} of type {type(eval_metric)})"
         )
-    return eval_metric
+    return scorer

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/metrics/abstract.py

@@ -161,7 +161,7 @@ class TimeSeriesScorer:
     @staticmethod
     def _safemean(array: Union[np.ndarray, pd.Series]) -> float:
         """Compute mean of a numpy array-like object, ignoring inf, -inf and nan values."""
-        return np.mean(array[np.isfinite(array)])
+        return float(np.mean(array[np.isfinite(array)]))
 
     @staticmethod
     def _get_point_forecast_score_inputs(

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/metrics/point.py

@@ -248,7 +248,7 @@ class MASE(TimeSeriesScorer):
 
         num_items = len(self._past_abs_seasonal_error)
         # Reshape abs errors into [num_items, prediction_length] to normalize per item without groupby
-        abs_errors = np.abs(y_true.values - y_pred.values).reshape([num_items, -1])
+        abs_errors = np.abs(y_true.to_numpy() - y_pred.to_numpy()).reshape([num_items, -1])
         return self._safemean(abs_errors / self._past_abs_seasonal_error.values[:, None])
 
 
@@ -308,7 +308,7 @@ class RMSSE(TimeSeriesScorer):
 
         num_items = len(self._past_squared_seasonal_error)
         # Reshape squared errors into [num_items, prediction_length] to normalize per item without groupby
-        squared_errors = ((y_true.values - y_pred.values) ** 2.0).reshape([num_items, -1])
+        squared_errors = ((y_true.to_numpy() - y_pred.to_numpy()) ** 2.0).reshape([num_items, -1])
         return np.sqrt(self._safemean(squared_errors / self._past_squared_seasonal_error.values[:, None]))
 
 
@@ -335,7 +335,9 @@ class RMSLE(TimeSeriesScorer):
     - `Scikit-learn: <https://scikit-learn.org/stable/modules/model_evaluation.html#mean-squared-log-error>`_
     """
 
-    def compute_metric(self, data_future, predictions, target, **kwargs):
+    def compute_metric(
+        self, data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target", **kwargs
+    ) -> float:
         y_true, y_pred = self._get_point_forecast_score_inputs(data_future, predictions, target=target)
         y_pred = np.clip(y_pred, a_min=0.0, a_max=None)
 
@@ -399,6 +401,7 @@ class WCD(TimeSeriesScorer):
 
     def _fast_cumsum(self, y: np.ndarray) -> np.ndarray:
         """Compute the cumulative sum for each consecutive `prediction_length` items in the array."""
+        assert self.num_items is not None, "Make sure to call `save_past_metrics` before `compute_metric`"
         y = y.reshape(self.num_items, -1)
         return np.nancumsum(y, axis=1).ravel()
 

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -3,7 +3,7 @@ import os
 import re
 import time
 from contextlib import nullcontext
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 import pandas as pd
 
@@ -138,6 +138,7 @@ class AbstractTimeSeriesModel(AbstractModel):
         self.target_scaler: Optional[LocalTargetScaler] = None
         self.covariate_scaler: Optional[CovariateScaler] = None
         self.covariate_regressor: Optional[CovariateRegressor] = None
+        self.fit_time: Optional[float]
 
     def __repr__(self) -> str:
         return self.name
@@ -389,7 +390,7 @@ class AbstractTimeSeriesModel(AbstractModel):
 
     def predict(
         self,
-        data: Union[TimeSeriesDataFrame, Dict[str, TimeSeriesDataFrame]],
+        data: Union[TimeSeriesDataFrame, Dict[str, Optional[TimeSeriesDataFrame]]],
         known_covariates: Optional[TimeSeriesDataFrame] = None,
         **kwargs,
     ) -> TimeSeriesDataFrame:
@@ -402,7 +403,7 @@ class AbstractTimeSeriesModel(AbstractModel):
 
         Parameters
         ----------
-        data: Union[TimeSeriesDataFrame, Dict[str, TimeSeriesDataFrame]]
+        data: Union[TimeSeriesDataFrame, Dict[str, Optional[TimeSeriesDataFrame]]]
             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]
@@ -543,8 +544,12 @@ class AbstractTimeSeriesModel(AbstractModel):
         return False
 
     def hyperparameter_tune(
-        self, hyperparameter_tune_kwargs="auto", hpo_executor: HpoExecutor = None, time_limit: float = None, **kwargs
-    ):
+        self,
+        hyperparameter_tune_kwargs: Union[str, dict] = "auto",
+        hpo_executor: Optional[HpoExecutor] = None,
+        time_limit: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
         if hpo_executor is None:
             hpo_executor = self._get_default_hpo_executor()
             default_num_trials = kwargs.pop("default_num_trials", None)

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py

@@ -20,7 +20,7 @@ class AbstractTimeSeriesEnsembleModel(AbstractTimeSeriesModel):
         self,
         predictions_per_window: Dict[str, List[TimeSeriesDataFrame]],
         data_per_window: List[TimeSeriesDataFrame],
-        time_limit: Optional[int] = None,
+        time_limit: Optional[float] = None,
         **kwargs,
     ):
         """Fit ensemble model given predictions of candidate base models and the true data.
@@ -67,7 +67,7 @@ class AbstractTimeSeriesEnsembleModel(AbstractTimeSeriesModel):
         """
         raise NotImplementedError
 
-    def predict(self, data: Dict[str, TimeSeriesDataFrame], **kwargs) -> TimeSeriesDataFrame:
+    def predict(self, data: Dict[str, Optional[TimeSeriesDataFrame]], **kwargs) -> TimeSeriesDataFrame:
         raise NotImplementedError
 
     def remap_base_models(self, model_refit_map: Dict[str, str]) -> None:

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/models/ensemble/greedy_ensemble.py

@@ -143,7 +143,7 @@ class TimeSeriesGreedyEnsemble(AbstractTimeSeriesEnsembleModel):
     def model_weights(self) -> np.ndarray:
         return np.array(list(self.model_to_weight.values()), dtype=np.float64)
 
-    def predict(self, data: Dict[str, TimeSeriesDataFrame], **kwargs) -> TimeSeriesDataFrame:
+    def predict(self, data: Dict[str, Optional[TimeSeriesDataFrame]], **kwargs) -> TimeSeriesDataFrame:
         if set(data.keys()) != set(self.model_names):
             raise ValueError(
                 f"Set of models given for prediction in {self.name} differ from those provided during initialization."

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/models/presets.py

@@ -179,7 +179,7 @@ def get_default_hps(key):
 
 
 def get_preset_models(
-    freq: str,
+    freq: Optional[str],
     prediction_length: int,
     path: str,
     eval_metric: TimeSeriesScorer,
@@ -188,7 +188,7 @@ def get_preset_models(
     hyperparameter_tune: bool,
     metadata: CovariateMetadata,
     all_assigned_names: List[str],
-    excluded_model_types: List[str],
+    excluded_model_types: Optional[List[str]],
     multi_window: bool = False,
     **kwargs,
 ):

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/predictor.py

@@ -1445,7 +1445,7 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
         past_data, known_covariates = test_data.get_model_inputs_for_scoring(
             prediction_length=self.prediction_length, known_covariates_names=trainer.metadata.known_covariates
         )
-        pred_proba_dict_test: Dict[str, TimeSeriesDataFrame] = trainer.get_model_pred_dict(
+        pred_proba_dict_test, _ = trainer.get_model_pred_dict(
             base_model_names, data=past_data, known_covariates=known_covariates
         )
 

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/splitter.py

@@ -13,6 +13,9 @@ class AbstractWindowSplitter:
         self.prediction_length = prediction_length
         self.num_val_windows = num_val_windows
 
+    def split(self, data: TimeSeriesDataFrame) -> Iterator[Tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]]:
+        raise NotImplementedError
+
 
 class ExpandingWindowSplitter(AbstractWindowSplitter):
     """For each train / validation split, training data includes all available past data.

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/trainer/abstract_trainer.py

@@ -66,7 +66,7 @@ class SimpleAbstractTrainer:
         """
         return self.get_model_names() + list(self._extra_banned_names)
 
-    def get_models_attribute_dict(self, attribute: str, models: List[str] = None) -> Dict[str, Any]:
+    def get_models_attribute_dict(self, attribute: str, models: Optional[List[str]] = None) -> Dict[str, Any]:
         """Get an attribute from the `model_graph` for each of the model names
         specified. If `models` is none, the attribute will be returned for all models"""
         results = {}
@@ -150,15 +150,15 @@ class SimpleAbstractTrainer:
         model_type: Optional[Type[AbstractModel]] = None,
     ) -> AbstractTimeSeriesModel:
         if isinstance(model_name, AbstractModel):
+            assert isinstance(model_name, AbstractTimeSeriesModel)
             return model_name
         if model_name in self.models.keys():
             return self.models[model_name]
 
-        if path is None:
-            path = self.get_model_attribute(model=model_name, attribute="path")
-        if model_type is None:
-            model_type = self.get_model_attribute(model=model_name, attribute="type")
-        return model_type.load(path=os.path.join(self.path, path), reset_paths=self.reset_paths)
+        path_ = path if path is not None else self.get_model_attribute(model=model_name, attribute="path")
+        type_ = model_type if model_type is not None else self.get_model_attribute(model=model_name, attribute="type")
+
+        return type_.load(path=os.path.join(self.path, path_), reset_paths=self.reset_paths)
 
     def construct_model_templates(self, hyperparameters: Union[str, Dict[str, Any]], **kwargs):
         raise NotImplementedError
@@ -177,7 +177,7 @@ class SimpleAbstractTrainer:
             minimum_model_set = [m for m in minimum_model_set if m != model]
         return minimum_model_set
 
-    def get_models_info(self, models: List[str] = None) -> Dict[str, Any]:
+    def get_models_info(self, models: Optional[List[str]] = None) -> Dict[str, Any]:
         if models is None:
             models = self.get_model_names()
         model_info_dict = dict()
@@ -212,7 +212,7 @@ class SimpleAbstractTrainer:
         save_json.save(path=os.path.join(self.path, self.trainer_info_json_name), obj=info)
         return info
 
-    def get_model_best(self, *args, **kwargs) -> AbstractModel:
+    def get_model_best(self, *args, **kwargs) -> str:
         raise NotImplementedError
 
     def get_info(self, include_model_info: bool = False) -> Dict[str, Any]:
@@ -254,7 +254,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
     def __init__(
         self,
         path: str,
-        prediction_length: Optional[int] = 1,
+        prediction_length: int = 1,
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
         eval_metric_seasonal_period: Optional[int] = None,
         save_data: bool = True,
@@ -347,7 +347,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
     def _add_model(
         self,
         model: AbstractTimeSeriesModel,
-        base_models: List[str] = None,
+        base_models: Optional[List[str]] = None,
     ):
         """Add a model to the model graph of the trainer. If the model is an ensemble, also add
         information about dependencies to the model graph (list of models specified via ``base_models``).
@@ -400,7 +400,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
 
         return levels
 
-    def get_model_best(self) -> str:
+    def get_model_best(self, *args, **kwargs) -> str:
         """Return the name of the best model by model performance on the validation set."""
         models = self.get_model_names()
         if not models:
@@ -642,6 +642,9 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
                     )
                 logger.info(fit_log_message)
                 with tqdm.external_write_mode():
+                    assert hyperparameter_tune_kwargs is not None, (
+                        "`hyperparameter_tune_kwargs` must be provided if hyperparameters contain a search space"
+                    )
                     model_names_trained += self.tune_model_hyperparameters(
                         model,
                         time_limit=time_left_for_model,
@@ -760,7 +763,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         for window_idx, data in enumerate(data_per_window):
             predictions = ensemble.predict({n: model_preds[n][window_idx] for n in ensemble.model_names})
             score_per_fold.append(self._score_with_predictions(data, predictions))
-        ensemble.val_score = np.mean(score_per_fold)
+        ensemble.val_score = float(np.mean(score_per_fold, dtype=np.float64))
 
         self._log_scores_and_times(
             val_score=ensemble.val_score,
@@ -814,7 +817,6 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
                 model_names=model_names,
                 data=past_data,
                 known_covariates=known_covariates,
-                record_pred_time=True,
                 raise_exception_if_failed=False,
                 use_cache=use_cache,
             )
@@ -934,14 +936,17 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         **kwargs,
     ) -> TimeSeriesDataFrame:
         model_name = self._get_model_for_prediction(model)
-        model_pred_dict = self.get_model_pred_dict(
+        model_pred_dict, _ = self.get_model_pred_dict(
             model_names=[model_name],
             data=data,
             known_covariates=known_covariates,
             use_cache=use_cache,
             random_seed=random_seed,
         )
-        return model_pred_dict[model_name]
+        predictions = model_pred_dict[model_name]
+        if predictions is None:
+            raise ValueError(f"Model {model_name} failed to predict. Please check the model's logs.")
+        return predictions
 
     def _score_with_predictions(
         self,
@@ -981,10 +986,10 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
             prediction_length=self.prediction_length, known_covariates_names=self.metadata.known_covariates
         )
         predictions = self.predict(data=past_data, known_covariates=known_covariates, model=model, use_cache=use_cache)
-        if not isinstance(metrics, list):  # a single metric is provided
-            metrics = [metrics]
+
+        metrics_ = [metrics] if not isinstance(metrics, list) else metrics
         scores_dict = {}
-        for metric in metrics:
+        for metric in metrics_:
             eval_metric = self.eval_metric if metric is None else check_get_evaluation_metric(metric)
             scores_dict[eval_metric.name] = self._score_with_predictions(
                 data=data, predictions=predictions, metric=eval_metric
@@ -1034,6 +1039,10 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
             "permutation": PermutationFeatureImportanceTransform,
             "naive": ConstantReplacementFeatureImportanceTransform,
         }.get(method)
+        assert importance_transform_type is not None, (
+            f"Invalid feature importance method {method}. Valid methods are 'permutation' and 'naive',"
+        )
+
         importance_transform = importance_transform_type(
             covariate_metadata=self.metadata,
             prediction_length=self.prediction_length,
@@ -1050,7 +1059,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         for n in range(num_iterations):
             if subsample_size < data.num_items:
                 item_ids_sampled = data.item_ids.to_series().sample(subsample_size)  # noqa
-                data_sample = data.query("item_id in @item_ids_sampled")
+                data_sample: TimeSeriesDataFrame = data.query("item_id in @item_ids_sampled")  # type: ignore
             else:
                 data_sample = data
 
@@ -1094,7 +1103,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
 
         return importance_df
 
-    def _model_uses_feature(self, model: Optional[Union[str, AbstractTimeSeriesModel]], feature: str) -> bool:
+    def _model_uses_feature(self, model: Union[str, AbstractTimeSeriesModel], feature: str) -> bool:
         """Check if the given model uses the given feature."""
         models_with_ancestors = set(self.get_minimum_model_set(model))
 
@@ -1138,7 +1147,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         self,
         model: Union[str, AbstractTimeSeriesModel],
         data: TimeSeriesDataFrame,
-        model_pred_dict: Dict[str, TimeSeriesDataFrame],
+        model_pred_dict: Dict[str, Optional[TimeSeriesDataFrame]],
         known_covariates: Optional[TimeSeriesDataFrame] = None,
     ) -> TimeSeriesDataFrame:
         """Generate predictions using the given model.
@@ -1147,15 +1156,15 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         """
         if isinstance(model, str):
             model = self.load_model(model)
-        data = self._get_inputs_to_model(model=model, data=data, model_pred_dict=model_pred_dict)
-        return model.predict(data, known_covariates=known_covariates)
+        model_inputs = self._get_inputs_to_model(model=model, data=data, model_pred_dict=model_pred_dict)
+        return model.predict(model_inputs, known_covariates=known_covariates)
 
     def _get_inputs_to_model(
         self,
-        model: str,
+        model: Union[str, AbstractTimeSeriesModel],
         data: TimeSeriesDataFrame,
-        model_pred_dict: Dict[str, TimeSeriesDataFrame],
-    ) -> Union[TimeSeriesDataFrame, Dict[str, TimeSeriesDataFrame]]:
+        model_pred_dict: Dict[str, Optional[TimeSeriesDataFrame]],
+    ) -> Union[TimeSeriesDataFrame, Dict[str, Optional[TimeSeriesDataFrame]]]:
         """Get the first argument that should be passed to model.predict.
 
         This method assumes that model_pred_dict contains the predictions of all base models, if model is an ensemble.
@@ -1174,11 +1183,10 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         model_names: List[str],
         data: TimeSeriesDataFrame,
         known_covariates: Optional[TimeSeriesDataFrame] = None,
-        record_pred_time: bool = False,
         raise_exception_if_failed: bool = True,
         use_cache: bool = True,
         random_seed: Optional[int] = None,
-    ) -> Union[Dict[str, TimeSeriesDataFrame], Tuple[Dict[str, TimeSeriesDataFrame], Dict[str, float]]]:
+    ) -> Tuple[Dict[str, Optional[TimeSeriesDataFrame]], Dict[str, float]]:
         """Return a dictionary with predictions of all models for the given dataset.
 
         Parameters
@@ -1204,14 +1212,14 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
             model_pred_dict, pred_time_dict_marginal = self._get_cached_pred_dicts(dataset_hash)
         else:
             model_pred_dict = {}
-            pred_time_dict_marginal = {}
+            pred_time_dict_marginal: Dict[str, Any] = {}
 
         model_set = set()
         for model_name in model_names:
             model_set.update(self.get_minimum_model_set(model_name))
         if len(model_set) > 1:
             model_to_level = self._get_model_levels()
-            model_set = sorted(model_set, key=model_to_level.get)
+            model_set = sorted(model_set, key=model_to_level.get)  # type: ignore
         logger.debug(f"Prediction order: {model_set}")
 
         failed_models = []
@@ -1239,16 +1247,16 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
             raise RuntimeError(f"Following models failed to predict: {failed_models}")
         if self.cache_predictions and use_cache:
             self._save_cached_pred_dicts(
-                dataset_hash, model_pred_dict=model_pred_dict, pred_time_dict=pred_time_dict_marginal
+                dataset_hash,  # type: ignore
+                model_pred_dict=model_pred_dict,
+                pred_time_dict=pred_time_dict_marginal,
             )
         pred_time_dict_total = self._get_total_pred_time_from_marginal(pred_time_dict_marginal)
 
         final_model_pred_dict = {model_name: model_pred_dict[model_name] for model_name in model_names}
         final_pred_time_dict_total = {model_name: pred_time_dict_total[model_name] for model_name in model_names}
-        if record_pred_time:
-            return final_model_pred_dict, final_pred_time_dict_total
-        else:
-            return final_model_pred_dict
+
+        return final_model_pred_dict, final_pred_time_dict_total
 
     def _get_total_pred_time_from_marginal(self, pred_time_dict_marginal: Dict[str, float]) -> Dict[str, float]:
         pred_time_dict_total = defaultdict(float)
@@ -1270,7 +1278,9 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         combined_hash = hash_pandas_df(data) + hash_pandas_df(known_covariates) + hash_pandas_df(data.static_features)
         return combined_hash
 
-    def _get_cached_pred_dicts(self, dataset_hash: str) -> Tuple[Dict[str, TimeSeriesDataFrame], Dict[str, float]]:
+    def _get_cached_pred_dicts(
+        self, dataset_hash: str
+    ) -> Tuple[Dict[str, Optional[TimeSeriesDataFrame]], Dict[str, float]]:
         """Load cached predictions for given dataset_hash from disk, if possible. Otherwise returns empty dicts."""
         if self._cached_predictions_path.exists():
             cached_predictions = load_pkl.load(str(self._cached_predictions_path))
@@ -1286,7 +1296,10 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         return {}, {}
 
     def _save_cached_pred_dicts(
-        self, dataset_hash: str, model_pred_dict: Dict[str, TimeSeriesDataFrame], pred_time_dict: Dict[str, float]
+        self,
+        dataset_hash: str,
+        model_pred_dict: Dict[str, Optional[TimeSeriesDataFrame]],
+        pred_time_dict: Dict[str, float],
     ) -> None:
         # TODO: Save separate file for each dataset if _cached_predictions file grows large?
         if self._cached_predictions_path.exists():
@@ -1315,7 +1328,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         self,
         train_data: Optional[TimeSeriesDataFrame] = None,
         val_data: Optional[TimeSeriesDataFrame] = None,
-        models: List[str] = None,
+        models: Optional[List[str]] = None,
     ) -> List[str]:
         train_data = train_data or self.load_train_data()
         val_data = val_data or self.load_val_data()
@@ -1325,7 +1338,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
             models = self.get_model_names()
 
         model_to_level = self._get_model_levels()
-        models_sorted_by_level = sorted(models, key=model_to_level.get)
+        models_sorted_by_level = sorted(models, key=model_to_level.get)  # type: ignore
 
         model_refit_map = {}
         models_trained_full = []
@@ -1392,7 +1405,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         return copy.deepcopy(self.model_refit_map)
 
     def construct_model_templates(
-        self, hyperparameters: Union[str, Dict[str, Any]], multi_window: bool = False, **kwargs
+        self, hyperparameters: Optional[Union[str, Dict[str, Any]]], multi_window: bool = False, **kwargs
     ) -> List[AbstractTimeSeriesModel]:
         """Constructs a list of unfit models based on the hyperparameters dict."""
         raise NotImplementedError

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/trainer/auto_trainer.py

@@ -14,6 +14,7 @@ class AutoTimeSeriesTrainer(AbstractTimeSeriesTrainer):
         eval_metric_seasonal_period = kwargs.pop("eval_metric", self.eval_metric_seasonal_period)
         quantile_levels = kwargs.pop("quantile_levels", self.quantile_levels)
         hyperparameter_tune = kwargs.get("hyperparameter_tune", False)
+
         return get_preset_models(
             path=path,
             eval_metric=eval_metric,

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon/timeseries/version.py

@@ -1,3 +1,4 @@
 """This is the autogluon version file."""
-__version__ = '1.2.1b20250114'
+
+__version__ = "1.2.1b20250116"
 __lite__ = False

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon.timeseries.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.2.1b20250114
+Version: 1.2.1b20250116
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.timeseries-1.2.1b20250114 → autogluon.timeseries-1.2.1b20250116}/src/autogluon.timeseries.egg-info/requires.txt

@@ -9,17 +9,17 @@ transformers[sentencepiece]<5,>=4.38.0
 accelerate<1.0,>=0.34.0
 gluonts<0.17,>=0.15.0
 networkx<4,>=3.0
-statsforecast<1.8,>=1.7.0
-mlforecast==0.13.4
-utilsforecast<0.2.5,>=0.2.3
-coreforecast==0.0.12
+statsforecast<2.0.1,>=1.7.0
+mlforecast<0.14,>0.13
+utilsforecast<0.2.11,>=0.2.3
+coreforecast<0.0.16,>=0.0.12
 fugue>=0.9.0
 tqdm<5,>=4.38
 orjson~=3.9
 tensorboard<3,>=2.9
-autogluon.core[raytune]==1.2.1b20250114
-autogluon.common==1.2.1b20250114
-autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250114
+autogluon.core[raytune]==1.2.1b20250116
+autogluon.common==1.2.1b20250116
+autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250116
 
 [all]