pyramid.arima.ARIMA

class pyramid.arima.ARIMA(order, seasonal_order=None, start_params=None, trend='c', method=None, transparams=True, solver='lbfgs', maxiter=50, disp=0, callback=None, suppress_warnings=False, out_of_sample_size=0, scoring='mse', scoring_args=None)

An ARIMA estimator.

An ARIMA, or autoregressive integrated moving average, is a generalization of an autoregressive moving average (ARMA) and is fitted to time-series data in an effort to forecast future points. ARIMA models can be especially efficacious in cases where data shows evidence of non-stationarity.

The “AR” part of ARIMA indicates that the evolving variable of interest is regressed on its own lagged (i.e., prior observed) values. The “MA” part indicates that the regression error is actually a linear combination of error terms whose values occurred contemporaneously and at various times in the past. The “I” (for “integrated”) indicates that the data values have been replaced with the difference between their values and the previous values (and this differencing process may have been performed more than once). The purpose of each of these features is to make the model fit the data as well as possible.

Non-seasonal ARIMA models are generally denoted ARIMA(p,d,q) where parameters p, d, and q are non-negative integers, p is the order (number of time lags) of the autoregressive model, d is the degree of differencing (the number of times the data have had past values subtracted), and q is the order of the moving-average model. Seasonal ARIMA models are usually denoted ARIMA(p,d,q)(P,D,Q)m, where m refers to the number of periods in each season, and the uppercase P, D, Q refer to the autoregressive, differencing, and moving average terms for the seasonal part of the ARIMA model.

When two out of the three terms are zeros, the model may be referred to based on the non-zero parameter, dropping “AR”, “I” or “MA” from the acronym describing the model. For example, ARIMA(1,0,0) is AR(1), ARIMA(0,1,0) is I(1), and ARIMA(0,0,1) is MA(1). [1]

See notes for more practical information on the ARIMA class.

Parameters:

order : iterable or array-like, shape=(3,)

The (p,d,q) order of the model for the number of AR parameters, differences, and MA parameters to use. p is the order (number of time lags) of the auto-regressive model, and is a non-negative integer. d is the degree of differencing (the number of times the data have had past values subtracted), and is a non-negative integer. q is the order of the moving-average model, and is a non-negative integer.

seasonal_order : array-like, shape=(4,), optional (default=None)

The (P,D,Q,s) order of the seasonal component of the model for the AR parameters, differences, MA parameters, and periodicity. D must be an integer indicating the integration order of the process, while P and Q may either be an integers indicating the AR and MA orders (so that all lags up to those orders are included) or else iterables giving specific AR and / or MA lags to include. S is an integer giving the periodicity (number of periods in season), often it is 4 for quarterly data or 12 for monthly data. Default is no seasonal effect.

start_params : array-like, optional (default=None)

Starting parameters for ARMA(p,q). If None, the default is given by ARMA._fit_start_params.

transparams : bool, optional (default=True)

Whehter or not to transform the parameters to ensure stationarity. Uses the transformation suggested in Jones (1980). If False, no checking for stationarity or invertibility is done.

method : str, one of {‘css-mle’,’mle’,’css’}, optional (default=None)

This is the loglikelihood to maximize. If “css-mle”, the conditional sum of squares likelihood is maximized and its values are used as starting values for the computation of the exact likelihood via the Kalman filter. If “mle”, the exact likelihood is maximized via the Kalman Filter. If “css” the conditional sum of squares likelihood is maximized. All three methods use start_params as starting parameters. See above for more information. If fitting a seasonal ARIMA, the default is ‘lbfgs’

trend : str or iterable, optional (default=’c’)

Parameter controlling the deterministic trend polynomial \(A(t)\). Can be specified as a string where ‘c’ indicates a constant (i.e. a degree zero component of the trend polynomial), ‘t’ indicates a linear trend with time, and ‘ct’ is both. Can also be specified as an iterable defining the polynomial as in numpy.poly1d, where [1,1,0,1] would denote \(a + bt + ct^3\).

solver : str or None, optional (default=’lbfgs’)

Solver to be used. The default is ‘lbfgs’ (limited memory Broyden-Fletcher-Goldfarb-Shanno). Other choices are ‘bfgs’, ‘newton’ (Newton-Raphson), ‘nm’ (Nelder-Mead), ‘cg’ - (conjugate gradient), ‘ncg’ (non-conjugate gradient), and ‘powell’. By default, the limited memory BFGS uses m=12 to approximate the Hessian, projected gradient tolerance of 1e-8 and factr = 1e2. You can change these by using kwargs.

