BaggingForecaster

class BaggingForecaster(bootstrap_transformer=None, forecaster: BaseForecaster = None, sp: int = 2, random_state: int | RandomState = None)[source]

Forecast a time series by aggregating forecasts from its bootstraps.

Bagged “Bootstrap Aggregating” Forecasts are obtained by forecasting bootstrapped time series and then aggregating the resulting forecasts. For the point forecast, the different forecasts are aggregated using the mean function [1]. Prediction intervals and quantiles are calculated for each time point in the forecasting horizon by calculating the sampled forecast quantiles.

Bergmeir et al. (2016) [2] show that, on average, bagging ETS forecasts gives better forecasts than just applying ETS directly. The default bootstrapping transformer and forecaster are selected as in [2].

Parameters:

bootstrap_transformersktime transformer BaseTransformer descendant instance: (default = sktime.transformations.bootstrap.STLBootstrapTransformer) Bootstrapping Transformer that takes a series (with tag scitype:transform-input=Series) as input and returns a panel (with tag scitype:transform-input=Panel) of bootstrapped time series if not specified sktime.transformations.bootstrap.STLBootstrapTransformer is used.
forecastersktime forecaster, BaseForecaster descendant instance, optional: (default = sktime.forecating.ets.AutoETS) If not specified, sktime.forecating.ets.AutoETS is used.
sp: int (default=2): Seasonal period for default Forecaster and Transformer. Must be 2 or greater. Ignored for the bootstrap_transformer and forecaster if they are specified.
random_state: int or np.random.RandomState (default=None): The random state of the estimator, used to control the random number generator

Attributes:

cutoff: Cut-off = “present time” state of forecaster.
fh: Forecasting horizon that was passed.
is_fitted: Whether fit has been called.
state: State of the estimator.

References

[1]

Hyndman, R.J., & Athanasopoulos, G. (2021) Forecasting: principles and practice, 3rd edition, OTexts: Melbourne, Australia. OTexts.com/fpp3, Chapter 12.5. Accessed on February 13th 2022.

[2]

Bergmeir, C., Hyndman, R. J., & Benítez, J. M. (2016). Bagging exponential smoothing methods using STL decomposition and Box-Cox transformation. International Journal of Forecasting, 32(2), 303-312

Examples

>>> from sktime.transformations.bootstrap import STLBootstrapTransformer
>>> from sktime.forecasting.naive import NaiveForecaster
>>> from sktime.forecasting.compose import BaggingForecaster
>>> from sktime.datasets import load_airline
>>> y = load_airline()
>>> forecaster = BaggingForecaster(
...     STLBootstrapTransformer(sp=12), NaiveForecaster(sp=12)
... )
>>> forecaster.fit(y)
BaggingForecaster(...)
>>> y_hat = forecaster.predict([1,2,3])

Methods

`check_is_fitted`([method_name])	Check if the estimator has been fitted.
`clone`()	Obtain a clone of the object with same hyper-parameters and config.
`clone_tags`(estimator[, tag_names])	Clone tags from another object as dynamic override.
`create_test_instance`([parameter_set])	Construct an instance of the class, using first test parameter set.
`create_test_instances_and_names`([parameter_set])	Create list of all test instances and a list of names for them.
`fit`(y[, X, fh])	Fit forecaster to training data.
`fit_predict`(y[, X, fh, X_pred])	Fit and forecast time series at future horizon.
`get_class_tag`(tag_name[, tag_value_default])	Get class tag value from class, with tag level inheritance from parents.
`get_class_tags`()	Get class tags from class, with tag level inheritance from parent classes.
`get_config`()	Get config flags for self.
`get_fitted_params`([deep])	Get fitted parameters.
`get_param_defaults`()	Get object's parameter defaults.
`get_param_names`([sort])	Get object's parameter names.
`get_params`([deep])	Get a dict of parameters values for this object.
`get_pretrained_params`([deep])	Get pretrained parameters of this estimator.
`get_tag`(tag_name[, tag_value_default, ...])	Get tag value from instance, with tag level inheritance and overrides.
`get_tags`()	Get tags from instance, with tag level inheritance and overrides.
`get_test_params`()	Return testing parameter settings for the estimator.
`is_composite`()	Check if the object is composed of other BaseObjects.
`load_from_path`(serial)	Load object from file location.
`load_from_serial`(serial)	Load object from serialized memory container.
`predict`([fh, X])	Forecast time series at future horizon.
`predict_interval`([fh, X, coverage])	Compute/return prediction interval forecasts.
`predict_proba`([fh, X, marginal])	Compute/return fully probabilistic forecasts.
`predict_quantiles`([fh, X, alpha])	Compute/return quantile forecasts.
`predict_residuals`([y, X])	Return residuals of time series forecasts.
`predict_var`([fh, X, cov])	Compute/return variance forecasts.
`pretrain`(y[, X, fh])	Pre-train forecaster on panel (global) data.
`reset`()	Reset the object to a clean post-init state.
`save`([path, serialization_format])	Save serialized self to bytes-like object or to (.zip) file.
`score`(y[, X, fh])	Scores forecast against ground truth, using MAPE (non-symmetric).
`set_config`(**config_dict)	Set config flags to given values.
`set_params`(**params)	Set the parameters of this object.
`set_random_state`([random_state, deep, ...])	Set random_state pseudo-random seed parameters for self.
`set_tags`(**tag_dict)	Set instance level tag overrides to given values.
`update`(y[, X, update_params])	Update cutoff value and, optionally, fitted parameters.
`update_predict`(y[, cv, X, update_params, ...])	Make predictions and update model iteratively over the test set.
`update_predict_single`([y, fh, X, update_params])	Update model with new data and make forecasts.