I denne hands-on tutorial, vil vi dække emnet tid serie med modellering med autoregressive processer.

denne artikel vil dække følgende nøgleelementer i tidsserieanalyse:

• autoregressiv proces
• Yule-rollator ligning
• stationaritet
• Augmented Dicker-Fuller test

sørg for at have en Jupyter notebook klar til at følge med. Koden og datasættet findes her.

lad os komme i gang!

Lær hvordan du arbejder med mere komplekse modeller som f. eks.

Autoregressiv proces

en autoregressiv model bruger en lineær kombination af tidligere værdier af målet til at lave prognoser. Selvfølgelig er regressionen lavet mod selve målet. Matematisk udtrykkes en AR(p) model som:

div >

hvor:

• p: er ordren
• C: er en konstant
• epsilon: støj

AR(p) model er utrolig fleksibel, og den kan modellere mange forskellige typer tidsseriemønstre. Dette visualiseres let, når vi simulerer autoregressive processer.

normalt anvendes autoregressive modeller kun til stationære tidsserier. Dette begrænser rækkevidden af parametrene phi.

for eksempel vil en AR(1) model begrænse phi mellem -1 og 1. Disse begrænsninger bliver mere komplekse, når rækkefølgen af modellen øges, men de overvejes automatisk, når de modelleres i Python.

simulering af en AR(2) proces

lad os simulere en AR(2) proces i Python.

Vi starter med at importere nogle biblioteker. Ikke alle vil blive brugt til simuleringen, men de vil være nødvendige for resten af denne tutorial.

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 bruger ArmaProcess-biblioteket til at simulere tidsserien. Det kræver, at vi definerer vores parametre.

vi simulerer følgende proces:

da vi har at gøre med en autoregressiv model af rækkefølge 2, skal vi definere koefficienten ved lag 0, 1 og 2.

vi annullerer også effekten af en glidende gennemsnitsproces.

endelig genererer vi 10 000 datapunkter.

i kode:

ar2 = np.array()
ma = np.array()simulated_AR2_data = ArmaProcess(ar2, ma).generate_sample(nsample=10000)

Vi kan plotte tidsserien:

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, at koefficienten langsomt forfalder. Det betyder, at det er usandsynligt en glidende gennemsnitsproces, og det tyder på, at tidsserierne sandsynligvis kan modelleres med en autoregressiv proces (hvilket giver mening siden det, vi simulerer).

for at sikre, at dette er rigtigt, lad os plotte den delvise autokorrelation plot:

plot_pacf(simulated_AR2_data);

div>

som du kan se koefficienterne er ikke signifikante efter lag 2. Derfor er det delvise autokorrelationsplot nyttigt til at bestemme rækkefølgen af en AR(p) – proces.

Du kan også kontrollere værdierne for hver koefficient ved at køre:

pacf_coef_AR2 = pacf(simulated_AR2_data)
print(pacf_coef_AR2)

nu kan det i en reel projektindstilling være let at finde rækkefølgen af en AR(p) – proces, men vi skal finde en måde at estimere koefficienterne phi på.

for at gøre det bruger vi Yule-rollator-ligningen. Disse ligninger giver os mulighed for at estimere koefficienterne for en AR(p) – model, da vi kender rækkefølgen.

rho, sigma = yule_walker(simulated_AR2_data, 2, method='mle')
print(f'rho: {-rho}')
print(f'sigma: {sigma}')

som du kan se, gjorde Yule-rollator-ligningen et anstændigt stykke arbejde med at estimere vores koefficienter og kom meget tæt på 0,33 og 0,5.

simulering af en AR(3) proces

lad os nu simulere en AR(3) proces. Konkret vil vi simulere:

på samme måde som hvad der tidligere blev gjort, lad os definere vores koefficienter og generere 10 000 datapunkter:

ar3 = np.array()
ma = np.array()simulated_AR3_data = ArmaProcess(ar3,ma).generate_sample(nsample=10000)

derefter kan vi visualisere tidsserien:

plt.figure(figsize=); # Set dimensions for figure
plt.plot(simulated_AR3_data)
plt.title("Simulated AR(3) Process")
plt.show()

og du skal se noget, der ligner:

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}')

igen er estimaterne ret tæt på de faktiske værdier.

projekt — prognoser kvartalsvis EPS for Johnson&Johnson

lad os nu anvende vores viden om autoregressive processer i en projektindstilling.

målet er at modellere kvartalsindtjeningen pr.aktie (EPS) for virksomheden Johnson&Johnson mellem 1960 og 1980.

lad os først læse datasættet:

import pandas as pddata = pd.read_csv('jj.csv')
data.head()

nu er de første fem rækker ikke særlig nyttige for os. Lad os plotte hele datasættet for at få en bedre visuel repræsentation.

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()

fantastisk! Nu kan vi, at der er en klar opadgående tendens i dataene. Selvom dette kan være et godt tegn for virksomheden, er det ikke godt med hensyn til tidsseriemodellering, da det betyder, at tidsserien ikke er stationær.

som nævnt fungerer AR(p) – processen kun for stationære serier.

derfor skal vi anvende nogle transformationer på vores data for at gøre dem stationære.

i dette tilfælde vil tage logforskellen. Dette svarer til at tage loggen for hver værdi og trække den forrige værdi.

# Take the log difference to make data stationarydata = np.log(data)
data = data.diff()
data = data.drop(data.index)
data.head()

planlægning af den transformerede tidsserie:

plt.figure(figsize=); # Set dimensions for figure
plt.plot(data)
plt.title("Log Difference of Quaterly EPS for Johnson & Johnson")
plt.show()

nu ser det ud til, at vi fjernede tendensen. Vi skal dog være sikre på, at vores serie er stationær, før vi modellerer med en AR(p) – proces.

Vi vil således bruge augmented Dicker-Fuller-testen. Dette vil give os den statistiske tillid til, at vores tidsserier faktisk er stationære.

ad_fuller_result = adfuller(data)
print(f'ADF Statistic: {ad_fuller_result}')
print(f'p-value: {ad_fuller_result}')

da vi får en stor negativ ADF-statistik og p-værdi mindre end 0,05, kan vi afvise nulhypotesen og sige, at vores tidsserie er stationær.

lad os nu finde rækkefølgen af processen ved at plotte PACF:

plot_pacf(data);
plot_acf(data);

som du kan se, efter lag 4 er pacf-koefficienterne ikke længere signifikante. Derfor antager vi en autoregressiv proces med ordre 4.

nu vil vi bruge disse oplysninger til at estimere koefficienterne ved hjælp af Yule-rollator-ligningen:

# 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 forstår nu, hvad en autoregressiv model er, hvordan man genkender en autoregressiv proces, hvordan man bestemmer dens rækkefølge, og hvordan man bruger den til at modellere en realtidsserie.

Skærp dine tidsserieanalysefærdigheder, og lær de nyeste bedste fremgangsmåder til tidsserieanalyse i Python:

• anvendt tidsserieanalyse i Python

skål