maxiter : int, optional (default=50)

The maximum number of function evaluations. Default is 50.

disp : int, optional (default=0)

If True, convergence information is printed. For the default ‘lbfgs’ solver, disp controls the frequency of the output during the iterations. disp < 0 means no output in this case.

callback : callable, optional (default=None)

Called after each iteration as callback(xk) where xk is the current parameter vector. This is only used in non-seasonal ARIMA models.

suppress_warnings : bool, optional (default=False)

Many warnings might be thrown inside of statsmodels. If suppress_warnings is True, all of these warnings will be squelched.

out_of_sample_size : int, optional (default=0)

The number of examples from the tail of the time series to hold out and use as validation examples. The model will not be fit on these samples, but the observations will be added into the model’s endog and exog arrays so that future forecast values originate from the end of the endogenous vector. See add_new_observations().

For instance:

y = [0, 1, 2, 3, 4, 5, 6]
out_of_sample_size = 2

> Fit on: [0, 1, 2, 3, 4]
> Score on: [5, 6]
> Append [5, 6] to end of self.arima_res_.data.endog values

scoring : str, optional (default=’mse’)

If performing validation (i.e., if out_of_sample_size > 0), the metric to use for scoring the out-of-sample data. One of {‘mse’, ‘mae’}

scoring_args : dict, optional (default=None)

A dictionary of key-word arguments to be passed to the scoring metric.

See also

pyramid.arima.auto_arima()

Notes

• Since the ARIMA class currently wraps statsmodels.tsa.arima_model.ARIMA, which does not provide support for seasonality, the only way to fit seasonal ARIMAs is to manually lag/pre-process your data appropriately. This might change in the future. [2]
• After the model fit, many more methods will become available to the fitted model (i.e., pvalues(), params(), etc.). These are delegate methods which wrap the internal ARIMA results instance.

References

[R17]

https://wikipedia.org/wiki/Autoregressive_integrated_moving_average

[R18]

Statsmodels ARIMA documentation: http://bit.ly/2wc9Ra8

Methods

add_new_observations(y[, exogenous])	Update the endog/exog samples after a model fit.
aic()	Get the AIC, the Akaike Information Criterion:
aicc()	Get the AICc, the corrected Akaike Information Criterion:
arparams()	Get the parameters associated with the AR coefficients in the model.
arroots()	The roots of the AR coefficients are the solution to:
bic()	Get the BIC, the Bayes Information Criterion:
bse()	Get the standard errors of the parameters.
conf_int([alpha])	Returns the confidence interval of the fitted parameters.
df_model()	The model degrees of freedom: k_exog + k_trend + k_ar + k_ma.
df_resid()	Get the residual degrees of freedom:
fit(y[, exogenous])	Fit an ARIMA to a vector, y, of observations with an optional matrix of exogenous variables.
fit_predict(y[, exogenous, n_periods])	Fit an ARIMA to a vector, y, of observations with an optional matrix of exogenous variables, and then generate predictions.
get_params([deep])	Get parameters for this estimator.
hqic()	Get the Hannan-Quinn Information Criterion:
maparams()	Get the value of the moving average coefficients.
maroots()	The roots of the MA coefficients are the solution to:
oob()	If the model was built with out_of_sample_size > 0, a validation score will have been computed.
params()	Get the parameters of the model.
predict([n_periods, exogenous, …])	Generate predictions (forecasts) n_periods in the future.
predict_in_sample([exogenous, start, end, …])	Generate in-sample predictions from the fit ARIMA model.
pvalues()	Get the p-values associated with the t-values of the coefficients.
resid()	Get the model residuals.
set_params(**params)	Set the parameters of this estimator.
summary()	Get a summary of the ARIMA model

__init__(order, seasonal_order=None, start_params=None, trend='c', method=None, transparams=True, solver='lbfgs', maxiter=50, disp=0, callback=None, suppress_warnings=False, out_of_sample_size=0, scoring='mse', scoring_args=None)

Initialize self. See help(type(self)) for accurate signature.

add_new_observations(y, exogenous=None)

Update the endog/exog samples after a model fit.

After fitting your model and creating forecasts, you’re going to need to attach new samples to the data you fit on. These are used to compute new forecasts (but using the same estimated parameters).

Parameters:

