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

autogluon/timeseries/models/chronos/model.py

@@ -482,9 +482,12 @@ class ChronosModel(AbstractTimeSeriesModel):
 
                 if self.prediction_length != fine_tune_prediction_length:
                     logger.debug(
-                        f"\tChronosBolt models can only be fine-tuned with a maximum prediction_length of {model_prediction_length}. "
+                        f"\tChronos-Bolt models can only be fine-tuned with a maximum prediction_length of {model_prediction_length}. "
                         f"Fine-tuning prediction_length has been changed to {fine_tune_prediction_length}."
                     )
+                if self.quantile_levels != self.model_pipeline.quantiles:
+                    self.model_pipeline.model.update_output_quantiles(self.quantile_levels)
+                    logger.info(f"\tChronos-Bolt will be fine-tuned with quantile_levels={self.quantile_levels}")
             else:
                 raise ValueError(f"Unsupported model pipeline: {type(self.model_pipeline)}")
 

autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py

@@ -371,6 +371,56 @@ class ChronosBoltModelForForecasting(T5PreTrainedModel):
 
         return decoder_outputs.last_hidden_state  # sequence_outputs, b x 1 x d_model
 
+    def update_output_quantiles(self, new_quantiles: list[float]) -> None:
+        """In-place updates model's output layer to support only the specified new quantiles by copying weights from closest existing quantiles."""
+        old_quantiles = self.chronos_config.quantiles
+        new_quantiles = sorted(new_quantiles)
+
+        if new_quantiles == old_quantiles:
+            return
+
+        self.chronos_config.quantiles = new_quantiles
+        self.num_quantiles = len(new_quantiles)
+        self.register_buffer("quantiles", torch.tensor(new_quantiles, dtype=self.dtype), persistent=False)
+
+        old_output_layer = self.output_patch_embedding
+        new_output_layer = ResidualBlock(
+            in_dim=self.config.d_model,
+            h_dim=self.config.d_ff,
+            out_dim=len(new_quantiles) * self.chronos_config.prediction_length,
+            act_fn_name=self.config.dense_act_fn,
+            dropout_p=self.config.dropout_rate,
+        )
+
+        # hidden_layer is shared across all quantiles
+        new_output_layer.hidden_layer.weight.data.copy_(old_output_layer.hidden_layer.weight.data)
+        if old_output_layer.hidden_layer.bias is not None:
+            new_output_layer.hidden_layer.bias.data.copy_(old_output_layer.hidden_layer.bias.data)
+
+        def copy_quantile_weights(src_idx: int, dst_idx: int):
+            """Copy weights for one quantile from src_idx to dst_idx"""
+            prediction_length = self.chronos_config.prediction_length
+            src_start, src_end = src_idx * prediction_length, (src_idx + 1) * prediction_length
+            dst_start, dst_end = dst_idx * prediction_length, (dst_idx + 1) * prediction_length
+
+            for layer_name in ["output_layer", "residual_layer"]:
+                old_layer_attr = getattr(old_output_layer, layer_name)
+                new_layer_attr = getattr(new_output_layer, layer_name)
+
+                new_layer_attr.weight[dst_start:dst_end] = old_layer_attr.weight[src_start:src_end]
+                if old_layer_attr.bias is not None:
+                    new_layer_attr.bias[dst_start:dst_end] = old_layer_attr.bias[src_start:src_end]
+
+        with torch.no_grad():
+            for new_idx, new_q in enumerate(new_quantiles):
+                closest_q = min(old_quantiles, key=lambda x: abs(x - new_q))
+                closest_idx = old_quantiles.index(closest_q)
+                copy_quantile_weights(closest_idx, new_idx)
+
+        self.output_patch_embedding = new_output_layer
+        self.config.chronos_config["quantiles"] = new_quantiles
+        self.chronos_config.quantiles = new_quantiles
+
 
 class ChronosBoltPipeline(BaseChronosPipeline):
     forecast_type: ForecastType = ForecastType.QUANTILES

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.1b20250905"
 __lite__ = False

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.4.1b20250829
+Version: 1.4.1b20250905
 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.1b20250905
+Requires-Dist: autogluon.common==1.4.1b20250905
+Requires-Dist: autogluon.features==1.4.1b20250905
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20250905
 Provides-Extra: all
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"

{autogluon.timeseries-1.4.1b20250829.dist-info → autogluon.timeseries-1.4.1b20250905.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.1b20250905-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=IPQrSZMK4KFRJPrPfw9aEl6tbYRIUkJ_GZ7f_Y5oSxQ,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
@@ -28,11 +28,11 @@ autogluon/timeseries/models/autogluon_tabular/per_step.py,sha256=M5rhj_jjcQz27wP
 autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=aI1QJLJaOB5Xy2WA0jo6Jh25MRVyyZ8ONrqlV96kpw0,2735
 autogluon/timeseries/models/autogluon_tabular/utils.py,sha256=Fn3Vu_Q0PCtEUbtNgLp1xIblg7dOdpFlF3W5kLHgruI,63
 autogluon/timeseries/models/chronos/__init__.py,sha256=wT77HzTtmQxW3sw2k0mA5Ot6PSHivX-Uvn5fjM05EU4,60
-autogluon/timeseries/models/chronos/model.py,sha256=UYLI1HVwsW5KfA-jXqJdBel-7N6l6ggdBVrjLLaq9P0,32333
+autogluon/timeseries/models/chronos/model.py,sha256=-z6Y5Fyo5_X-U8BCeSZBhqQqaJaGBCNIAYDd5y6WaMQ,32614
 autogluon/timeseries/models/chronos/pipeline/__init__.py,sha256=bkTR0LSKIxAaKFOr9A0HSkCtnRdikDPUPp810WOKgxE,247
 autogluon/timeseries/models/chronos/pipeline/base.py,sha256=Us-TUpHSN3mM3ut05IVc2a9Q6KYq1n9pTb7JZG7b6kA,5546
 autogluon/timeseries/models/chronos/pipeline/chronos.py,sha256=bgow5FkHG7y5qWBXcggqXemnistJUfrl0lWFXcGXg5g,20197
-autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=KJYgxASTW2VhS0ObkP5DUQXyfnTRTXzjRD5Gm-FQFI4,21355
+autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=5zM8G6K9id7qrWhRT37z_xoPVE-BJXwms1SwjF0TBG4,23949
 autogluon/timeseries/models/chronos/pipeline/utils.py,sha256=WYeCKFP5dxs4u09XTncBI2486VV22O1DiM9a3ZvZ1OE,12790
 autogluon/timeseries/models/ensemble/__init__.py,sha256=x2Y6dWk15XugTEWNUKq8U5z6nIjelo3UjpI-TfS13OE,159
 autogluon/timeseries/models/ensemble/abstract.py,sha256=wvtXNZTwiYpIurPkOYSzsi3XTRRx5guJLMYLmXTdOeQ,5695
@@ -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.1b20250905.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.4.1b20250905.dist-info/METADATA,sha256=aYgm8hJDfpEySfHy1jBFoYUp2wd0OSsA7ZrCsFxRMnA,12463
+autogluon.timeseries-1.4.1b20250905.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.4.1b20250905.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.timeseries-1.4.1b20250905.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.4.1b20250905.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.4.1b20250905.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.4.1b20250905.dist-info/RECORD,,