ARIMA-Modelle

Eine Reihe, die sich an sich selbst erinnert

Viele Reihen tragen Information über ihre eigene Zukunft. Zinsspreads, Volatilität und die Lücke zwischen zwei verwandten Preisen driften auf ein Niveau zurück, statt frei umherzuwandern. ARIMA-Modelle erfassen das mit drei Ideen: I, die Reihe differenzieren, um sie stationär zu machen; AR, sie auf ihre eigenen Verzögerungen regressieren; MA, die jüngsten Prognosefehler nutzen. Aktienrenditen selbst zeigen kaum ein solches Gedächtnis, ARIMA gehört also zu persistenten oder mean-reverting Reihen.

import numpy as np

prices = np.array([100.0, 101.5, 103.2, 104.1, 106.0, 107.2])

print(np.diff(prices))              # first differences: the changes             [1.5 1.7 0.9 1.9 1.2]
print(np.diff(prices, n=2))         # second differences: the change of the changes
print(np.diff(np.log(prices)))      # the differenced log price is the log return

Differenzierung und Autokorrelation

Preise wandern und haben keinen stabilen Mittelwert; ihre Änderungen oft schon. Die erste Differenz (Ordnung d = 1) entfernt einen Trend, eine zweite (d = 2) einen gekrümmten Trend. Die Autokorrelationsfunktion (ACF) zeigt dann das Gedächtnis: Ihr Wert bei Lag k ist die Korrelation der Reihe mit sich selbst k Schritte früher, sum((x[t] - m) * (x[t+k] - m)) / sum((x[t] - m)**2). Eine langsam abklingende ACF deutet auf ein AR-Modell; eine ACF nahe null bei allen Lags heißt, es gibt nichts vorherzusagen.

# The ACF of a persistent series decays slowly; the ACF of noise is near zero
import numpy as np

def acf(series, lags):
    dev = series - series.mean()
    total = np.sum(dev ** 2)
    return np.array([np.sum(dev[:len(series) - k] * dev[k:]) / total for k in range(1, lags + 1)])

rng = np.random.default_rng(1)
noise = rng.normal(size=500)
persistent = np.empty(500)
persistent[0] = 0.0
for t in range(1, 500):
    persistent[t] = 0.8 * persistent[t - 1] + noise[t]           # an AR(1) with phi = 0.8
print(np.round(acf(persistent, 4), 3))                           # decays slowly: 0.74, 0.58, 0.48, 0.39 in this sample
print(np.round(acf(noise, 4), 3))                                # all near 0

# Differencing a trending series makes its mean stable
import numpy as np

rng = np.random.default_rng(6)
trend = 100 + 0.5 * np.arange(200) + rng.normal(0, 1, size=200).cumsum()          # a trending random walk
changes = np.diff(trend)
print(round(float(trend[:100].mean()), 1), round(float(trend[100:].mean()), 1))     # the level drifts: the halves differ a lot
print(round(float(changes[:100].mean()), 2), round(float(changes[100:].mean()), 2))   # the changes have a similar mean in both halves

Ein AR(1) anpassen und vorhersagen

Ein AR(1) sagt x[t] = c + phi * x[t-1] + Rauschen. Es ist eine Geradenregression jedes Werts auf den vorherigen: phi ist die Steigung, c der Achsenabschnitt, aus denselben Summen wie das Beta im CAPM-Thema. Die Prognose ist rekursiv: Der erste Schritt ist c + phi * last, jeder weitere nutzt die vorherige Prognose. Für |phi| < 1 konvergieren die Prognosen gegen den langfristigen Mittelwert c / (1 - phi), mit einer von phi bestimmten Geschwindigkeit: eine mean-reverting Reihe.

import numpy as np

def fit_ar1(series):
    a, b = series[:-1], series[1:]
    phi = np.sum((a - a.mean()) * (b - b.mean())) / np.sum((a - a.mean()) ** 2)
    return float(b.mean() - phi * a.mean()), float(phi)

def forecast_ar1(last, c, phi, steps):
    out, value = [], last
    for _ in range(steps):
        value = c + phi * value
        out.append(value)
    return np.array(out)

rng = np.random.default_rng(3)
x = np.empty(400)
x[0] = 2.0
for t in range(1, 400):
    x[t] = 0.5 + 0.75 * x[t - 1] + rng.normal(0, 0.3)             # true c = 0.5, phi = 0.75, mean 2.0
c, phi = fit_ar1(x)
print(round(c, 3), round(phi, 3))
print(np.round(forecast_ar1(4.0, c, phi, 5), 3), round(c / (1 - phi), 3))

• ARIMA = Differenzierung (I) + Autoregression (AR) + vergangene Fehler (MA); Differenzieren macht eine Reihe mit Trend stationär.
• Die ACF bei Lag k ist die Korrelation der Reihe mit sich selbst k Schritte früher; langsames Abklingen deutet auf ein AR-Modell.
• Eine AR(1)-Anpassung ist eine Regression von x[1:] auf x[:-1]; Prognosen speisen sich gegenseitig und konvergieren bei |phi| < 1 gegen c / (1 - phi); schlagen Sie stets die Prognose „keine Änderung“.

Als Nächstes: GARCH-Volatilitätsmodelle, nicht das Niveau der Renditen vorhersagen, sondern wie heftig sie sich bewegen.

Lab: Was bewertet wird

• Mit difference den Trend entfernen25 Pkt.
• Mit acf das Gedächtnis messen25 Pkt.
• Mit fit_ar1 das Modell anpassen25 Pkt.
• Mit forecast_ar1 vorausschauen25 Pkt.