autogluon.timeseries 1.2.1b20250224__py3-none-any.whl → 1.4.1b20251215__py3-none-any.whl

autogluon/timeseries/models/chronos/{pipeline/utils.py → utils.py}

@@ -1,26 +1,23 @@
 import logging
-import os
-import re
 import time
 from itertools import chain, cycle
-from pathlib import Path
-from typing import TYPE_CHECKING, Callable, Iterable, Iterator, List, Literal, Optional
+from typing import TYPE_CHECKING, Callable, Iterable, Iterator, Literal
 
 import numpy as np
 import torch
+from chronos.chronos_bolt import ChronosBoltModelForForecasting, ResidualBlock
 from gluonts.dataset.field_names import FieldName
 from gluonts.transform import ExpectedNumInstanceSampler, InstanceSplitter, ValidationSplitSampler
 from torch.utils.data import IterableDataset
 from transformers import TrainerCallback
 
-from autogluon.common.loaders.load_s3 import download, list_bucket_prefix_suffix_contains_s3
 from autogluon.core.utils.exceptions import TimeLimitExceeded
-from autogluon.timeseries.dataset.ts_dataframe import TimeSeriesDataFrame
-from autogluon.timeseries.models.gluonts.abstract_gluonts import SimpleGluonTSDataset
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
+from autogluon.timeseries.models.gluonts.dataset import SimpleGluonTSDataset
 
 if TYPE_CHECKING:
     # TODO: fix the underlying reason for this circular import, the pipeline should handle tokenization
-    from autogluon.timeseries.models.chronos.pipeline.chronos import ChronosTokenizer
+    from chronos import ChronosTokenizer
 
 
 logger = logging.getLogger("autogluon.timeseries.models.chronos")
@@ -73,19 +70,19 @@ class ChronosFineTuningDataset(IterableDataset):
 
     Parameters
     ----------
-    target_df : TimeSeriesDataFrame
+    target_df
         The ``TimeSeriesDataFrame`` to be converted
-    target_column : str, default = "target"
+    target_column
         The name of the column which contains the target time series, by default "target"
-    context_length : int, default = 512
+    context_length
         The length of the historical context
-    prediction_length : int, default = 64
+    prediction_length
         The prediction_length, i.e., length of label or target
-    tokenizer : ``ChronosTokenizer``, default = None
+    tokenizer
         When a ``ChronosTokenizer`` object is provided, data will be converted into the
         HuggingFace format accepted by the original Chronos models using this ``ChronosTokenizer``.
         If None, data will be converted into the format accepted by ChronosBolt models.
-    mode : Literal["training", "validation"], default = "training"
+    mode
         When ``training``, random slices from the time series will be returned for training purposes.
         If ``validation``, the last slice of each time series returned in the original order.
     """
@@ -96,7 +93,7 @@ class ChronosFineTuningDataset(IterableDataset):
         target_column: str = "target",
         context_length: int = 512,
         prediction_length: int = 64,
-        tokenizer: Optional["ChronosTokenizer"] = None,
+        tokenizer: "ChronosTokenizer | None" = None,
         mode: Literal["training", "validation"] = "training",
     ) -> None:
         super().__init__()
@@ -132,11 +129,11 @@ class ChronosFineTuningDataset(IterableDataset):
     def _create_training_data(self, data: Iterable[dict]):
         data = chain.from_iterable(cycle([data]))
         split_transform = self._create_instance_splitter("training")
-        data = split_transform.apply(data, is_train=True)
+        data = split_transform.apply(data, is_train=True)  # type: ignore
         return data
 
     def _create_validation_data(self, data: Iterable[dict]):
-        data = self._create_instance_splitter("validation").apply(data, is_train=False)
+        data = self._create_instance_splitter("validation").apply(data, is_train=False)  # type: ignore
         return data
 
     def to_chronos_format(self, entry: dict) -> dict:
@@ -145,7 +142,7 @@ class ChronosFineTuningDataset(IterableDataset):
 
         Parameters
         ----------
-        entry : dict
+        entry
             time series data entry in GluonTS format with ``past_target`` and ``future_target`` keys
 
         Returns
@@ -172,7 +169,7 @@ class ChronosFineTuningDataset(IterableDataset):
 
         Parameters
         ----------
-        entry : dict
+        entry
             time series data entry in GluonTS format with ``past_target`` and ``future_target`` keys
 
         Returns
@@ -190,17 +187,19 @@ class ChronosFineTuningDataset(IterableDataset):
             iterable = self._create_training_data(self.gluonts_dataset)
         elif self.mode == "validation":
             iterable = self._create_validation_data(self.gluonts_dataset)
+        else:
+            raise ValueError(f"Unknown mode {self.mode}")
 
         format_transform_fn = self.to_chronos_format if self.tokenizer is not None else self.to_chronos_bolt_format
         for entry in iterable:
             yield format_transform_fn(entry)
 
-    def shuffle(self, shuffle_buffer_size: Optional[int] = None):
+    def shuffle(self, shuffle_buffer_size: int | None = None):
         """Returns a (pseudo) shuffled version of this iterable dataset.
 
         Parameters
         ----------
