autogluon.timeseries 1.4.1b20250907__py3-none-any.whl → 1.5.1b20260122__py3-none-any.whl

autogluon/timeseries/models/ensemble/array_based/regressor/linear_stacker.py

@@ -0,0 +1,186 @@
+from typing import Literal
+
+import numpy as np
+from typing_extensions import Self
+
+from autogluon.timeseries.utils.timer import Timer
+
+from .abstract import EnsembleRegressor
+
+
+class LinearStackerEnsembleRegressor(EnsembleRegressor):
+    """Linear stacker ensemble regressor using PyTorch optimization with softmax weights.
+
+    Implements weighted averaging of base model predictions with learnable weights optimized
+    via gradient descent. Uses PyTorch during training for optimization, then stores weights
+    as numpy arrays for efficient prediction.
+
+    Parameters
+    ----------
+    quantile_levels
+        List of quantile levels for quantile predictions (e.g., [0.1, 0.5, 0.9]).
+    weights_per
+        Weight configuration specifying which dimensions to learn weights for:
+
+        - "m": Per-model weights (shape: num_models), defaults to "m"
+        - "mt": Per-model and per-time weights (shape: prediction_length, num_models)
+        - "mq": Per-model and per-model-output (quantiles and mean) weights
+          (shape: num_quantiles+1, num_models)
+        - "mtq": Per-model, per-time, and per-quantile weights
+          (shape: prediction_length, num_quantiles+1, num_models)
+    lr
+        Learning rate for Adam optimizer. Defaults to 0.1.
+    max_epochs
+        Maximum number of training epochs. Defaults to 10000.
+    relative_tolerance
+        Convergence tolerance for relative loss change between epochs. Defaults to 1e-7.
+    prune_below
+        Importance threshold for model sparsification. Models with importance below this
+        threshold are dropped after weight optimization. Set to 0.0 to disable sparsification.
+        Defaults to 0.0.
+    """
+
+    def __init__(
+        self,
+        quantile_levels: list[float],
+        weights_per: Literal["m", "mt", "mq", "mtq"] = "m",
+        lr: float = 0.1,
+        max_epochs: int = 10_000,
+        relative_tolerance: float = 1e-7,
+        prune_below: float = 0.0,
+    ):
+        super().__init__()
+        self.quantile_levels = quantile_levels
+        self.weights_per = weights_per
+        self.lr = lr
+        self.max_epochs = max_epochs
+        self.relative_tolerance = relative_tolerance
+        self.prune_below = prune_below
+
+        self.weights: np.ndarray | None = None
+        self.kept_indices: list[int] | None = None
+
+    def _compute_weight_shape(self, base_model_predictions_shape: tuple) -> tuple:
+        """Compute weight tensor shape based on weights_per configuration."""
+        _, _, prediction_length, num_outputs, num_models = base_model_predictions_shape
+
+        shapes = {
+            "m": (1, 1, num_models),
+            "mt": (prediction_length, 1, num_models),
+            "mq": (1, num_outputs, num_models),
+            "mtq": (prediction_length, num_outputs, num_models),
+        }
+        try:
+            return (1, 1) + shapes[self.weights_per]
+        except KeyError:
+            raise ValueError(f"Unsupported weights_per: {self.weights_per}")
+
+    def make_weighted_average_module(self, base_model_predictions_shape: tuple):
+        import torch
+
+        class WeightedAverage(torch.nn.Module):
+            def __init__(self, shape):
+                super().__init__()
+                self.raw_weights = torch.nn.Parameter(torch.zeros(*shape, dtype=torch.float32))
+
+            def get_normalized_weights(self):
+                return torch.softmax(self.raw_weights, dim=-1)  # softmax over models
+
+            def forward(self, base_model_predictions: torch.Tensor):
+                return torch.sum(self.get_normalized_weights() * base_model_predictions, dim=-1)
+
+        return WeightedAverage(self._compute_weight_shape(base_model_predictions_shape))
+
+    def fit(
+        self,
+        base_model_mean_predictions: np.ndarray,
+        base_model_quantile_predictions: np.ndarray,
+        labels: np.ndarray,
+        time_limit: float | None = None,
+    ) -> Self:
+        import torch
+
+        def _ql(
+            labels_tensor: torch.Tensor,
+            ensemble_predictions: torch.Tensor,
+        ) -> torch.Tensor:
+            """Compute the weighted quantile loss on predictions and ground truth (labels).
+            Considering that the first dimension of predictions is the mean, we treat
+            mean predictions on the same footing as median (0.5) predictions as contribution
+            to the overall weighted quantile loss.
+            """
+            quantile_levels = torch.tensor([0.5] + self.quantile_levels, dtype=torch.float32)
+            error = labels_tensor - ensemble_predictions  # (num_windows, num_items, num_time, num_outputs)
+            quantile_loss = torch.maximum(quantile_levels * error, (quantile_levels - 1) * error)
+            return torch.mean(quantile_loss)
+
+        timer = Timer(time_limit).start()
+
+        base_model_predictions = torch.tensor(
+            np.concatenate(
+                [base_model_mean_predictions, base_model_quantile_predictions],
+                axis=3,
+            ),
+            dtype=torch.float32,
+        )
+        labels_tensor = torch.tensor(labels, dtype=torch.float32)
+
+        weighted_average = self.make_weighted_average_module(base_model_predictions.shape)
+
+        optimizer = torch.optim.Adam(weighted_average.parameters(), lr=self.lr)
+
+        prev_loss = float("inf")
+        for _ in range(self.max_epochs):
+            optimizer.zero_grad()
+
+            ensemble_predictions = weighted_average(base_model_predictions)
+
+            loss = _ql(labels_tensor, ensemble_predictions)
+            loss.backward()
+            optimizer.step()
+
+            loss_change = abs(prev_loss - loss.item()) / (loss.item() + 1e-8)
+            if loss_change < self.relative_tolerance:
+                break
+            prev_loss = loss.item()
+
+            if timer.timed_out():
+                break
+
+        with torch.no_grad():
+            self.weights = weighted_average.get_normalized_weights().detach().numpy()
+
+        assert self.weights is not None
+        if self.prune_below > 0.0:
+            importances = self.weights.mean(axis=tuple(range(self.weights.ndim - 1)))  # shape (num_models,)
+
+            mask = importances >= self.prune_below
+            if not mask.any():
+                mask[importances.argmax()] = True
+
+            if not mask.all():
+                self.kept_indices = np.where(mask)[0].tolist()
+                self.weights = self.weights[..., mask]
+                self.weights = self.weights / self.weights.sum(axis=-1, keepdims=True)
+
+        return self
+
+    def predict(
+        self,
+        base_model_mean_predictions: np.ndarray,
+        base_model_quantile_predictions: np.ndarray,
+    ) -> tuple[np.ndarray, np.ndarray]:
+        if self.weights is None:
+            raise ValueError("Model must be fitted before prediction")
+
+        all_predictions = np.concatenate([base_model_mean_predictions, base_model_quantile_predictions], axis=3)
+
+        if self.kept_indices is not None:
+            assert all_predictions.shape[-1] == len(self.kept_indices)
+
+        ensemble_pred = np.sum(self.weights * all_predictions, axis=-1)
+
+        mean_predictions = ensemble_pred[:, :, :, :1]
+        quantile_predictions = ensemble_pred[:, :, :, 1:]
+
+        return mean_predictions, quantile_predictions

