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

autogluon/timeseries/dataset/ts_dataframe.py

@@ -490,7 +490,7 @@ class TimeSeriesDataFrame(pd.DataFrame):
                 except ValueError:
                     inferred_freq = None
                 else:
-                    inferred_freq = candidate_freq
+                    inferred_freq = candidate_freq.freqstr
             return inferred_freq
 
         freq_for_each_item = index_df.groupby(ITEMID, sort=False).agg(get_freq)[TIMESTAMP]

autogluon/timeseries/models/abstract/__init__.py

@@ -1,3 +1,3 @@
-from .abstract_timeseries_model import AbstractTimeSeriesModel
+from .abstract_timeseries_model import AbstractTimeSeriesModel, TimeSeriesModelBase
 
-__all__ = ["AbstractTimeSeriesModel"]
+__all__ = ["AbstractTimeSeriesModel", "TimeSeriesModelBase"]

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -32,7 +32,8 @@ logger = logging.getLogger(__name__)
 
 
 class TimeSeriesModelBase(ModelBase, ABC):
-    """Abstract class for all `Model` objects in autogluon.timeseries.
+    """Abstract base class for all `Model` objects in autogluon.timeseries, including both
+    forecasting models and forecast combination/ensemble models.
 
     Parameters
     ----------
@@ -134,11 +135,6 @@ class TimeSeriesModelBase(ModelBase, ABC):
         )
         self.val_score: Optional[float] = None  # Score with eval_metric (Validation data)
 
-        self.target_scaler: Optional[TargetScaler]
-        self.covariate_scaler: Optional[CovariateScaler]
-        self.covariate_regressor: Optional[CovariateRegressor]
-        self._initialize_transforms_and_regressor()
-
     def __repr__(self) -> str:
         return self.name
 
@@ -249,21 +245,6 @@ class TimeSeriesModelBase(ModelBase, ABC):
             self._oof_predictions = self.load_oof_predictions(self.path)
         return self._oof_predictions
 
-    def _initialize_transforms_and_regressor(self) -> None:
-        self.target_scaler = get_target_scaler(self.get_hyperparameters().get("target_scaler"), target=self.target)
-        self.covariate_scaler = get_covariate_scaler(
-            self.get_hyperparameters().get("covariate_scaler"),
-            covariate_metadata=self.covariate_metadata,
-            use_static_features=self.supports_static_features,
-            use_known_covariates=self.supports_known_covariates,
-            use_past_covariates=self.supports_past_covariates,
-        )
-        self.covariate_regressor = get_covariate_regressor(
-            self.get_hyperparameters().get("covariate_regressor"),
-            target=self.target,
-            covariate_metadata=self.covariate_metadata,
-        )
-
     def _get_default_hyperparameters(self) -> dict:
         return {}
 
@@ -303,78 +284,6 @@ class TimeSeriesModelBase(ModelBase, ABC):
             else:
                 raise
 