-        shuffle_buffer_size : int, optional, default = None
+        shuffle_buffer_size
             The shuffle buffer size used for pseudo shuffling
         """
         assert shuffle_buffer_size is None or shuffle_buffer_size >= 0
@@ -209,7 +208,7 @@ class ChronosFineTuningDataset(IterableDataset):
         return PseudoShuffledIterableDataset(self, shuffle_buffer_size)
 
 
-def left_pad_and_stack_1D(tensors: List[torch.Tensor]) -> torch.Tensor:
+def left_pad_and_stack_1D(tensors: list[torch.Tensor]) -> torch.Tensor:
     max_len = max(len(c) for c in tensors)
     padded = []
     for c in tensors:
@@ -220,27 +219,6 @@ def left_pad_and_stack_1D(tensors: List[torch.Tensor]) -> torch.Tensor:
     return torch.stack(padded)
 
 
-def cache_model_from_s3(s3_uri: str, force=False):
-    if re.match("^s3://([^/]+)/(.*?([^/]+)/?)$", s3_uri) is None:
-        raise ValueError(f"Not a valid S3 URI: {s3_uri}")
-
-    # we expect the prefix to point to a "directory" on S3
-    if not s3_uri.endswith("/"):
-        s3_uri += "/"
-
-    cache_home = Path(os.environ.get("XDG_CACHE_HOME") or Path.home() / ".cache")
-    bucket, prefix = s3_uri.replace("s3://", "").split("/", 1)
-    bucket_cache_path = cache_home / "autogluon" / "timeseries" / bucket
-
-    for obj_path in list_bucket_prefix_suffix_contains_s3(bucket=bucket, prefix=prefix):
-        destination_path = bucket_cache_path / obj_path
-        if not force and destination_path.exists():
-            continue
-        download(bucket, obj_path, local_path=str(destination_path))
-
-    return str(bucket_cache_path / prefix)
-
-
 class ChronosInferenceDataset:
     """A container for time series datasets that implements the ``torch.utils.data.Dataset`` interface"""
 
@@ -255,8 +233,7 @@ class ChronosInferenceDataset:
         self.target_array = target_df[target_column].to_numpy(dtype=np.float32)
 
         # store pointer to start:end of each time series
-        cum_sizes = target_df.num_timesteps_per_item().values.cumsum()
-        self.indptr = np.append(0, cum_sizes).astype(np.int32)
+        self.indptr = target_df.get_indptr()
 
     def __len__(self):
         return len(self.indptr) - 1  # noqa
@@ -281,7 +258,7 @@ class ChronosInferenceDataLoader(torch.utils.data.DataLoader):
         self.callback: Callable = kwargs.pop("on_batch", lambda: None)
         super().__init__(*args, **kwargs)
 
-    def __iter__(self):
+    def __iter__(self):  # type: ignore
         for item in super().__iter__():
             yield item
             self.callback()
@@ -298,13 +275,13 @@ class EvaluateAndSaveFinalStepCallback(TrainerCallback):
 
 
 class TimeLimitCallback(TrainerCallback):
-    def __init__(self, time_limit: int):
+    def __init__(self, time_limit: float):
         """
         Callback to stop training once a specified time has elapsed.
 
         Parameters
         ----------
