autogluon.timeseries 1.4.1b20251206__tar.gz → 1.5.1b20260117__tar.gz

{autogluon_timeseries-1.4.1b20251206/src/autogluon.timeseries.egg-info → autogluon_timeseries-1.5.1b20260117}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autogluon.timeseries
-Version: 1.4.1b20251206
+Version: 1.5.1b20260117
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -53,22 +53,22 @@ Requires-Dist: fugue>=0.9.0
 Requires-Dist: tqdm<5,>=4.38
 Requires-Dist: orjson~=3.9
 Requires-Dist: einops<1,>=0.7
-Requires-Dist: chronos-forecasting<3,>=2.2.0rc4
+Requires-Dist: chronos-forecasting<2.4,>=2.2.2
 Requires-Dist: peft<0.18,>=0.13.0
 Requires-Dist: tensorboard<3,>=2.9
-Requires-Dist: autogluon.core==1.4.1b20251206
-Requires-Dist: autogluon.common==1.4.1b20251206
-Requires-Dist: autogluon.features==1.4.1b20251206
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.4.1b20251206
+Requires-Dist: autogluon.core==1.5.1b20260117
+Requires-Dist: autogluon.common==1.5.1b20260117
+Requires-Dist: autogluon.features==1.5.1b20260117
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.5.1b20260117
 Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: ruff>=0.0.285; extra == "tests"
 Requires-Dist: flaky<4,>=3.7; extra == "tests"
 Requires-Dist: pytest-timeout<3,>=2.1; extra == "tests"
 Provides-Extra: ray
-Requires-Dist: autogluon.core[raytune]==1.4.1b20251206; extra == "ray"
+Requires-Dist: autogluon.core[raytune]==1.5.1b20260117; extra == "ray"
 Provides-Extra: all
-Requires-Dist: autogluon.core[raytune]==1.4.1b20251206; extra == "all"
+Requires-Dist: autogluon.core[raytune]==1.5.1b20260117; extra == "all"
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

{autogluon_timeseries-1.4.1b20251206 → autogluon_timeseries-1.5.1b20260117}/setup.py