-    @property
-    def allowed_hyperparameters(self) -> List[str]:
-        """List of hyperparameters allowed by the model."""
-        return ["target_scaler", "covariate_regressor"]
-
-    def _score_with_predictions(
-        self,
-        data: TimeSeriesDataFrame,
-        predictions: TimeSeriesDataFrame,
-        metric: Optional[str] = None,
-    ) -> float:
-        """Compute the score measuring how well the predictions align with the data."""
-        eval_metric = self.eval_metric if metric is None else check_get_evaluation_metric(metric)
-        return eval_metric.score(
-            data=data,
-            predictions=predictions,
-            prediction_length=self.prediction_length,
-            target=self.target,
-            seasonal_period=self.eval_metric_seasonal_period,
-        )
-
-    def score(self, data: TimeSeriesDataFrame, metric: Optional[str] = None) -> float:  # type: ignore
-        """Return the evaluation scores for given metric and dataset. The last
-        `self.prediction_length` time steps of each time series in the input data set
-        will be held out and used for computing the evaluation score. Time series
-        models always return higher-is-better type scores.
-
-        Parameters
-        ----------
-        data: TimeSeriesDataFrame
-            Dataset used for scoring.
-        metric: str
-            String identifier of evaluation metric to use, from one of
-            `autogluon.timeseries.utils.metric_utils.AVAILABLE_METRICS`.
-
-        Other Parameters
-        ----------------
-        num_samples: int
-            Number of samples to use for making evaluation predictions if the probabilistic
-            forecasts are generated by forward sampling from the fitted model.
-
-        Returns
-        -------
-        score: float
-            The computed forecast evaluation score on the last `self.prediction_length`
-            time steps of each time series.
-        """
-        past_data, known_covariates = data.get_model_inputs_for_scoring(
-            prediction_length=self.prediction_length, known_covariates_names=self.covariate_metadata.known_covariates
-        )
-        predictions = self.predict(past_data, known_covariates=known_covariates)
-        return self._score_with_predictions(data=data, predictions=predictions, metric=metric)
-
-    def score_and_cache_oof(
-        self,
-        val_data: TimeSeriesDataFrame,
-        store_val_score: bool = False,
-        store_predict_time: bool = False,
-        **predict_kwargs,
-    ) -> None:
-        """Compute val_score, predict_time and cache out-of-fold (OOF) predictions."""
-        past_data, known_covariates = val_data.get_model_inputs_for_scoring(
-            prediction_length=self.prediction_length, known_covariates_names=self.covariate_metadata.known_covariates
-        )
-        predict_start_time = time.time()
-        oof_predictions = self.predict(past_data, known_covariates=known_covariates, **predict_kwargs)
-        self._oof_predictions = [oof_predictions]
-        if store_predict_time:
-            self.predict_time = time.time() - predict_start_time
-        if store_val_score:
-            self.val_score = self._score_with_predictions(val_data, oof_predictions)
-
     def _is_gpu_available(self) -> bool:
         return False
 
@@ -391,16 +300,6 @@ class TimeSeriesModelBase(ModelBase, ABC):
     def _get_model_base(self) -> Self:
         return self
 
