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

autogluon/timeseries/models/abstract/abstract_timeseries_model.py

@@ -8,7 +8,6 @@ import time
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
-import numpy as np
 import pandas as pd
 from typing_extensions import Self
 
@@ -33,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
     ----------
@@ -60,9 +60,6 @@ class TimeSeriesModelBase(ModelBase, ABC):
     eval_metric_seasonal_period : int, optional
         Seasonal period used to compute some evaluation metrics such as mean absolute scaled error (MASE). Defaults to
         ``None``, in which case the seasonal period is computed based on the data frequency.
-    horizon_weight : np.ndarray, optional
-        Weight assigned to each time step in the forecast horizon when computing the metric. If provided, this list
-        must contain `prediction_length` non-negative values, with `sum(horizon_weight) = prediction_length`.
     hyperparameters : dict, default = None
         Hyperparameters that will be used by the model (can be search spaces instead of fixed values).
         If None, model defaults are used. This is identical to passing an empty dictionary.
@@ -92,7 +89,6 @@ class TimeSeriesModelBase(ModelBase, ABC):
         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,
-        horizon_weight: Optional[np.ndarray] = None,
     ):
         self.name = name or re.sub(r"Model$", "", self.__class__.__name__)
 
@@ -109,7 +105,6 @@ class TimeSeriesModelBase(ModelBase, ABC):
 
         self.eval_metric: TimeSeriesScorer = check_get_evaluation_metric(eval_metric)
         self.eval_metric_seasonal_period = eval_metric_seasonal_period
-        self.horizon_weight = horizon_weight
         self.target: str = target
         self.covariate_metadata = covariate_metadata or CovariateMetadata()
 
@@ -140,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
 
@@ -255,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 {}
 
@@ -309,79 +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,
-            horizon_weight=self.horizon_weight,
-        )
-
-    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
 
@@ -398,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
@@ -434,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,
@@ -556,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,
@@ -654,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(
@@ -716,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()}