en praktisk handledning om AR(p)-process för tidsserieanalys i Python
i denna praktiska handledning kommer vi att täcka ämnet tidsseriemodellering med autoregressiva processer.
denna artikel kommer att täcka följande nyckelelement i tidsserieanalys:
- autoregressiv process
- Yule-Walker ekvation
- stationäritet
- Augmented Dicker-Fuller test
se till att ha en Jupyter notebook redo att följa med. Koden och datamängden finns här.
Låt oss komma igång!
lär dig att arbeta med mer komplexa modeller som SARIMAX, VARMAX och tillämpa djupa inlärningsmodeller (LSTM, CNN, ResNet, autoregressiv LSTM) för tidsserieanalys med tillämpad tidsserieanalys i Python!
Autoregressiv Process
en autoregressiv modell använder en linjär kombination av tidigare värden för målet för att göra prognoser. Naturligtvis görs regressionen mot själva målet. Matematiskt uttrycks en AR(p) – modell som:
där:
- p: är ordningen
- C: är en konstant
- Epsilon: noise
ar(p) – modellen är otroligt flexibel och kan modellera många olika typer av tidsseriemönster. Detta visualiseras enkelt när vi simulerar autoregressiva processer.
vanligtvis tillämpas autoregressiva modeller endast på stationära tidsserier. Detta begränsar intervallet för parametrarna phi.
till exempel kommer en AR(1) – modell att begränsa phi mellan -1 och 1. Dessa begränsningar blir mer komplexa när modellens ordning ökar, men de beaktas automatiskt när man modellerar i Python.
simulering av en AR(2) process
låt oss simulera en AR (2) process i Python.
vi börjar med att importera några bibliotek. Inte alla kommer att användas för simuleringen, men de kommer att krävas för resten av denna handledning.
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
Vi använder ArmaProcess-biblioteket för att simulera tidsserierna. Det kräver att vi definierar våra parametrar.
Vi kommer att simulera följande process:
eftersom vi har att göra med en autoregressiv modell av ordning 2 måste vi definiera koefficienten vid lag 0, 1 och 2.
Vi kommer också att avbryta effekten av en glidande medelprocess.
slutligen kommer vi att generera 10 000 datapunkter.
i kod:
ar2 = np.array()
ma = np.array()simulated_AR2_data = ArmaProcess(ar2, ma).generate_sample(nsample=10000)
Vi kan plotta tidsserierna:
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);
Du kan se att koefficienten sakta sönderfaller. Detta innebär att det är osannolikt en glidande medelprocess och det tyder på att tidsserierna förmodligen kan modelleras med en autoregressiv process (vilket är meningsfullt eftersom det vi simulerar).
för att se till att detta är rätt, låt oss plotta den partiella autokorrelationsplanen:
plot_pacf(simulated_AR2_data);
som du kan se är koefficienterna inte signifikanta efter fördröjning 2. Därför är den partiella autokorrelationsplanen användbar för att bestämma ordningen för en AR(p) – process.
Du kan också kontrollera värdena för varje koefficient genom att köra:
pacf_coef_AR2 = pacf(simulated_AR2_data)
print(pacf_coef_AR2)
nu, i en riktig Projektinställning, kan det vara lätt att hitta ordningen på en AR(p) – process, men vi måste hitta ett sätt att uppskatta koefficienterna phi.
för att göra det använder vi Yule-Walker-ekvationen. Dessa ekvationer tillåter oss att uppskatta koefficienterna för en AR(p) – modell, med tanke på att vi känner till ordningen.
rho, sigma = yule_walker(simulated_AR2_data, 2, method='mle')
print(f'rho: {-rho}')
print(f'sigma: {sigma}')
som du kan se gjorde Yule-Walker-ekvationen ett anständigt jobb för att uppskatta våra koefficienter och kom mycket nära 0.33 och 0.5.
simulering av en AR(3) process
låt oss nu simulera en AR (3) process. Specifikt kommer vi att simulera:
på samma sätt som vad som tidigare gjordes, låt oss definiera våra koefficienter och generera 10 000 datapunkter:
ar3 = np.array()
ma = np.array()simulated_AR3_data = ArmaProcess(ar3,ma).generate_sample(nsample=10000)
sedan kan vi visualisera tidsserien:
plt.figure(figsize=); # Set dimensions for figure
plt.plot(simulated_AR3_data)
plt.title("Simulated AR(3) Process")
plt.show()
och du borde se något liknande:
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}')
återigen är uppskattningarna ganska nära de faktiska värdena.
projekt-prognoser för kvartalsvisa EPS för Johnson&Johnson
Låt oss nu tillämpa vår kunskap om autoregressiva processer i en Projektinställning.
målet är att modellera kvartalsresultatet per aktie (EPS) för företaget Johnson&Johnson mellan 1960 och 1980.
Låt oss först läsa datasetet:
import pandas as pddata = pd.read_csv('jj.csv')
data.head()
nu är de första fem raderna inte särskilt användbara för oss. Låt oss plotta hela datasetet för att få en bättre visuell representation.
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()
fantastiskt! Nu kan vi det finns en tydlig uppåtgående trend i data. Även om detta kan vara ett gott tecken för företaget, är det inte bra när det gäller tidsseriemodellering, eftersom det betyder att tidsserierna inte är stillastående.
som nämnts fungerar AR(p) – processen endast för stationära serier.
därför måste vi tillämpa vissa omvandlingar på våra data för att göra den stationär.
i det här fallet tar loggskillnaden. Detta motsvarar att ta loggen för varje värde och subtrahera det föregående värdet.
# Take the log difference to make data stationarydata = np.log(data)
data = data.diff()
data = data.drop(data.index)
data.head()
plotta den transformerade tidsserien:
plt.figure(figsize=); # Set dimensions for figure
plt.plot(data)
plt.title("Log Difference of Quaterly EPS for Johnson & Johnson")
plt.show()
nu verkar det som om vi tog bort trenden. Vi måste dock vara säkra på att vår serie är stillastående innan vi modellerar med en AR (p) – process.
Vi kommer således att använda augmented Dicker-Fuller-testet. Detta kommer att ge oss det statistiska förtroendet för att vår tidsserie verkligen är stillastående.
ad_fuller_result = adfuller(data)
print(f'ADF Statistic: {ad_fuller_result}')
print(f'p-value: {ad_fuller_result}')
eftersom vi får en stor negativ ADF-statistik och p-värde mindre än 0,05 kan vi avvisa nollhypotesen och säga att vår tidsserie är stillastående.
nu, låt oss hitta ordningen på processen genom att plotta PACF:
plot_pacf(data);
plot_acf(data);
som du kan se, efter fördröjning 4, är pacf-koefficienterna inte signifikanta längre. Därför antar vi en autoregressiv process av order 4.
Nu kommer vi att använda denna information för att uppskatta koefficienterna med hjälp av Yule-Walker-ekvationen:
# 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! Du förstår nu vad en autoregressiv modell är, hur man känner igen en autoregressiv process, hur man bestämmer sin ordning och hur man använder den för att modellera en verklig tidsserie.
vässa dina tidsserieanalysfärdigheter och lär dig de senaste bästa metoderna för tidsserieanalys i Python:
- tillämpad tidsserieanalys i Python
skål