-    def preprocess(  # type: ignore
-        self,
-        data: TimeSeriesDataFrame,
-        known_covariates: Optional[TimeSeriesDataFrame] = None,
-        is_train: bool = False,
-        **kwargs,
-    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
-        """Method that implements model-specific preprocessing logic."""
-        return data, known_covariates
-
     def persist(self) -> Self:
         """Ask the model to persist its assets in memory, i.e., to predict with low latency. In practice
         this is used for pretrained models that have to lazy-load model parameters to device memory at
@@ -427,8 +326,112 @@ class TimeSeriesModelBase(ModelBase, ABC):
             "can_use_val_data": False,
         }
 
+    def get_params(self) -> dict:
+        """Get the constructor parameters required for cloning this model object"""
+        # We only use the user-provided hyperparameters for cloning. We cannot use the output of get_hyperparameters()
+        # since it may contain search spaces that won't be converted to concrete values during HPO
+        hyperparameters = self._hyperparameters.copy()
+        if self._extra_ag_args:
+            hyperparameters[AG_ARGS_FIT] = self._extra_ag_args.copy()
+
+        return dict(
+            path=self.path_root,
+            name=self.name,
+            eval_metric=self.eval_metric,
+            hyperparameters=hyperparameters,
+            freq=self.freq,
+            prediction_length=self.prediction_length,
+            quantile_levels=self.quantile_levels,
+            covariate_metadata=self.covariate_metadata,
+            target=self.target,
+        )
+
+    def convert_to_refit_full_via_copy(self) -> Self:
+        # save the model as a new model on disk
+        previous_name = self.name
+        self.rename(self.name + REFIT_FULL_SUFFIX)
+        refit_model_path = self.path
+        self.save(path=self.path, verbose=False)
+
+        self.rename(previous_name)
+
+        refit_model = self.load(path=refit_model_path, verbose=False)
+        refit_model.val_score = None
+        refit_model.predict_time = None
+
+        return refit_model
+
+    def convert_to_refit_full_template(self) -> Self:
+        """After calling this function, returned model should be able to be fit without `val_data`."""
+        params = copy.deepcopy(self.get_params())
+
+        if "hyperparameters" not in params:
+            params["hyperparameters"] = dict()
+
+        if AG_ARGS_FIT not in params["hyperparameters"]:
+            params["hyperparameters"][AG_ARGS_FIT] = dict()
+
+        params["name"] = params["name"] + REFIT_FULL_SUFFIX
+        template = self.__class__(**params)
+
+        return template
+
 
 class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
+    """Abstract base class for all time series models that take historical data as input and
+    make predictions for the forecast horizon.
+    """
+
+    def __init__(
+        self,
+        path: Optional[str] = None,
+        name: Optional[str] = None,
+        hyperparameters: Optional[Dict[str, Any]] = None,
+        freq: Optional[str] = None,
+        prediction_length: int = 1,
+        covariate_metadata: Optional[CovariateMetadata] = None,
+        target: str = "target",
+        quantile_levels: Sequence[float] = (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9),
+        eval_metric: Union[str, TimeSeriesScorer, None] = None,
+        eval_metric_seasonal_period: Optional[int] = None,
+    ):
+        super().__init__(
+            path=path,
+            name=name,
+            hyperparameters=hyperparameters,
+            freq=freq,
+            prediction_length=prediction_length,
+            covariate_metadata=covariate_metadata,
+            target=target,
+            quantile_levels=quantile_levels,
+            eval_metric=eval_metric,
+            eval_metric_seasonal_period=eval_metric_seasonal_period,
+        )
+        self.target_scaler: Optional[TargetScaler]
+        self.covariate_scaler: Optional[CovariateScaler]
+        self.covariate_regressor: Optional[CovariateRegressor]
+        self._initialize_transforms_and_regressor()
+
+    def _initialize_transforms_and_regressor(self) -> None:
+        self.target_scaler = get_target_scaler(self.get_hyperparameters().get("target_scaler"), target=self.target)
+        self.covariate_scaler = get_covariate_scaler(
+            self.get_hyperparameters().get("covariate_scaler"),
+            covariate_metadata=self.covariate_metadata,
+            use_static_features=self.supports_static_features,
+            use_known_covariates=self.supports_known_covariates,
+            use_past_covariates=self.supports_past_covariates,
+        )
+        self.covariate_regressor = get_covariate_regressor(
+            self.get_hyperparameters().get("covariate_regressor"),
+            target=self.target,
+            covariate_metadata=self.covariate_metadata,
+        )
+
+    @property
+    def allowed_hyperparameters(self) -> List[str]:
+        """List of hyperparameters allowed by the model."""
+        return ["target_scaler", "covariate_regressor"]
+
     def fit(
         self,
         train_data: TimeSeriesDataFrame,
@@ -549,7 +552,7 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
                 "as hyperparameters when initializing or use `hyperparameter_tune` instead."
             )
 
-    def predict(  # type: ignore
+    def predict(
         self,
         data: TimeSeriesDataFrame,
         known_covariates: Optional[TimeSeriesDataFrame] = None,
@@ -647,24 +650,6 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
 
         return template
 
-    def get_params(self) -> dict:
-        """Get the constructor parameters required for cloning this model object"""
-        hyperparameters = self.get_hyperparameters().copy()
-        if self._extra_ag_args:
-            hyperparameters[AG_ARGS_FIT] = self._extra_ag_args.copy()
-
-        return dict(
-            path=self.path_root,
-            name=self.name,
-            eval_metric=self.eval_metric,
-            hyperparameters=hyperparameters,
-            freq=self.freq,
-            prediction_length=self.prediction_length,
-            quantile_levels=self.quantile_levels,
-            covariate_metadata=self.covariate_metadata,
-            target=self.target,
-        )
-
     def get_forecast_horizon_index(self, data: TimeSeriesDataFrame) -> pd.MultiIndex:
         """For each item in the dataframe, get timestamps for the next `prediction_length` time steps into the future."""
         return pd.MultiIndex.from_frame(
@@ -709,3 +694,74 @@ class AbstractTimeSeriesModel(TimeSeriesModelBase, TimeSeriesTunable, ABC):
         """
         params = self._hyperparameters.copy()
         return params
+
+    def _score_with_predictions(
+        self,
+        data: TimeSeriesDataFrame,
+        predictions: TimeSeriesDataFrame,
+        metric: Optional[str] = None,
+    ) -> float:
+        """Compute the score measuring how well the predictions align with the data."""
+        eval_metric = self.eval_metric if metric is None else check_get_evaluation_metric(metric)
+        return eval_metric.score(
+            data=data,
+            predictions=predictions,
+            prediction_length=self.prediction_length,
+            target=self.target,
+            seasonal_period=self.eval_metric_seasonal_period,
+        )
+
+    def score(self, data: TimeSeriesDataFrame, metric: Optional[str] = None) -> float:
+        """Return the evaluation scores for given metric and dataset. The last
+        `self.prediction_length` time steps of each time series in the input data set
+        will be held out and used for computing the evaluation score. Time series
+        models always return higher-is-better type scores.
+
+        Parameters
+        ----------
+        data: TimeSeriesDataFrame
+            Dataset used for scoring.
+        metric: str
+            String identifier of evaluation metric to use, from one of
+            `autogluon.timeseries.utils.metric_utils.AVAILABLE_METRICS`.
+
+        Returns
+        -------
+        score: float
+            The computed forecast evaluation score on the last `self.prediction_length`
+            time steps of each time series.
+        """
+        past_data, known_covariates = data.get_model_inputs_for_scoring(
+            prediction_length=self.prediction_length, known_covariates_names=self.covariate_metadata.known_covariates
+        )
+        predictions = self.predict(past_data, known_covariates=known_covariates)
+        return self._score_with_predictions(data=data, predictions=predictions, metric=metric)
+
+    def score_and_cache_oof(
+        self,
+        val_data: TimeSeriesDataFrame,
+        store_val_score: bool = False,
+        store_predict_time: bool = False,
+        **predict_kwargs,
+    ) -> None:
+        """Compute val_score, predict_time and cache out-of-fold (OOF) predictions."""
+        past_data, known_covariates = val_data.get_model_inputs_for_scoring(
+            prediction_length=self.prediction_length, known_covariates_names=self.covariate_metadata.known_covariates
+        )
+        predict_start_time = time.time()
+        oof_predictions = self.predict(past_data, known_covariates=known_covariates, **predict_kwargs)
+        self._oof_predictions = [oof_predictions]
+        if store_predict_time:
+            self.predict_time = time.time() - predict_start_time
+        if store_val_score:
+            self.val_score = self._score_with_predictions(val_data, oof_predictions)
+
+    def preprocess(
+        self,
+        data: TimeSeriesDataFrame,
+        known_covariates: Optional[TimeSeriesDataFrame] = None,
+        is_train: bool = False,
+        **kwargs,
+    ) -> Tuple[TimeSeriesDataFrame, Optional[TimeSeriesDataFrame]]:
+        """Method that implements model-specific preprocessing logic."""
+        return data, known_covariates

autogluon/timeseries/models/chronos/model.py

@@ -196,8 +196,9 @@ class ChronosModel(AbstractTimeSeriesModel):
         name = name if name is not None else "Chronos"
         if not isinstance(model_path_input, Space):
             # we truncate the name to avoid long path errors on Windows
-            model_path_safe = str(model_path_input).replace("/", "__").replace(os.path.sep, "__")[-50:]
-            name += f"[{model_path_safe}]"
+            model_path_suffix = "[" + str(model_path_input).replace("/", "__").replace(os.path.sep, "__")[-50:] + "]"
+            if model_path_suffix not in name:
+                name += model_path_suffix
 
         super().__init__(
             path=path,

autogluon/timeseries/models/ensemble/__init__.py

@@ -1,2 +1,3 @@
-from .abstract_timeseries_ensemble import AbstractTimeSeriesEnsembleModel
-from .greedy_ensemble import TimeSeriesGreedyEnsemble
+from .abstract import AbstractTimeSeriesEnsembleModel
+from .greedy import GreedyEnsemble
+from .basic import SimpleAverageEnsemble, PerformanceWeightedEnsemble

autogluon/timeseries/models/ensemble/abstract.py

@@ -0,0 +1,139 @@
+import functools
+import logging
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional
+
+import numpy as np
+from typing_extensions import final
+
+from autogluon.core.utils.exceptions import TimeLimitExceeded
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
+from autogluon.timeseries.models.abstract import TimeSeriesModelBase
+
+logger = logging.getLogger(__name__)
+
+
+class AbstractTimeSeriesEnsembleModel(TimeSeriesModelBase, ABC):
+    """Abstract class for time series ensemble models."""
+
+    @property
+    @abstractmethod
+    def model_names(self) -> List[str]:
+        """Names of base models included in the ensemble."""
+        pass
+
+    @final
+    def fit(
+        self,
+        predictions_per_window: Dict[str, List[TimeSeriesDataFrame]],
+        data_per_window: List[TimeSeriesDataFrame],
+        model_scores: Optional[Dict[str, float]] = None,
+        time_limit: Optional[float] = None,
+    ):
+        """Fit ensemble model given predictions of candidate base models and the true data.
+
+        Parameters
+        ----------
+        predictions_per_window : Dict[str, List[TimeSeriesDataFrame]]
+            Dictionary that maps the names of component models to their respective predictions for each validation
+            window.
+        data_per_window : List[TimeSeriesDataFrame]
+            Observed ground truth data used to train the ensemble for each validation window. Each entry in the list
+            includes both the forecast horizon (for which the predictions are given in ``predictions``), as well as the
+            "history".
+        model_scores : Optional[Dict[str, float]]
+            Scores (higher is better) for the models that will constitute the ensemble.
+        time_limit : Optional[float]
+            Maximum allowed time for training in seconds.
+        """
+        if time_limit is not None and time_limit <= 0:
+            logger.warning(
+                f"\tWarning: Model has no time left to train, skipping model... (Time Left = {round(time_limit, 1)}s)"
+            )
+            raise TimeLimitExceeded
+        if isinstance(data_per_window, TimeSeriesDataFrame):
+            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:
+                raise ValueError(f"For model {model} predictions are unavailable for some validation windows")
+        self._fit(
+            predictions_per_window=predictions_per_window,
+            data_per_window=data_per_window,
+            model_scores=model_scores,
+            time_limit=time_limit,
+        )
+        return self
+
+    def _fit(
+        self,
+        predictions_per_window: Dict[str, List[TimeSeriesDataFrame]],
+        data_per_window: List[TimeSeriesDataFrame],
+        model_scores: Optional[Dict[str, float]] = None,
+        time_limit: Optional[float] = 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.
+        """
+        raise NotImplementedError
+
+    @final
+    def predict(self, data: Dict[str, 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 self._predict(data=data, **kwargs)
+
+    @abstractmethod
+    def _predict(self, data: Dict[str, TimeSeriesDataFrame], **kwargs) -> TimeSeriesDataFrame:
+        pass
+
+    @abstractmethod
+    def remap_base_models(self, model_refit_map: Dict[str, str]) -> None:
+        """Update names of the base models based on the mapping in model_refit_map.
+
+        This method should be called after performing refit_full to point to the refitted base models, if necessary.
+        """
+        pass
+
+
+class AbstractWeightedTimeSeriesEnsembleModel(AbstractTimeSeriesEnsembleModel, ABC):
+    """Abstract class for weighted ensembles which assign one (global) weight per model."""
+
+    def __init__(self, name: Optional[str] = None, **kwargs):
+        if name is None:
+            name = "WeightedEnsemble"
+        super().__init__(name=name, **kwargs)
+        self.model_to_weight: Dict[str, float] = {}
+
+    @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, TimeSeriesDataFrame], **kwargs) -> TimeSeriesDataFrame:
+        weighted_predictions = [data[model_name] * weight for model_name, weight in self.model_to_weight.items()]
+        return functools.reduce(lambda x, y: x + y, weighted_predictions)
+
+    def get_info(self) -> dict:
+        info = super().get_info()
+        info["model_weights"] = self.model_to_weight.copy()
+        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/ensemble/basic.py

@@ -0,0 +1,88 @@
+from typing import Dict, List, Optional
+
+import numpy as np
+
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
+
+from .abstract import AbstractWeightedTimeSeriesEnsembleModel
+
+
+class SimpleAverageEnsemble(AbstractWeightedTimeSeriesEnsembleModel):
+    """Constructs a weighted ensemble using a simple average of the constituent models' predictions."""
+
+    def __init__(self, name: Optional[str] = None, **kwargs):
+        if name is None:
+            name = "SimpleAverageEnsemble"
+        super().__init__(name=name, **kwargs)
+
+    def _fit(
+        self,
+        predictions_per_window: Dict[str, List[TimeSeriesDataFrame]],
+        data_per_window: List[TimeSeriesDataFrame],
+        model_scores: Optional[Dict[str, float]] = None,
+        time_limit: Optional[float] = None,
+    ):
+        self.model_to_weight = {}
+        num_models = len(predictions_per_window)
+        for model_name in predictions_per_window.keys():
+            self.model_to_weight[model_name] = 1.0 / num_models
+
+
+class PerformanceWeightedEnsemble(AbstractWeightedTimeSeriesEnsembleModel):
+    """Constructs a weighted ensemble, where the weights are assigned in proportion to the
+    (inverse) validation scores.
+
+    Other Parameters
+    ----------------
+    weight_scheme: Literal["sq", "inv", "loginv"], default = "loginv"
+        Method used to compute the weights as a function of the validation scores.
+        - "sqrt" computes weights in proportion to `sqrt(1 / S)`. This is the default.
+        - "inv" computes weights in proportion to `(1 / S)`.
+        - "sq" computes the weights in proportion to `(1 / S)^2` as outlined in [PC2020]_.
+
+    References
+    ----------
+    .. [PC2020] Pawlikowski, Maciej, and Agata Chorowska.
+        "Weighted ensemble of statistical models." International Journal of Forecasting
+        36.1 (2020): 93-97.
+    """
+
+    def __init__(self, name: Optional[str] = None, **kwargs):
+        if name is None:
+            name = "PerformanceWeightedEnsemble"
+        super().__init__(name=name, **kwargs)
+
+    def _get_default_hyperparameters(self) -> Dict:
+        return {"weight_scheme": "sqrt"}
+
+    def _fit(
+        self,
+        predictions_per_window: Dict[str, List[TimeSeriesDataFrame]],
+        data_per_window: List[TimeSeriesDataFrame],
+        model_scores: Optional[Dict[str, float]] = None,
+        time_limit: Optional[float] = None,
+    ):
+        assert model_scores is not None
+
+        weight_scheme = self.get_hyperparameters()["weight_scheme"]
+
+        # drop NaNs
+        model_scores = {k: v for k, v in model_scores.items() if np.isfinite(v)}
+        assert len(model_scores) > 0, (
+            "All models have NaN scores. At least one model must score successfully to fit an ensemble"
+        )
+        assert all(s <= 0 for s in model_scores.values()), (
+            "All model scores must be negative, in higher-is-better format."
+        )
+
+        score_transform = {
+            "sq": lambda x: np.square(np.reciprocal(x)),
+            "inv": lambda x: np.reciprocal(x),
+            "sqrt": lambda x: np.sqrt(np.reciprocal(x)),
+        }[weight_scheme]
+
+        self.model_to_weight = {
+            model_name: score_transform(-model_scores[model_name] + 1e-5) for model_name in model_scores.keys()
+        }
+        total_weight = sum(self.model_to_weight.values())
+        self.model_to_weight = {k: v / total_weight for k, v in self.model_to_weight.items()}

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,15 +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,
+        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,
@@ -43,13 +44,33 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         self.prediction_length = prediction_length
         self.target = target
         self.eval_metric_seasonal_period = eval_metric_seasonal_period
+        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]
@@ -75,16 +96,27 @@ 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]
@@ -98,27 +130,42 @@ 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,
@@ -136,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/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
@@ -73,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
 
@@ -145,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
@@ -153,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.
@@ -442,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
@@ -558,13 +560,18 @@ 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(
@@ -579,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
@@ -589,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))
 
