autogluon.timeseries 1.4.1b20250824__tar.gz → 1.4.1b20250826__tar.gz

{autogluon.timeseries-1.4.1b20250824 → autogluon.timeseries-1.4.1b20250826}/PKG-INFO

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

autogluon.timeseries-1.4.1b20250826/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.1b20250826/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.1b20250826/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.1b20250824 → autogluon.timeseries-1.4.1b20250826}/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.1b20250824 → autogluon.timeseries-1.4.1b20250826}/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.1b20250826/src/autogluon/timeseries/trainer/__init__.py

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

autogluon.timeseries-1.4.1b20250826/src/autogluon/timeseries/trainer/model_set_builder.py

@@ -0,0 +1,256 @@
+import copy
+import logging
+import re
+from collections import defaultdict
+from typing import Any, Optional, Type, Union
+
+from autogluon.common import space
+from autogluon.core import constants
+from autogluon.timeseries.configs import get_hyperparameter_presets
+from autogluon.timeseries.metrics import TimeSeriesScorer
+from autogluon.timeseries.models import ModelRegistry
+from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
+from autogluon.timeseries.models.multi_window import MultiWindowBacktestingModel
+from autogluon.timeseries.utils.features import CovariateMetadata
+
+logger = logging.getLogger(__name__)
+
+
+ModelKey = Union[str, Type[AbstractTimeSeriesModel]]
+ModelHyperparameters = dict[str, Any]
+TrainerHyperparameterSpec = dict[ModelKey, list[ModelHyperparameters]]
+
+
+class TrainableModelSetBuilder:
+    """Responsible for building a list of model objects, in priority order, that will be trained by the
+    Trainer."""
+
+    VALID_AG_ARGS_KEYS = {
+        "name",
+        "name_prefix",
+        "name_suffix",
+    }
+
+    def __init__(
+        self,
+        path: str,
+        freq: Optional[str],
+        prediction_length: int,
+        eval_metric: TimeSeriesScorer,
+        target: str,
+        quantile_levels: list[float],
+        covariate_metadata: CovariateMetadata,
+        multi_window: bool,
+    ):
+        self.path = path
+        self.freq = freq
+        self.prediction_length = prediction_length
+        self.eval_metric = eval_metric
+        self.target = target
+        self.quantile_levels = quantile_levels
+        self.covariate_metadata = covariate_metadata
+        self.multi_window = multi_window
+
+    def get_model_set(
+        self,
+        hyperparameters: Union[str, dict, None],
+        hyperparameter_tune: bool,
+        excluded_model_types: Optional[list[str]],
+        banned_model_names: Optional[list[str]] = None,
+    ) -> list[AbstractTimeSeriesModel]:
+        """Resolve hyperparameters and create the requested list of models"""
+        models = []
+        banned_model_names = [] if banned_model_names is None else banned_model_names.copy()
+
+        # resolve and normalize hyperparameters
+        model_hp_map: TrainerHyperparameterSpec = HyperparameterBuilder(
+            hyperparameters=hyperparameters,
+            hyperparameter_tune=hyperparameter_tune,
+            excluded_model_types=excluded_model_types,
+        ).get_hyperparameters()
+
+        for k in model_hp_map.keys():
+            if isinstance(k, type) and not issubclass(k, AbstractTimeSeriesModel):
+                raise ValueError(f"Custom model type {k} must inherit from `AbstractTimeSeriesModel`.")
+
+        model_priority_list = sorted(
+            model_hp_map.keys(), key=lambda x: ModelRegistry.get_model_priority(x), reverse=True
+        )
+
+        for model_key in model_priority_list:
+            model_type = self._get_model_type(model_key)
+
+            for model_hps in model_hp_map[model_key]:
+                ag_args = model_hps.pop(constants.AG_ARGS, {})
+
+                for key in ag_args:
+                    if key not in self.VALID_AG_ARGS_KEYS:
+                        raise ValueError(
+                            f"Model {model_type} received unknown ag_args key: {key} (valid keys {self.VALID_AG_ARGS_KEYS})"
+                        )
+                model_name_base = self._get_model_name(ag_args, model_type)
+
+                model_type_kwargs: dict[str, Any] = dict(
+                    name=model_name_base,
+                    hyperparameters=model_hps,
+                    **self._get_default_model_init_kwargs(),
+                )
+
+                # add models while preventing name collisions
+                model = model_type(**model_type_kwargs)
+                model_type_kwargs.pop("name", None)
+
+                increment = 1
+                while model.name in banned_model_names:
+                    increment += 1
+                    model = model_type(name=f"{model_name_base}_{increment}", **model_type_kwargs)
+
+                if self.multi_window:
+                    model = MultiWindowBacktestingModel(model_base=model, name=model.name, **model_type_kwargs)  # type: ignore
+
+                banned_model_names.append(model.name)
+                models.append(model)
+
+        return models
+
+    def _get_model_type(self, model: ModelKey) -> Type[AbstractTimeSeriesModel]:
+        if isinstance(model, str):
+            model_type: Type[AbstractTimeSeriesModel] = ModelRegistry.get_model_class(model)
+        elif isinstance(model, type):
+            model_type = model
+        else:
+            raise ValueError(
+                f"Keys of the `hyperparameters` dictionary must be strings or types, received {type(model)}."
+            )
+
+        return model_type
+
+    def _get_default_model_init_kwargs(self) -> dict[str, Any]:
+        return dict(
+            path=self.path,
+            freq=self.freq,
+            prediction_length=self.prediction_length,
+            eval_metric=self.eval_metric,
+            target=self.target,
+            quantile_levels=self.quantile_levels,
+            covariate_metadata=self.covariate_metadata,
+        )
+
+    def _get_model_name(self, ag_args: dict[str, Any], model_type: Type[AbstractTimeSeriesModel]) -> str:
+        name = ag_args.get("name")
+        if name is None:
+            name_stem = re.sub(r"Model$", "", model_type.__name__)
+            name_prefix = ag_args.get("name_prefix", "")
+            name_suffix = ag_args.get("name_suffix", "")
+            name = name_prefix + name_stem + name_suffix
+        return name
+
+
+class HyperparameterBuilder:
+    """Given user hyperparameter specifications, this class resolves them against presets, removes
+    excluded model types and canonicalizes the hyperparameter specification.
+    """
+
+    def __init__(
+        self,
+        hyperparameters: Union[str, dict, None],
+        hyperparameter_tune: bool,
+        excluded_model_types: Optional[list[str]],
+    ):
+        self.hyperparameters = hyperparameters
+        self.hyperparameter_tune = hyperparameter_tune
+        self.excluded_model_types = excluded_model_types
+
+    def get_hyperparameters(self) -> TrainerHyperparameterSpec:
+        hyperparameter_dict = {}
+        hp_presets = get_hyperparameter_presets()
+
+        if self.hyperparameters is None:
+            hyperparameter_dict = hp_presets["default"]
+        elif isinstance(self.hyperparameters, str):
+            try:
+                hyperparameter_dict = hp_presets[self.hyperparameters]
+            except KeyError:
+                raise ValueError(f"{self.hyperparameters} is not a valid preset.")
+        elif isinstance(self.hyperparameters, dict):
+            hyperparameter_dict = copy.deepcopy(self.hyperparameters)
+        else:
+            raise ValueError(
+                f"hyperparameters must be a dict, a string or None (received {type(self.hyperparameters)}). "
+                f"Please see the documentation for TimeSeriesPredictor.fit"
+            )
+
+        return self._check_and_clean_hyperparameters(hyperparameter_dict)  # type: ignore
+
+    def _check_and_clean_hyperparameters(
+        self,
+        hyperparameters: dict[ModelKey, Union[ModelHyperparameters, list[ModelHyperparameters]]],
+    ) -> TrainerHyperparameterSpec:
+        """Convert the hyperparameters dictionary to a unified format:
+        - Remove 'Model' suffix from model names, if present
+        - Make sure that each value in the hyperparameters dict is a list with model configurations
+        - Checks if hyperparameters contain searchspaces
+        """
+        excluded_models = self._get_excluded_models()
+        hyperparameters_clean = defaultdict(list)
+        for model_name, model_hyperparameters in hyperparameters.items():
+            # Handle model names ending with "Model", e.g., "DeepARModel" is mapped to "DeepAR"
+            if isinstance(model_name, str):
+                model_name = self._normalize_model_type_name(model_name)
+                if model_name in excluded_models:
+                    logger.info(
+                        f"\tFound '{model_name}' model in `hyperparameters`, but '{model_name}' "
+                        "is present in `excluded_model_types` and will be removed."
+                    )
+                    continue
+            if not isinstance(model_hyperparameters, list):
+                model_hyperparameters = [model_hyperparameters]
+            hyperparameters_clean[model_name].extend(model_hyperparameters)
+
+        self._verify_searchspaces(hyperparameters_clean)
+
+        return dict(hyperparameters_clean)
+
+    def _get_excluded_models(self) -> set[str]:
+        excluded_models = set()
+        if self.excluded_model_types is not None and len(self.excluded_model_types) > 0:
+            if not isinstance(self.excluded_model_types, list):
+                raise ValueError(f"`excluded_model_types` must be a list, received {type(self.excluded_model_types)}")
+            logger.info(f"Excluded model types: {self.excluded_model_types}")
+            for model in self.excluded_model_types:
+                if not isinstance(model, str):
+                    raise ValueError(f"Each entry in `excluded_model_types` must be a string, received {type(model)}")
+                excluded_models.add(self._normalize_model_type_name(model))
+        return excluded_models
+
+    @staticmethod
+    def _normalize_model_type_name(model_name: str) -> str:
+        return model_name.removesuffix("Model")
+
+    def _verify_searchspaces(self, hyperparameters: dict[str, list[ModelHyperparameters]]):
+        if self.hyperparameter_tune:
+            for model, model_hps_list in hyperparameters.items():
+                for model_hps in model_hps_list:
+                    if contains_searchspace(model_hps):
+                        return
+
+            raise ValueError(
+                "Hyperparameter tuning specified, but no model contains a hyperparameter search space. "
+                "Please disable hyperparameter tuning with `hyperparameter_tune_kwargs=None` or provide a search space "
+                "for at least one model."
+            )
+        else:
+            for model, model_hps_list in hyperparameters.items():
+                for model_hps in model_hps_list:
+                    if contains_searchspace(model_hps):
+                        raise ValueError(
+                            f"Hyperparameter tuning not specified, so hyperparameters must have fixed values. "
+                            f"However, for model {model} hyperparameters {model_hps} contain a search space."
+                        )
+
+
+def contains_searchspace(model_hyperparameters: ModelHyperparameters) -> bool:
+    for hp_value in model_hyperparameters.values():
+        if isinstance(hp_value, space.Space):
+            return True
+    return False

