autogluon.timeseries 1.4.1b20250823__tar.gz → 1.4.1b20250920__tar.gz

{autogluon.timeseries-1.4.1b20250823 → autogluon.timeseries-1.4.1b20250920}/PKG-INFO

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

autogluon.timeseries-1.4.1b20250920/src/autogluon/timeseries/configs/__init__.py

@@ -0,0 +1,4 @@
+from .hyperparameter_presets import get_hyperparameter_presets
+from .predictor_presets import get_predictor_presets
+
+__all__ = ["get_hyperparameter_presets", "get_predictor_presets"]

autogluon.timeseries-1.4.1b20250920/src/autogluon/timeseries/configs/hyperparameter_presets.py

@@ -0,0 +1,62 @@
+from typing import Any, Union
+
+
+def get_hyperparameter_presets() -> dict[str, dict[str, Union[dict[str, Any], list[dict[str, Any]]]]]:
+    return {
+        "very_light": {
+            "Naive": {},
+            "SeasonalNaive": {},
+            "ETS": {},
+            "Theta": {},
+            "RecursiveTabular": {"max_num_samples": 100_000},
+            "DirectTabular": {"max_num_samples": 100_000},
+        },
+        "light": {
+            "Naive": {},
+            "SeasonalNaive": {},
+            "ETS": {},
+            "Theta": {},
+            "RecursiveTabular": {},
+            "DirectTabular": {},
+            "TemporalFusionTransformer": {},
+            "Chronos": {"model_path": "bolt_small"},
+        },
+        "light_inference": {
+            "SeasonalNaive": {},
+            "DirectTabular": {},
+            "RecursiveTabular": {},
+            "TemporalFusionTransformer": {},
+            "PatchTST": {},
+        },
+        "default": {
+            "SeasonalNaive": {},
+            "AutoETS": {},
+            "NPTS": {},
+            "DynamicOptimizedTheta": {},
+            "RecursiveTabular": {},
+            "DirectTabular": {},
+            "TemporalFusionTransformer": {},
+            "PatchTST": {},
+            "DeepAR": {},
+            "Chronos": [
+                {
+                    "ag_args": {"name_suffix": "ZeroShot"},
+                    "model_path": "bolt_base",
+                },
+                {
+                    "ag_args": {"name_suffix": "FineTuned"},
+                    "model_path": "bolt_small",
+                    "fine_tune": True,
+                    "target_scaler": "standard",
+                    "covariate_regressor": {"model_name": "CAT", "model_hyperparameters": {"iterations": 1_000}},
+                },
+            ],
+            "TiDE": {
+                "encoder_hidden_dim": 256,
+                "decoder_hidden_dim": 256,
+                "temporal_hidden_dim": 64,
+                "num_batches_per_epoch": 100,
+                "lr": 1e-4,
+            },
+        },
+    }

autogluon.timeseries-1.4.1b20250920/src/autogluon/timeseries/configs/predictor_presets.py

@@ -0,0 +1,84 @@
+"""Preset configurations for autogluon.timeseries Predictors"""
+
+from typing import Any
+
+from . import get_hyperparameter_presets
+
+TIMESERIES_PRESETS_ALIASES = dict(
+    chronos="chronos_small",
+    best="best_quality",
+    high="high_quality",
+    medium="medium_quality",
+    bq="best_quality",
+    hq="high_quality",
+    mq="medium_quality",
+)
+
+
+def get_predictor_presets() -> dict[str, Any]:
+    hp_presets = get_hyperparameter_presets()
+
+    predictor_presets = dict(
+        best_quality={"hyperparameters": "default", "num_val_windows": 2},
+        high_quality={"hyperparameters": "default"},
+        medium_quality={"hyperparameters": "light"},
+        fast_training={"hyperparameters": "very_light"},
+        # Chronos-Bolt models
+        bolt_tiny={
+            "hyperparameters": {"Chronos": {"model_path": "bolt_tiny"}},
+            "skip_model_selection": True,
+        },
+        bolt_mini={
+            "hyperparameters": {"Chronos": {"model_path": "bolt_mini"}},
+            "skip_model_selection": True,
+        },
+        bolt_small={
+            "hyperparameters": {"Chronos": {"model_path": "bolt_small"}},
+            "skip_model_selection": True,
+        },
+        bolt_base={
+            "hyperparameters": {"Chronos": {"model_path": "bolt_base"}},
+            "skip_model_selection": True,
+        },
+        # Original Chronos models
+        chronos_tiny={
+            "hyperparameters": {"Chronos": {"model_path": "tiny"}},
+            "skip_model_selection": True,
+        },
+        chronos_mini={
+            "hyperparameters": {"Chronos": {"model_path": "mini"}},
+            "skip_model_selection": True,
+        },
+        chronos_small={
+            "hyperparameters": {"Chronos": {"model_path": "small"}},
+            "skip_model_selection": True,
+        },
+        chronos_base={
+            "hyperparameters": {"Chronos": {"model_path": "base"}},
+            "skip_model_selection": True,
+        },
+        chronos_large={
+            "hyperparameters": {"Chronos": {"model_path": "large", "batch_size": 8}},
+            "skip_model_selection": True,
+        },
+        chronos_ensemble={
+            "hyperparameters": {
+                "Chronos": {"model_path": "small"},
+                **hp_presets["light_inference"],
+            }
+        },
+        chronos_large_ensemble={
+            "hyperparameters": {
+                "Chronos": {"model_path": "large", "batch_size": 8},
+                **hp_presets["light_inference"],
+            }
+        },
+    )
+
+    # update with aliases
+    predictor_presets = {
+        **predictor_presets,
+        **{k: predictor_presets[v].copy() for k, v in TIMESERIES_PRESETS_ALIASES.items()},
+    }
+
+    return predictor_presets

