fotografie de Elena koycheva pe Unsplash

în acest tutorial practic, vom acoperi subiectul modelării seriilor de timp cu procese autoregresive.

Acest articol va acoperi următoarele elemente cheie în analiza seriilor de timp:

• proces autoregresiv
• ecuația Yule-Walker
• staționaritate
• test Dicker-Fuller augmentat

asigurați-vă că aveți un notebook Jupyter gata de urmat. Codul și setul de date sunt disponibile aici.

Să începem!

Aflați cum să lucrați cu modele mai complexe, cum ar fi SARIMAX, VARMAX și să aplicați modele de învățare profundă (LSTM, CNN, ResNet, lstm autoregresiv) pentru analiza seriilor de timp cu analiza seriilor de timp aplicate în Python!

proces autoregresiv

un model autoregresiv folosește o combinație liniară de valori anterioare ale țintei pentru a face prognoze. Desigur, regresia se face împotriva țintei în sine. Matematic, un model AR(p) este exprimat ca:

unde:

• p: este ordinea
• C: este o constantă
• epsilon: noise

modelul AR(p) este incredibil de flexibil și poate modela multe tipuri diferite de modele de serii de timp. Acest lucru este ușor de vizualizat atunci când simulăm procese autoregresive.

De obicei, modelele autoregresive sunt aplicate numai seriilor de timp staționare. Aceasta constrânge intervalul parametrilor phi.

de exemplu, un model AR(1) va constrânge phi între -1 și 1. Aceste constrângeri devin mai complexe pe măsură ce ordinea modelului crește, dar sunt luate în considerare automat la modelarea în Python.

simularea unui proces AR(2)

să simulăm un proces AR(2) în Python.

începem prin importarea unor biblioteci. Nu toate vor fi folosite pentru simulare, dar vor fi necesare pentru restul acestui 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

vom folosi biblioteca ArmaProcess pentru a simula seriile de timp. Ne cere să ne definim parametrii.

vom simula următorul proces:

AR(2) proces

deoarece avem de-a face cu un model autoregresiv de ordinul 2, trebuie să definim coeficientul la lag 0, 1 și 2.

De asemenea, vom anula efectul unui proces mediu în mișcare.

în cele din urmă, vom genera 10 000 de puncte de date.

în Cod:

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

putem trasa seriile de timp:

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

puteți vedea că coeficientul se descompune încet. Aceasta înseamnă că este puțin probabil un proces mediu în mișcare și sugerează că seriile de timp pot fi probabil modelate cu un proces autoregresiv (ceea ce are sens din moment ce ceea ce simulăm).

pentru a vă asigura că acest lucru este corect, să complot complot autocorelație parțială:

plot_pacf(simulated_AR2_data);

după cum puteți vedea, coeficienții nu sunt semnificativi după lag 2. Prin urmare, graficul de autocorelare parțială este util pentru a determina ordinea unui proces AR(p).

de asemenea, puteți verifica valorile fiecărui coeficient rulând:

pacf_coef_AR2 = pacf(simulated_AR2_data)
print(pacf_coef_AR2)

acum, într-un cadru de proiect real, poate fi ușor să găsiți ordinea unui proces AR(p), dar trebuie să găsim o modalitate de a estima coeficienții phi.

pentru a face acest lucru, folosim ecuația Yule-Walker. Aceste ecuații ne permit să estimăm coeficienții unui model AR (p), având în vedere că cunoaștem ordinea.

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

după cum puteți vedea, ecuația Yule-Walker a făcut o treabă decentă la estimarea coeficienților noștri și s-a apropiat foarte mult de 0,33 și 0,5.

simularea unui proces AR(3)

acum, să simulăm un proces AR(3). Mai exact, vom simula:

AR(3) proces de simulare

similar cu ceea ce s-a făcut anterior, să definim coeficienții noștri și să generăm 10 000 de puncte de date:

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

apoi, putem vizualiza seriile de timp:

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

și ar trebui să vedeți ceva similar cu:

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

din nou, estimările sunt destul de apropiate de valorile reale.

Project — prognozarea EPS trimestrial pentru Johnson&Johnson

acum, să aplicăm cunoștințele noastre despre procesele autoregresive într-un cadru de proiect.

obiectivul este de a modela câștigurile trimestriale pe acțiune (EPS) ale companiei Johnson&Johnson între 1960 și 1980.

în primul rând, să citim setul de date:

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

acum, primele cinci rânduri nu sunt foarte utile pentru noi. Să complot întregul set de date pentru a obține o reprezentare vizuală mai bună.

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

minunat! Acum putem există o tendință clară în sus a datelor. Deși acest lucru poate fi un semn bun pentru companie, nu este bun în ceea ce privește modelarea seriilor de timp, deoarece înseamnă că seriile de timp nu sunt staționare.

după cum sa menționat mai sus, procesul AR(p) funcționează numai pentru seriile staționare.prin urmare, trebuie să aplicăm unele transformări datelor noastre pentru a le face staționare.

în acest caz, va lua diferența jurnal. Acest lucru este echivalent cu luarea jurnalului fiecărei valori și scăderea valorii anterioare.

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

trasarea seriilor de timp transformate:

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

acum, se pare că am eliminat tendința. Cu toate acestea, trebuie să fim siguri că seria noastră este staționară înainte de modelare cu un proces AR(p).

vom folosi astfel testul Dicker-Fuller augmentat. Acest lucru ne va da încrederea statistică că seriile noastre de timp sunt într-adevăr staționare.

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

deoarece obținem o statistică ADF negativă mare și o valoare p mai mică de 0,05, putem respinge ipoteza nulă și putem spune că seriile noastre de timp sunt staționare.

acum, să găsim ordinea procesului prin trasarea PACF:

plot_pacf(data);
plot_acf(data);

după cum puteți vedea, după lag 4, coeficienții pacf nu mai sunt semnificativi. Prin urmare, vom presupune un proces autoregresiv de ordinul 4.

acum, vom folosi aceste informații pentru a estima coeficienții folosind ecuația Yule-Walker:

# 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! Acum înțelegeți ce este un model autoregresiv, cum să recunoașteți un proces autoregresiv, cum să-i determinați ordinea și cum să-l utilizați pentru a modela o serie de timp din viața reală.

ascuți-ți abilitățile de analiză a seriilor de timp și învață cele mai noi practici pentru analiza seriilor de timp în Python:

• analiza seriilor de timp aplicate în Python

noroc