Estimation is either done by exact or conditional Maximum Likelihood or conditional least-squares, either using Kalman Filter or direct filters.
Currently, functions and classes have to be imported from the corresponding module, but the main classes will be made available in the statsmodels.tsa namespace. The module structure is within statsmodels.tsa is
Some additional functions that are also useful for time series analysis are in other parts of statsmodels, for example additional statistical tests.
Some related functions are also available in matplotlib, nitime, and scikits.talkbox. Those functions are designed more for the use in signal processing where longer time series are available and work more often in the frequency domain.
stattools.acovf(x[, unbiased, demean, fft, …]) | Autocovariance for 1D |
stattools.acf(x[, unbiased, nlags, qstat, …]) | Autocorrelation function for 1d arrays. |
stattools.pacf(x[, nlags, method, alpha]) | Partial autocorrelation estimated |
stattools.pacf_yw(x[, nlags, method]) | Partial autocorrelation estimated with non-recursive yule_walker |
stattools.pacf_ols(x[, nlags]) | Calculate partial autocorrelations |
stattools.ccovf(x, y[, unbiased, demean]) | crosscovariance for 1D |
stattools.ccf(x, y[, unbiased]) | cross-correlation function for 1d |
stattools.periodogram(X) | Returns the periodogram for the natural frequency of X |
stattools.adfuller(x[, maxlag, regression, …]) | Augmented Dickey-Fuller unit root test |
stattools.kpss(x[, regression, lags, store]) | Kwiatkowski-Phillips-Schmidt-Shin test for stationarity. |
stattools.coint(y0, y1[, trend, method, …]) | Test for no-cointegration of a univariate equation |
stattools.bds(x[, max_dim, epsilon, distance]) | Calculate the BDS test statistic for independence of a time series |
stattools.q_stat(x, nobs[, type]) | Return’s Ljung-Box Q Statistic |
stattools.grangercausalitytests(x, maxlag[, …]) | four tests for granger non causality of 2 timeseries |
stattools.levinson_durbin(s[, nlags, isacov]) | Levinson-Durbin recursion for autoregressive processes |
stattools.arma_order_select_ic(y[, max_ar, …]) | Returns information criteria for many ARMA models |
x13.x13_arima_select_order(endog[, …]) | Perform automatic seaonal ARIMA order identification using x12/x13 ARIMA. |
x13.x13_arima_analysis(endog[, maxorder, …]) | Perform x13-arima analysis for monthly or quarterly data. |
The following are the main estimation classes, which can be accessed through statsmodels.tsa.api and their result classes
arima_model.ARMA(endog, order[, exog, …]) | Autoregressive Moving Average ARMA(p,q) Model |
arima_model.ARMAResults(model, params[, …]) | Class to hold results from fitting an ARMA model. |
arima_model.ARIMA(endog, order[, exog, …]) | Autoregressive Integrated Moving Average ARIMA(p,d,q) Model |
arima_model.ARIMAResults(model, params[, …]) | |
kalmanf.kalmanfilter.KalmanFilter | Kalman Filter code intended for use with the ARMA model. |
Besides estimation, several process properties and additional results after estimation are available for vector autoregressive processes.
vector_ar.var_model.LagOrderResults(ics, …) | Results class for choosing a model’s lag order. |
vector_ar.var_model.VAR(endog[, exog, …]) | Fit VAR(p) process and do lag order selection |
vector_ar.var_model.VARProcess(coefs, …[, …]) | Class represents a known VAR(p) process |
vector_ar.var_model.VARResults(endog, …[, …]) | Estimate VAR(p) process with fixed number of lags |
vector_ar.irf.IRAnalysis(model[, P, …]) | Impulse response analysis class. |
vector_ar.var_model.FEVD(model[, P, periods]) | Compute and plot Forecast error variance decomposition and asymptotic standard errors |
vector_ar.hypothesis_test_results.HypothesisTestResults(…) | Results class for hypothesis tests. |
vector_ar.hypothesis_test_results.CausalityTestResults(…) | Results class for Granger-causality and instantaneous causality. |
vector_ar.hypothesis_test_results.NormalityTestResults(…) | Results class for the Jarque-Bera-test for nonnormality. |
vector_ar.hypothesis_test_results.WhitenessTestResults(…) | Results class for the Portmanteau-test for residual autocorrelation. |
vector_ar.dynamic.DynamicVAR(data[, …]) | Estimates time-varying vector autoregression (VAR(p)) using equation-by-equation least squares |
vector_ar.vecm.select_order(data, maxlags[, …]) | Compute lag order selections based on each of the available information criteria. |
vector_ar.vecm.select_coint_rank(endog, …) | Calculate the cointegration rank of a VECM. |
vector_ar.vecm.CointRankResults(rank, neqs, …) | A class for holding the results from testing the cointegration rank. |
vector_ar.vecm.VECM(endog[, exog, …]) | Class representing a Vector Error Correction Model (VECM). |
vector_ar.vecm.VECMResults(endog, exog, …) | Class for holding estimation related results of a vector error correction model (VECM). |
vector_ar.vecm.coint_johansen(endog, …) | Perform the Johansen cointegration test for determining the cointegration rank of a VECM. |
The following are tools to work with the theoretical properties of an ARMA process for given lag-polynomials.
arima_process.ArmaProcess([ar, ma, nobs]) | Theoretical properties of an ARMA process for specified lag-polynomials |
arima_process.ar2arma(ar_des, p, q[, n, …]) | Find arma approximation to ar process |
arima_process.arma2ar(ar, ma[, lags]) | Get the AR representation of an ARMA process |
arima_process.arma2ma(ar, ma[, lags]) | Get the MA representation of an ARMA process |
arima_process.arma_acf(ar, ma[, lags]) | Theoretical autocorrelation function of an ARMA process |
arima_process.arma_acovf(ar, ma[, nobs]) | Theoretical autocovariance function of ARMA process |
arima_process.arma_generate_sample(ar, ma, …) | Generate a random sample of an ARMA process |
arima_process.arma_impulse_response(ar, ma) | Get the impulse response function (MA representation) for ARMA process |
arima_process.arma_pacf(ar, ma[, lags]) | Partial autocorrelation function of an ARMA process |
arima_process.arma_periodogram(ar, ma[, …]) | Periodogram for ARMA process given by lag-polynomials ar and ma |
arima_process.deconvolve(num, den[, n]) | Deconvolves divisor out of signal, division of polynomials for n terms |
arima_process.index2lpol(coeffs, index) | Expand coefficients to lag poly |
arima_process.lpol2index(ar) | Remove zeros from lag polynomial |
arima_process.lpol_fiar(d[, n]) | AR representation of fractional integration |
arima_process.lpol_fima(d[, n]) | MA representation of fractional integration |
arima_process.lpol_sdiff(s) | return coefficients for seasonal difference (1-L^s) |
filters.bk_filter.bkfilter(X[, low, high, K]) | Baxter-King bandpass filter |
filters.hp_filter.hpfilter(X[, lamb]) | Hodrick-Prescott filter |
filters.cf_filter.cffilter(X[, low, high, drift]) | Christiano Fitzgerald asymmetric, random walk filter |
filters.filtertools.convolution_filter(x, filt) | Linear filtering via convolution. |
filters.filtertools.recursive_filter(x, ar_coeff) | Autoregressive, or recursive, filtering. |
filters.filtertools.miso_lfilter(ar, ma, x) | use nd convolution to merge inputs, then use lfilter to produce output |
filters.filtertools.fftconvolve3(in1[, in2, …]) | Convolve two N-dimensional arrays using FFT. |
filters.filtertools.fftconvolveinv(in1, in2) | Convolve two N-dimensional arrays using FFT. |
seasonal.seasonal_decompose(x[, model, …]) | Seasonal decomposition using moving averages |
tsatools.add_trend(x[, trend, prepend, …]) | Adds a trend and/or constant to an array. |
tsatools.detrend(x[, order, axis]) | Detrend an array with a trend of given order along axis 0 or 1 |
tsatools.lagmat(x, maxlag[, trim, original, …]) | Create 2d array of lags |
tsatools.lagmat2ds(x, maxlag0[, maxlagex, …]) | Generate lagmatrix for 2d array, columns arranged by variables |