autogluon.timeseries 1.4.1b20250820__py3-none-any.whl → 1.4.1b20250901__py3-none-any.whl

autogluon/timeseries/configs/__init__.py

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

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/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/dataset/ts_dataframe.py

@@ -7,7 +7,7 @@ import reprlib
 from collections.abc import Iterable
 from itertools import islice
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, List, Optional, Tuple, Type, Union, overload
+from typing import TYPE_CHECKING, Any, Optional, Type, Union, overload
 
 import numpy as np
 import pandas as pd
@@ -118,7 +118,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
 
     """
 
-    index: pd.MultiIndex
+    index: pd.MultiIndex  # type: ignore
     _metadata = ["_static_features"]
 
     def __init__(
@@ -572,7 +572,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
             self.static_features = other._static_features
         return self
 
-    def split_by_time(self, cutoff_time: pd.Timestamp) -> Tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]:
+    def split_by_time(self, cutoff_time: pd.Timestamp) -> tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]:
         """Split dataframe to two different ``TimeSeriesDataFrame`` s before and after a certain ``cutoff_time``.
 
         Parameters
@@ -900,15 +900,15 @@ class TimeSeriesDataFrame(pd.DataFrame):
         return super().sort_index(*args, **kwargs)  # type: ignore
 
     def get_model_inputs_for_scoring(
-        self, prediction_length: int, known_covariates_names: Optional[List[str]] = None
-    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
+        self, prediction_length: int, known_covariates_names: Optional[list[str]] = None
+    ) -> tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
         """Prepare model inputs necessary to predict the last ``prediction_length`` time steps of each time series in the dataset.
 
         Parameters
         ----------
         prediction_length : int
             The forecast horizon, i.e., How many time steps into the future must be predicted.
-        known_covariates_names : List[str], optional
+        known_covariates_names : list[str], optional
             Names of the dataframe columns that contain covariates known in the future.
             See ``known_covariates_names`` of :class:`~autogluon.timeseries.TimeSeriesPredictor` for more details.
 
@@ -933,7 +933,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
         prediction_length: int,
         end_index: Optional[int] = None,
         suffix: Optional[str] = None,
-    ) -> Tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]:
+    ) -> tuple[TimeSeriesDataFrame, TimeSeriesDataFrame]:
         """Generate a train/test split from the given dataset.
 
         This method can be used to generate splits for multi-window backtesting.
@@ -1083,7 +1083,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
             iterable = iter(iterable)
             return iter(lambda: tuple(islice(iterable, size)), ())
 
-        def resample_chunk(chunk: Iterable[Tuple[str, pd.DataFrame]]) -> pd.DataFrame:
+        def resample_chunk(chunk: Iterable[tuple[str, pd.DataFrame]]) -> pd.DataFrame:
             resampled_dfs = []
             for item_id, df in chunk:
                 resampled_df = df.resample(offset, level=TIMESTAMP, **kwargs).agg(aggregation)
@@ -1139,6 +1139,6 @@ class TimeSeriesDataFrame(pd.DataFrame):
             ...
 
         @overload
-        def __getitem__(self, items: List[str]) -> Self: ...  # type: ignore
+        def __getitem__(self, items: list[str]) -> Self: ...  # type: ignore
         @overload
         def __getitem__(self, item: str) -> pd.Series: ...  # type: ignore

autogluon/timeseries/learner.py

@@ -1,7 +1,7 @@
 import logging
 import reprlib
 import time
-from typing import Any, Dict, List, Literal, Optional, Type, Union
+from typing import Any, Literal, Optional, Type, Union
 
 import pandas as pd
 
@@ -26,7 +26,7 @@ class TimeSeriesLearner(AbstractLearner):
         self,
         path_context: str,
         target: str = "target",
-        known_covariates_names: Optional[List[str]] = None,
+        known_covariates_names: Optional[list[str]] = None,
         trainer_type: Type[TimeSeriesTrainer] = TimeSeriesTrainer,
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
         prediction_length: int = 1,