autogluon/timeseries/models/ensemble/array_based/regressor/per_quantile_tabular.py

@@ -0,0 +1,94 @@
+import logging
+
+import numpy as np
+import pandas as pd
+from typing_extensions import Self
+
+from autogluon.tabular.registry import ag_model_registry as tabular_ag_model_registry
+from autogluon.timeseries.utils.timer import SplitTimer
+
+from .abstract import EnsembleRegressor
+
+logger = logging.getLogger(__name__)
+
+
+class PerQuantileTabularEnsembleRegressor(EnsembleRegressor):
+    """Ensemble regressor using separate models per quantile plus dedicated mean model."""
+
+    def __init__(
+        self,
+        quantile_levels: list[float],
+        model_name: str,
+        model_hyperparameters: dict | None = None,
+    ):
+        super().__init__()
+        self.quantile_levels = quantile_levels
+        model_type = tabular_ag_model_registry.key_to_cls(model_name)
+        model_hyperparameters = model_hyperparameters or {}
+        self.mean_model = model_type(
+            problem_type="regression",
+            hyperparameters=model_hyperparameters,
+            path="",
+            name=f"{model_name}_mean",
+        )
+        self.quantile_models = [
+            model_type(
+                problem_type="quantile",
+                hyperparameters=model_hyperparameters | {"ag.quantile_levels": [quantile]},
+                path="",
+                name=f"{model_name}_q{quantile}",
+            )
+            for quantile in quantile_levels
+        ]
+
+    def fit(
+        self,
+        base_model_mean_predictions: np.ndarray,
+        base_model_quantile_predictions: np.ndarray,
+        labels: np.ndarray,
+        time_limit: float | None = None,
+    ) -> Self:
+        num_windows, num_items, prediction_length = base_model_mean_predictions.shape[:3]
+        y = pd.Series(labels.reshape(num_windows * num_items * prediction_length))
+
+        total_rounds = 1 + len(self.quantile_levels)
+        timer = SplitTimer(time_limit, rounds=total_rounds).start()
+
+        # Fit mean model
+        X_mean = self._get_feature_df(base_model_mean_predictions, 0)
+        self.mean_model.fit(X=X_mean, y=y, time_limit=timer.round_time_remaining())
+        timer.next_round()
+
+        # Fit quantile models
+        for i, model in enumerate(self.quantile_models):
+            X_q = self._get_feature_df(base_model_quantile_predictions, i)
+            model.fit(X=X_q, y=y, time_limit=timer.round_time_remaining())
+            timer.next_round()
+
+        return self
+
+    def _get_feature_df(self, predictions: np.ndarray, index: int) -> pd.DataFrame:
+        num_windows, num_items, prediction_length, _, num_models = predictions.shape
+        num_tabular_items = num_windows * num_items * prediction_length
+        return pd.DataFrame(
+            predictions[:, :, :, index].reshape(num_tabular_items, num_models),
+            columns=[f"model_{mi}" for mi in range(num_models)],
+        )
+
+    def predict(
+        self, base_model_mean_predictions: np.ndarray, base_model_quantile_predictions: np.ndarray
+    ) -> tuple[np.ndarray, np.ndarray]:
+        assert self.mean_model.is_fit()
+        num_windows, num_items, prediction_length = base_model_mean_predictions.shape[:3]
+        assert num_windows == 1, "Prediction expects a single window to be provided"
+
+        X_mean = self._get_feature_df(base_model_mean_predictions, 0)
+        mean_predictions = self.mean_model.predict(X_mean).reshape(num_windows, num_items, prediction_length, 1)
+
+        quantile_predictions_list = []
+        for i, model in enumerate(self.quantile_models):
+            X_q = self._get_feature_df(base_model_quantile_predictions, i)
+            quantile_predictions_list.append(model.predict(X_q).reshape(num_windows, num_items, prediction_length))
+        quantile_predictions = np.stack(quantile_predictions_list, axis=-1)
+
+        return mean_predictions, quantile_predictions