{autogluon.timeseries-1.4.1b20250823 → autogluon.timeseries-1.4.1b20250920}/src/autogluon/timeseries/metrics/abstract.py

@@ -2,7 +2,6 @@ import warnings
 from typing import Optional, Sequence, Union, overload
 
 import numpy as np
-import numpy.typing as npt
 import pandas as pd
 
 from autogluon.timeseries import TimeSeriesDataFrame
@@ -242,12 +241,12 @@ class TimeSeriesScorer:
     @staticmethod
     def check_get_horizon_weight(
         horizon_weight: Union[Sequence[float], np.ndarray], prediction_length: int
-    ) -> npt.NDArray[np.float64]: ...
+    ) -> np.ndarray: ...
 
     @staticmethod
     def check_get_horizon_weight(
         horizon_weight: Union[Sequence[float], np.ndarray, None], prediction_length: int
-    ) -> Optional[npt.NDArray[np.float64]]:
+    ) -> Optional[np.ndarray]:
         """Convert horizon_weight to a non-negative numpy array that sums up to prediction_length.
         Raises an exception if horizon_weight has an invalid shape or contains invalid values.
 

{autogluon.timeseries-1.4.1b20250823 → autogluon.timeseries-1.4.1b20250920}/src/autogluon/timeseries/models/__init__.py

@@ -27,6 +27,7 @@ from .local import (
     ThetaModel,
     ZeroModel,
 )
+from .registry import ModelRegistry
 
 __all__ = [
     "ADIDAModel",
@@ -43,6 +44,7 @@ __all__ = [
     "ETSModel",
     "IMAPAModel",
     "ChronosModel",
+    "ModelRegistry",
     "NPTSModel",
     "NaiveModel",
     "PatchTSTModel",

{autogluon.timeseries-1.4.1b20250823 → autogluon.timeseries-1.4.1b20250920}/src/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-1.4.1b20250823 → autogluon.timeseries-1.4.1b20250920}/src/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-1.4.1b20250823 → autogluon.timeseries-1.4.1b20250920}/src/autogluon/timeseries/models/multi_window/multi_window_model.py

@@ -7,6 +7,7 @@ import time
 from typing import Any, Optional, Type, Union
 
 import numpy as np
+from typing_extensions import Self
 
 import autogluon.core as ag
 from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
@@ -73,10 +74,6 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
     def supports_past_covariates(self) -> bool:
         return self.model_base.supports_past_covariates
 
-    @property
-    def supports_cat_covariates(self) -> bool:
-        return self.model_base.supports_cat_covariates
-
     def _get_model_base(self):
         return self.model_base
 
@@ -86,15 +83,18 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
     def _is_gpu_available(self) -> bool:
         return self._get_model_base()._is_gpu_available()
 
-    def get_minimum_resources(self, is_gpu_available: bool = False) -> bool:
+    def get_minimum_resources(self, is_gpu_available: bool = False) -> dict[str, Union[int, float]]:
         return self._get_model_base().get_minimum_resources(is_gpu_available)
 
     def _fit(
         self,
         train_data: TimeSeriesDataFrame,
         val_data: Optional[TimeSeriesDataFrame] = None,
-        time_limit: Optional[int] = None,
-        val_splitter: AbstractWindowSplitter = None,
+        time_limit: Optional[float] = None,
+        num_cpus: Optional[int] = None,
+        num_gpus: Optional[int] = None,
+        verbosity: int = 2,
+        val_splitter: Optional[AbstractWindowSplitter] = None,
         refit_every_n_windows: Optional[int] = 1,
         **kwargs,
     ):
@@ -111,11 +111,15 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
 
         oof_predictions_per_window = []
         global_fit_start_time = time.time()
+        model: Optional[AbstractTimeSeriesModel] = None
 
         for window_index, (train_fold, val_fold) in enumerate(val_splitter.split(train_data)):
             logger.debug(f"\tWindow {window_index}")
+
             # refit_this_window is always True for the 0th window
             refit_this_window = window_index % refit_every_n_windows == 0
+            assert window_index != 0 or refit_this_window
+
             if time_limit is None:
                 time_left_for_window = None
             else:
@@ -148,6 +152,7 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
             else:
                 time_left_for_prediction = time_limit - (time.time() - global_fit_start_time)
 
+            assert model is not None
             model.score_and_cache_oof(
                 val_fold, store_val_score=True, store_predict_time=True, time_limit=time_left_for_prediction
             )
@@ -172,11 +177,13 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
 
         # Only the model trained on most recent data is saved & used for prediction
         self.most_recent_model = model
-        self.most_recent_model_folder = most_recent_refit_window
+        assert self.most_recent_model is not None
+
+        self.most_recent_model_folder = most_recent_refit_window  # type: ignore
         self.predict_time = self.most_recent_model.predict_time
-        self.fit_time = time.time() - global_fit_start_time - self.predict_time
+        self.fit_time = time.time() - global_fit_start_time - self.predict_time  # type: ignore
         self._oof_predictions = oof_predictions_per_window
-        self.val_score = np.mean([info["val_score"] for info in self.info_per_val_window])
+        self.val_score = np.mean([info["val_score"] for info in self.info_per_val_window])  # type: ignore
 
     def get_info(self) -> dict:
         info = super().get_info()
@@ -227,7 +234,7 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
         train_fn_kwargs["init_params"]["model_base_kwargs"] = self.get_params()
         return train_fn_kwargs
 
-    def save(self, path: str = None, verbose=True) -> str:
+    def save(self, path: Optional[str] = None, verbose: bool = True) -> str:
         most_recent_model = self.most_recent_model
         self.most_recent_model = None
         save_path = super().save(path, verbose)
@@ -238,32 +245,36 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
             most_recent_model.save()
         return save_path
 
-    def persist(self):
+    def persist(self) -> Self:
         if self.most_recent_model is None:
             raise ValueError(f"{self.name} must be fit before persisting")
         self.most_recent_model.persist()
+        return self
 
     @classmethod
     def load(
         cls, path: str, reset_paths: bool = True, load_oof: bool = False, verbose: bool = True
     ) -> AbstractTimeSeriesModel:
         model = super().load(path=path, reset_paths=reset_paths, load_oof=load_oof, verbose=verbose)
-        most_recent_model_path = os.path.join(model.path, model.most_recent_model_folder)
-        model.most_recent_model = model.model_base_type.load(
-            most_recent_model_path,
-            reset_paths=reset_paths,
-            verbose=verbose,
-        )
+        if model.most_recent_model_folder is not None:
+            most_recent_model_path = os.path.join(model.path, model.most_recent_model_folder)
+            model.most_recent_model = model.model_base_type.load(
+                most_recent_model_path,
+                reset_paths=reset_paths,
+                verbose=verbose,
+            )
         return model
 
     def convert_to_refit_full_template(self) -> AbstractTimeSeriesModel:
         # refit_model is an instance of base model type, not MultiWindowBacktestingModel
+        assert self.most_recent_model is not None, "Most recent model is None. Model must be fit first."
         refit_model = self.most_recent_model.convert_to_refit_full_template()
         refit_model.rename(self.name + ag.constants.REFIT_FULL_SUFFIX)
         return refit_model
 
     def convert_to_refit_full_via_copy(self) -> AbstractTimeSeriesModel:
         # refit_model is an instance of base model type, not MultiWindowBacktestingModel
+        assert self.most_recent_model is not None, "Most recent model is None. Model must be fit first."
         refit_model = self.most_recent_model.convert_to_refit_full_via_copy()
         refit_model.rename(self.name + ag.constants.REFIT_FULL_SUFFIX)
         return refit_model

{autogluon.timeseries-1.4.1b20250823 → autogluon.timeseries-1.4.1b20250920}/src/autogluon/timeseries/predictor.py

@@ -21,7 +21,7 @@ from autogluon.core.utils.decorators import apply_presets
 from autogluon.core.utils.loaders import load_pkl, load_str
 from autogluon.core.utils.savers import save_pkl, save_str
 from autogluon.timeseries import __version__ as current_ag_version
-from autogluon.timeseries.configs import TIMESERIES_PRESETS_CONFIGS
+from autogluon.timeseries.configs import get_predictor_presets
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TimeSeriesDataFrame
 from autogluon.timeseries.learner import TimeSeriesLearner
 from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_metric
@@ -432,7 +432,7 @@ class TimeSeriesPredictor:
             )
         return train_data
 
-    @apply_presets(TIMESERIES_PRESETS_CONFIGS)
+    @apply_presets(get_predictor_presets())
     def fit(
         self,
         train_data: Union[TimeSeriesDataFrame, pd.DataFrame, Path, str],

autogluon.timeseries-1.4.1b20250920/src/autogluon/timeseries/trainer/__init__.py

@@ -0,0 +1,3 @@
+from .trainer import TimeSeriesTrainer
+
+__all__ = ["TimeSeriesTrainer"]