@@ -42,7 +42,7 @@ install_requires = [
     "tqdm",  # version range defined in `core/_setup_utils.py`
     "orjson~=3.9",  # use faster JSON implementation in GluonTS
     "einops>=0.7,<1",  # required by Chronos-2 and Toto
-    "chronos-forecasting>=2.2.0rc4,<3",
+    "chronos-forecasting>=2.2.2,<2.4",
     "peft>=0.13.0,<0.18",  # version range same as in chronos-forecasting[extras]
     "tensorboard>=2.9,<3",  # fixes https://github.com/autogluon/autogluon/issues/3612
     f"autogluon.core=={version}",

autogluon_timeseries-1.5.1b20260117/src/autogluon/timeseries/configs/hyperparameter_presets.py

@@ -0,0 +1,47 @@
+from typing import Any
+
+
+def get_hyperparameter_presets() -> dict[str, dict[str, 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": {
+            "SeasonalNaive": {},
+            "ETS": {},
+            "Theta": {},
+            "RecursiveTabular": {},
+            "DirectTabular": {},
+            "TemporalFusionTransformer": {},
+            "Chronos2": {"model_path": "autogluon/chronos-2-small"},
+        },
+        "default": {
+            "SeasonalNaive": {},
+            "AutoETS": {},
+            "DynamicOptimizedTheta": {},
+            "RecursiveTabular": {},
+            "DirectTabular": {},
+            "TemporalFusionTransformer": {},
+            "DeepAR": {},
+            "Chronos2": [
+                {},
+                {
+                    "ag_args": {"name_suffix": "SmallFineTuned"},
+                    "model_path": "autogluon/chronos-2-small",
+                    "fine_tune": True,
+                    "eval_during_fine_tune": True,
+                },
+            ],
+            "Chronos": {
+                "ag_args": {"name_suffix": "WithRegressor"},
+                "model_path": "bolt_small",
+                "target_scaler": "standard",
+                "covariate_regressor": {"model_name": "CAT", "model_hyperparameters": {"iterations": 1000}},
+            },
+        },
+    }

{autogluon_timeseries-1.4.1b20251206 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/configs/predictor_presets.py

@@ -2,10 +2,7 @@
 
 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",
@@ -16,13 +13,33 @@ TIMESERIES_PRESETS_ALIASES = dict(
 
 
 def get_predictor_presets() -> dict[str, Any]:
-    hp_presets = get_hyperparameter_presets()
-
     predictor_presets = dict(
-        best_quality={"hyperparameters": "default", "num_val_windows": 2},
+        best_quality={"hyperparameters": "default", "num_val_windows": "auto", "refit_every_n_windows": "auto"},
         high_quality={"hyperparameters": "default"},
         medium_quality={"hyperparameters": "light"},
         fast_training={"hyperparameters": "very_light"},
+        # Chronos-2 models
+        chronos2={
+            "hyperparameters": {"Chronos2": {"model_path": "autogluon/chronos-2"}},
+            "skip_model_selection": True,
+        },
+        chronos2_small={
+            "hyperparameters": {"Chronos2": {"model_path": "autogluon/chronos-2-small"}},
+            "skip_model_selection": True,
+        },
+        chronos2_ensemble={
+            "hyperparameters": {
+                "Chronos2": [
+                    {"model_path": "autogluon/chronos-2", "ag_args": {"name_suffix": "ZeroShot"}},
+                    {
+                        "model_path": "autogluon/chronos-2-small",
+                        "fine_tune": True,
+                        "eval_during_fine_tune": True,
+                        "ag_args": {"name_suffix": "SmallFineTuned"},
+                    },
+                ]
+            },
+        },
         # Chronos-Bolt models
         bolt_tiny={
             "hyperparameters": {"Chronos": {"model_path": "bolt_tiny"}},
@@ -40,39 +57,6 @@ def get_predictor_presets() -> dict[str, Any]:
             "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

{autogluon_timeseries-1.4.1b20251206 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/learner.py

@@ -58,8 +58,9 @@ class TimeSeriesLearner(AbstractLearner):
         hyperparameters: str | dict,
         val_data: TimeSeriesDataFrame | None = None,
         hyperparameter_tune_kwargs: str | dict | None = None,
+        ensemble_hyperparameters: dict[str, Any] | list[dict[str, Any]] | None = None,
         time_limit: float | None = None,
-        num_val_windows: int = 1,
+        num_val_windows: tuple[int, ...] = (1,),
         val_step_size: int | None = None,
         refit_every_n_windows: int | None = 1,
         random_seed: int | None = None,
@@ -112,6 +113,7 @@ class TimeSeriesLearner(AbstractLearner):
             val_data=val_data,
             hyperparameters=hyperparameters,
             hyperparameter_tune_kwargs=hyperparameter_tune_kwargs,
+            ensemble_hyperparameters=ensemble_hyperparameters,
             excluded_model_types=kwargs.get("excluded_model_types"),
             time_limit=time_limit,
             random_seed=random_seed,

{autogluon_timeseries-1.4.1b20251206 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -668,7 +668,6 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
         pass
 
     def _preprocess_time_limit(self, time_limit: float) -> float:
-        original_time_limit = time_limit
         max_time_limit_ratio = self._extra_ag_args.get("max_time_limit_ratio", self.default_max_time_limit_ratio)
         max_time_limit = self._extra_ag_args.get("max_time_limit")
 
@@ -677,16 +676,6 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, metaclass=
         if max_time_limit is not None:
             time_limit = min(time_limit, max_time_limit)
 
-        if original_time_limit != time_limit:
-            time_limit_og_str = f"{original_time_limit:.2f}s" if original_time_limit is not None else "None"
-            time_limit_str = f"{time_limit:.2f}s" if time_limit is not None else "None"
-            logger.debug(
-                f"\tTime limit adjusted due to model hyperparameters: "
-                f"{time_limit_og_str} -> {time_limit_str} "
-                f"(ag.max_time_limit={max_time_limit}, "
-                f"ag.max_time_limit_ratio={max_time_limit_ratio}"
-            )
-
         return time_limit
 
     def _get_search_space(self):

{autogluon_timeseries-1.4.1b20251206 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/models/abstract/model_trial.py

@@ -76,7 +76,8 @@ def fit_and_save_model(model, fit_kwargs, train_data, val_data, eval_metric, tim
     time_fit_start = time.time()
     model.fit(train_data=train_data, val_data=val_data, time_limit=time_left, **fit_kwargs)
     model.fit_time = time.time() - time_fit_start
-    model.score_and_cache_oof(val_data, store_val_score=True, store_predict_time=True)
+    if val_data is not None:
+        model.score_and_cache_oof(val_data, store_val_score=True, store_predict_time=True)
 
     logger.debug(f"\tHyperparameter tune run: {model.name}")
     logger.debug(f"\t\t{model.val_score:<7.4f}".ljust(15) + f"= Validation score ({eval_metric.name_with_sign})")

{autogluon_timeseries-1.4.1b20251206 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/models/autogluon_tabular/per_step.py

@@ -80,7 +80,7 @@ class PerStepTabularModel(AbstractTimeSeriesModel):
         If None, automatically determined based on available memory to prevent OOM errors.
     """
 
-    ag_priority = 70
+    ag_priority = 80
     _dummy_freq = "D"
 
     def __init__(self, *args, **kwargs):

{autogluon_timeseries-1.4.1b20251206 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/models/chronos/chronos2.py

@@ -74,9 +74,16 @@ class Chronos2Model(AbstractTimeSeriesModel):
         a default configuration will be used. Example: ``{"r": 8, "lora_alpha": 16}``.
     fine_tune_trainer_kwargs : dict, optional
         Extra keyword arguments passed to ``transformers.TrainingArguments``
+    revision : str, default = None
+        Model revision to use (branch name or commit hash). If None, the default branch (usually "main") is used.
+    disable_known_covariates : bool, default = False
+        If True, known covariates won't be used by the model even if they are present in the dataset.
+    disable_past_covariates : bool, default = False
+        If True, past covariates won't be used by the model even if they are present in the dataset.
     """
 
     ag_model_aliases = ["Chronos-2"]
+    ag_priority = 75
     fine_tuned_ckpt_name: str = "fine-tuned-ckpt"
 
     _supports_known_covariates = True
@@ -140,7 +147,7 @@ class Chronos2Model(AbstractTimeSeriesModel):
         self.load_model_pipeline()
 
         # NOTE: This must be placed after load_model_pipeline to ensure that the loggers are available in loggerDict
-        self._update_transformers_loggers(logging.ERROR if verbosity <= 3 else logging.INFO)
+        self._update_transformers_loggers(logging.ERROR if verbosity <= 3 else logging.WARNING)
 
         if self.get_hyperparameter("fine_tune"):
             self._fine_tune(train_data, val_data, time_limit=time_limit, verbosity=verbosity)
@@ -172,6 +179,9 @@ class Chronos2Model(AbstractTimeSeriesModel):
             "eval_during_fine_tune": False,
             "fine_tune_eval_max_items": 256,
             "fine_tune_lora_config": None,
+            "revision": None,
+            "disable_known_covariates": False,
+            "disable_past_covariates": False,
         }
 
     @property
@@ -192,14 +202,35 @@ class Chronos2Model(AbstractTimeSeriesModel):
             "fine_tune_eval_max_items",
             "fine_tune_lora_config",
             "fine_tune_trainer_kwargs",
+            "revision",
+            "disable_known_covariates",
+            "disable_past_covariates",
         ]
 
+    def _remove_disabled_covariates(
+        self, past_df: pd.DataFrame, future_df: pd.DataFrame | None
+    ) -> tuple[pd.DataFrame, pd.DataFrame | None]:
+        """Remove covariates from dataframes based on disable flags."""
+        cols_to_remove = []
+        if self.get_hyperparameter("disable_past_covariates"):
+            cols_to_remove.extend(self.covariate_metadata.past_covariates)
+        if self.get_hyperparameter("disable_known_covariates"):
+            cols_to_remove.extend(self.covariate_metadata.known_covariates)
+            future_df = None
+
+        if cols_to_remove:
+            past_df = past_df.drop(columns=cols_to_remove)
+
+        return past_df, future_df
+
     def _predict(
         self,
         data: TimeSeriesDataFrame,
         known_covariates: TimeSeriesDataFrame | None = None,
         **kwargs,
     ) -> TimeSeriesDataFrame:
+        from .utils import timeout_callback
+
         if self._model_pipeline is None:
             self.load_model_pipeline()
         assert self._model_pipeline is not None
@@ -220,6 +251,9 @@ class Chronos2Model(AbstractTimeSeriesModel):
         cross_learning = self.get_hyperparameter("cross_learning")
         context_length = self.get_hyperparameter("context_length")
         future_df = known_covariates.reset_index().to_data_frame() if known_covariates is not None else None
+        time_limit = kwargs.get("time_limit")
+
+        context_df, future_df = self._remove_disabled_covariates(context_df, future_df)
 
         forecast_df = self._model_pipeline.predict_df(
             df=context_df,
@@ -231,6 +265,7 @@ class Chronos2Model(AbstractTimeSeriesModel):
             batch_size=batch_size,
             validate_inputs=False,
             cross_learning=cross_learning,
+            after_batch=timeout_callback(time_limit),
         )
 
         forecast_df = forecast_df.rename(columns={"predictions": "mean"}).drop(columns="target_name")
@@ -243,7 +278,11 @@ class Chronos2Model(AbstractTimeSeriesModel):
         device = (self.get_hyperparameter("device") or "cuda") if self._is_gpu_available() else "cpu"
 
         assert self.model_path is not None
-        pipeline = Chronos2Pipeline.from_pretrained(self.model_path, device_map=device)
+        pipeline = Chronos2Pipeline.from_pretrained(
+            self.model_path,
+            device_map=device,
+            revision=self.get_hyperparameter("revision"),
+        )
 
         self._model_pipeline = pipeline
 
@@ -269,8 +308,11 @@ class Chronos2Model(AbstractTimeSeriesModel):
         from .utils import LoggerCallback, TimeLimitCallback
 
         def convert_data(df: TimeSeriesDataFrame):
+            past_df = df.reset_index().to_data_frame()
+            past_df, _ = self._remove_disabled_covariates(past_df, None)
+
             inputs, _, _ = convert_df_input_to_list_of_dicts_input(
-                df=df.reset_index().to_data_frame(),
+                df=past_df,
                 future_df=None,
                 target_columns=[self.target],
                 prediction_length=self.prediction_length,
@@ -280,13 +322,13 @@ class Chronos2Model(AbstractTimeSeriesModel):
             # The above utility will only split the dataframe into target and past_covariates, where past_covariates contains
             # past values of both past-only and known-future covariates. We need to add future_covariates to enable fine-tuning
             # with known covariates by indicating which covariates are known in the future.
-            known_covariates = self.covariate_metadata.known_covariates
-
-            if len(known_covariates) > 0:
-                for input_dict in inputs:
-                    # NOTE: the covariates are empty because the actual values are not used
-                    # This only indicates which covariates are known in the future
-                    input_dict["future_covariates"] = {name: np.array([]) for name in known_covariates}
+            if not self.get_hyperparameter("disable_known_covariates"):
+                known_covariates = self.covariate_metadata.known_covariates
+                if len(known_covariates) > 0:
+                    for input_dict in inputs:
+                        # NOTE: the covariates are empty because the actual values are not used
+                        # This only indicates which covariates are known in the future
+                        input_dict["future_covariates"] = {name: np.array([]) for name in known_covariates}
 
             return inputs
 

{autogluon_timeseries-1.4.1b20251206 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/models/chronos/model.py

@@ -186,6 +186,8 @@ class ChronosModel(AbstractTimeSeriesModel):
         Extra keyword arguments passed to ``transformers.TrainingArguments``
     keep_transformers_logs : bool, default = False
         If True, the logs generated by transformers will NOT be removed after fine-tuning
+    revision : str, default = None
+        Model revision to use (branch name or commit hash). If None, the default branch (usually "main") is used.
     """
 
     ag_priority = 55
@@ -319,6 +321,7 @@ class ChronosModel(AbstractTimeSeriesModel):
             self.model_path,
             device_map=device,
             torch_dtype=self.torch_dtype,
+            revision=self.get_hyperparameter("revision"),
         )
 
         self._model_pipeline = pipeline
@@ -361,6 +364,7 @@ class ChronosModel(AbstractTimeSeriesModel):
             "eval_during_fine_tune": False,
             "fine_tune_eval_max_items": 256,
             "fine_tune_shuffle_buffer_size": 10_000,
+            "revision": None,
         }
 
     @property
@@ -382,6 +386,7 @@ class ChronosModel(AbstractTimeSeriesModel):
             "fine_tune_eval_max_items",
             "fine_tune_trainer_kwargs",
             "keep_transformers_logs",
+            "revision",
         ]
 
     def _get_fine_tune_trainer_kwargs(self, init_args, eval_during_fine_tune: bool):
@@ -466,7 +471,7 @@ class ChronosModel(AbstractTimeSeriesModel):
         for logger_name in logging.root.manager.loggerDict:
             if "transformers" in logger_name:
                 transformers_logger = logging.getLogger(logger_name)
-                transformers_logger.setLevel(logging.ERROR if verbosity <= 3 else logging.INFO)
+                transformers_logger.setLevel(logging.ERROR if verbosity <= 3 else logging.WARNING)
 
         self._check_fit_params()
         self._log_unused_hyperparameters()
@@ -634,7 +639,7 @@ class ChronosModel(AbstractTimeSeriesModel):
             batch_size=batch_size,
             shuffle=False,
             num_workers=num_workers,
-            on_batch=timeout_callback(seconds=time_limit),
+            after_batch=timeout_callback(seconds=time_limit),
         )
 
     def _get_context_length(self, data: TimeSeriesDataFrame) -> int:

{autogluon_timeseries-1.4.1b20251206 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/models/chronos/utils.py

@@ -255,7 +255,7 @@ class ChronosInferenceDataset:
 
 class ChronosInferenceDataLoader(torch.utils.data.DataLoader):
     def __init__(self, *args, **kwargs):
-        self.callback: Callable = kwargs.pop("on_batch", lambda: None)
+        self.callback: Callable = kwargs.pop("after_batch", lambda: None)
         super().__init__(*args, **kwargs)
 
     def __iter__(self):  # type: ignore

{autogluon_timeseries-1.4.1b20251206 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/models/ensemble/__init__.py

@@ -6,19 +6,21 @@ from .weighted import GreedyEnsemble, PerformanceWeightedEnsemble, SimpleAverage
 
 def get_ensemble_class(name: str):
     mapping = {
-        "GreedyEnsemble": GreedyEnsemble,
-        "PerItemGreedyEnsemble": PerItemGreedyEnsemble,
-        "PerformanceWeightedEnsemble": PerformanceWeightedEnsemble,
-        "SimpleAverageEnsemble": SimpleAverageEnsemble,
-        "WeightedEnsemble": GreedyEnsemble,  # old alias for this model
-        "MedianEnsemble": MedianEnsemble,
-        "TabularEnsemble": TabularEnsemble,
-        "PerQuantileTabularEnsemble": PerQuantileTabularEnsemble,
-        "LinearStackerEnsemble": LinearStackerEnsemble,
+        "Greedy": GreedyEnsemble,
+        "PerItemGreedy": PerItemGreedyEnsemble,
+        "PerformanceWeighted": PerformanceWeightedEnsemble,
+        "SimpleAverage": SimpleAverageEnsemble,
+        "Weighted": GreedyEnsemble,  # old alias for this model
+        "Median": MedianEnsemble,
+        "Tabular": TabularEnsemble,
+        "PerQuantileTabular": PerQuantileTabularEnsemble,
+        "LinearStacker": LinearStackerEnsemble,
     }
-    if name not in mapping:
+
+    name_clean = name.removesuffix("Ensemble")
+    if name_clean not in mapping:
         raise ValueError(f"Unknown ensemble type: {name}. Available: {list(mapping.keys())}")
-    return mapping[name]
+    return mapping[name_clean]
 
 
 __all__ = [

{autogluon_timeseries-1.4.1b20251206 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/models/ensemble/abstract.py

@@ -11,7 +11,12 @@ logger = logging.getLogger(__name__)
 
 
 class AbstractTimeSeriesEnsembleModel(TimeSeriesModelBase, ABC):
-    """Abstract class for time series ensemble models."""
+    """Abstract base class for time series ensemble models that combine predictions from multiple base models.
+
+    Ensemble training process operates on validation predictions from base models rather than raw time series
+    data. This allows the ensemble to learn optimal combination strategies based on each model's performance
+    across different validation windows and time series patterns.
+    """
 
     @property
     @abstractmethod
@@ -49,7 +54,7 @@ class AbstractTimeSeriesEnsembleModel(TimeSeriesModelBase, ABC):
             )
             raise TimeLimitExceeded
         if isinstance(data_per_window, TimeSeriesDataFrame):
-            raise ValueError("When fitting ensemble, `data` should contain ground truth for each validation window")
+            raise ValueError("When fitting ensemble, ``data`` should contain ground truth for each validation window")
         num_val_windows = len(data_per_window)
         for model, preds in predictions_per_window.items():
             if len(preds) != num_val_windows:
@@ -69,8 +74,8 @@ class AbstractTimeSeriesEnsembleModel(TimeSeriesModelBase, ABC):
         model_scores: dict[str, float] | None = None,
         time_limit: float | None = None,
     ) -> None:
-        """Private method for `fit`. See `fit` for documentation of arguments. Apart from the model
-        training logic, `fit` additionally implements other logic such as keeping track of the time limit.
+        """Private method for ``fit``. See ``fit`` for documentation of arguments. Apart from the model
+        training logic, ``fit`` additionally implements other logic such as keeping track of the time limit.
         """
         raise NotImplementedError
 

{autogluon_timeseries-1.4.1b20251206 → autogluon_timeseries-1.5.1b20260117}/src/autogluon/timeseries/models/ensemble/array_based/abstract.py

@@ -12,15 +12,19 @@ from .regressor import EnsembleRegressor
 
 
 class ArrayBasedTimeSeriesEnsembleModel(AbstractTimeSeriesEnsembleModel, ABC):
-    """Abstract base class for time series ensemble models which operate on arrays of base model
-    predictions for training and inference.
+    """Abstract base class for ensemble models that operate on multi-dimensional arrays of base model predictions.
+
+    Array-based ensembles convert time series predictions into structured numpy arrays for efficient processing
+    and enable sophisticated combination strategies beyond simple weighted averaging. Array-based ensembles also
+    support isotonization in quantile forecasts--ensuring quantile crossing does not occur. They also have built-in
+    failed model detection and filtering capabilities.
 
     Other Parameters
     ----------------
-    isotonization: str, default = "sort"
+    isotonization : str, default = "sort"
         The isotonization method to use (i.e. the algorithm to prevent quantile non-crossing).
         Currently only "sort" is supported.
-    detect_and_ignore_failures: bool, default = True
+    detect_and_ignore_failures : bool, default = True
         Whether to detect and ignore "failed models", defined as models which have a loss that is larger
         than 10x the median loss of all the models. This can be very important for the regression-based
         ensembles, as moving the weight from such a "failed model" to zero can require a long training
@@ -67,8 +71,8 @@ class ArrayBasedTimeSeriesEnsembleModel(AbstractTimeSeriesEnsembleModel, ABC):
         Parameters
         ----------
         df
-            TimeSeriesDataFrame to convert to an array. Must contain exactly `prediction_length`
-            values for each item. The columns of `df` can correspond to ground truth values
+            TimeSeriesDataFrame to convert to an array. Must contain exactly ``prediction_length``
+            values for each item. The columns of ``df`` can correspond to ground truth values
             or predictions (in which case, these will be the mean or quantile forecasts).
 
         Returns