autogluon/timeseries/models/ensemble/array_based/regressor/tabular.py

@@ -0,0 +1,107 @@
+import logging
+
+import numpy as np
+import pandas as pd
+from typing_extensions import Self
+
+from autogluon.tabular.registry import ag_model_registry as tabular_ag_model_registry
+
+from .abstract import EnsembleRegressor
+
+logger = logging.getLogger(__name__)
+
+
+class TabularEnsembleRegressor(EnsembleRegressor):
+    """Ensemble regressor based on a single model from AutoGluon-Tabular that predicts all quantiles simultaneously."""
+
+    def __init__(
+        self,
+        quantile_levels: list[float],
+        model_name: str,
+        model_hyperparameters: dict | None = None,
+    ):
+        super().__init__()
+        self.quantile_levels = quantile_levels
+        model_type = tabular_ag_model_registry.key_to_cls(model_name)
+        model_hyperparameters = model_hyperparameters or {}
+        self.model = model_type(
+            problem_type="quantile",
+            hyperparameters=model_hyperparameters | {"ag.quantile_levels": quantile_levels},
+            path="",
+            name=model_name,
+        )
+
+    def fit(
+        self,
+        base_model_mean_predictions: np.ndarray,
+        base_model_quantile_predictions: np.ndarray,
+        labels: np.ndarray,
+        time_limit: float | None = None,
+    ) -> Self:
+        X = self._get_feature_df(base_model_mean_predictions, base_model_quantile_predictions)
+        num_windows, num_items, prediction_length = base_model_mean_predictions.shape[:3]
+        y = pd.Series(labels.reshape(num_windows * num_items * prediction_length))
+        self.model.fit(X=X, y=y, time_limit=time_limit)
+        return self
+
+    def predict(
+        self,
+        base_model_mean_predictions: np.ndarray,
+        base_model_quantile_predictions: np.ndarray,
+    ) -> tuple[np.ndarray, np.ndarray]:
+        assert self.model.is_fit()
+        num_windows, num_items, prediction_length = base_model_mean_predictions.shape[:3]
+        assert num_windows == 1, "Prediction expects a single window to be provided"
+
+        X = self._get_feature_df(base_model_mean_predictions, base_model_quantile_predictions)
+
+        pred = self.model.predict(X)
+
+        # Reshape back to (num_windows, num_items, prediction_length, num_quantiles)
+        pred = pred.reshape(num_windows, num_items, prediction_length, len(self.quantile_levels))
+
+        # Use median quantile as mean prediction
+        median_idx = self._get_median_quantile_index()
+        mean_pred = pred[:, :, :, median_idx : median_idx + 1]
+        quantile_pred = pred
+
+        return mean_pred, quantile_pred
+
+    def _get_feature_df(
+        self,
+        base_model_mean_predictions: np.ndarray,
+        base_model_quantile_predictions: np.ndarray,
+    ) -> pd.DataFrame:
+        num_windows, num_items, prediction_length, _, num_models = base_model_mean_predictions.shape
+        num_tabular_items = num_windows * num_items * prediction_length
+        features_array = np.hstack(
+            [
+                base_model_mean_predictions.reshape(num_tabular_items, -1),
+                base_model_quantile_predictions.reshape(num_tabular_items, -1),
+            ]
+        )
+        return pd.DataFrame(features_array, columns=self._get_feature_names(num_models))
+
+    def _get_feature_names(self, num_models: int) -> list[str]:
+        feature_names = []
+        for mi in range(num_models):
+            feature_names.append(f"model_{mi}_mean")
+        for quantile in self.quantile_levels:
+            for mi in range(num_models):
+                feature_names.append(f"model_{mi}_q{quantile}")
+
+        return feature_names
+
+    def _get_median_quantile_index(self):
+        """Get quantile index closest to 0.5"""
+        quantile_array = np.array(self.quantile_levels)
+        median_idx = int(np.argmin(np.abs(quantile_array - 0.5)))
+        selected_quantile = quantile_array[median_idx]
+
+        if selected_quantile != 0.5:
+            logger.warning(
+                f"Selected quantile {selected_quantile} is not exactly 0.5. "
+                f"Using closest available quantile for median prediction."
+            )
+
+        return median_idx

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

