autogluon.timeseries 1.4.1b20250829__py3-none-any.whl → 1.4.1b20250903__py3-none-any.whl

autogluon/timeseries/trainer/prediction_cache.py

@@ -0,0 +1,149 @@
+import logging
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Optional
+
+from autogluon.common.utils.utils import hash_pandas_df
+from autogluon.core.utils.loaders import load_pkl
+from autogluon.core.utils.savers import save_pkl
+from autogluon.timeseries import TimeSeriesDataFrame
+
+logger = logging.getLogger(__name__)
+
+
+class PredictionCache(ABC):
+    """A prediction cache is an abstract key-value store for time series predictions. The storage is keyed by
+    (data, known_covariates) pairs and stores (model_pred_dict, pred_time_dict) pair values. In this stored pair,
+    (model_pred_dict, pred_time_dict), both dictionaries are keyed by model names.
+    """
+
+    def __init__(self, root_path: str):
+        self.root_path = Path(root_path)
+
+    @abstractmethod
+    def get(
+        self, data: TimeSeriesDataFrame, known_covariates: Optional[TimeSeriesDataFrame]
+    ) -> tuple[dict[str, Optional[TimeSeriesDataFrame]], dict[str, float]]:
+        pass
+
+    @abstractmethod
+    def put(
+        self,
+        data: TimeSeriesDataFrame,
+        known_covariates: Optional[TimeSeriesDataFrame],
+        model_pred_dict: dict[str, Optional[TimeSeriesDataFrame]],
+        pred_time_dict: dict[str, float],
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def clear(self) -> None:
+        pass
+
+
+def get_prediction_cache(use_cache: bool, root_path: str) -> PredictionCache:
+    if use_cache:
+        return FileBasedPredictionCache(root_path=root_path)
+    else:
+        return NoOpPredictionCache(root_path=root_path)
+
+
+def compute_dataset_hash(data: TimeSeriesDataFrame, known_covariates: Optional[TimeSeriesDataFrame] = None) -> str:
+    """Compute a unique string that identifies the time series dataset."""
+    combined_hash = hash_pandas_df(data) + hash_pandas_df(known_covariates) + hash_pandas_df(data.static_features)
+    return combined_hash
+
+
+class NoOpPredictionCache(PredictionCache):
+    """A dummy (no-op) prediction cache."""
+
+    def get(
+        self, data: TimeSeriesDataFrame, known_covariates: Optional[TimeSeriesDataFrame]
+    ) -> tuple[dict[str, Optional[TimeSeriesDataFrame]], dict[str, float]]:
+        return {}, {}
+
+    def put(
+        self,
+        data: TimeSeriesDataFrame,
+        known_covariates: Optional[TimeSeriesDataFrame],
+        model_pred_dict: dict[str, Optional[TimeSeriesDataFrame]],
+        pred_time_dict: dict[str, float],
+    ) -> None:
+        pass
+
+    def clear(self) -> None:
+        pass
+
+
+class FileBasedPredictionCache(PredictionCache):
+    """A file-backed cache of model predictions."""
+
+    _cached_predictions_filename = "cached_predictions.pkl"
+
+    @property
+    def path(self) -> Path:
+        return Path(self.root_path) / self._cached_predictions_filename
+
+    def get(
+        self, data: TimeSeriesDataFrame, known_covariates: Optional[TimeSeriesDataFrame]
+    ) -> tuple[dict[str, Optional[TimeSeriesDataFrame]], dict[str, float]]:
+        dataset_hash = compute_dataset_hash(data, known_covariates)
+        return self._get_cached_pred_dicts(dataset_hash)
+
+    def put(
+        self,
+        data: TimeSeriesDataFrame,
+        known_covariates: Optional[TimeSeriesDataFrame],
+        model_pred_dict: dict[str, Optional[TimeSeriesDataFrame]],
+        pred_time_dict: dict[str, float],
+    ) -> None:
+        dataset_hash = compute_dataset_hash(data, known_covariates)
+        self._save_cached_pred_dicts(dataset_hash, model_pred_dict, pred_time_dict)
+
+    def clear(self) -> None:
+        if self.path.exists():
+            logger.debug(f"Removing existing cached predictions file {self.path}")
+            self.path.unlink()
+
+    def _load_cached_predictions(self) -> dict[str, dict[str, dict[str, Any]]]:
+        if self.path.exists():
+            try:
+                cached_predictions = load_pkl.load(str(self.path))
+            except Exception:
+                cached_predictions = {}
+        else:
+            cached_predictions = {}
+        return cached_predictions
+
+    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.
+
+        If loading fails for any reason, empty dicts are returned.
+        """
+        cached_predictions = self._load_cached_predictions()
+        if dataset_hash in cached_predictions:
+            try:
+                model_pred_dict = cached_predictions[dataset_hash]["model_pred_dict"]
+                pred_time_dict = cached_predictions[dataset_hash]["pred_time_dict"]
+                assert model_pred_dict.keys() == pred_time_dict.keys()
+                return model_pred_dict, pred_time_dict
+            except Exception:
+                logger.warning("Cached predictions are corrupted. Predictions will be made from scratch.")
+        return {}, {}
+
+    def _save_cached_pred_dicts(
+        self,
+        dataset_hash: str,
+        model_pred_dict: dict[str, Optional[TimeSeriesDataFrame]],
+        pred_time_dict: dict[str, float],
+    ) -> None:
+        cached_predictions = self._load_cached_predictions()
+        # Do not save results for models that failed
+        cached_predictions[dataset_hash] = {
+            "model_pred_dict": {k: v for k, v in model_pred_dict.items() if v is not None},
+            "pred_time_dict": {k: v for k, v in pred_time_dict.items() if v is not None},
+        }
+        save_pkl.save(str(self.path), object=cached_predictions)
+        logger.debug(f"Cached predictions saved to {self.path}")

autogluon/timeseries/trainer/trainer.py

@@ -12,7 +12,7 @@ import numpy as np
 import pandas as pd
 from tqdm import tqdm
 
-from autogluon.common.utils.utils import hash_pandas_df, seed_everything
+from autogluon.common.utils.utils import seed_everything
 from autogluon.core.trainer.abstract_trainer import AbstractTrainer
 from autogluon.core.utils.exceptions import TimeLimitExceeded
 from autogluon.core.utils.loaders import load_pkl
@@ -31,13 +31,12 @@ from autogluon.timeseries.utils.features import (
 from autogluon.timeseries.utils.warning_filters import disable_tqdm, warning_filter
 
 from .model_set_builder import TrainableModelSetBuilder, contains_searchspace
+from .prediction_cache import PredictionCache, get_prediction_cache
 
 logger = logging.getLogger("autogluon.timeseries.trainer")
 
 
 class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
-    _cached_predictions_filename = "cached_predictions.pkl"
-
     max_rel_importance_score: float = 1e5
     eps_abs_importance_score: float = 1e-5
     max_ensemble_time_limit: float = 600.0
@@ -92,12 +91,10 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         assert isinstance(val_splitter, AbstractWindowSplitter), "val_splitter must be of type AbstractWindowSplitter"
         self.val_splitter = val_splitter
         self.refit_every_n_windows = refit_every_n_windows
-        self.cache_predictions = cache_predictions
         self.hpo_results = {}
 
-        if self._cached_predictions_path.exists():
-            logger.debug(f"Removing existing cached predictions file {self._cached_predictions_path}")
-            self._cached_predictions_path.unlink()
+        self.prediction_cache: PredictionCache = get_prediction_cache(cache_predictions, self.path)
+        self.prediction_cache.clear()
 
     @property
     def path_pkl(self) -> str:
@@ -1055,9 +1052,10 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         use_cache
             If False, will ignore the cache even if it's available.
         """
-        if self.cache_predictions and use_cache:
-            dataset_hash = self._compute_dataset_hash(data=data, known_covariates=known_covariates)
-            model_pred_dict, pred_time_dict_marginal = self._get_cached_pred_dicts(dataset_hash)
+        if use_cache:
+            model_pred_dict, pred_time_dict_marginal = self.prediction_cache.get(
+                data=data, known_covariates=known_covariates
+            )
         else:
             model_pred_dict = {}
             pred_time_dict_marginal: dict[str, Any] = {}
@@ -1093,9 +1091,11 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
 
         if len(failed_models) > 0 and raise_exception_if_failed:
             raise RuntimeError(f"Following models failed to predict: {failed_models}")
-        if self.cache_predictions and use_cache:
-            self._save_cached_pred_dicts(
-                dataset_hash,  # type: ignore
+
+        if use_cache:
+            self.prediction_cache.put(
+                data=data,
+                known_covariates=known_covariates,
                 model_pred_dict=model_pred_dict,
                 pred_time_dict=pred_time_dict_marginal,
             )
@@ -1114,62 +1114,6 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
                     pred_time_dict_total[model_name] += pred_time_dict_marginal[base_model]
         return dict(pred_time_dict_total)
 
-    @property
-    def _cached_predictions_path(self) -> Path:
-        return Path(self.path) / self._cached_predictions_filename
-
-    @staticmethod
-    def _compute_dataset_hash(
-        data: TimeSeriesDataFrame, known_covariates: Optional[TimeSeriesDataFrame] = None
-    ) -> str:
-        """Compute a unique string that identifies the time series dataset."""
-        combined_hash = hash_pandas_df(data) + hash_pandas_df(known_covariates) + hash_pandas_df(data.static_features)
-        return combined_hash
-
-    def _load_cached_predictions(self) -> dict[str, dict[str, dict[str, Any]]]:
-        """Load cached predictions from disk. If loading fails, an empty dictionary is returned."""
-        if self._cached_predictions_path.exists():
-            try:
-                cached_predictions = load_pkl.load(str(self._cached_predictions_path))
-            except Exception:
-                cached_predictions = {}
-        else:
-            cached_predictions = {}
-        return cached_predictions
-
-    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.
-
-        If loading fails for any reason, empty dicts are returned.
-        """
-        cached_predictions = self._load_cached_predictions()
-        if dataset_hash in cached_predictions:
-            try:
-                model_pred_dict = cached_predictions[dataset_hash]["model_pred_dict"]
-                pred_time_dict = cached_predictions[dataset_hash]["pred_time_dict"]
-                assert model_pred_dict.keys() == pred_time_dict.keys()
-                return model_pred_dict, pred_time_dict
-            except Exception:
-                logger.warning("Cached predictions are corrupted. Predictions will be made from scratch.")
-        return {}, {}
-
-    def _save_cached_pred_dicts(
-        self,
-        dataset_hash: str,
-        model_pred_dict: dict[str, Optional[TimeSeriesDataFrame]],
-        pred_time_dict: dict[str, float],
-    ) -> None:
-        cached_predictions = self._load_cached_predictions()
-        # Do not save results for models that failed
-        cached_predictions[dataset_hash] = {
-            "model_pred_dict": {k: v for k, v in model_pred_dict.items() if v is not None},
-            "pred_time_dict": {k: v for k, v in pred_time_dict.items() if v is not None},
-        }
-        save_pkl.save(str(self._cached_predictions_path), object=cached_predictions)
-        logger.debug(f"Cached predictions saved to {self._cached_predictions_path}")
-
     def _merge_refit_full_data(
         self, train_data: TimeSeriesDataFrame, val_data: Optional[TimeSeriesDataFrame]
     ) -> TimeSeriesDataFrame:

autogluon/timeseries/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.4.1b20250829"
+__version__ = "1.4.1b20250903"
 __lite__ = False

{autogluon.timeseries-1.4.1b20250829.dist-info → autogluon.timeseries-1.4.1b20250903.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.4.1b20250829
+Version: 1.4.1b20250903
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -55,10 +55,10 @@ 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.4.1b20250829
-Requires-Dist: autogluon.common==1.4.1b20250829
-Requires-Dist: autogluon.features==1.4.1b20250829
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20250829
+Requires-Dist: autogluon.core[raytune]==1.4.1b20250903
+Requires-Dist: autogluon.common==1.4.1b20250903
+Requires-Dist: autogluon.features==1.4.1b20250903
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20250903
 Provides-Extra: all
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"

{autogluon.timeseries-1.4.1b20250829.dist-info → autogluon.timeseries-1.4.1b20250903.dist-info}/RECORD

@@ -1,11 +1,11 @@
-autogluon.timeseries-1.4.1b20250829-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.4.1b20250903-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=eQrqFVOmL-2JC85LgCMkbyoLpKS02Dilg1T8RUeS_LI,13887
 autogluon/timeseries/predictor.py,sha256=7X4YsWYa3Xk2RI1Irf2O-c3-I82Zqhg-cgj8cj_4AoA,88427
 autogluon/timeseries/regressor.py,sha256=lc8Qr3-8v4oxajtCnV3sxpUaW6vxXXJOA6Kr-qVne4k,11926
 autogluon/timeseries/splitter.py,sha256=8ACkuCXeUhQGUx4jz_Vv17q814WrHJQeKvq2v4-oE6s,3158
-autogluon/timeseries/version.py,sha256=fdnoxP7_6J-f5AFaSCedYkeNZuZiNC9bvzdn_HbpQf4,91
+autogluon/timeseries/version.py,sha256=uHI6DT5kkDkJAqxxc3nHhMMDhvmEdq_ZnwFmY32rfjg,91
 autogluon/timeseries/configs/__init__.py,sha256=wiLBwxZkDTQBJkSJ9-xz3p_yJxX0dbHe108dS1P5O6A,183
 autogluon/timeseries/configs/hyperparameter_presets.py,sha256=GbI2sd3uakWtaeaMyF7B5z_lmyfb6ToK6PZEUZTyG9w,2031
 autogluon/timeseries/configs/predictor_presets.py,sha256=B5HFHIelh91hhG0YYE5SJ7_14P7sylFAABgHX8n_53M,2712
@@ -51,7 +51,8 @@ autogluon/timeseries/models/multi_window/__init__.py,sha256=Bq7AT2Jxdd4WNqmjTdze
 autogluon/timeseries/models/multi_window/multi_window_model.py,sha256=Hn-H2jLdeuB0_TxhAdununS8ti-iO-WSl3FOoxzcEJA,12369
 autogluon/timeseries/trainer/__init__.py,sha256=_tw3iioJfvtIV7wnjtEMv0yS8oabmCFxDnGRodYE7RI,72
 autogluon/timeseries/trainer/model_set_builder.py,sha256=s6tozfND3lLfst6Vxa_oP_wgCmDapyCJYFmCjkEn-es,10788
-autogluon/timeseries/trainer/trainer.py,sha256=4_0IOzBL64OsJhgfvJNPRXbPWO4OQ2E6DYZNxYVNZbs,57754
+autogluon/timeseries/trainer/prediction_cache.py,sha256=Vi6EbMiMheq_smA93U_MoMxYUV85RdPm0dvJFdsM8K4,5551
+autogluon/timeseries/trainer/trainer.py,sha256=LF2X5UNnrU8w5h_i09SphGWvGFvZ6KvPDq89Z3GzZZQ,54959
 autogluon/timeseries/transforms/__init__.py,sha256=fKlT4pkJ_8Gl7IUTc3uSDzt2Xow5iH5w6fPB3ePNrTg,127
 autogluon/timeseries/transforms/covariate_scaler.py,sha256=9lEfDS4wnVZohQNnm9OcAXr3voUl83RCnctKR3O66iU,7030
 autogluon/timeseries/transforms/target_scaler.py,sha256=kTQrXAsDHCnYuqfpaVuvefyTgyp_ylDpUIPz7pArjeY,6043
@@ -64,11 +65,11 @@ autogluon/timeseries/utils/datetime/base.py,sha256=3NdsH3NDq4cVAOSoy3XpaNixyNlbj
 autogluon/timeseries/utils/datetime/lags.py,sha256=rjJtdBU0M41R1jwfmvCbo045s-6XBjhGVnGBQJ9-U1E,5997
 autogluon/timeseries/utils/datetime/seasonality.py,sha256=YK_2k8hvYIMW-sJPnjGWRtCnvIOthwA2hATB3nwVoD4,834
 autogluon/timeseries/utils/datetime/time_features.py,sha256=kEOFls4Nzh8nO0Pcz1DwLsC_NA3hMI4JUlZI3kuvuts,2666
-autogluon.timeseries-1.4.1b20250829.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.4.1b20250829.dist-info/METADATA,sha256=FCOH4-qBjpvRH7bn6CVhcwtnL5iQuDTUnpXD5IieB8U,12463
-autogluon.timeseries-1.4.1b20250829.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.4.1b20250829.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.timeseries-1.4.1b20250829.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.4.1b20250829.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.4.1b20250829.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.4.1b20250829.dist-info/RECORD,,
+autogluon.timeseries-1.4.1b20250903.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.4.1b20250903.dist-info/METADATA,sha256=-Pfm6sMsDGYcGOZmOvJ-RhPMS_VdOEUz9PqiHGw7evc,12463
+autogluon.timeseries-1.4.1b20250903.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.4.1b20250903.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.timeseries-1.4.1b20250903.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.4.1b20250903.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.4.1b20250903.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.4.1b20250903.dist-info/RECORD,,