autogluon.timeseries 1.2.1b20250422__py3-none-any.whl → 1.2.1b20250423__py3-none-any.whl

autogluon/timeseries/models/ensemble/{greedy_ensemble.py → greedy.py}

@@ -9,9 +9,10 @@ import autogluon.core as ag
 from autogluon.core.models.greedy_ensemble.ensemble_selection import EnsembleSelection
 from autogluon.timeseries import TimeSeriesDataFrame
 from autogluon.timeseries.metrics import TimeSeriesScorer
-from autogluon.timeseries.models.ensemble import AbstractTimeSeriesEnsembleModel
 from autogluon.timeseries.utils.datetime import get_seasonality
 
+from .abstract import AbstractWeightedTimeSeriesEnsembleModel
+
 logger = logging.getLogger(__name__)
 
 
@@ -24,16 +25,15 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         sorted_initialization: bool = False,
         bagging: bool = False,
         tie_breaker: str = "random",
-        random_state: np.random.RandomState = None,
+        random_state: Optional[np.random.RandomState] = None,
         prediction_length: int = 1,
         target: str = "target",
-        eval_metric_seasonal_period: Optional[int] = None,
-        horizon_weight: Optional[np.ndarray] = None,
+        eval_metric_seasonal_period: int = 1,
         **kwargs,
     ):
         super().__init__(
             ensemble_size=ensemble_size,
-            metric=metric,
+            metric=metric,  # type: ignore
             problem_type=problem_type,
             sorted_initialization=sorted_initialization,
             bagging=bagging,
@@ -44,14 +44,33 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         self.prediction_length = prediction_length
         self.target = target
         self.eval_metric_seasonal_period = eval_metric_seasonal_period
-        self.horizon_weight = horizon_weight
+        self.metric: TimeSeriesScorer
 
-    def _fit(
+        self.dummy_pred_per_window = []
+        self.scorer_per_window = []
+
+        self.dummy_pred_per_window: Optional[List[TimeSeriesDataFrame]]
+        self.scorer_per_window: Optional[List[TimeSeriesScorer]]
+        self.data_future_per_window: Optional[List[TimeSeriesDataFrame]]
+
+    def fit(  # type: ignore
         self,
-        predictions: List[List[TimeSeriesDataFrame]],  # first dim: model, second dim: val window index
+        predictions: List[List[TimeSeriesDataFrame]],
         labels: List[TimeSeriesDataFrame],
-        time_limit: Optional[int] = None,
-        sample_weight=None,
+        time_limit: Optional[float] = None,
+    ):
+        return super().fit(
+            predictions=predictions,  # type: ignore
+            labels=labels,  # type: ignore
+            time_limit=time_limit,
+        )
+
+    def _fit(  # type: ignore
+        self,
+        predictions: List[List[TimeSeriesDataFrame]],
+        labels: List[TimeSeriesDataFrame],
+        time_limit: Optional[float] = None,
+        sample_weight: Optional[List[float]] = None,
     ):
         # Stack predictions for each model into a 3d tensor of shape [num_val_windows, num_rows, num_cols]
         stacked_predictions = [np.stack(preds) for preds in predictions]
@@ -77,26 +96,33 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
 
         super()._fit(
             predictions=stacked_predictions,
-            labels=data_future,
+            labels=data_future,  # type: ignore
             time_limit=time_limit,
         )
         self.dummy_pred_per_window = None
         self.evaluator_per_window = None
         self.data_future_per_window = None
 
-    def _calculate_regret(self, y_true, y_pred_proba, metric=None, sample_weight=None):  # noqa
+    def _calculate_regret(  # type: ignore
+        self,
+        y_true,
+        y_pred_proba,
+        metric: TimeSeriesScorer,
+        sample_weight=None,
+    ):
         # Compute average score across all validation windows
         total_score = 0.0
+
+        assert self.data_future_per_window is not None
+        assert self.dummy_pred_per_window is not None
+        assert self.scorer_per_window is not None
+
         for window_idx, data_future in enumerate(self.data_future_per_window):
             dummy_pred = self.dummy_pred_per_window[window_idx]
             dummy_pred[list(dummy_pred.columns)] = y_pred_proba[window_idx]
             # We use scorer.compute_metric instead of scorer.score to avoid repeated calls to scorer.save_past_metrics
             metric_value = self.scorer_per_window[window_idx].compute_metric(
-                data_future,
-                dummy_pred,
-                target=self.target,
-                prediction_length=self.prediction_length,
-                horizon_weight=self.horizon_weight,
+                data_future, dummy_pred, target=self.target
             )
             total_score += metric.sign * metric_value
         avg_score = total_score / len(self.data_future_per_window)
@@ -104,32 +130,46 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         return -avg_score
 
 
-class TimeSeriesGreedyEnsemble(AbstractTimeSeriesEnsembleModel):
-    """Constructs a weighted ensemble using the greedy Ensemble Selection algorithm."""
+class GreedyEnsemble(AbstractWeightedTimeSeriesEnsembleModel):
+    """Constructs a weighted ensemble using the greedy Ensemble Selection algorithm by
+    Caruana et al. [Car2004]
+
+    Other Parameters
+    ----------------
+    ensemble_size: int, default = 100
+        Number of models (with replacement) to include in the ensemble.
+
+    References
+    ----------
+    .. [Car2024] Caruana, Rich, et al. "Ensemble selection from libraries of models."
+        Proceedings of the twenty-first international conference on Machine learning. 2004.
+    """
 
-    def __init__(self, name: Optional[str] = None, ensemble_size: int = 100, **kwargs):
+    def __init__(self, name: Optional[str] = None, **kwargs):
         if name is None:
+            # FIXME: the name here is kept for backward compatibility. it will be called
+            # GreedyEnsemble in v1.4 once ensemble choices are exposed
             name = "WeightedEnsemble"
         super().__init__(name=name, **kwargs)
-        self.ensemble_size = ensemble_size
-        self.model_to_weight: Dict[str, float] = {}
 
-    def _fit_ensemble(
+    def _get_default_hyperparameters(self) -> Dict:
+        return {"ensemble_size": 100}
+
+    def _fit(
         self,
         predictions_per_window: Dict[str, List[TimeSeriesDataFrame]],
         data_per_window: List[TimeSeriesDataFrame],
-        time_limit: Optional[int] = None,
-        **kwargs,
+        model_scores: Optional[Dict[str, float]] = None,
+        time_limit: Optional[float] = None,
     ):
         if self.eval_metric_seasonal_period is None:
             self.eval_metric_seasonal_period = get_seasonality(self.freq)
         ensemble_selection = TimeSeriesEnsembleSelection(
-            ensemble_size=self.ensemble_size,
+            ensemble_size=self.get_hyperparameters()["ensemble_size"],
             metric=self.eval_metric,
             prediction_length=self.prediction_length,
             target=self.target,
             eval_metric_seasonal_period=self.eval_metric_seasonal_period,
-            horizon_weight=self.horizon_weight,
         )
         ensemble_selection.fit(
             predictions=list(predictions_per_window.values()),
@@ -143,37 +183,3 @@ class TimeSeriesGreedyEnsemble(AbstractTimeSeriesEnsembleModel):
 
         weights_for_printing = {model: round(weight, 2) for model, weight in self.model_to_weight.items()}
         logger.info(f"\tEnsemble weights: {pprint.pformat(weights_for_printing, width=200)}")
-
-    @property
-    def model_names(self) -> List[str]:
-        return list(self.model_to_weight.keys())
-
-    @property
-    def model_weights(self) -> np.ndarray:
-        return np.array(list(self.model_to_weight.values()), dtype=np.float64)
-
-    def predict(self, data: Dict[str, Optional[TimeSeriesDataFrame]], **kwargs) -> TimeSeriesDataFrame:
-        if not set(self.model_names).issubset(set(data.keys())):
-            raise ValueError(
-                f"Set of models given for prediction in {self.name} differ from those provided during initialization."
-            )
-        for model_name, model_pred in data.items():
-            if model_pred is None:
-                raise RuntimeError(f"{self.name} cannot predict because base model {model_name} failed.")
-
-        # Make sure that all predictions have same shape
-        assert len(set(pred.shape for pred in data.values())) == 1
-
-        return sum(data[model_name] * weight for model_name, weight in self.model_to_weight.items())
-
-    def get_info(self) -> dict:
-        info = super().get_info()
-        info["model_weights"] = self.model_to_weight
-        return info
-
-    def remap_base_models(self, model_refit_map: Dict[str, str]) -> None:
-        updated_weights = {}
-        for model, weight in self.model_to_weight.items():
-            model_full_name = model_refit_map.get(model, model)
-            updated_weights[model_full_name] = weight
-        self.model_to_weight = updated_weights

autogluon/timeseries/models/presets.py

@@ -4,8 +4,6 @@ import re
 from collections import defaultdict
 from typing import Any, Dict, List, Optional, Type, Union
 
-import numpy as np
-
 from autogluon.common import space
 from autogluon.core import constants
 from autogluon.timeseries.metrics import TimeSeriesScorer
@@ -186,7 +184,6 @@ def get_preset_models(
     path: str,
     eval_metric: Union[str, TimeSeriesScorer],
     eval_metric_seasonal_period: Optional[int],
-    horizon_weight: Optional[np.ndarray],
     hyperparameters: Union[str, Dict, None],
     hyperparameter_tune: bool,
     covariate_metadata: CovariateMetadata,
@@ -265,7 +262,6 @@ def get_preset_models(
                 eval_metric=eval_metric,
                 eval_metric_seasonal_period=eval_metric_seasonal_period,
                 covariate_metadata=covariate_metadata,
-                horizon_weight=horizon_weight,
                 hyperparameters=model_hps,
                 **kwargs,
             )

autogluon/timeseries/predictor.py

@@ -24,7 +24,7 @@ from autogluon.timeseries import __version__ as current_ag_version
 from autogluon.timeseries.configs import TIMESERIES_PRESETS_CONFIGS
 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, check_get_horizon_weight
+from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_metric
 from autogluon.timeseries.splitter import ExpandingWindowSplitter
 from autogluon.timeseries.trainer import TimeSeriesTrainer
 from autogluon.timeseries.utils.forecast import make_future_data_frame
@@ -93,14 +93,6 @@ class TimeSeriesPredictor:
     eval_metric_seasonal_period : int, optional
         Seasonal period used to compute some evaluation metrics such as mean absolute scaled error (MASE). Defaults to
         ``None``, in which case the seasonal period is computed based on the data frequency.
-    horizon_weight : List[float], optional
-        Weight assigned to each time step in the forecast horizon when computing the `eval_metric`. If provided, this
-        must be a list with `prediction_length` non-negative values, where at least some values are greater than zero.
-        AutoGluon will automatically normalize the weights so that they sum up to `prediction_length`. By default, all
-        time steps in the forecast horizon have the same weight, which is equivalent to setting `horizon_weight = [1] * prediction_length`.
-
-        This parameter only affects model selection and ensemble construction; it has no effect on the loss function of
-        the individual forecasting models.
     known_covariates_names: List[str], optional
         Names of the covariates that are known in advance for all time steps in the forecast horizon. These are also
         known as dynamic features, exogenous variables, additional regressors or related time series. Examples of such
@@ -152,7 +144,6 @@ class TimeSeriesPredictor:
         freq: Optional[str] = None,
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
         eval_metric_seasonal_period: Optional[int] = None,
-        horizon_weight: list[float] | None = None,
         path: Optional[Union[str, Path]] = None,
         verbosity: int = 2,
         log_to_file: bool = True,
@@ -198,7 +189,6 @@ class TimeSeriesPredictor:
             self.freq = std_freq
         self.eval_metric = check_get_evaluation_metric(eval_metric)
         self.eval_metric_seasonal_period = eval_metric_seasonal_period
-        self.horizon_weight = check_get_horizon_weight(horizon_weight, prediction_length=self.prediction_length)
         if quantile_levels is None:
             quantile_levels = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
         self.quantile_levels = sorted(quantile_levels)
@@ -206,7 +196,6 @@ class TimeSeriesPredictor:
             path_context=self.path,
             eval_metric=eval_metric,
             eval_metric_seasonal_period=eval_metric_seasonal_period,
-            horizon_weight=self.horizon_weight,
             target=self.target,
             known_covariates_names=self.known_covariates_names,
             prediction_length=self.prediction_length,

autogluon/timeseries/trainer.py

@@ -19,8 +19,8 @@ from autogluon.core.utils.loaders import load_pkl
 from autogluon.core.utils.savers import save_pkl
 from autogluon.timeseries import TimeSeriesDataFrame
 from autogluon.timeseries.metrics import TimeSeriesScorer, check_get_evaluation_metric
-from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
-from autogluon.timeseries.models.ensemble import AbstractTimeSeriesEnsembleModel, TimeSeriesGreedyEnsemble
+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
@@ -34,7 +34,7 @@ from autogluon.timeseries.utils.warning_filters import disable_tqdm, warning_fil
 logger = logging.getLogger("autogluon.timeseries.trainer")
 
 
-class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
+class TimeSeriesTrainer(AbstractTrainer[TimeSeriesModelBase]):
     _cached_predictions_filename = "cached_predictions.pkl"
 
     max_rel_importance_score: float = 1e5
@@ -47,7 +47,6 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
         prediction_length: int = 1,
         eval_metric: Union[str, TimeSeriesScorer, None] = None,
         eval_metric_seasonal_period: Optional[int] = None,
-        horizon_weight: Optional[np.ndarray] = None,
         save_data: bool = True,
         skip_model_selection: bool = False,
         enable_ensemble: bool = True,
@@ -74,12 +73,12 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
         # Ensemble cannot be fit if val_scores are not computed
         self.enable_ensemble = enable_ensemble and not skip_model_selection
         if ensemble_model_type is None:
-            ensemble_model_type = TimeSeriesGreedyEnsemble
+            ensemble_model_type = GreedyEnsemble
         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.ensemble_model_type: Type[AbstractTimeSeriesEnsembleModel] = ensemble_model_type
 
         self.verbosity = verbosity
 
@@ -89,7 +88,6 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
 
         self.eval_metric: TimeSeriesScorer = check_get_evaluation_metric(eval_metric)
         self.eval_metric_seasonal_period = eval_metric_seasonal_period
-        self.horizon_weight = horizon_weight
         if val_splitter is None:
             val_splitter = ExpandingWindowSplitter(prediction_length=self.prediction_length)
         assert isinstance(val_splitter, AbstractWindowSplitter), "val_splitter must be of type AbstractWindowSplitter"
@@ -147,7 +145,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
 
     def _add_model(
         self,
-        model: AbstractTimeSeriesModel,
+        model: TimeSeriesModelBase,
         base_models: Optional[List[str]] = None,
     ):
         """Add a model to the model graph of the trainer. If the model is an ensemble, also add
@@ -155,7 +153,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
 
         Parameters
         ----------
-        model : AbstractTimeSeriesModel
+        model : TimeSeriesModelBase
             The model to be added to the model graph.
         base_models : List[str], optional, default None
             If the model is an ensemble, the list of base model names that are included in the ensemble.
@@ -444,6 +442,8 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
         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
@@ -560,20 +560,24 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
         return ensemble_name
 
     def fit_ensemble(
-        self, data_per_window: List[TimeSeriesDataFrame], model_names: List[str], time_limit: Optional[float] = None
+        self,
+        data_per_window: List[TimeSeriesDataFrame],
+        model_names: List[str],
+        time_limit: Optional[float] = None,
     ) -> str:
         logger.info("Fitting simple weighted ensemble.")
 
-        model_preds: Dict[str, List[TimeSeriesDataFrame]] = {}
+        predictions_per_window: Dict[str, List[TimeSeriesDataFrame]] = {}
+        base_model_scores = self.get_models_attribute_dict(attribute="val_score", models=self.get_model_names(0))
+
         for model_name in model_names:
-            model_preds[model_name] = self._get_model_oof_predictions(model_name=model_name)
+            predictions_per_window[model_name] = self._get_model_oof_predictions(model_name=model_name)
 
         time_start = time.time()
         ensemble = self.ensemble_model_type(
             name=self._get_ensemble_model_name(),
             eval_metric=self.eval_metric,
             eval_metric_seasonal_period=self.eval_metric_seasonal_period,
-            horizon_weight=self.horizon_weight,
             target=self.target,
             prediction_length=self.prediction_length,
             path=self.path,
@@ -582,7 +586,12 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
             covariate_metadata=self.covariate_metadata,
         )
         with warning_filter():
-            ensemble.fit_ensemble(model_preds, data_per_window=data_per_window, time_limit=time_limit)
+            ensemble.fit(
+                predictions_per_window=predictions_per_window,
+                data_per_window=data_per_window,
+                model_scores=base_model_scores,
+                time_limit=time_limit,
+            )
         ensemble.fit_time = time.time() - time_start
 
         predict_time = 0
@@ -592,7 +601,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
 
         score_per_fold = []
         for window_idx, data in enumerate(data_per_window):
-            predictions = ensemble.predict({n: model_preds[n][window_idx] for n in ensemble.model_names})
+            predictions = ensemble.predict({n: predictions_per_window[n][window_idx] for n in ensemble.model_names})
             score_per_fold.append(self._score_with_predictions(data, predictions))
         ensemble.val_score = float(np.mean(score_per_fold, dtype=np.float64))
 
@@ -737,7 +746,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
         return unpersisted_models
 
     def _get_model_for_prediction(
-        self, model: Optional[Union[str, AbstractTimeSeriesModel]] = None, verbose: bool = True
+        self, model: Optional[Union[str, TimeSeriesModelBase]] = None, verbose: bool = True
     ) -> str:
         """Given an optional identifier or model object, return the name of the model with which to predict.
 
@@ -754,7 +763,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
                 )
             return self.model_best
         else:
-            if isinstance(model, AbstractTimeSeriesModel):
+            if isinstance(model, TimeSeriesModelBase):
                 return model.name
             else:
                 if model not in self.get_model_names():
@@ -765,7 +774,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
         self,
         data: TimeSeriesDataFrame,
         known_covariates: Optional[TimeSeriesDataFrame] = None,
-        model: Optional[Union[str, AbstractTimeSeriesModel]] = None,
+        model: Optional[Union[str, TimeSeriesModelBase]] = None,
         use_cache: bool = True,
         random_seed: Optional[int] = None,
     ) -> TimeSeriesDataFrame:
@@ -796,13 +805,12 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
             prediction_length=self.prediction_length,
             target=self.target,
             seasonal_period=self.eval_metric_seasonal_period,
-            horizon_weight=self.horizon_weight,
         )
 
     def score(
         self,
         data: TimeSeriesDataFrame,
-        model: Optional[Union[str, AbstractTimeSeriesModel]] = None,
+        model: Optional[Union[str, TimeSeriesModelBase]] = None,
         metric: Union[str, TimeSeriesScorer, None] = None,
         use_cache: bool = True,
     ) -> float:
@@ -813,7 +821,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
     def evaluate(
         self,
         data: TimeSeriesDataFrame,
-        model: Optional[Union[str, AbstractTimeSeriesModel]] = None,
+        model: Optional[Union[str, TimeSeriesModelBase]] = None,
         metrics: Optional[Union[str, TimeSeriesScorer, List[Union[str, TimeSeriesScorer]]]] = None,
         use_cache: bool = True,
     ) -> Dict[str, float]:
@@ -835,7 +843,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
         self,
         data: TimeSeriesDataFrame,
         features: List[str],
-        model: Optional[Union[str, AbstractTimeSeriesModel]] = None,
+        model: Optional[Union[str, TimeSeriesModelBase]] = None,
         metric: Optional[Union[str, TimeSeriesScorer]] = None,
         time_limit: Optional[float] = None,
         method: Literal["naive", "permutation"] = "permutation",
@@ -938,7 +946,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
 
         return importance_df
 
-    def _model_uses_feature(self, model: Union[str, AbstractTimeSeriesModel], feature: str) -> bool:
+    def _model_uses_feature(self, model: Union[str, TimeSeriesModelBase], feature: str) -> bool:
         """Check if the given model uses the given feature."""
         models_with_ancestors = set(self.get_minimum_model_set(model))
 
@@ -980,7 +988,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
 
     def _predict_model(
         self,
-        model: Union[str, AbstractTimeSeriesModel],
+        model: Union[str, TimeSeriesModelBase],
         data: TimeSeriesDataFrame,
         model_pred_dict: Dict[str, Optional[TimeSeriesDataFrame]],
         known_covariates: Optional[TimeSeriesDataFrame] = None,
@@ -996,7 +1004,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
 
     def _get_inputs_to_model(
         self,
-        model: Union[str, AbstractTimeSeriesModel],
+        model: Union[str, TimeSeriesModelBase],
         data: TimeSeriesDataFrame,
         model_pred_dict: Dict[str, Optional[TimeSeriesDataFrame]],
     ) -> Union[TimeSeriesDataFrame, Dict[str, Optional[TimeSeriesDataFrame]]]:
@@ -1188,6 +1196,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
             model_name = model.name
             if model._get_tags()["can_refit_full"]:
                 model_full = model.convert_to_refit_full_template()
+                assert isinstance(model_full, AbstractTimeSeriesModel)
                 logger.info(f"Fitting model: {model_full.name}")
                 models_trained = self._train_and_save(
                     train_data=refit_full_data,
@@ -1253,12 +1262,11 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
         freq: Optional[str] = None,
         excluded_model_types: Optional[List[str]] = None,
         hyperparameter_tune: bool = False,
-    ) -> List[AbstractTimeSeriesModel]:
+    ) -> List[TimeSeriesModelBase]:
         return get_preset_models(
             path=self.path,
             eval_metric=self.eval_metric,
             eval_metric_seasonal_period=self.eval_metric_seasonal_period,
-            horizon_weight=self.horizon_weight,
             prediction_length=self.prediction_length,
             freq=freq,
             hyperparameters=hyperparameters,

autogluon/timeseries/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.2.1b20250422"
+__version__ = "1.2.1b20250423"
 __lite__ = False

{autogluon.timeseries-1.2.1b20250422.dist-info → autogluon.timeseries-1.2.1b20250423.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.2.1b20250422
+Version: 1.2.1b20250423
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -55,9 +55,9 @@ Requires-Dist: fugue>=0.9.0
 Requires-Dist: tqdm<5,>=4.38
 Requires-Dist: orjson~=3.9
 Requires-Dist: tensorboard<3,>=2.9
-Requires-Dist: autogluon.core[raytune]==1.2.1b20250422
-Requires-Dist: autogluon.common==1.2.1b20250422
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250422
+Requires-Dist: autogluon.core[raytune]==1.2.1b20250423
+Requires-Dist: autogluon.common==1.2.1b20250423
+Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250423
 Provides-Extra: all
 Provides-Extra: chronos-onnx
 Requires-Dist: optimum[onnxruntime]<1.23,>=1.17; extra == "chronos-onnx"

{autogluon.timeseries-1.2.1b20250422.dist-info → autogluon.timeseries-1.2.1b20250423.dist-info}/RECORD

@@ -1,25 +1,25 @@
-autogluon.timeseries-1.2.1b20250422-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.timeseries-1.2.1b20250423-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
 autogluon/timeseries/__init__.py,sha256=_CrLLc1fkjen7UzWoO0Os8WZoHOgvZbHKy46I8v_4k4,304
 autogluon/timeseries/evaluator.py,sha256=l642tYfTHsl8WVIq_vV6qhgAFVFr9UuZD7gLra3A_Kc,250
-autogluon/timeseries/learner.py,sha256=F3RhHCFc4EB3QmKSaYV9WH7vvoN5T8HoneSdraNJ_2Q,14281
-autogluon/timeseries/predictor.py,sha256=Fvf1C2Eap61DIc6a5aYcbSOOqKdzroU83MgWpqfhM-k,86680
+autogluon/timeseries/learner.py,sha256=7dqSHKCIX2osjv9cmWWLwaGvdrPvla0HTnsR75bdenY,14112
+autogluon/timeseries/predictor.py,sha256=eklp1Qils6f4vIex8KhLD6nVsUQwZ6Jt9UKkTsSyErM,85739
 autogluon/timeseries/regressor.py,sha256=xw5VPrXS-NQ_Ts4ppDjoNV0TdqUYjW4VINUtb_BZdiI,11868
 autogluon/timeseries/splitter.py,sha256=yzPca9p2bWV-_VJAptUyyzQsxu-uixAdpMoGQtDzMD4,3205
-autogluon/timeseries/trainer.py,sha256=R_u7a90PyB9apSMknEGMwpcMRXvepuNnn0NAACw5sSg,57942
-autogluon/timeseries/version.py,sha256=CZZ1almZ8IwUvIs8IcJ7fdkqLQwq9WIQ8u_uKA5X8YU,91
+autogluon/timeseries/trainer.py,sha256=-8UBCe_uzwOoMk8wHgVEEhN7mN2biumUzGrf5YY6n4w,58131
+autogluon/timeseries/version.py,sha256=5cHaVBGEbXKlEyQMJ8g3TzPJ5O8xRFYaKM8gVl6YgvE,91
 autogluon/timeseries/configs/__init__.py,sha256=BTtHIPCYeGjqgOcvqb8qPD4VNX-ICKOg6wnkew1cPOE,98
 autogluon/timeseries/configs/presets_configs.py,sha256=cLat8ecLlWrI-SC5KLBDCX2SbVXaucemy2pjxJAtSY0,2543
 autogluon/timeseries/dataset/__init__.py,sha256=UvnhAN5tjgxXTHoZMQDy64YMDj4Xxa68yY7NP4vAw0o,81
-autogluon/timeseries/dataset/ts_dataframe.py,sha256=SodnGhEA2V-hnfYHuAkH8rK4hQlLH8K5Tb6dsGapvPM,47161
-autogluon/timeseries/metrics/__init__.py,sha256=IWEG1X0NP_WbBwgLO7iC9TAoKZD7v-G6rrzqgWqhx08,3552
-autogluon/timeseries/metrics/abstract.py,sha256=nrnFZpBJo6f7zg5fbqJoLubTZyQdj3_rh-Z8D5qfxAk,8825
-autogluon/timeseries/metrics/point.py,sha256=yHs5ivgINO8WlhkhERVBFyP-hgk2tjBSJsOF7OszYgk,18814
-autogluon/timeseries/metrics/quantile.py,sha256=s2N70vdVgMVJpaFNBCbOfmvYVKZMlSyqfyy75WLpzZY,4552
+autogluon/timeseries/dataset/ts_dataframe.py,sha256=uX639T0zD6DDmsO4PbCY_X2gI_4M95Gf4oYCy4etGhk,47169
+autogluon/timeseries/metrics/__init__.py,sha256=dJCrZ2cHwqhqNctwQjwG-FHgGUmzIFT-D0z72f4RAVM,2104
+autogluon/timeseries/metrics/abstract.py,sha256=CHUZB6xt9oF9yijSOjgGtjLuKo2X0mT6dQDuwg4ZzpU,8192
+autogluon/timeseries/metrics/point.py,sha256=2nlieQcPBCI9hXMT3v0Oe802ykZDuzvEtDpunzt0IVA,15785
+autogluon/timeseries/metrics/quantile.py,sha256=wvFeDMvRf1mFurhvVr_7g13Kg-hKIRoW4y9t2no_e7A,3969
 autogluon/timeseries/metrics/utils.py,sha256=HuDe1BNe8yJU4f_DKM913nNrUueoRaw6zhxm1-S20s0,910
 autogluon/timeseries/models/__init__.py,sha256=MYD9JJ-wUDE5B6jW6E6LU2eXQ6vflfQBvqQJkdzJa3A,1189
-autogluon/timeseries/models/presets.py,sha256=k5V2GgH5xFEqDrHBhfnLph61ASq_B1elcPLPurvFo0U,12431
-autogluon/timeseries/models/abstract/__init__.py,sha256=wvDsQAZIV0N3AwBeMaGItoQ82trEfnT-nol2AAOIxBg,102
-autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=UeSgldAHam7hI0J8jY4ALJLwZNC3_hRjo8NdK1UesyA,31247
+autogluon/timeseries/models/presets.py,sha256=BdSTW91-flgqhVNuZIvqEf7wUj1iB6BPger4tJaoAZQ,12322
+autogluon/timeseries/models/abstract/__init__.py,sha256=Htfkjjc3vo92RvyM8rIlQ0PLWt3jcrCKZES07UvCMV0,146
+autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=ZaMkFUgr3YTxGAjm3k3xZCp0bIbgelTzZ2kwWqQ1IQ4,32978
 autogluon/timeseries/models/abstract/model_trial.py,sha256=ENPg_7nsdxIvaNM0o0UShZ3x8jFlRmwRc5m0fGPC0TM,3720
 autogluon/timeseries/models/abstract/tunable.py,sha256=SFl4vjkb6BfFFaRPVdftnnLYlIyCThutLHxiiAlV6tY,7168
 autogluon/timeseries/models/autogluon_tabular/__init__.py,sha256=r9i6jWcyeLHYClkcMSKRVsfrkBUMxpDrTATNTBc_qgQ,136
@@ -27,15 +27,16 @@ autogluon/timeseries/models/autogluon_tabular/mlforecast.py,sha256=QaQcImTXJpzl-
 autogluon/timeseries/models/autogluon_tabular/transforms.py,sha256=CVvNun8DKH7UQGyXU-iO2xmvBIHRQElw72gIrZ7QjkU,2504
 autogluon/timeseries/models/autogluon_tabular/utils.py,sha256=Fn3Vu_Q0PCtEUbtNgLp1xIblg7dOdpFlF3W5kLHgruI,63
 autogluon/timeseries/models/chronos/__init__.py,sha256=wT77HzTtmQxW3sw2k0mA5Ot6PSHivX-Uvn5fjM05EU4,60
-autogluon/timeseries/models/chronos/model.py,sha256=9kKVUBCEdgQ176YM33tvcn3pQsEpv0_OLw7VK-Scxw8,31590
+autogluon/timeseries/models/chronos/model.py,sha256=dYc3nZE6BqpunwI2IyuOm1LGW1RJJEzxYCB5ZW0585E,31649
 autogluon/timeseries/models/chronos/pipeline/__init__.py,sha256=N-YZH9BGBoi99r5cznJe1zEEjwjIg7cOYIHZkKuJq44,247
 autogluon/timeseries/models/chronos/pipeline/base.py,sha256=14OAKHmio6LmO4mVom2mPGB0CvIrOjMGJzb-MVSAq-s,5596
 autogluon/timeseries/models/chronos/pipeline/chronos.py,sha256=uFJLsSb2WQiSrmDZ0g2mO-lhTFUlq7vplGRBXZ9_VBk,22591
 autogluon/timeseries/models/chronos/pipeline/chronos_bolt.py,sha256=kNIDesojKB3rbEK9jM8st4k7ZeaT6tz1znf4PsRDv2Q,20066
 autogluon/timeseries/models/chronos/pipeline/utils.py,sha256=dtDX5Pyu95bGv7qmqgfUc1iYowWPY84dnGN0uyqyHyQ,13131
-autogluon/timeseries/models/ensemble/__init__.py,sha256=kFr11Gmt7lQJu9Rr8HuIPphQN5l1TsoorfbJm_O3a_s,128
-autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py,sha256=LzL64JASiwkLsuFxGToXJGRItcMxq5_Ig2QP5Zm7SHw,3537
-autogluon/timeseries/models/ensemble/greedy_ensemble.py,sha256=S9ghBwfSUGT0fvHZl5HHcOPmaBnQE2ZQR0lLrC5TXsE,7610
+autogluon/timeseries/models/ensemble/__init__.py,sha256=_BivnZaOWJiIvu93IQy0mrLdCZKT2NHHSqkf31hwF2s,158
+autogluon/timeseries/models/ensemble/abstract.py,sha256=ie-BKD4JIkQQoKqtf6sYI5Aix7dSgywFsSdeGPxoElk,5821
+autogluon/timeseries/models/ensemble/basic.py,sha256=BRPWg_Wgfb87iInFSoTRE75BRHaovRR5HFRvzxET_wU,3423
+autogluon/timeseries/models/ensemble/greedy.py,sha256=2MVLTPvJ9Khuqri1gwQlo0RmKFeWK4qFkEcLH1Dh41E,7362
 autogluon/timeseries/models/gluonts/__init__.py,sha256=asC1PTj4j9xMbilvk1IT1julnpeoKbv5ZNuAR6-DFgA,361
 autogluon/timeseries/models/gluonts/abstract_gluonts.py,sha256=35T8rty6sPGiaSFNpiVNmeseo1_qpn664UcWo92W5eI,32906
 autogluon/timeseries/models/gluonts/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -59,11 +60,11 @@ autogluon/timeseries/utils/datetime/base.py,sha256=3NdsH3NDq4cVAOSoy3XpaNixyNlbj
 autogluon/timeseries/utils/datetime/lags.py,sha256=gQDk5_zmsY5DUWDUpSaCKYkQ9nHKKY-LsywJQRAoYSk,5988
 autogluon/timeseries/utils/datetime/seasonality.py,sha256=YK_2k8hvYIMW-sJPnjGWRtCnvIOthwA2hATB3nwVoD4,834
 autogluon/timeseries/utils/datetime/time_features.py,sha256=MjLi3zQ00uWWJtXH9oGX2GJkTbvjdSiuabSa4kcVuxE,2672
-autogluon.timeseries-1.2.1b20250422.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.2.1b20250422.dist-info/METADATA,sha256=4UirSdHj-jRgjGXA8AAVHrCVhTECV4Za_K6-yidbEJc,12687
-autogluon.timeseries-1.2.1b20250422.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.2.1b20250422.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.timeseries-1.2.1b20250422.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250422.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250422.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.2.1b20250422.dist-info/RECORD,,
+autogluon.timeseries-1.2.1b20250423.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.timeseries-1.2.1b20250423.dist-info/METADATA,sha256=vs0Qvp4NFtgEq_tw4OkGPvAwv8EPGJWseJ7StCv_cU4,12687
+autogluon.timeseries-1.2.1b20250423.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.timeseries-1.2.1b20250423.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.timeseries-1.2.1b20250423.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.2.1b20250423.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.timeseries-1.2.1b20250423.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.timeseries-1.2.1b20250423.dist-info/RECORD,,