@@ -1,7 +1,4 @@
 import copy
-import logging
-import pprint
-from typing import Any, Optional
 
 import numpy as np
 
@@ -11,10 +8,6 @@ from autogluon.timeseries import TimeSeriesDataFrame
 from autogluon.timeseries.metrics import TimeSeriesScorer
 from autogluon.timeseries.utils.datetime import get_seasonality
 
-from .abstract import AbstractWeightedTimeSeriesEnsembleModel
-
-logger = logging.getLogger(__name__)
-
 
 class TimeSeriesEnsembleSelection(EnsembleSelection):
     def __init__(
@@ -25,7 +18,7 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         sorted_initialization: bool = False,
         bagging: bool = False,
         tie_breaker: str = "random",
-        random_state: Optional[np.random.RandomState] = None,
+        random_state: np.random.RandomState | None = None,
         prediction_length: int = 1,
         target: str = "target",
         **kwargs,
@@ -47,15 +40,15 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         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]]
+        self.dummy_pred_per_window: list[TimeSeriesDataFrame] | None
+        self.scorer_per_window: list[TimeSeriesScorer] | None
+        self.data_future_per_window: list[TimeSeriesDataFrame] | None
 
     def fit(  # type: ignore
         self,
         predictions: list[list[TimeSeriesDataFrame]],
         labels: list[TimeSeriesDataFrame],
-        time_limit: Optional[float] = None,
+        time_limit: float | None = None,
     ):
         return super().fit(
             predictions=predictions,  # type: ignore
@@ -67,8 +60,8 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         self,
         predictions: list[list[TimeSeriesDataFrame]],
         labels: list[TimeSeriesDataFrame],
-        time_limit: Optional[float] = None,
-        sample_weight: Optional[list[float]] = None,
+        time_limit: float | None = None,
+        sample_weight: list[float] | None = 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]
@@ -135,53 +128,40 @@ class TimeSeriesEnsembleSelection(EnsembleSelection):
         return -avg_score
 
 