@@ -734,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.
 
@@ -751,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():
@@ -762,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:
@@ -798,7 +810,7 @@ class TimeSeriesTrainer(AbstractTrainer[AbstractTimeSeriesModel]):
     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:
@@ -809,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]:
@@ -831,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",
@@ -934,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))
 
@@ -976,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,
@@ -992,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]]]:
@@ -1184,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,
@@ -1249,7 +1262,7 @@ 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,

autogluon/timeseries/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.timeseries
-Version: 1.2.1b20250421
+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.1b20250421
-Requires-Dist: autogluon.common==1.2.1b20250421
-Requires-Dist: autogluon.tabular[catboost,lightgbm,xgboost]==1.2.1b20250421
+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.1b20250421.dist-info → autogluon.timeseries-1.2.1b20250423.dist-info}/RECORD

@@ -1,16 +1,16 @@
-autogluon.timeseries-1.2.1b20250421-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=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=LHLaLvzOLjjwFHfKifydp5NOCLLv2nv2BJLerbeNWuU,57700
-autogluon/timeseries/version.py,sha256=w-cB2fz5-mm5dxzYRX6litgefPHSxeBnNxZVL1Yml6E,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/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
@@ -18,8 +18,8 @@ autogluon/timeseries/metrics/quantile.py,sha256=wvFeDMvRf1mFurhvVr_7g13Kg-hKIRoW
 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=BdSTW91-flgqhVNuZIvqEf7wUj1iB6BPger4tJaoAZQ,12322
