ExponentialSmoothing

class ExponentialSmoothing(trend=None, damped_trend=False, seasonal=None, sp=None, initial_level=None, initial_trend=None, initial_seasonal=None, use_boxcox=None, initialization_method='estimated', smoothing_level=None, smoothing_trend=None, smoothing_seasonal=None, damping_trend=None, optimized=True, remove_bias=False, start_params=None, method=None, minimize_kwargs=None, use_brute=True, random_state=None)[source]

Holt-Winters exponential smoothing forecaster.

Direct interface for statsmodels.tsa.holtwinters.

Default settings use simple exponential smoothing without trend and seasonality components.

Parameters:

trend{“add”, “mul”, “additive”, “multiplicative”, None}, default=None: Type of trend component.
damped_trendbool, default=False: Should the trend component be damped.
seasonal{“add”, “mul”, “additive”, “multiplicative”, None}, default=None: Type of seasonal component.Takes one of
spint or None, default=None: The number of seasonal periods to consider.
initial_levelfloat or None, default=None: The alpha value of the simple exponential smoothing, if the value is set then this value will be used as the value.
initial_trendfloat or None, default=None: The beta value of the Holt’s trend method, if the value is set then this value will be used as the value.
initial_seasonalfloat or None, default=None: The gamma value of the holt winters seasonal method, if the value is set then this value will be used as the value.
use_boxcox{True, False, ‘log’, float}, default=None: Should the Box-Cox transform be applied to the data first? If ‘log’ then apply the log. If float then use lambda equal to float.
initialization_method:{‘estimated’,’heuristic’,’legacy-heuristic’,’known’,None},: default=’estimated’ Method for initialize the recursions. If ‘known’ initialization is used, then initial_level must be passed, as well as initial_trend and initial_seasonal if applicable. ‘heuristic’ uses a heuristic based on the data to estimate initial level, trend, and seasonal state. ‘estimated’ uses the same heuristic as initial guesses, but then estimates the initial states as part of the fitting process.
smoothing_levelfloat, optional: The alpha value of the simple exponential smoothing, if the value is set then this value will be used as the value.
smoothing_trendfloat, optional: The beta value of the Holt’s trend method, if the value is set then this value will be used as the value.
smoothing_seasonalfloat, optional: The gamma value of the holt winters seasonal method, if the value is set then this value will be used as the value.
damping_trendfloat, optional: The phi value of the damped method, if the value is set then this value will be used as the value.
optimizedbool, optional: Estimate model parameters by maximizing the log-likelihood.
remove_biasbool, optional: Remove bias from forecast values and fitted values by enforcing that the average residual is equal to zero.
start_paramsarray_like, optional: Starting values to used when optimizing the fit. If not provided, starting values are determined using a combination of grid search and reasonable values based on the initial values of the data. See the notes for the structure of the model parameters.
methodstr, default “SLSQP”: The minimizer used. Valid options are “L-BFGS-B” , “TNC”, “SLSQP” (default), “Powell”, “trust-constr”, “basinhopping” (also “bh”) and “least_squares” (also “ls”). basinhopping tries multiple starting values in an attempt to find a global minimizer in non-convex problems, and so is slower than the others.
minimize_kwargsdict[str, Any]: A dictionary of keyword arguments passed to SciPy’s minimize function if method is one of “L-BFGS-B”, “TNC”, “SLSQP”, “Powell”, or “trust-constr”, or SciPy’s basinhopping or least_squares functions. The valid keywords are optimizer specific. Consult SciPy’s documentation for the full set of options.
use_brutebool, optional: Search for good starting values using a brute force (grid) optimizer. If False, a naive set of starting values is used.
random_stateint, RandomState instance or None, optional ,: default=None - If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by np.random.

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, Rob J., and George Athanasopoulos. Forecasting: principles: and practice. OTexts, 2014.

Examples

>>> from sktime.datasets import load_airline
>>> from sktime.forecasting.exp_smoothing import ExponentialSmoothing
>>> y = load_airline()
>>> forecaster = ExponentialSmoothing(
...     trend='add', seasonal='multiplicative', sp=12
... )
>>> forecaster.fit(y)
ExponentialSmoothing(...)
>>> y_pred = forecaster.predict(fh=[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`([parameter_set])	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.