{autogluon.timeseries-1.4.1b20250824/src/autogluon/timeseries → autogluon.timeseries-1.4.1b20250826/src/autogluon/timeseries/trainer}/trainer.py

@@ -22,7 +22,6 @@ from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel, TimeSeriesModelBase
 from autogluon.timeseries.models.ensemble import AbstractTimeSeriesEnsembleModel, GreedyEnsemble
 from autogluon.timeseries.models.multi_window import MultiWindowBacktestingModel
-from autogluon.timeseries.models.presets import contains_searchspace, get_preset_models
 from autogluon.timeseries.splitter import AbstractWindowSplitter, ExpandingWindowSplitter
 from autogluon.timeseries.utils.features import (
     ConstantReplacementFeatureImportanceTransform,
@@ -31,6 +30,8 @@ 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
+
 logger = logging.getLogger("autogluon.timeseries.trainer")
 
 
@@ -416,7 +417,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
                 self.save_val_data(val_data)
             self.is_data_saved = True
 
-        models = self.construct_model_templates(
+        models = self.get_trainable_base_models(
             hyperparameters=hyperparameters,
             hyperparameter_tune=hyperparameter_tune_kwargs is not None,  # TODO: remove hyperparameter_tune
             freq=train_data.freq,
@@ -440,8 +441,6 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         num_base_models = len(models)
         model_names_trained = []
         for i, model in enumerate(models):
-            assert isinstance(model, AbstractTimeSeriesModel)
-
             if time_limit is None:
                 time_left = None
                 time_left_for_model = None
@@ -1261,7 +1260,7 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         logger.info(f"Total runtime: {time.time() - time_start:.2f} s")
         return copy.deepcopy(self.model_refit_map)
 
-    def construct_model_templates(
+    def get_trainable_base_models(
         self,
         hyperparameters: Union[str, dict[str, Any]],
         *,
@@ -1269,21 +1268,21 @@ class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
         freq: Optional[str] = None,
         excluded_model_types: Optional[list[str]] = None,
         hyperparameter_tune: bool = False,
-    ) -> list[TimeSeriesModelBase]:
-        return get_preset_models(
+    ) -> list[AbstractTimeSeriesModel]:
+        return TrainableModelSetBuilder(
+            freq=freq,
+            prediction_length=self.prediction_length,
             path=self.path,
             eval_metric=self.eval_metric,
-            prediction_length=self.prediction_length,
-            freq=freq,
-            hyperparameters=hyperparameters,
-            hyperparameter_tune=hyperparameter_tune,
             quantile_levels=self.quantile_levels,
-            all_assigned_names=self._get_banned_model_names(),
             target=self.target,
             covariate_metadata=self.covariate_metadata,
-            excluded_model_types=excluded_model_types,
-            # if skip_model_selection = True, we skip backtesting
             multi_window=multi_window and not self.skip_model_selection,
+        ).get_model_set(
+            hyperparameters=hyperparameters,
+            hyperparameter_tune=hyperparameter_tune,
+            excluded_model_types=excluded_model_types,
+            banned_model_names=self._get_banned_model_names(),
         )
 
     def fit(

{autogluon.timeseries-1.4.1b20250824 → autogluon.timeseries-1.4.1b20250826}/src/autogluon/timeseries/version.py

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

{autogluon.timeseries-1.4.1b20250824 → autogluon.timeseries-1.4.1b20250826}/src/autogluon.timeseries.egg-info/PKG-INFO

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

{autogluon.timeseries-1.4.1b20250824 → autogluon.timeseries-1.4.1b20250826}/src/autogluon.timeseries.egg-info/SOURCES.txt

@@ -14,10 +14,10 @@ src/autogluon/timeseries/learner.py
 src/autogluon/timeseries/predictor.py
 src/autogluon/timeseries/regressor.py
 src/autogluon/timeseries/splitter.py
-src/autogluon/timeseries/trainer.py
 src/autogluon/timeseries/version.py
 src/autogluon/timeseries/configs/__init__.py
-src/autogluon/timeseries/configs/presets_configs.py
+src/autogluon/timeseries/configs/hyperparameter_presets.py
+src/autogluon/timeseries/configs/predictor_presets.py
 src/autogluon/timeseries/dataset/__init__.py
 src/autogluon/timeseries/dataset/ts_dataframe.py
 src/autogluon/timeseries/metrics/__init__.py
@@ -26,7 +26,6 @@ src/autogluon/timeseries/metrics/point.py
 src/autogluon/timeseries/metrics/quantile.py
 src/autogluon/timeseries/metrics/utils.py
 src/autogluon/timeseries/models/__init__.py
-src/autogluon/timeseries/models/presets.py
 src/autogluon/timeseries/models/registry.py
 src/autogluon/timeseries/models/abstract/__init__.py
 src/autogluon/timeseries/models/abstract/abstract_timeseries_model.py
@@ -59,6 +58,9 @@ src/autogluon/timeseries/models/local/npts.py
 src/autogluon/timeseries/models/local/statsforecast.py
 src/autogluon/timeseries/models/multi_window/__init__.py
 src/autogluon/timeseries/models/multi_window/multi_window_model.py
+src/autogluon/timeseries/trainer/__init__.py
+src/autogluon/timeseries/trainer/model_set_builder.py
+src/autogluon/timeseries/trainer/trainer.py
 src/autogluon/timeseries/transforms/__init__.py
 src/autogluon/timeseries/transforms/covariate_scaler.py
 src/autogluon/timeseries/transforms/target_scaler.py

{autogluon.timeseries-1.4.1b20250824 → autogluon.timeseries-1.4.1b20250826}/src/autogluon.timeseries.egg-info/requires.txt

@@ -17,10 +17,10 @@ fugue>=0.9.0
 tqdm<5,>=4.38
 orjson~=3.9
 tensorboard<3,>=2.9
-autogluon.core[raytune]==1.4.1b20250824
-autogluon.common==1.4.1b20250824
-autogluon.features==1.4.1b20250824
-autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20250824
+autogluon.core[raytune]==1.4.1b20250826
+autogluon.common==1.4.1b20250826
+autogluon.features==1.4.1b20250826
+autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20250826
 
 [all]
 

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

@@ -1,3 +0,0 @@
-from .presets_configs import TIMESERIES_PRESETS_CONFIGS
-
-__all__ = ["TIMESERIES_PRESETS_CONFIGS"]

autogluon.timeseries-1.4.1b20250824/src/autogluon/timeseries/configs/presets_configs.py

@@ -1,79 +0,0 @@
-"""Preset configurations for autogluon.timeseries Predictors"""
-
-from autogluon.timeseries.models.presets import get_default_hps
-
-# TODO: change default HPO settings when other HPO strategies (e.g., Ray tune) are available
-# TODO: add refit_full arguments once refitting is available
-
-TIMESERIES_PRESETS_CONFIGS = 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"},
-            **get_default_hps("light_inference"),
-        }
-    },
-    chronos_large_ensemble={
-        "hyperparameters": {
-            "Chronos": {"model_path": "large", "batch_size": 8},
-            **get_default_hps("light_inference"),
-        }
-    },
-)
-
-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",
-)
-
-# update with aliases
-TIMESERIES_PRESETS_CONFIGS = {
-    **TIMESERIES_PRESETS_CONFIGS,
-    **{k: TIMESERIES_PRESETS_CONFIGS[v].copy() for k, v in TIMESERIES_PRESETS_ALIASES.items()},
-}

autogluon.timeseries-1.4.1b20250824/src/autogluon/timeseries/models/presets.py

@@ -1,280 +0,0 @@
-import copy
-import logging
-import re
-from collections import defaultdict
-from typing import Any, Optional, Type, Union
-
-from autogluon.common import space
-from autogluon.core import constants
-from autogluon.timeseries.metrics import TimeSeriesScorer
-from autogluon.timeseries.utils.features import CovariateMetadata
-
-from .abstract import AbstractTimeSeriesModel
-from .multi_window.multi_window_model import MultiWindowBacktestingModel
-from .registry import ModelRegistry
-
-logger = logging.getLogger(__name__)
-
-ModelHyperparameters = dict[str, Any]
-
-
-VALID_AG_ARGS_KEYS = {
-    "name",
-    "name_prefix",
-    "name_suffix",
-}
-
-
-def get_default_hps(key):
-    default_model_hps = {
-        "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,
-            },
-        },
-    }
-    return default_model_hps[key]
-
-
-def get_preset_models(
-    freq: Optional[str],
-    prediction_length: int,
-    path: str,
-    eval_metric: Union[str, TimeSeriesScorer],
-    hyperparameters: Union[str, dict, None],
-    hyperparameter_tune: bool,
-    covariate_metadata: CovariateMetadata,
-    all_assigned_names: list[str],
-    excluded_model_types: Optional[list[str]],
-    multi_window: bool = False,
-    **kwargs,
-):
-    """
-    Create a list of models according to hyperparameters. If hyperparamaters=None,
-    will create models according to presets.
-    """
-    models = []
-    hyperparameter_dict = get_hyperparameter_dict(hyperparameters, hyperparameter_tune)
-
-    model_priority_list = sorted(
-        hyperparameter_dict.keys(), key=lambda x: ModelRegistry.get_model_priority(x), reverse=True
-    )
-    excluded_models = get_excluded_models(excluded_model_types)
-    all_assigned_names = all_assigned_names.copy()
-
-    for model in model_priority_list:
-        if isinstance(model, str):
-            if model in excluded_models:
-                logger.info(
-                    f"\tFound '{model}' model in `hyperparameters`, but '{model}' "
-                    "is present in `excluded_model_types` and will be removed."
-                )
-                continue
-            model_type: Type[AbstractTimeSeriesModel] = ModelRegistry.get_model_class(model)
-        elif isinstance(model, type):
-            if not issubclass(model, AbstractTimeSeriesModel):
-                raise ValueError(f"Custom model type {model} must inherit from `AbstractTimeSeriesModel`.")
-            model_type = model
-        else:
-            raise ValueError(
-                f"Keys of the `hyperparameters` dictionary must be strings or types, received {type(model)}."
-            )
-
-        for model_hps in hyperparameter_dict[model]:
-            ag_args = model_hps.pop(constants.AG_ARGS, {})
-            for key in ag_args:
-                if key not in VALID_AG_ARGS_KEYS:
-                    raise ValueError(
-                        f"Model {model_type} received unknown ag_args key: {key} (valid keys {VALID_AG_ARGS_KEYS})"
-                    )
-            model_name_base = get_model_name(ag_args, model_type)
-
-            model_type_kwargs: dict[str, Any] = dict(
-                name=model_name_base,
-                path=path,
-                freq=freq,
-                prediction_length=prediction_length,
-                eval_metric=eval_metric,
-                covariate_metadata=covariate_metadata,
-                hyperparameters=model_hps,
-                **kwargs,
-            )
-
-            # add models while preventing name collisions
-            model = model_type(**model_type_kwargs)
-            model_type_kwargs.pop("name", None)
-
-            increment = 1
-            while model.name in all_assigned_names:
-                increment += 1
-                model = model_type(name=f"{model_name_base}_{increment}", **model_type_kwargs)
-
-            if multi_window:
-                model = MultiWindowBacktestingModel(model_base=model, name=model.name, **model_type_kwargs)  # type: ignore
-
-            all_assigned_names.append(model.name)
-            models.append(model)
-
-    return models
-
-
-def get_excluded_models(excluded_model_types: Optional[list[str]]) -> set[str]:
-    excluded_models = set()
-    if excluded_model_types is not None and len(excluded_model_types) > 0:
-        if not isinstance(excluded_model_types, list):
-            raise ValueError(f"`excluded_model_types` must be a list, received {type(excluded_model_types)}")
-        logger.info(f"Excluded model types: {excluded_model_types}")
-        for model in excluded_model_types:
-            if not isinstance(model, str):
-                raise ValueError(f"Each entry in `excluded_model_types` must be a string, received {type(model)}")
-            excluded_models.add(normalize_model_type_name(model))
-    return excluded_models
-
-
-def get_hyperparameter_dict(
-    hyperparameters: Union[str, dict[str, Union[ModelHyperparameters, list[ModelHyperparameters]]], None],
-    hyperparameter_tune: bool,
-) -> dict[str, list[ModelHyperparameters]]:
-    hyperparameter_dict = {}
-
-    if hyperparameters is None:
-        hyperparameter_dict = copy.deepcopy(get_default_hps("default"))
-    elif isinstance(hyperparameters, str):
-        hyperparameter_dict = copy.deepcopy(get_default_hps(hyperparameters))
-    elif isinstance(hyperparameters, dict):
-        hyperparameter_dict = copy.deepcopy(hyperparameters)
-    else:
-        raise ValueError(
-            f"hyperparameters must be a dict, a string or None (received {type(hyperparameters)}). "
-            f"Please see the documentation for TimeSeriesPredictor.fit"
-        )
-
-    hyperparameter_dict = check_and_clean_hyperparameters(
-        hyperparameter_dict, must_contain_searchspace=hyperparameter_tune
-    )
-
-    return hyperparameter_dict
-
-
-def normalize_model_type_name(model_name: str) -> str:
-    """Remove 'Model' suffix from the end of the string, if it's present."""
-    if model_name.endswith("Model"):
-        model_name = model_name[: -len("Model")]
-    return model_name
-
-
-def check_and_clean_hyperparameters(
-    hyperparameters: dict[str, Union[ModelHyperparameters, list[ModelHyperparameters]]],
-    must_contain_searchspace: bool,
-) -> dict[str, list[ModelHyperparameters]]:
-    """Convert the hyperparameters dictionary to a unified format:
-    - Remove 'Model' suffix from model names, if present
-    - Make sure that each value in the hyperparameters dict is a list with model configurations
-    - Checks if hyperparameters contain searchspaces
-    """
-    hyperparameters_clean = defaultdict(list)
-    for key, value in hyperparameters.items():
-        # Handle model names ending with "Model", e.g., "DeepARModel" is mapped to "DeepAR"
-        if isinstance(key, str):
-            key = normalize_model_type_name(key)
-        if not isinstance(value, list):
-            value = [value]
-        hyperparameters_clean[key].extend(value)
-
-    if must_contain_searchspace:
-        verify_contains_at_least_one_searchspace(hyperparameters_clean)
-    else:
-        verify_contains_no_searchspaces(hyperparameters_clean)
-
-    return dict(hyperparameters_clean)
-
-
-def get_model_name(ag_args: dict[str, Any], model_type: Type[AbstractTimeSeriesModel]) -> str:
-    name = ag_args.get("name")
-    if name is None:
-        name_stem = re.sub(r"Model$", "", model_type.__name__)
-        name_prefix = ag_args.get("name_prefix", "")
-        name_suffix = ag_args.get("name_suffix", "")
-        name = name_prefix + name_stem + name_suffix
-    return name
-
-
-def contains_searchspace(model_hyperparameters: ModelHyperparameters) -> bool:
-    for hp_value in model_hyperparameters.values():
-        if isinstance(hp_value, space.Space):
-            return True
-    return False
-
-
-def verify_contains_at_least_one_searchspace(hyperparameters: dict[str, list[ModelHyperparameters]]):
-    for model, model_hps_list in hyperparameters.items():
-        for model_hps in model_hps_list:
-            if contains_searchspace(model_hps):
-                return
-
-    raise ValueError(
-        "Hyperparameter tuning specified, but no model contains a hyperparameter search space. "
-        "Please disable hyperparameter tuning with `hyperparameter_tune_kwargs=None` or provide a search space "
-        "for at least one model."
-    )
-
-
-def verify_contains_no_searchspaces(hyperparameters: dict[str, list[ModelHyperparameters]]):
-    for model, model_hps_list in hyperparameters.items():
-        for model_hps in model_hps_list:
-            if contains_searchspace(model_hps):
-                raise ValueError(
-                    f"Hyperparameter tuning not specified, so hyperparameters must have fixed values. "
-                    f"However, for model {model} hyperparameters {model_hps} contain a search space."
-                )