ARIMA Models in IronPython QuickStart Sample

Illustrates how to work with ARIMA time series models using classes in the Numerics.NET.Statistics.TimeSeriesAnalysis namespace in IronPython.

This sample is also available in: C#, Visual Basic, F#.

Overview

This QuickStart sample demonstrates how to use the ArimaModel class to perform time series analysis and forecasting using ARIMA (AutoRegressive Integrated Moving Average) models in Numerics.NET.

The sample illustrates two common ARIMA model specifications:

An ARMA(2,1) model without differencing
An ARIMA(0,1,1) model with first-order differencing

For each model, the sample shows how to:

Create and configure the model
Fit the model to sunspot time series data
Access model parameters and their statistical properties
Examine model fit statistics including log-likelihood, AIC, and BIC
Generate forecasts for future time periods

The sample also demonstrates how to:

Work with model parameters including standard errors and significance tests
Control model estimation options like mean estimation
Access diagnostic information about the fitted model
Generate both single-step and multi-step forecasts

This provides a practical introduction to time series modeling and forecasting using ARIMA models in Numerics.NET.

The code

import numerics

from Extreme.Mathematics import *
from Extreme.Statistics import *
from Extreme.Statistics.TimeSeriesAnalysis import *

# Illustrates the use of the ArimaModel class to perform
# estimation and forecasting of ARIMA time series models..

# This QuickStart Sample fits an ARMA(2,1) model and
# an ARIMA(0,1,1) model to sunspot data.

# The time series data is stored in a numerical variable:
sunspots = NumericalVariable("sunspots", Vector([ \
    100.8, 81.6, 66.5, 34.8, 30.6, 7, 19.8, 92.5, 154.4, \
    125.9, 84.8, 68.1, 38.5, 22.8, 10.2, 24.1, 82.9, \
    132, 130.9, 118.1, 89.9, 66.6, 60, 46.9, 41, 21.3, \
    16, 6.4, 4.1, 6.8, 14.5, 34, 45, 43.1, 47.5, 42.2, \
    28.1, 10.1, 8.1, 2.5, 0, 1.4, 5, 12.2, 13.9, 35.4, \
    45.8, 41.1, 30.4, 23.9, 15.7, 6.6, 4, 1.8, 8.5, \
    16.6, 36.3, 49.7, 62.5, 67, 71, 47.8, 27.5, 8.5, \
    13.2, 56.9, 121.5, 138.3, 103.2, 85.8, 63.2, 36.8, \
    24.2, 10.7, 15, 40.1, 61.5, 98.5, 124.3, 95.9, 66.5, \
    64.5, 54.2, 39, 20.6, 6.7, 4.3, 22.8, 54.8, 93.8, \
    95.7, 77.2, 59.1, 44, 47, 30.5, 16.3, 7.3, 37.3, 73.9 ]))

# ARMA models (no differencing) are constructed from
# the variable containing the time series data, and the
# AR and MA orders. The following constructs an ARMA(2,1)
# model:
model = ArimaModel(sunspots, 2, 1)

# The Compute methods fits the model.
model.Compute()

# The model's Parameters collection contains the fitted values.
# For an ARIMA(p,d,q) model, the first p parameters are the 
# auto-regressive parameters. The last q parametere are the
# moving average parameters.
print "Parameter      Value  Std.Error  t-stat  p-Value"
for parameter in model.Parameters:
    # Parameter objects have the following properties:
    print "{0:10}{1:10.5f} {2:10.5f}{3:8.2f} {4:7.4f}".format( # Name, usually the name of the variable:
        parameter.Name, # Estimated value of the parameter:
        parameter.Value, # Standard error:
        parameter.StandardError, # The value of the t statistic for the hypothesis that the parameter
        # is zero.
        parameter.Statistic, # Probability corresponding to the t statistic.
        parameter.PValue)


# The log-likelihood of the computed solution is also available:
print "Log-likelihood: {0:.4f}".format(model.GetLogLikelihood())
# as is the Akaike Information Criterion (AIC):
print "AIC: {0:.4f}".format(model.GetAkaikeInformationCriterion())
# and the Baysian Information Criterion (BIC):
print "BIC: {0:.4f}".format(model.GetBayesianInformationCriterion())

# The Forecast method can be used to predict the next value in the series...
nextValue = model.Forecast()
print "One step ahead forecast: {0:.3f}".format(nextValue)

# or to predict a specified number of values:
nextValues = model.Forecast(5)
print "First five forecasts: ", nextValues.ToString("F3")


# An integrated model (with differencing) is constructed
# by supplying the degree of differencing. Note the order
# of the orders is the traditional one for an ARIMA(p,d,q)
# model (p, d, q).
# The following constructs an ARIMA(0,1,1) model:
model2 = ArimaModel(sunspots, 0, 1, 1)

# By default, the mean is assumed to be zero for an integrated model.
# We can override this by setting the EstimateMean property to True:
model2.EstimateMean = True

# The Compute methods fits the model.
model2.Compute()

# The mean shows up as one of the parameters.
print "Parameter      Value  Std.Error  t-stat  p-Value"
for parameter in model2.Parameters:
    print "{0:10}{1:10.5f} {2:10.5f}{3:8.2f} {4:7.4f}".format(
        parameter.Name, parameter.Value, parameter.StandardError, parameter.Statistic, parameter.PValue)

# We can also get the error variance:
print "Error variance: {0:.4f}".format(model2.ErrorVariance)

print "Log-likelihood: {0:.4f}".format(model2.GetLogLikelihood())
print "AIC: {0:.4f}".format(model2.GetAkaikeInformationCriterion())
print "BIC: {0:.4f}".format(model2.GetBayesianInformationCriterion())