y : array-like or iterable, shape=(n_samples,)

The time-series data to add to the endogenous samples on which the ARIMA estimator was previously fit. This may either be a Pandas Series object or a numpy array. This should be a one- dimensional array of finite floats.

exogenous : array-like, shape=[n_obs, n_vars], optional (default=None)

An optional 2-d array of exogenous variables. If the model was fit with an exogenous array of covariates, it will be required for updating the observed values.

Notes

This does not constitute re-fitting, as the model params do not change, so do not use this in place of periodically refreshing the model. Use it only to add new observed values from which to forecast new values.

aic()

Get the AIC, the Akaike Information Criterion:

-2 * llf + 2 * df_model

Where df_model (the number of degrees of freedom in the model) includes all AR parameters, MA parameters, constant terms parameters on constant terms and the variance.

Returns:

aic : float

The AIC

References

[R19]

https://en.wikipedia.org/wiki/Akaike_information_criterion

aicc()

Get the AICc, the corrected Akaike Information Criterion:

AIC + 2 * df_model * (df_model + 1) / (nobs - df_model - 1)

Where df_model (the number of degrees of freedom in the model) includes all AR parameters, MA parameters, constant terms parameters on constant terms and the variance. And nobs is the sample size.

Returns:

aicc : float

The AICc

References

[R20]

https://en.wikipedia.org/wiki/Akaike_information_criterion#AICc

arparams()

Get the parameters associated with the AR coefficients in the model.

Returns:

arparams : array-like

The AR coefficients.

arroots()

The roots of the AR coefficients are the solution to:

(1 - arparams[0] * z - arparams[1] * z^2 - ... - arparams[ p-1] * z^k_ar) = 0

Stability requires that the roots in modulus lie outside the unit circle.

Returns:

arroots : array-like

The roots of the AR coefficients.

bic()

Get the BIC, the Bayes Information Criterion:

-2 * llf + log(nobs) * df_model

Where if the model is fit using conditional sum of squares, the number of observations nobs does not include the p pre-sample observations.

Returns:

bse : float

The BIC

References

[R21]

https://en.wikipedia.org/wiki/Bayesian_information_criterion

bse()

Get the standard errors of the parameters. These are computed using the numerical Hessian.

Returns:

bse : array-like

The BSE

conf_int(alpha=0.05, **kwargs)

Returns the confidence interval of the fitted parameters.

Returns:

alpha : float, optional (default=0.05)

The significance level for the confidence interval. ie., the default alpha = .05 returns a 95% confidence interval.

**kwargs : keyword args or dict

Keyword arguments to pass to the confidence interval function. Could include ‘cols’ or ‘method’

df_model()

The model degrees of freedom: k_exog + k_trend + k_ar + k_ma.

Returns:

df_model : array-like

The degrees of freedom in the model.

df_resid()

Get the residual degrees of freedom:

nobs - df_model

Returns:

df_resid : array-like

The residual degrees of freedom.

fit(y, exogenous=None, **fit_args)

Fit an ARIMA to a vector, y, of observations with an optional matrix of exogenous variables.

Parameters:

y : array-like or iterable, shape=(n_samples,)

The time-series to which to fit the ARIMA estimator. This may either be a Pandas Series object (statsmodels can internally use the dates in the index), or a numpy array. This should be a one-dimensional array of floats, and should not contain any np.nan or np.inf values.

exogenous : array-like, shape=[n_obs, n_vars], optional (default=None)

An optional 2-d array of exogenous variables. If provided, these variables are used as additional features in the regression operation. This should not include a constant or trend. Note that if an ARIMA is fit on exogenous features, it must be provided exogenous features for making predictions.

**fit_args : dict or kwargs

Any keyword arguments to pass to the statsmodels ARIMA fit.

fit_predict(y, exogenous=None, n_periods=10, **fit_args)

Fit an ARIMA to a vector, y, of observations with an optional matrix of exogenous variables, and then generate predictions.

Parameters:

y : array-like or iterable, shape=(n_samples,)

The time-series to which to fit the ARIMA estimator. This may either be a Pandas Series object (statsmodels can internally use the dates in the index), or a numpy array. This should be a one-dimensional array of floats, and should not contain any np.nan or np.inf values.

exogenous : array-like, shape=[n_obs, n_vars], optional (default=None)

An optional 2-d array of exogenous variables. If provided, these variables are used as additional features in the regression operation. This should not include a constant or trend. Note that if an ARIMA is fit on exogenous features, it must be provided exogenous features for making predictions.