-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.
+def fit_time_series_ensemble_selection(
+    data_per_window: list[TimeSeriesDataFrame],
+    predictions_per_window: dict[str, list[TimeSeriesDataFrame]],
+    ensemble_size: int,
+    eval_metric: TimeSeriesScorer,
+    prediction_length: int = 1,
+    target: str = "target",
+    time_limit: float | None = None,
+) -> dict[str, float]:
+    """Fit ensemble selection for time series forecasting and return ensemble weights.
 
-    References
+    Parameters
     ----------
-    .. [Car2024] Caruana, Rich, et al. "Ensemble selection from libraries of models."
-        Proceedings of the twenty-first international conference on Machine learning. 2004.
+    data_per_window:
+        List of ground truth time series data for each validation window.
+    predictions_per_window:
+        Dictionary mapping model names to their predictions for each validation window.
+    ensemble_size:
+        Number of iterations of the ensemble selection algorithm.
+
+    Returns
+    -------
+    weights:
+        Dictionary mapping the model name to its weight in the ensemble.
     """
-
-    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)
-
-    def _get_default_hyperparameters(self) -> dict[str, Any]:
-        return {"ensemble_size": 100}
-
-    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,
-    ):
-        ensemble_selection = TimeSeriesEnsembleSelection(
-            ensemble_size=self.get_hyperparameters()["ensemble_size"],
-            metric=self.eval_metric,
-            prediction_length=self.prediction_length,
-            target=self.target,
-        )
-        ensemble_selection.fit(
-            predictions=list(predictions_per_window.values()),
-            labels=data_per_window,
-            time_limit=time_limit,
-        )
-        self.model_to_weight = {}
-        for model_name, weight in zip(predictions_per_window.keys(), ensemble_selection.weights_):
-            if weight != 0:
-                self.model_to_weight[model_name] = weight
-
-        weights_for_printing = {model: round(float(weight), 2) for model, weight in self.model_to_weight.items()}
-        logger.info(f"\tEnsemble weights: {pprint.pformat(weights_for_printing, width=200)}")
+    ensemble_selection = TimeSeriesEnsembleSelection(
+        ensemble_size=ensemble_size,
+        metric=eval_metric,
+        prediction_length=prediction_length,
+        target=target,
+    )
+    ensemble_selection.fit(
+        predictions=list(predictions_per_window.values()),
+        labels=data_per_window,
+        time_limit=time_limit,
+    )
+    return {model: float(weight) for model, weight in zip(predictions_per_window.keys(), ensemble_selection.weights_)}