-autogluon/timeseries/models/abstract/__init__.py,sha256=wvDsQAZIV0N3AwBeMaGItoQ82trEfnT-nol2AAOIxBg,102
-autogluon/timeseries/models/abstract/abstract_timeseries_model.py,sha256=gGairH3JX5rMEWhSj6VYy6zu7isZ04IaIj4lDXaTc1E,30814
+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=v5A2xv4d_QynA1GWD7iqmn-VVEFpD88Oiswyp72yBCc,7321
+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.1b20250421.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.timeseries-1.2.1b20250421.dist-info/METADATA,sha256=xGnEawYe3fyJ9cqSQ1j5EqCdjY5G3G7gNsdWMad9QUw,12687
-autogluon.timeseries-1.2.1b20250421.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.timeseries-1.2.1b20250421.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.timeseries-1.2.1b20250421.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250421.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.timeseries-1.2.1b20250421.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.timeseries-1.2.1b20250421.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,,

autogluon/timeseries/models/ensemble/abstract_timeseries_ensemble.py

@@ -1,86 +0,0 @@
-import logging
-from typing import Dict, List, Optional
-
-from autogluon.core.utils.exceptions import TimeLimitExceeded
-from autogluon.timeseries.dataset import TimeSeriesDataFrame
-from autogluon.timeseries.models.abstract import AbstractTimeSeriesModel
-
-logger = logging.getLogger(__name__)
-
-
-class AbstractTimeSeriesEnsembleModel(AbstractTimeSeriesModel):
-    """Abstract class for time series ensemble models."""
-
-    @property
-    def model_names(self) -> List[str]:
-        """Names of base models included in the ensemble."""
-        raise NotImplementedError
-
-    def fit_ensemble(
-        self,
-        predictions_per_window: Dict[str, List[TimeSeriesDataFrame]],
-        data_per_window: List[TimeSeriesDataFrame],
-        time_limit: Optional[float] = None,
-        **kwargs,
-    ):
-        """Fit ensemble model given predictions of candidate base models and the true data.
-
-        Parameters
-        ----------
-        predictions_per_window : Dict[str, List[TimeSeriesDataFrame]]
-            Dictionary that maps the names of component models to their respective predictions for each validation
-            window.
-        data_per_window : List[TimeSeriesDataFrame]
-            Observed ground truth data used to train the ensemble for each validation window. Each entry in the list
-            includes both the forecast horizon (for which the predictions are given in ``predictions``), as well as the
-            "history".
-        time_limit : Optional[int]
-            Maximum allowed time for training in seconds.
-        """
-        if time_limit is not None and time_limit <= 0:
-            logger.warning(
-                f"\tWarning: Model has no time left to train, skipping model... (Time Left = {round(time_limit, 1)}s)"
-            )
-            raise TimeLimitExceeded
-        if isinstance(data_per_window, TimeSeriesDataFrame):
-            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:
-                raise ValueError(f"For model {model} predictions are unavailable for some validation windows")
-        self._fit_ensemble(
-            predictions_per_window=predictions_per_window,
-            data_per_window=data_per_window,
-            time_limit=time_limit,
-        )
-        return self
-
-    def _fit_ensemble(
-        self,
-        predictions_per_window: Dict[str, List[TimeSeriesDataFrame]],
-        data_per_window: List[TimeSeriesDataFrame],
-        time_limit: Optional[int] = None,
-        **kwargs,
-    ):
-        """Private method for `fit_ensemble`. See `fit_ensemble` for documentation of arguments. Apart from the model
-        training logic, `fit_ensemble` additionally implements other logic such as keeping track of the time limit.
-        """
-        raise NotImplementedError
-
-    def predict(self, data: Dict[str, Optional[TimeSeriesDataFrame]], **kwargs) -> TimeSeriesDataFrame:
-        raise NotImplementedError
-
-    def remap_base_models(self, model_refit_map: Dict[str, str]) -> None:
-        """Update names of the base models based on the mapping in model_refit_map.
-
-        This method should be called after performing refit_full to point to the refitted base models, if necessary.
-        """
-        raise NotImplementedError
-
-    # TODO: remove
-    def _fit(*args, **kwargs):
-        pass
-
-    # TODO: remove
-    def _predict(*args, **kwargs):
-        pass