@@ -56,7 +56,7 @@ class TimeSeriesLearner(AbstractLearner):
     def fit(
         self,
         train_data: TimeSeriesDataFrame,
-        hyperparameters: Union[str, Dict],
+        hyperparameters: Union[str, dict],
         val_data: Optional[TimeSeriesDataFrame] = None,
         hyperparameter_tune_kwargs: Optional[Union[str, dict]] = None,
         time_limit: Optional[float] = None,
@@ -194,9 +194,9 @@ class TimeSeriesLearner(AbstractLearner):
         self,
         data: TimeSeriesDataFrame,
         model: Optional[str] = None,
-        metrics: Optional[Union[str, TimeSeriesScorer, List[Union[str, TimeSeriesScorer]]]] = None,
+        metrics: Optional[Union[str, TimeSeriesScorer, list[Union[str, TimeSeriesScorer]]]] = None,
         use_cache: bool = True,
-    ) -> Dict[str, float]:
+    ) -> dict[str, float]:
         data = self.feature_generator.transform(data)
         return self.load_trainer().evaluate(data=data, model=model, metrics=metrics, use_cache=use_cache)
 
@@ -205,7 +205,7 @@ class TimeSeriesLearner(AbstractLearner):
         data: Optional[TimeSeriesDataFrame] = None,
         model: Optional[str] = None,
         metric: Optional[Union[str, TimeSeriesScorer]] = None,
-        features: Optional[List[str]] = None,
+        features: Optional[list[str]] = None,
         time_limit: Optional[float] = None,
         method: Literal["naive", "permutation"] = "permutation",
         subsample_size: int = 50,
@@ -273,7 +273,7 @@ class TimeSeriesLearner(AbstractLearner):
         self,
         data: Optional[TimeSeriesDataFrame] = None,
         extra_info: bool = False,
-        extra_metrics: Optional[List[Union[str, TimeSeriesScorer]]] = None,
+        extra_metrics: Optional[list[Union[str, TimeSeriesScorer]]] = None,
         use_cache: bool = True,
     ) -> pd.DataFrame:
         if data is not None:
@@ -282,7 +282,7 @@ class TimeSeriesLearner(AbstractLearner):
             data, extra_info=extra_info, extra_metrics=extra_metrics, use_cache=use_cache
         )
 
-    def get_info(self, include_model_info: bool = False, **kwargs) -> Dict[str, Any]:
+    def get_info(self, include_model_info: bool = False, **kwargs) -> dict[str, Any]:
         learner_info = super().get_info(include_model_info=include_model_info)
         trainer = self.load_trainer()
         trainer_info = trainer.get_info(include_model_info=include_model_info)
@@ -300,31 +300,31 @@ class TimeSeriesLearner(AbstractLearner):
         return learner_info
 
     def persist_trainer(
-        self, models: Union[Literal["all", "best"], List[str]] = "all", with_ancestors: bool = False
-    ) -> List[str]:
+        self, models: Union[Literal["all", "best"], list[str]] = "all", with_ancestors: bool = False
+    ) -> list[str]:
         """Loads models and trainer in memory so that they don't have to be
         loaded during predictions
 
         Returns
         -------
-        list_of_models : List[str]
+        list_of_models
             List of models persisted in memory
         """
         self.trainer = self.load_trainer()
         return self.trainer.persist(models, with_ancestors=with_ancestors)
 
-    def unpersist_trainer(self) -> List[str]:
+    def unpersist_trainer(self) -> list[str]:
         """Unloads models and trainer from memory. Models will have to be reloaded from disk
         when predicting.
 
         Returns
         -------
-        list_of_models : List[str]
+        list_of_models
             List of models removed from memory
         """
         unpersisted_models = self.load_trainer().unpersist()
         self.trainer = None  # type: ignore
         return unpersisted_models
 
-    def refit_full(self, model: str = "all") -> Dict[str, str]:
+    def refit_full(self, model: str = "all") -> dict[str, str]:
         return self.load_trainer().refit_full(model=model)