n_periods : int, optional (default=10)

The number of periods in the future to forecast.

fit_args : dict or kwargs, optional (default=None)

Any keyword args to pass to the fit method.

get_params(deep=True)

Get parameters for this estimator.

Parameters:

deep : boolean, optional

If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns:

params : mapping of string to any

Parameter names mapped to their values.

hqic()

Get the Hannan-Quinn Information Criterion:

-2 * llf + 2 * (`df_model) * log(log(nobs))`

Like bic() if the model is fit using conditional sum of squares then the k_ar pre-sample observations are not counted in nobs.

Returns:

hqic : float

The HQIC

References

[R22]

https://en.wikipedia.org/wiki/Hannan-Quinn_information_criterion

maparams()

Get the value of the moving average coefficients.

Returns:

maparams : array-like

The MA coefficients.

maroots()

The roots of the MA coefficients are the solution to:

(1 + maparams[0] * z + maparams[1] * z^2 + ... + maparams[ q-1] * z^q) = 0

Stability requires that the roots in modules lie outside the unit circle.

Returns:

maroots : array-like

The MA roots.

oob()

If the model was built with out_of_sample_size > 0, a validation score will have been computed. Otherwise it will be np.nan.

Returns:

oob_ : float

The “out-of-bag” score.

params()

Get the parameters of the model. The order of variables is the trend coefficients and the k_exog() exogenous coefficients, then the k_ar() AR coefficients, and finally the k_ma() MA coefficients.

Returns:

params : array-like

The parameters of the model.

predict(n_periods=10, exogenous=None, return_conf_int=False, alpha=0.05)

Generate predictions (forecasts) n_periods in the future. Note that if exogenous variables were used in the model fit, they will be expected for the predict procedure and will fail otherwise.

Parameters:

n_periods : int, optional (default=10)

The number of periods in the future to forecast.

exogenous : array-like, shape=[n_obs, n_vars], optional (default=None)

An optional 2-d array of exogenous variables. If provided, these variables are used as additional features in the regression operation. This should not include a constant or trend. Note that if an ARIMA is fit on exogenous features, it must be provided exogenous features for making predictions.

return_conf_int : bool, optional (default=False)

Whether to get the confidence intervals of the forecasts.

alpha : float, optional (default=0.05)

The confidence intervals for the forecasts are (1 - alpha) %

Returns:

forecasts : array-like, shape=(n_periods,)

The array of fore-casted values.

conf_int : array-like, shape=(n_periods, 2), optional

The confidence intervals for the forecasts. Only returned if return_conf_int is True.

predict_in_sample(exogenous=None, start=None, end=None, dynamic=False)

Generate in-sample predictions from the fit ARIMA model. This can be useful when wanting to visualize the fit, and qualitatively inspect the efficacy of the model, or when wanting to compute the residuals of the model.

Parameters:

exogenous : array-like, shape=[n_obs, n_vars], optional (default=None)

An optional 2-d array of exogenous variables. If provided, these variables are used as additional features in the regression operation. This should not include a constant or trend. Note that if an ARIMA is fit on exogenous features, it must be provided exogenous features for making predictions.

start : int, optional (default=None)

Zero-indexed observation number at which to start forecasting, ie., the first forecast is start.

end : int, optional (default=None)

Zero-indexed observation number at which to end forecasting, ie., the first forecast is start.

dynamic : bool, optional

The dynamic keyword affects in-sample prediction. If dynamic is False, then the in-sample lagged values are used for prediction. If dynamic is True, then in-sample forecasts are used in place of lagged dependent variables. The first forecasted value is start.

Returns:

predict : array

The predicted values.

pvalues()

Get the p-values associated with the t-values of the coefficients. Note that the coefficients are assumed to have a Student’s T distribution.

Returns:

pvalues : array-like

The p-values.

resid()

Get the model residuals. If the model is fit using ‘mle’, then the residuals are created via the Kalman Filter. If the model is fit using ‘css’ then the residuals are obtained via scipy.signal.lfilter adjusted such that the first k_ma() residuals are zero. These zero residuals are not returned.

Returns:

resid : array-like

The model residuals.

set_params(**params)

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as pipelines). The latter have parameters of the form <component>__<parameter> so that it’s possible to update each component of a nested object.

Returns:self

summary()

Get a summary of the ARIMA model