Ein praktisches Tutorial zum AR(p) -Prozess für die Zeitreihenanalyse in Python
In diesem praktischen Tutorial behandeln wir das Thema Zeitreihenmodellierung mit autoregressiven Prozessen.
Dieser Artikel behandelt die folgenden Schlüsselelemente der Zeitreihenanalyse:
- autoregressiver Prozess
- Yule-Walker-Gleichung
- Stationarität
- Erweiterter Dicker-Fuller-Test
Stellen Sie sicher, dass Sie ein Jupyter-Notizbuch bereit haben, dem Sie folgen können. Der Code und der Datensatz sind hier verfügbar.
Los geht’s!
Erfahren Sie, wie Sie mit komplexeren Modellen wie SARIMAX, VARMAX arbeiten und Deep-Learning-Modelle (LSTM, CNN, ResNet, autoregressives LSTM) für die Zeitreihenanalyse anwenden Angewandte Zeitreihenanalyse in Python!
Autoregressiver Prozess
Ein autoregressives Modell verwendet eine lineare Kombination vergangener Werte des Ziels, um Prognosen zu erstellen. Natürlich wird die Regression gegen das Ziel selbst durchgeführt. Mathematisch wird ein AR(p) -Modell ausgedrückt als:
Wobei:
- p: ist die Reihenfolge
- c: ist eine Konstante
- epsilon: noise
Das AR(p) -Modell ist unglaublich flexibel und kann viele verschiedene Arten von Zeitreihenmustern modellieren. Dies lässt sich leicht visualisieren, wenn wir autoregressive Prozesse simulieren.
Normalerweise werden autoregressive Modelle nur auf stationäre Zeitreihen angewendet. Dies schränkt den Bereich der Parameter phi ein.
Zum Beispiel wird ein AR(1) -Modell phi zwischen -1 und 1 einschränken. Diese Einschränkungen werden mit zunehmender Reihenfolge des Modells komplexer, werden jedoch bei der Modellierung in Python automatisch berücksichtigt.
Simulation eines AR(2) -Prozesses
Lassen Sie uns einen AR(2) -Prozess in Python simulieren.
Wir beginnen mit dem Import einiger Bibliotheken. Nicht alle werden für die Simulation verwendet, aber sie werden für den Rest dieses Tutorials benötigt.
from statsmodels.graphics.tsaplots import plot_pacf
from statsmodels.graphics.tsaplots import plot_acf
from statsmodels.tsa.arima_process import ArmaProcess
from statsmodels.tsa.stattools import pacf
from statsmodels.regression.linear_model import yule_walker
from statsmodels.tsa.stattools import adfuller
import matplotlib.pyplot as plt
import numpy as np%matplotlib inline
Wir werden die ArmaProcess-Bibliothek verwenden, um die Zeitreihen zu simulieren. Es erfordert, dass wir unsere Parameter definieren.
Wir werden den folgenden Prozess simulieren:
Da es sich um ein autoregressives Modell der Ordnung 2 handelt, müssen wir den Koeffizienten bei Verzögerung 0, 1 und 2 definieren.
Außerdem werden wir den Effekt eines gleitenden Durchschnittsprozesses aufheben.
Schließlich werden wir 10 000 Datenpunkte generieren.
Im Code:
ar2 = np.array()
ma = np.array()simulated_AR2_data = ArmaProcess(ar2, ma).generate_sample(nsample=10000)
Wir können die Zeitreihe zeichnen:
plt.figure(figsize=); # Set dimensions for figure
plt.plot(simulated_AR2_data)
plt.title("Simulated AR(2) Process")
plt.show()
And you should get something similar to this:
Now, let’s take a look at the autocorrelation plot (correlogram):
plot_acf(simulated_AR2_data);
Sie können sehen, dass der Koeffizient langsam abnimmt. Dies bedeutet, dass es sich wahrscheinlich nicht um einen gleitenden Durchschnittsprozess handelt, und es deutet darauf hin, dass die Zeitreihe wahrscheinlich mit einem autoregressiven Prozess modelliert werden kann (was sinnvoll ist, da wir dies simulieren).
Um sicherzustellen, dass dies richtig ist, zeichnen wir das partielle Autokorrelationsdiagramm:
plot_pacf(simulated_AR2_data);
R(2) process
Wie Sie sehen können, sind die Koeffizienten nach Lag 2 nicht signifikant. Daher ist das partielle Autokorrelationsdiagramm nützlich, um die Reihenfolge eines AR (p) -Prozesses zu bestimmen.
Sie können die Werte der einzelnen Koeffizienten auch überprüfen, indem Sie:
pacf_coef_AR2 = pacf(simulated_AR2_data)
print(pacf_coef_AR2)
In einer realen Projektumgebung kann es nun einfach sein, die Reihenfolge eines AR(p) -Prozesses zu finden, aber wir müssen einen Weg finden, um die Koeffizienten phi .
Dazu verwenden wir die Yule-Walker-Gleichung. Diese Gleichungen ermöglichen es uns, die Koeffizienten eines AR (p) -Modells zu schätzen, da wir die Reihenfolge kennen.
rho, sigma = yule_walker(simulated_AR2_data, 2, method='mle')
print(f'rho: {-rho}')
print(f'sigma: {sigma}')
Yule-Walker-Koeffizientenschätzungen
Wie Sie sehen können, hat die Yule-Walker-Gleichung unsere Koeffizienten gut abgeschätzt und kam sehr nahe an 0,33 und 0,5 heran.
Simulation eines AR(3) -Prozesses
Lassen Sie uns nun einen AR(3) -Prozess simulieren. Konkret simulieren wir:
Ähnlich wie zuvor definieren wir unsere Koeffizienten und generieren 10 000-Datenpunkte:
ar3 = np.array()
ma = np.array()simulated_AR3_data = ArmaProcess(ar3,ma).generate_sample(nsample=10000)
Dann können wir die Zeitreihe visualisieren:
plt.figure(figsize=); # Set dimensions for figure
plt.plot(simulated_AR3_data)
plt.title("Simulated AR(3) Process")
plt.show()
Und Sie sollten etwas Ähnliches sehen, wie:
Now, looking at the PACF and ACF:
plot_pacf(simulated_AR3_data);
plot_acf(simulated_AR3_data);
You see that the coefficients are not significant after lag 3 for the PACF function as expected.
Finally, let’s use the Yule-Walker equation to estimate the coefficients:
rho, sigma = yule_walker(simulated_AR3_data, 3, method='mle')
print(f'rho: {-rho}')
print(f'sigma: {sigma}')
chätzungen
Auch hier liegen die Schätzungen ziemlich nahe an den tatsächlichen Werten.
Projekt — Prognose des vierteljährlichen EPS für Johnson&Johnson
Lassen Sie uns nun unser Wissen über autoregressive Prozesse in einer Projektumgebung anwenden.
Ziel ist es, das Quartalsergebnis je Aktie (EPS) des Unternehmens Johnson&Johnson zwischen 1960 und 1980 zu modellieren.
Lesen wir zuerst den Datensatz:
import pandas as pddata = pd.read_csv('jj.csv')
data.head()
Nun sind die ersten fünf Zeilen für uns nicht sehr nützlich. Lassen Sie uns den gesamten Datensatz plotten, um eine bessere visuelle Darstellung zu erhalten.
plt.figure(figsize=); # Set dimensions for figure
plt.scatter(data, data)
plt.title('Quaterly EPS for Johnson & Johnson')
plt.ylabel('EPS per share ($)')
plt.xlabel('Date')
plt.xticks(rotation=90)
plt.grid(True)
plt.show()
Genial! Jetzt können wir sehen, dass es einen klaren Aufwärtstrend in den Daten gibt. Während dies ein gutes Zeichen für das Unternehmen sein kann, ist es in Bezug auf die Zeitreihenmodellierung nicht gut, da es bedeutet, dass die Zeitreihe nicht stationär ist.
Wie bereits erwähnt, funktioniert der AR(p) -Prozess nur für stationäre Serien.
Daher müssen wir einige Transformationen auf unsere Daten anwenden, um sie stationär zu machen.
In diesem Fall wird die Log-Differenz genommen. Dies entspricht dem Protokoll jedes Werts und dem Subtrahieren des vorherigen Werts.
# Take the log difference to make data stationarydata = np.log(data)
data = data.diff()
data = data.drop(data.index)
data.head()
Zeichnen der transformierten Zeitreihe:
plt.figure(figsize=); # Set dimensions for figure
plt.plot(data)
plt.title("Log Difference of Quaterly EPS for Johnson & Johnson")
plt.show()
Log Differenz des vierteljährlichen EPS für Johnson&Johnson
Nun scheint es, dass wir den Trend entfernt haben. Wir müssen jedoch sicherstellen, dass unsere Serie stationär ist, bevor wir mit einem AR (p) -Prozess modellieren.
Wir werden daher den erweiterten Dicker-Fuller-Test verwenden. Dies gibt uns die statistische Sicherheit, dass unsere Zeitreihen tatsächlich stationär sind.
ad_fuller_result = adfuller(data)
print(f'ADF Statistic: {ad_fuller_result}')
print(f'p-value: {ad_fuller_result}')
Da wir eine große negative ADF-Statistik und einen p-Wert kleiner als 0,05 erhalten, können wir die Nullhypothese ablehnen und sagen, dass unsere Zeitreihe stationär ist.
Lassen Sie uns nun die Reihenfolge des Prozesses ermitteln, indem wir den PACF zeichnen:
plot_pacf(data);
plot_acf(data);
Wie Sie sehen können, sind die PACF-Koeffizienten nach Lag 4 nicht mehr signifikant. Daher gehen wir von einem autoregressiven Prozess der Ordnung 4 aus.
Nun werden wir diese Informationen verwenden, um die Koeffizienten mit der Yule-Walker-Gleichung zu schätzen:
# Try a AR(4) model
rho, sigma = yule_walker(data, 4)
print(f'rho: {-rho}')
print(f'sigma: {sigma}')
Therefore, the function is approximated as:
Note that this equation models the transformed series.
Conclusion
Congratulations! Sie verstehen jetzt, was ein autoregressives Modell ist, wie man einen autoregressiven Prozess erkennt, wie man seine Reihenfolge bestimmt und wie man es verwendet, um eine reale Zeitreihe zu modellieren.
Schärfen Sie Ihre Fähigkeiten zur Zeitreihenanalyse und lernen Sie die neuesten Best Practices für die Zeitreihenanalyse in Python kennen:
- Angewandte Zeitreihenanalyse in Python
Cheers 🍺