autogluon/timeseries/metrics/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pprint import pformat
-from typing import Any, Dict, Optional, Sequence, Type, Union
+from typing import Any, Optional, Sequence, Type, Union
 
 import numpy as np
 
@@ -28,7 +28,7 @@ __all__ = [
 
 DEFAULT_METRIC_NAME = "WQL"
 
-AVAILABLE_METRICS: Dict[str, Type[TimeSeriesScorer]] = {
+AVAILABLE_METRICS: dict[str, Type[TimeSeriesScorer]] = {
     "MASE": MASE,
     "MAPE": MAPE,
     "SMAPE": SMAPE,
@@ -48,7 +48,7 @@ DEPRECATED_METRICS = {
 }
 
 # Experimental metrics that are not yet user facing
-EXPERIMENTAL_METRICS: Dict[str, Type[TimeSeriesScorer]] = {
+EXPERIMENTAL_METRICS: dict[str, Type[TimeSeriesScorer]] = {
     "WCD": WCD,
 }
 
@@ -63,7 +63,7 @@ def check_get_evaluation_metric(
 
     Returns
     -------
-    scorer :
+    scorer
         A `TimeSeriesScorer` object based on the provided `eval_metric`.
 
         `scorer.prediction_length` is always set to the `prediction_length` provided to this method.
@@ -75,7 +75,7 @@ def check_get_evaluation_metric(
         value of `horizon_weight` is kept.
     """
     scorer: TimeSeriesScorer
-    metric_kwargs: Dict[str, Any] = dict(
+    metric_kwargs: dict[str, Any] = dict(
         prediction_length=prediction_length, seasonal_period=seasonal_period, horizon_weight=horizon_weight
     )
     if isinstance(eval_metric, TimeSeriesScorer):

autogluon/timeseries/metrics/abstract.py

@@ -1,8 +1,7 @@
 import warnings
-from typing import Optional, Sequence, Tuple, Union, overload
+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
@@ -200,14 +199,14 @@ class TimeSeriesScorer:
     @staticmethod
     def _get_point_forecast_score_inputs(
         data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target"
-    ) -> Tuple[pd.Series, pd.Series]:
+    ) -> tuple[pd.Series, pd.Series]:
         """Get inputs necessary to compute point forecast metrics.
 
         Returns
         -------
-        y_true : pd.Series, shape [num_items * prediction_length]
+        y_true
             Target time series values during the forecast horizon.
-        y_pred : pd.Series, shape [num_items * prediction_length]
+        y_pred
             Predicted time series values during the forecast horizon.
         """
         y_true = data_future[target]
@@ -217,16 +216,16 @@ class TimeSeriesScorer:
     @staticmethod
     def _get_quantile_forecast_score_inputs(
         data_future: TimeSeriesDataFrame, predictions: TimeSeriesDataFrame, target: str = "target"
-    ) -> Tuple[pd.Series, pd.DataFrame, np.ndarray]:
+    ) -> tuple[pd.Series, pd.DataFrame, np.ndarray]:
         """Get inputs necessary to compute quantile forecast metrics.
 
         Returns
         -------
-        y_true : pd.Series, shape [num_items * prediction_length]
+        y_true
             Target time series values during the forecast horizon.
-        q_pred : pd.DataFrame, shape [num_items * prediction_length, num_quantiles]
+        q_pred
             Quantile forecast for each predicted quantile level. Column order corresponds to ``quantile_levels``.
-        quantile_levels : np.ndarray, shape [num_quantiles]
+        quantile_levels
             Quantile levels for which the forecasts are generated (as floats).
         """
         quantile_columns = [col for col in predictions.columns if col != "mean"]
@@ -242,18 +241,18 @@ 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.
 
         Returns
         -------
-        horizon_weight:
+        horizon_weight
             None if the input is None, otherwise a numpy array of shape [1, prediction_length].
         """
         if horizon_weight is None:

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",