autogluon.timeseries 1.2.1b20250421__tar.gz → 1.2.1b20250423__tar.gz

{autogluon.timeseries-1.2.1b20250421 → autogluon.timeseries-1.2.1b20250423}/PKG-INFO

@@ -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

{autogluon.timeseries-1.2.1b20250421 → autogluon.timeseries-1.2.1b20250423}/src/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-1.2.1b20250423/src/autogluon/timeseries/models/abstract/__init__.py

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

{autogluon.timeseries-1.2.1b20250421 → autogluon.timeseries-1.2.1b20250423}/src/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-1.2.1b20250421 → autogluon.timeseries-1.2.1b20250423}/src/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-1.2.1b20250423/src/autogluon/timeseries/models/ensemble/__init__.py

@@ -0,0 +1,3 @@
+from .abstract import AbstractTimeSeriesEnsembleModel
+from .greedy import GreedyEnsemble
+from .basic import SimpleAverageEnsemble, PerformanceWeightedEnsemble

autogluon.timeseries-1.2.1b20250423/src/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-1.2.1b20250423/src/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()}