autogluon.timeseries 1.1.2b20241118__tar.gz → 1.1.2b20241120__tar.gz

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/PKG-INFO

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

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/configs/presets_configs.py

@@ -10,6 +10,24 @@ TIMESERIES_PRESETS_CONFIGS = dict(
     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,

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/learner.py

@@ -32,6 +32,7 @@ class TimeSeriesLearner(AbstractLearner):
         eval_metric_seasonal_period: Optional[int] = None,
         prediction_length: int = 1,
         cache_predictions: bool = True,
+        ensemble_model_type: Optional[Type] = None,
         **kwargs,
     ):
         super().__init__(path_context=path_context)
@@ -44,6 +45,7 @@ class TimeSeriesLearner(AbstractLearner):
         self.quantile_levels = kwargs.get("quantile_levels", [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
         self.cache_predictions = cache_predictions
         self.freq: Optional[str] = None
+        self.ensemble_model_type = ensemble_model_type
 
         self.feature_generator = TimeSeriesFeatureGenerator(
             target=self.target, known_covariates_names=self.known_covariates_names
@@ -106,6 +108,7 @@ class TimeSeriesLearner(AbstractLearner):
                 val_splitter=val_splitter,
                 refit_every_n_windows=refit_every_n_windows,
                 cache_predictions=self.cache_predictions,
+                ensemble_model_type=self.ensemble_model_type,
             )
         )
         self.trainer = self.trainer_type(**trainer_init_kwargs)

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/metrics/point.py

@@ -8,7 +8,7 @@ import pandas as pd
 from autogluon.timeseries import TimeSeriesDataFrame
 
 from .abstract import TimeSeriesScorer
-from .utils import _in_sample_abs_seasonal_error, _in_sample_squared_seasonal_error
+from .utils import in_sample_abs_seasonal_error, in_sample_squared_seasonal_error
 
 logger = logging.getLogger(__name__)
 
@@ -232,7 +232,7 @@ class MASE(TimeSeriesScorer):
     def save_past_metrics(
         self, data_past: TimeSeriesDataFrame, target: str = "target", seasonal_period: int = 1, **kwargs
     ) -> None:
-        self._past_abs_seasonal_error = _in_sample_abs_seasonal_error(
+        self._past_abs_seasonal_error = in_sample_abs_seasonal_error(
             y_past=data_past[target], seasonal_period=seasonal_period
         )
 
@@ -292,7 +292,7 @@ class RMSSE(TimeSeriesScorer):
     def save_past_metrics(
         self, data_past: TimeSeriesDataFrame, target: str = "target", seasonal_period: int = 1, **kwargs
     ) -> None:
-        self._past_squared_seasonal_error = _in_sample_squared_seasonal_error(
+        self._past_squared_seasonal_error = in_sample_squared_seasonal_error(
             y_past=data_past[target], seasonal_period=seasonal_period
         )
 

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/metrics/quantile.py

@@ -6,7 +6,7 @@ import pandas as pd
 from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
 
 from .abstract import TimeSeriesScorer
-from .utils import _in_sample_abs_seasonal_error
+from .utils import in_sample_abs_seasonal_error
 
 
 class WQL(TimeSeriesScorer):
@@ -85,7 +85,7 @@ class SQL(TimeSeriesScorer):
     def save_past_metrics(
         self, data_past: TimeSeriesDataFrame, target: str = "target", seasonal_period: int = 1, **kwargs
     ) -> None:
-        self._past_abs_seasonal_error = _in_sample_abs_seasonal_error(
+        self._past_abs_seasonal_error = in_sample_abs_seasonal_error(
             y_past=data_past[target], seasonal_period=seasonal_period
         )
 

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/metrics/utils.py

@@ -7,12 +7,12 @@ def _get_seasonal_diffs(*, y_past: pd.Series, seasonal_period: int = 1) -> pd.Se
     return y_past.groupby(level=ITEMID, sort=False).diff(seasonal_period).abs()
 
 
-def _in_sample_abs_seasonal_error(*, y_past: pd.Series, seasonal_period: int = 1) -> pd.Series:
+def in_sample_abs_seasonal_error(*, y_past: pd.Series, seasonal_period: int = 1) -> pd.Series:
     """Compute seasonal naive forecast error (predict value from seasonal_period steps ago) for each time series."""
     seasonal_diffs = _get_seasonal_diffs(y_past=y_past, seasonal_period=seasonal_period)
     return seasonal_diffs.groupby(level=ITEMID, sort=False).mean().fillna(1.0)
 
 
-def _in_sample_squared_seasonal_error(*, y_past: pd.Series, seasonal_period: int = 1) -> pd.Series:
+def in_sample_squared_seasonal_error(*, y_past: pd.Series, seasonal_period: int = 1) -> pd.Series:
     seasonal_diffs = _get_seasonal_diffs(y_past=y_past, seasonal_period=seasonal_period)
     return seasonal_diffs.pow(2.0).groupby(level=ITEMID, sort=False).mean().fillna(1.0)

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -67,6 +67,7 @@ class AbstractTimeSeriesModel(AbstractModel):
     _oof_filename = "oof.pkl"
     # TODO: For which models should we override this parameter?
     _covariate_regressor_fit_time_fraction: float = 0.5
+    default_max_time_limit_ratio: float = 0.9
 
     # TODO: refactor "pruned" methods after AbstractModel is refactored
     predict_proba = None
@@ -174,6 +175,11 @@ class AbstractTimeSeriesModel(AbstractModel):
             self._oof_predictions = self.load_oof_predictions(self.path)
         return self._oof_predictions
 
+    def _get_default_auxiliary_params(self) -> dict:
+        default_auxiliary_params = super()._get_default_auxiliary_params()
+        default_auxiliary_params["max_time_limit_ratio"] = self.default_max_time_limit_ratio
+        return default_auxiliary_params
+
     def _initialize(self, **kwargs) -> None:
         self._init_params_aux()
         self._init_params()

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/models/autogluon_tabular/mlforecast.py

@@ -11,6 +11,7 @@ from sklearn.base import BaseEstimator
 import autogluon.core as ag
 from autogluon.tabular import TabularPredictor
 from autogluon.timeseries.dataset.ts_dataframe import ITEMID, TIMESTAMP, TimeSeriesDataFrame
+from autogluon.timeseries.metrics.utils import in_sample_squared_seasonal_error
 from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
 from autogluon.timeseries.models.local import SeasonalNaiveModel
 from autogluon.timeseries.utils.datetime import (
@@ -82,7 +83,6 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         self._mlf: Optional[MLForecast] = None
         self._scaler: Optional[BaseTargetTransform] = None
         self._residuals_std_per_item: Optional[pd.Series] = None
-        self._avg_residuals_std: Optional[float] = None
         self._train_target_median: Optional[float] = None
         self._non_boolean_real_covariates: List[str] = []
 
@@ -332,7 +332,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
     def _save_residuals_std(self, val_df: pd.DataFrame) -> None:
         """Compute standard deviation of residuals for each item using the validation set.
 
-        Saves per-item residuals to `self.residuals_std_per_item` and average std to `self._avg_residuals_std`.
+        Saves per-item residuals to `self.residuals_std_per_item`.
         """
         residuals_df = val_df[[MLF_ITEMID, MLF_TARGET]]
         residuals_df = residuals_df.assign(y_pred=self._mlf.models_["mean"].predict(val_df))
@@ -344,7 +344,6 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         self._residuals_std_per_item = (
             residuals.pow(2.0).groupby(val_df[MLF_ITEMID].values, sort=False).mean().pow(0.5)
         )
-        self._avg_residuals_std = np.sqrt(residuals.pow(2.0).mean())
 
     def _remove_short_ts_and_generate_fallback_forecast(
         self,
@@ -391,7 +390,7 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
             forecast_for_short_series = None
         return data_long, known_covariates_long, forecast_for_short_series
 
-    def _add_gaussian_quantiles(self, predictions: pd.DataFrame, repeated_item_ids: pd.Series):
+    def _add_gaussian_quantiles(self, predictions: pd.DataFrame, repeated_item_ids: pd.Series, past_target: pd.Series):
         """
         Add quantile levels assuming that residuals follow normal distribution
         """
@@ -403,9 +402,14 @@ class AbstractMLForecastModel(AbstractTimeSeriesModel):
         normal_scale_per_timestep = pd.Series(np.tile(sqrt_h, num_items), index=repeated_item_ids)
 
         residuals_std_per_timestep = self._residuals_std_per_item.reindex(repeated_item_ids)
-        # Use avg_residuals_std in case unseen item received for prediction
-        if residuals_std_per_timestep.isna().any():
-            residuals_std_per_timestep = residuals_std_per_timestep.fillna(value=self._avg_residuals_std)
+        # Use in-sample seasonal error in for items not seen during fit
+        items_not_seen_during_fit = residuals_std_per_timestep.index[residuals_std_per_timestep.isna()].unique()
+        if len(items_not_seen_during_fit) > 0:
+            scale_for_new_items: pd.Series = np.sqrt(
+                in_sample_squared_seasonal_error(y_past=past_target.loc[items_not_seen_during_fit])
+            )
+            residuals_std_per_timestep = residuals_std_per_timestep.fillna(scale_for_new_items)
+
         std_per_timestep = residuals_std_per_timestep * normal_scale_per_timestep
         for q in self.quantile_levels:
             predictions[str(q)] = predictions["mean"] + norm.ppf(q) * std_per_timestep.to_numpy()
@@ -493,7 +497,6 @@ class DirectTabularModel(AbstractMLForecastModel):
         if self.is_quantile_model:
             # Quantile model does not require residuals to produce prediction intervals
             self._residuals_std_per_item = pd.Series(1.0, index=val_df[MLF_ITEMID].unique())
-            self._avg_residuals_std = 1.0
         else:
             super()._save_residuals_std(val_df=val_df)
 
@@ -545,7 +548,9 @@ class DirectTabularModel(AbstractMLForecastModel):
                 predictions = apply_inverse_transform(predictions, transform=tfm)
 
         if not self.is_quantile_model:
-            predictions = self._add_gaussian_quantiles(predictions, repeated_item_ids=predictions[MLF_ITEMID])
+            predictions = self._add_gaussian_quantiles(
+                predictions, repeated_item_ids=predictions[MLF_ITEMID], past_target=data[self.target]
+            )
         predictions = TimeSeriesDataFrame(predictions.rename(columns={MLF_ITEMID: ITEMID, MLF_TIMESTAMP: TIMESTAMP}))
 
         if forecast_for_short_series is not None:
@@ -661,7 +666,9 @@ class RecursiveTabularModel(AbstractMLForecastModel):
             )
         predictions = raw_predictions.rename(columns={MLF_ITEMID: ITEMID, MLF_TIMESTAMP: TIMESTAMP})
         predictions = TimeSeriesDataFrame(
-            self._add_gaussian_quantiles(predictions, repeated_item_ids=predictions[ITEMID])
+            self._add_gaussian_quantiles(
+                predictions, repeated_item_ids=predictions[ITEMID], past_target=data[self.target]
+            )
         )
 
         if forecast_for_short_series is not None:

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/models/chronos/model.py

@@ -1,7 +1,6 @@
 import logging
 import os
 import shutil
-import time
 from pathlib import Path
 from typing import Any, Dict, Literal, Optional, Union
 
@@ -68,6 +67,7 @@ MODEL_ALIASES = {
     "small": "autogluon/chronos-t5-small",
     "base": "autogluon/chronos-t5-base",
     "large": "autogluon/chronos-t5-large",
+    "bolt-tiny": "autogluon/chronos-bolt-tiny",
     "bolt-mini": "autogluon/chronos-bolt-mini",
     "bolt-small": "autogluon/chronos-bolt-small",
     "bolt-base": "autogluon/chronos-bolt-base",
@@ -113,10 +113,12 @@ class ChronosModel(AbstractTimeSeriesModel):
     batch_size : int, default = 16
         Size of batches used during inference
     num_samples : int, default = 20
-        Number of samples used during inference
+        Number of samples used during inference, only used for the original Chronos models
     device : str, default = None
         Device to use for inference (and fine-tuning, if enabled). If None, model will use the GPU if available.
-        For larger model sizes `small`, `base`, and `large`; inference will fail if no GPU is available.
+        For larger Chronos model sizes ``small``, ``base``, and ``large``; inference will fail if no GPU is available.
+        For Chronos-Bolt models, inference can be done on the CPU. Although fine-tuning the smaller Chronos models
+        (``tiny`` and ``mini``) and all Chronos-Bolt is allowed on the CPU, we recommend using a GPU for faster fine-tuning.
     context_length : int or None, default = None
         The context length to use in the model. Shorter context lengths will decrease model accuracy, but result
         in faster inference. If None, the model will infer context length from the data set length at inference
@@ -140,9 +142,9 @@ class ChronosModel(AbstractTimeSeriesModel):
         If True, the pretrained model will be fine-tuned
     fine_tune_lr: float, default = 0.0001
         The learning rate used for fine-tuning
-    fine_tune_steps : int, default = 5000
+    fine_tune_steps : int, default = 1000
         The number of gradient update steps to fine-tune for
-    fine_tune_batch_size : int, default = 16
+    fine_tune_batch_size : int, default = 32
         The batch size to use for fine-tuning
     fine_tune_shuffle_buffer_size : int, default = 10000
         The size of the shuffle buffer to shuffle the data during fine-tuning. If None, shuffling will
@@ -162,6 +164,7 @@ class ChronosModel(AbstractTimeSeriesModel):
     # default number of samples for prediction
     default_num_samples: int = 20
     default_model_path = "autogluon/chronos-t5-small"
+    default_max_time_limit_ratio = 0.8
     maximum_context_length = 2048
     fine_tuned_ckpt_name: str = "fine-tuned-ckpt"
 
@@ -216,7 +219,6 @@ class ChronosModel(AbstractTimeSeriesModel):
         )
 
         self.model_pipeline: Optional[Any] = None  # of type BaseChronosPipeline
-        self.time_limit: Optional[float] = None
 
     def save(self, path: str = None, verbose: bool = True) -> str:
         pipeline = self.model_pipeline
@@ -234,7 +236,7 @@ class ChronosModel(AbstractTimeSeriesModel):
 
         fine_tune_ckpt_path = Path(model.path) / cls.fine_tuned_ckpt_name
         if fine_tune_ckpt_path.exists():
-            logger.debug(f"Fine-tuned checkpoint exists, setting model_path to {fine_tune_ckpt_path}")
+            logger.debug(f"\tFine-tuned checkpoint exists, setting model_path to {fine_tune_ckpt_path}")
             model.model_path = fine_tune_ckpt_path
 
         return model
@@ -320,8 +322,8 @@ class ChronosModel(AbstractTimeSeriesModel):
         init_args.setdefault("fine_tune", False)
         init_args.setdefault("keep_transformers_logs", False)
         init_args.setdefault("fine_tune_lr", 1e-4)
-        init_args.setdefault("fine_tune_steps", 5000)
-        init_args.setdefault("fine_tune_batch_size", self.default_batch_size)
+        init_args.setdefault("fine_tune_steps", 1000)
+        init_args.setdefault("fine_tune_batch_size", 32)
         init_args.setdefault("eval_during_fine_tune", False)
         init_args.setdefault("fine_tune_eval_max_items", 256)
         init_args.setdefault("fine_tune_shuffle_buffer_size", 10_000)
@@ -399,7 +401,6 @@ class ChronosModel(AbstractTimeSeriesModel):
 
         eval_during_fine_tune = val_data is not None and fine_tune_args["eval_during_fine_tune"]
 
-        start_time = time.monotonic()
         if do_fine_tune:
             context_length = self._get_context_length(train_data)
             # load model pipeline to device memory
@@ -428,7 +429,7 @@ class ChronosModel(AbstractTimeSeriesModel):
 
                 if self.prediction_length != fine_tune_prediction_length:
                     logger.debug(
-                        f"ChronosBolt models can only be fine-tuned with a maximum prediction_length of {model_prediction_length}. "
+                        f"\tChronosBolt 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}."
                     )
 
@@ -436,10 +437,15 @@ class ChronosModel(AbstractTimeSeriesModel):
             fine_tune_trainer_kwargs["disable_tqdm"] = fine_tune_trainer_kwargs.get("disable_tqdm", (verbosity < 3))
             fine_tune_trainer_kwargs["use_cpu"] = str(self.model_pipeline.inner_model.device) == "cpu"
 
-            # TODO: adamw_torch_fused is not supported on CPU in torch <= 2.3. When torch 2.4 becomes the lower bound
-            # this if block can be removed because torch >= 2.4 supports AdamW optimizer with fused=True on CPU
-            if fine_tune_trainer_kwargs["use_cpu"] and fine_tune_trainer_kwargs["optim"] == "adamw_torch_fused":
-                fine_tune_trainer_kwargs["optim"] = "adamw_torch"
+            if fine_tune_trainer_kwargs["use_cpu"]:
+                logger.info(
+                    "\tFine-tuning on the CPU detected. We recommend using a GPU for faster fine-tuning of Chronos."
+                )
+
+                # TODO: adamw_torch_fused is not supported on CPU in torch <= 2.3. When torch 2.4 becomes the lower bound
+                # this if block can be removed because torch >= 2.4 supports AdamW optimizer with fused=True on CPU
+                if fine_tune_trainer_kwargs["optim"] == "adamw_torch_fused":
+                    fine_tune_trainer_kwargs["optim"] = "adamw_torch"
 
             output_dir = Path(fine_tune_trainer_kwargs["output_dir"])
 
@@ -509,37 +515,16 @@ class ChronosModel(AbstractTimeSeriesModel):
                 )
                 trainer.add_callback(LoggerCallback())
 
-            if val_data is not None:
-                # evaluate once before training
-                zero_shot_eval_loss = trainer.evaluate()["eval_loss"]
-
             trainer.train()
 
-            if eval_during_fine_tune:
-                # get the best eval_loss logged during fine-tuning
-                log_history_df = pd.DataFrame(trainer.state.log_history)
-                best_train_eval_loss = log_history_df["eval_loss"].min()
-            elif val_data is not None:
-                # evaluate at the end of fine-tuning
-                best_train_eval_loss = trainer.evaluate()["eval_loss"]
-
-            if val_data is None or best_train_eval_loss <= zero_shot_eval_loss:
-                fine_tuned_ckpt_path = Path(self.path) / self.fine_tuned_ckpt_name
-                logger.info(f"Saving fine-tuned model to {fine_tuned_ckpt_path}")
-                self.model_pipeline.inner_model.save_pretrained(Path(self.path) / self.fine_tuned_ckpt_name)
-            else:
-                # Reset the model to its pretrained state
-                logger.info("Validation loss worsened after fine-tuning. Reverting to the pretrained model.")
-                self.model_pipeline = None
-                self.load_model_pipeline(is_training=False)
+            fine_tuned_ckpt_path = Path(self.path) / self.fine_tuned_ckpt_name
+            logger.info(f"\tSaving fine-tuned model to {fine_tuned_ckpt_path}")
+            self.model_pipeline.inner_model.save_pretrained(Path(self.path) / self.fine_tuned_ckpt_name)
 
             if not fine_tune_args["keep_transformers_logs"]:
                 logger.debug(f"Removing transformers_logs directory {output_dir}")
                 shutil.rmtree(output_dir)
 
-        if time_limit is not None:
-            self.time_limit = time_limit - (time.monotonic() - start_time)  # inference time budget
-
     def _get_inference_data_loader(
         self,
         data: TimeSeriesDataFrame,
@@ -635,16 +620,3 @@ class ChronosModel(AbstractTimeSeriesModel):
             "can_use_train_data": do_fine_tune,
             "can_use_val_data": do_fine_tune,
         }
-
-    def score_and_cache_oof(
-        self,
-        val_data: TimeSeriesDataFrame,
-        store_val_score: bool = False,
-        store_predict_time: bool = False,
-        **predict_kwargs,
-    ) -> None:
-        # All computation happens during inference, so we provide the time_limit at prediction time
-        # TODO: Once custom predict_kwargs is allowed, make sure that `time_limit` is not among the keys
-        super().score_and_cache_oof(
-            val_data, store_val_score, store_predict_time, time_limit=self.time_limit, **predict_kwargs
-        )

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/models/chronos/pipeline/base.py

@@ -135,6 +135,7 @@ class BaseChronosPipeline(metaclass=PipelineRegistry):
         """
         from transformers import AutoConfig
 
+        kwargs.setdefault("resume_download", None)  # silence huggingface_hub warning
         if str(pretrained_model_name_or_path).startswith("s3://"):
             from .utils import cache_model_from_s3
 

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/models/chronos/pipeline/chronos.py

@@ -546,6 +546,7 @@ class ChronosPipeline(BaseChronosPipeline):
                 "onnx",
                 "openvino",
             ], "optimization_strategy not recognized. Please provide one of `onnx` or `openvino`"
+            kwargs.pop("resume_download", None)  # Optimized pipeline does not support 'resume_download' kwargs
             torch_dtype = kwargs.pop("torch_dtype", "auto")
             if torch_dtype != "auto":
                 logger.warning(f"\t`torch_dtype` will be ignored for optimization_strategy {optimization_strategy}")

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/models/chronos/pipeline/utils.py

@@ -317,7 +317,8 @@ class TimeLimitCallback(TrainerCallback):
     def on_step_end(self, args, state, control, **kwargs):
         elapsed_time = time.monotonic() - self.start_time
         if elapsed_time > self.time_limit:
-            raise TimeLimitExceeded
+            logger.info("\tStopping fine-tuning since time_limit is reached")
+            control.should_training_stop = True
 
 
 class LoggerCallback(TrainerCallback):

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/models/local/abstract_local_model.py

@@ -44,6 +44,7 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
     allowed_local_model_args: List[str] = []
     default_n_jobs: Union[int, float] = AG_DEFAULT_N_JOBS
     default_max_ts_length: Optional[int] = 2500
+    default_max_time_limit_ratio = 1.0
     init_time_in_seconds: int = 0
 
     def __init__(
@@ -84,7 +85,6 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
 
         self._local_model_args: Dict[str, Any] = None
         self._seasonal_period: Optional[int] = None
-        self.time_limit: Optional[float] = None
         self._dummy_forecast: Optional[pd.DataFrame] = None
 
     @property
@@ -138,7 +138,6 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         self._seasonal_period = local_model_args["seasonal_period"]
 
         self._local_model_args = self._update_local_model_args(local_model_args=local_model_args)
-        self.time_limit = time_limit
 
         self._dummy_forecast = self._get_dummy_forecast(train_data)
         return self
@@ -187,18 +186,6 @@ class AbstractLocalModel(AbstractTimeSeriesModel):
         predictions_df.index = get_forecast_horizon_index_ts_dataframe(data, self.prediction_length, freq=self.freq)
         return TimeSeriesDataFrame(predictions_df)
 
-    def score_and_cache_oof(
-        self,
-        val_data: TimeSeriesDataFrame,
-        store_val_score: bool = False,
-        store_predict_time: bool = False,
-        **predict_kwargs,
-    ) -> None:
-        # All computation happens during inference, so we provide the time_limit at prediction time
-        super().score_and_cache_oof(
-            val_data, store_val_score, store_predict_time, time_limit=self.time_limit, **predict_kwargs
-        )
-
     def _predict_wrapper(self, time_series: pd.Series, end_time: Optional[float] = None) -> Tuple[pd.DataFrame, bool]:
         if end_time is not None and time.time() >= end_time:
             raise TimeLimitExceeded

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/models/multi_window/multi_window_model.py

@@ -33,6 +33,7 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
     """
 
     # TODO: Remove the MultiWindowBacktestingModel class, move the logic to AbstractTimeSeriesTrainer
+    default_max_time_limit_ratio = 1.0
 
     def __init__(
         self,
@@ -124,8 +125,7 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
                     num_refits_remaining = math.ceil(
                         (val_splitter.num_val_windows - window_index) / refit_every_n_windows
                     )
-                    # Reserve 10% of the remaining time for prediction, use 90% of time for training
-                    time_left_for_window = 0.9 * time_left / num_refits_remaining
+                    time_left_for_window = time_left / num_refits_remaining
 
             if refit_this_window:
                 model = self.get_child_model(window_index)
@@ -138,7 +138,15 @@ class MultiWindowBacktestingModel(AbstractTimeSeriesModel):
                 )
                 model.fit_time = time.time() - model_fit_start_time
                 most_recent_refit_window = f"W{window_index}"
-            model.score_and_cache_oof(val_fold, store_val_score=True, store_predict_time=True)
+
+            if time_limit is None:
+                time_left_for_prediction = None
+            else:
+                time_left_for_prediction = time_limit - (time.time() - global_fit_start_time)
+
+            model.score_and_cache_oof(
+                val_fold, store_val_score=True, store_predict_time=True, time_limit=time_left_for_prediction
+            )
 
             oof_predictions_per_window.append(model.get_oof_predictions()[0])
 

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/models/presets.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, List, 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 . import (
     ADIDAModel,
@@ -133,6 +134,7 @@ def get_default_hps(key):
             "RecursiveTabular": {},
             "DirectTabular": {},
             "TemporalFusionTransformer": {},
+            "Chronos": {"model_path": "bolt-small"},
         },
         "light_inference": {
             "SeasonalNaive": {},
@@ -145,18 +147,33 @@ def get_default_hps(key):
             "SeasonalNaive": {},
             "Croston": {},
             "AutoETS": {},
-            "AutoARIMA": {},
             "NPTS": {},
             "DynamicOptimizedTheta": {},
-            # TODO: Define separate model for each tabular submodel?
-            "RecursiveTabular": {
-                "tabular_hyperparameters": {"NN_TORCH": {"proc.impute_strategy": "constant"}, "GBM": {}},
-            },
+            "RecursiveTabular": {},
             "DirectTabular": {},
             "TemporalFusionTransformer": {},
             "PatchTST": {},
             "DeepAR": {},
-            "Chronos": {"model_path": "base"},
+            "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]
@@ -170,6 +187,7 @@ def get_preset_models(
     eval_metric_seasonal_period: Optional[int],
     hyperparameters: Union[str, Dict, None],
     hyperparameter_tune: bool,
+    metadata: CovariateMetadata,
     all_assigned_names: List[str],
     excluded_model_types: List[str],
     multi_window: bool = False,
@@ -247,6 +265,7 @@ def get_preset_models(
                 prediction_length=prediction_length,
                 eval_metric=eval_metric,
                 eval_metric_seasonal_period=eval_metric_seasonal_period,
+                metadata=metadata,
                 hyperparameters=model_hps,
                 **kwargs,
             )

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/predictor.py

@@ -217,6 +217,7 @@ class TimeSeriesPredictor(TimeSeriesPredictorDeprecatedMixin):
                 prediction_length=self.prediction_length,
                 quantile_levels=self.quantile_levels,
                 cache_predictions=self.cache_predictions,
+                ensemble_model_type=kwargs.pop("ensemble_model_type", None),
             )
         )
         # Using `TimeSeriesLearner` as default argument breaks doc generation with Sphnix

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/trainer/abstract_trainer.py

@@ -29,7 +29,7 @@ from autogluon.timeseries.utils.features import (
     CovariateMetadata,
     PermutationFeatureImportanceTransform,
 )
-from autogluon.timeseries.utils.warning_filters import disable_tqdm
+from autogluon.timeseries.utils.warning_filters import disable_tqdm, warning_filter
 
 logger = logging.getLogger("autogluon.timeseries.trainer")
 
@@ -264,6 +264,7 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         val_splitter: Optional[AbstractWindowSplitter] = None,
         refit_every_n_windows: Optional[int] = 1,
         cache_predictions: bool = True,
+        ensemble_model_type: Optional[Type] = None,
         **kwargs,
     ):
         super().__init__(path=path, save_data=save_data, low_memory=True, **kwargs)
@@ -276,7 +277,13 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
         self.skip_model_selection = skip_model_selection
         # Ensemble cannot be fit if val_scores are not computed
         self.enable_ensemble = enable_ensemble and not skip_model_selection
-        self.ensemble_model_type = TimeSeriesGreedyEnsemble
+        if ensemble_model_type is None:
+            ensemble_model_type = TimeSeriesGreedyEnsemble
+        else:
+            logger.warning(
+                "Using a custom `ensemble_model_type` is experimental functionality that may break in future versions."
+            )
+        self.ensemble_model_type = ensemble_model_type
 
         self.verbosity = verbosity
 
@@ -519,8 +526,12 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
             fit_end_time = time.time()
             model.fit_time = model.fit_time or (fit_end_time - fit_start_time)
 
+            if time_limit is not None:
+                time_limit = fit_end_time - fit_start_time
             if val_data is not None and not self.skip_model_selection:
-                model.score_and_cache_oof(val_data, store_val_score=True, store_predict_time=True)
+                model.score_and_cache_oof(
+                    val_data, store_val_score=True, store_predict_time=True, time_limit=time_limit
+                )
 
             self._log_scores_and_times(model.val_score, model.fit_time, model.predict_time)
 
@@ -736,7 +747,8 @@ class AbstractTimeSeriesTrainer(SimpleAbstractTrainer):
             quantile_levels=self.quantile_levels,
             metadata=self.metadata,
         )
-        ensemble.fit_ensemble(model_preds, data_per_window=data_per_window, time_limit=time_limit)
+        with warning_filter():
+            ensemble.fit_ensemble(model_preds, data_per_window=data_per_window, time_limit=time_limit)
         ensemble.fit_time = time.time() - time_start
 
         predict_time = 0

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon/timeseries/version.py

@@ -1,3 +1,3 @@
 """This is the autogluon version file."""
-__version__ = '1.1.2b20241118'
+__version__ = '1.1.2b20241120'
 __lite__ = False

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon.timeseries.egg-info/PKG-INFO

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

{autogluon.timeseries-1.1.2b20241118 → autogluon.timeseries-1.1.2b20241120}/src/autogluon.timeseries.egg-info/requires.txt

@@ -17,9 +17,9 @@ fugue>=0.9.0
 tqdm<5,>=4.38
 orjson~=3.9
 tensorboard<3,>=2.9
-autogluon.core[raytune]==1.1.2b20241118
-autogluon.common==1.1.2b20241118
-autogluon.tabular[catboost,lightgbm,xgboost]==1.1.2b20241118
+autogluon.core[raytune]==1.1.2b20241120
+autogluon.common==1.1.2b20241120
+autogluon.tabular[catboost,lightgbm,xgboost]==1.1.2b20241120
 
 [all]
 optimum[onnxruntime]<1.20,>=1.17