-        time_limit: int
+        time_limit
             maximum time allowed for training in seconds.
         """
         self.time_limit = time_limit
@@ -322,12 +299,13 @@ class TimeLimitCallback(TrainerCallback):
 
 class LoggerCallback(TrainerCallback):
     def on_log(self, args, state, control, logs=None, **kwargs):
-        logs.pop("total_flos", None)
+        if logs:
+            logs.pop("total_flos", None)
         if state.is_local_process_zero:
             logger.info(logs)
 
 
-def timeout_callback(seconds: Optional[float]) -> Callable:
+def timeout_callback(seconds: float | None) -> Callable:
     """Return a callback object that raises an exception if time limit is exceeded."""
     start_time = time.monotonic()
 
@@ -336,3 +314,56 @@ def timeout_callback(seconds: Optional[float]) -> Callable:
             raise TimeLimitExceeded
 
     return callback
+
+
+def update_output_quantiles(model: ChronosBoltModelForForecasting, new_quantiles: list[float]) -> None:
+    """In-place updates model's output layer to support only the specified new quantiles by copying
+    weights from closest existing quantiles.
+    """
+    old_quantiles = model.chronos_config.quantiles
+    new_quantiles = sorted(new_quantiles)
+
+    if new_quantiles == old_quantiles:
+        return
+
+    model.chronos_config.quantiles = new_quantiles
+    model.num_quantiles = len(new_quantiles)
+    model.register_buffer("quantiles", torch.tensor(new_quantiles, dtype=model.dtype), persistent=False)
+
+    old_output_layer = model.output_patch_embedding
+    new_output_layer = ResidualBlock(
+        in_dim=model.config.d_model,
+        h_dim=model.config.d_ff,
+        out_dim=len(new_quantiles) * model.chronos_config.prediction_length,
+        act_fn_name=model.config.dense_act_fn,
+        dropout_p=model.config.dropout_rate,
+    )
+
+    # hidden_layer is shared across all quantiles
+    new_output_layer.hidden_layer.weight.data.copy_(old_output_layer.hidden_layer.weight.data)
+    if old_output_layer.hidden_layer.bias is not None:
+        new_output_layer.hidden_layer.bias.data.copy_(old_output_layer.hidden_layer.bias.data)
+
+    def copy_quantile_weights(src_idx: int, dst_idx: int):
+        """Copy weights for one quantile from src_idx to dst_idx"""
+        prediction_length = model.chronos_config.prediction_length
+        src_start, src_end = src_idx * prediction_length, (src_idx + 1) * prediction_length
+        dst_start, dst_end = dst_idx * prediction_length, (dst_idx + 1) * prediction_length
+
+        for layer_name in ["output_layer", "residual_layer"]:
+            old_layer_attr = getattr(old_output_layer, layer_name)
+            new_layer_attr = getattr(new_output_layer, layer_name)
+
+            new_layer_attr.weight[dst_start:dst_end] = old_layer_attr.weight[src_start:src_end]
+            if old_layer_attr.bias is not None:
+                new_layer_attr.bias[dst_start:dst_end] = old_layer_attr.bias[src_start:src_end]
+
+    with torch.no_grad():
+        for new_idx, new_q in enumerate(new_quantiles):
+            closest_q = min(old_quantiles, key=lambda x: abs(x - new_q))
+            closest_idx = old_quantiles.index(closest_q)
+            copy_quantile_weights(closest_idx, new_idx)
+
+    model.output_patch_embedding = new_output_layer
+    model.config.chronos_config["quantiles"] = new_quantiles
+    model.chronos_config.quantiles = new_quantiles

autogluon/timeseries/models/ensemble/__init__.py

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

autogluon/timeseries/models/ensemble/abstract.py

@@ -0,0 +1,107 @@
+import logging
+from abc import ABC, abstractmethod
+
+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 base class for time series ensemble models that combine predictions from multiple base models.
+
+    Ensemble training process operates on validation predictions from base models rather than raw time series
+    data. This allows the ensemble to learn optimal combination strategies based on each model's performance
+    across different validation windows and time series patterns.
+    """
+
+    @property
+    @abstractmethod
+    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: dict[str, float] | None = None,
+        time_limit: float | None = None,
+    ):
+        """Fit ensemble model given predictions of candidate base models and the true data.
+
+        Parameters
+        ----------
+        predictions_per_window
+            Dictionary that maps the names of component models to their respective predictions for each validation
+            window.
+        data_per_window
+            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
+            Scores (higher is better) for the models that will constitute the ensemble.
+        time_limit
+            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: dict[str, float] | None = None,
+        time_limit: float | None = None,
+    ) -> None:
+        """Private method for ``fit``. See ``fit`` for documentation of arguments. Apart from the model
+        training logic, ``fit`` additionally implements other logic such as keeping track of the time limit.
+        """
+        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

autogluon/timeseries/models/ensemble/array_based/__init__.py

@@ -0,0 +1,3 @@
+from .models import LinearStackerEnsemble, MedianEnsemble, PerQuantileTabularEnsemble, TabularEnsemble
+
+__all__ = ["LinearStackerEnsemble", "MedianEnsemble", "PerQuantileTabularEnsemble", "TabularEnsemble"]

autogluon/timeseries/models/ensemble/array_based/abstract.py

@@ -0,0 +1,240 @@
+from abc import ABC, abstractmethod
+from typing import Any, Sequence
+
+import numpy as np
+
+from autogluon.timeseries.dataset import TimeSeriesDataFrame
+from autogluon.timeseries.metrics.abstract import TimeSeriesScorer
+from autogluon.timeseries.utils.features import CovariateMetadata
+
+from ..abstract import AbstractTimeSeriesEnsembleModel
+from .regressor import EnsembleRegressor
+
+
+class ArrayBasedTimeSeriesEnsembleModel(AbstractTimeSeriesEnsembleModel, ABC):
+    """Abstract base class for ensemble models that operate on multi-dimensional arrays of base model predictions.
+
+    Array-based ensembles convert time series predictions into structured numpy arrays for efficient processing
+    and enable sophisticated combination strategies beyond simple weighted averaging. Array-based ensembles also
+    support isotonization in quantile forecasts--ensuring quantile crossing does not occur. They also have built-in
+    failed model detection and filtering capabilities.
+
+    Other Parameters
+    ----------------
+    isotonization : str, default = "sort"
+        The isotonization method to use (i.e. the algorithm to prevent quantile non-crossing).
+        Currently only "sort" is supported.
+    detect_and_ignore_failures : bool, default = True
+        Whether to detect and ignore "failed models", defined as models which have a loss that is larger
+        than 10x the median loss of all the models. This can be very important for the regression-based
+        ensembles, as moving the weight from such a "failed model" to zero can require a long training
+        time.
+    """
+
+    def __init__(
+        self,
+        path: str | None = None,
+        name: str | None = None,
+        hyperparameters: dict[str, Any] | None = None,
+        freq: str | None = None,
+        prediction_length: int = 1,
+        covariate_metadata: CovariateMetadata | None = 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: str | TimeSeriesScorer | None = 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,
+        )
+        self.ensemble_regressor: EnsembleRegressor | None = None
+        self._model_names: list[str] = []
+
+    def _get_default_hyperparameters(self) -> dict[str, Any]:
+        return {
+            "isotonization": "sort",
+            "detect_and_ignore_failures": True,
+        }
+
+    @staticmethod
+    def to_array(df: TimeSeriesDataFrame) -> np.ndarray:
+        """Given a TimeSeriesDataFrame object, return a single array composing the values contained
+        in the data frame.
+
+        Parameters
+        ----------
+        df
+            TimeSeriesDataFrame to convert to an array. Must contain exactly ``prediction_length``
+            values for each item. The columns of ``df`` can correspond to ground truth values
+            or predictions (in which case, these will be the mean or quantile forecasts).
+
+        Returns
+        -------
+        array
+            of shape (num_items, prediction_length, num_outputs).
+        """
+        assert df.index.is_monotonic_increasing
+        array = df.to_numpy()
+        num_items = df.num_items
+        shape = (
+            num_items,
+            df.shape[0] // num_items,  # timesteps per item
+            df.shape[1],  # num_outputs
+        )
+        return array.reshape(shape)
+
+    def _get_base_model_predictions(
+        self,
+        predictions_per_window: dict[str, list[TimeSeriesDataFrame]] | dict[str, TimeSeriesDataFrame],
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Given a mapping from model names to a list of data frames representing
+        their predictions per window, return a multidimensional array representation.
+
+        Parameters
+        ----------
+        predictions_per_window
+            A dictionary with list[TimeSeriesDataFrame] values, where each TimeSeriesDataFrame
+            contains predictions for the window in question. If the dictionary values are
+            TimeSeriesDataFrame, they will be treated like a single window.
+
+        Returns
+        -------
+        base_model_mean_predictions
+            Array of shape (num_windows, num_items, prediction_length, 1, num_models)
+        base_model_quantile_predictions
+            Array of shape (num_windows, num_items, prediction_length, num_quantiles, num_models)
+        """
+
+        if not predictions_per_window:
+            raise ValueError("No base model predictions are provided.")
+
+        first_prediction = list(predictions_per_window.values())[0]
+        if isinstance(first_prediction, TimeSeriesDataFrame):
+            predictions_per_window = {k: [v] for k, v in predictions_per_window.items()}  # type: ignore
+
+        predictions = {
+            model_name: [self.to_array(window) for window in windows]  # type: ignore
+            for model_name, windows in predictions_per_window.items()
+        }
+        base_model_predictions = np.stack([x for x in predictions.values()], axis=-1)
+
+        return base_model_predictions[:, :, :, :1, :], base_model_predictions[:, :, :, 1:, :]
+
+    def _isotonize(self, prediction_array: np.ndarray) -> np.ndarray:
+        """Apply isotonization to ensure quantile non-crossing.
+
+        Parameters
+        ----------
+        prediction_array
+            Array of shape (num_windows, num_items, prediction_length, num_quantiles)
+
+        Returns
+        -------
+        isotonized_array
+            Array with same shape but quantiles sorted along last dimension
+        """
+        isotonization = self.get_hyperparameter("isotonization")
+        if isotonization == "sort":
+            return np.sort(prediction_array, axis=-1)
+        return prediction_array
+
+    def _fit(
+        self,
+        predictions_per_window: dict[str, list[TimeSeriesDataFrame]],
+        data_per_window: list[TimeSeriesDataFrame],
+        model_scores: dict[str, float] | None = None,
+        time_limit: float | None = None,
+    ) -> None:
+        # process inputs
+        filtered_predictions = self._filter_failed_models(predictions_per_window, model_scores)
+        base_model_mean_predictions, base_model_quantile_predictions = self._get_base_model_predictions(
+            filtered_predictions
+        )
+
+        # process labels
+        ground_truth_per_window = [y.slice_by_timestep(-self.prediction_length, None) for y in data_per_window]
+        labels = np.stack(
+            [self.to_array(gt) for gt in ground_truth_per_window], axis=0
+        )  # (num_windows, num_items, prediction_length, 1)
+
+        self._model_names = list(filtered_predictions.keys())
+        self.ensemble_regressor = self._get_ensemble_regressor()
+        self.ensemble_regressor.fit(
+            base_model_mean_predictions=base_model_mean_predictions,
+            base_model_quantile_predictions=base_model_quantile_predictions,
+            labels=labels,
+            time_limit=time_limit,
+        )
+
+    @abstractmethod
+    def _get_ensemble_regressor(self) -> EnsembleRegressor:
+        pass
+
+    def _predict(self, data: dict[str, TimeSeriesDataFrame], **kwargs) -> TimeSeriesDataFrame:
+        if self.ensemble_regressor is None:
+            if not self._model_names:
+                raise ValueError("Ensemble model has not been fitted yet.")
+            # Try to recreate the regressor (for loaded models)
+            self.ensemble_regressor = self._get_ensemble_regressor()
+
+        input_data = {}
+        for m in self.model_names:
+            assert m in data, f"Predictions for model {m} not provided during ensemble prediction."
+            input_data[m] = data[m]
+
+        base_model_mean_predictions, base_model_quantile_predictions = self._get_base_model_predictions(input_data)
+
+        mean_predictions, quantile_predictions = self.ensemble_regressor.predict(
+            base_model_mean_predictions=base_model_mean_predictions,
+            base_model_quantile_predictions=base_model_quantile_predictions,
+        )
+
+        quantile_predictions = self._isotonize(quantile_predictions)
+        prediction_array = np.concatenate([mean_predictions, quantile_predictions], axis=-1)
+
+        output = list(input_data.values())[0].copy()
+        num_folds, num_items, num_timesteps, num_outputs = prediction_array.shape
+        assert (num_folds, num_timesteps) == (1, self.prediction_length)
+        assert len(output.columns) == num_outputs
+
+        output[output.columns] = prediction_array.reshape((num_items * num_timesteps, num_outputs))
+
+        return output
+
+    @property
+    def model_names(self) -> list[str]:
+        return self._model_names
+
+    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."""
+        self._model_names = [model_refit_map.get(name, name) for name in self._model_names]
+
+    def _filter_failed_models(
+        self,
+        predictions_per_window: dict[str, list[TimeSeriesDataFrame]],
+        model_scores: dict[str, float] | None,
+    ) -> dict[str, list[TimeSeriesDataFrame]]:
+        """Filter out failed models based on detect_and_ignore_failures setting."""
+        if not self.get_hyperparameter("detect_and_ignore_failures"):
+            return predictions_per_window
+
+        if model_scores is None or len(model_scores) == 0:
+            return predictions_per_window
+
+        valid_scores = {k: v for k, v in model_scores.items() if np.isfinite(v)}
+        if len(valid_scores) == 0:
+            raise ValueError("All models have NaN scores. At least one model must run successfully to fit an ensemble")
+
+        losses = {k: -v for k, v in valid_scores.items()}
+        median_loss = np.nanmedian(list(losses.values()))
+        threshold = 10 * median_loss
+        good_models = {k for k, loss in losses.items() if loss <= threshold}
+
+        return {k: v for k, v in predictions_per_window.items() if k in good_models}