ebben a gyakorlati oktatóanyagban az idősoros modellezés témáját fogjuk lefedni autoregresszív folyamatokkal.

Ez a cikk az idősor-elemzés következő kulcselemeit tárgyalja:

• autoregresszív folyamat
• Yule-Walker egyenlet
• stationarity
• kibővített Dicker-Fuller teszt

győződjön meg róla, hogy a Jupyter notebook készen áll a követésre. A kód és az adatkészlet itt érhető el.

kezdjük!

Ismerje meg, hogyan kell dolgozni bonyolultabb modellek, mint a SARIMAX, VARMAX, és alkalmazza a deep learning modellek (LSTM, CNN, ResNet, autoregressive LSTM) idősor elemzés alkalmazott idősor elemzés Python!

Autoregresszív folyamat

az autoregresszív modell a cél múltbeli értékeinek lineáris kombinációját használja az előrejelzések készítéséhez. Természetesen a regresszió maga a cél ellen történik. Matematikailag egy AR(p) modell kifejezve:

Ahol:

• p: a rend
• c: állandó
• epszilon: zaj

az AR(p) modell hihetetlenül rugalmas, és sokféle idősor-mintát képes modellezni. Ez könnyen láthatóvá válik, amikor autoregresszív folyamatokat szimulálunk.

az autoregresszív modelleket általában csak álló idősorokra alkalmazzák. Ez korlátozza a Phi paraméterek tartományát.

például egy AR (1) modell korlátozza a phi-t -1 és 1 között. Ezek a korlátok összetettebbé válnak, ahogy a modell sorrendje növekszik, de automatikusan figyelembe veszik őket a Python modellezésekor.

egy AR(2) folyamat szimulációja

szimuláljunk egy AR (2) folyamatot Pythonban.

néhány könyvtár importálásával kezdjük. Nem mindegyiket fogják használni a szimulációhoz, de ezekre az oktatóanyag többi részéhez szükség lesz.

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

az ArmaProcess könyvtárat fogjuk használni az idősorok szimulálására. Meg kell határoznunk a paramétereinket.

a következő folyamatot szimuláljuk:

AR(2) process

mivel a 2.sorrend autoregresszív modelljével van dolgunk, meg kell határoznunk az együtthatót a 0, 1 és 2 késleltetésnél.

továbbá töröljük a mozgó átlagfolyamat hatását.

végül 10 000 adatpontot generálunk.

kódban:

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

az idősort ábrázolhatjuk:

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

>

láthatjuk, hogy az együttható lassan bomlik. Ez azt jelenti, hogy nem valószínű, hogy mozgóátlag folyamat, és azt sugallja, hogy az idősor valószínűleg modellezhető egy autoregresszív folyamattal (ami értelme, mivel ezt szimuláljuk).

annak érdekében, hogy ez helyes legyen, ábrázoljuk a részleges autokorrelációs diagramot:

plot_pacf(simulated_AR2_data);

mint látható, az együtthatók nem szignifikánsak a 2.késleltetés után. Ezért a részleges autokorrelációs diagram hasznos az AR(p) folyamat sorrendjének meghatározásához.

az egyes együtthatók értékeit futtatással is ellenőrizheti:

pacf_coef_AR2 = pacf(simulated_AR2_data)
print(pacf_coef_AR2)

most egy valós projektbeállításban könnyű megtalálni az AR(p) folyamat sorrendjét, de meg kell találnunk a módját a Phi együtthatók becslésére.

ehhez a Yule-Walker egyenletet használjuk. Ez az egyenlet lehetővé teszi számunkra az AR(p) modell együtthatóinak becslését, tekintettel arra, hogy ismerjük a sorrendet.

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

mint látható, a Yule-Walker egyenlet tisztességes munkát végzett az együtthatóink becslésében, és nagyon közel került a 0,33 és 0,5-hez.

egy AR(3) folyamat szimulációja

most szimuláljuk az AR(3) folyamatot. Pontosabban, szimulálni fogjuk:

AR(3) szimulációs folyamat

a korábbiakhoz hasonlóan határozzuk meg együtthatóinkat és generáljunk 10 000 adatpontot:

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

ezután megjeleníthetjük az idősort:

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

látnod kellene valami hasonlót:

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

ismét a becslések meglehetősen közel vannak a tényleges értékekhez.

projekt-a Johnson negyedéves EPS előrejelzése&Johnson

most alkalmazzuk az autoregresszív folyamatokkal kapcsolatos ismereteinket egy projektbeállításban.

a cél a Johnson&Johnson negyedéves részvényenkénti eredményének (EPS) modellezése 1960 és 1980 között.

először olvassuk el az adatkészletet:

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

az első öt sor nem túl hasznos számunkra. Ábrázoljuk a teljes adatkészletet, hogy jobb vizuális ábrázolást kapjunk.

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

félelmetes! Most már tudjuk, hogy az adatok egyértelműen felfelé mutatnak. Bár ez jó jel lehet a vállalat számára, az idősor-modellezés szempontjából nem jó, mivel ez azt jelenti, hogy az idősor nem helyhez kötött.

mint már említettük, az AR (p) folyamat csak helyhez kötött sorozatoknál működik.

ezért néhány átalakítást kell alkalmaznunk az adatainkra, hogy azok helyhez kötöttek legyenek.

ebben az esetben a log különbséget veszi. Ez egyenértékű az egyes értékek naplójának felvételével és az előző érték kivonásával.

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

a transzformált idősor ábrázolása:

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

most, úgy tűnik, hogy eltávolítottuk a trend. Azonban meg kell bizonyosodnunk arról, hogy sorozatunk helyhez kötött, mielőtt ar(p) eljárással modelleznénk.

így a kibővített Dicker-Fuller tesztet fogjuk használni. Ez statisztikai bizalmat ad nekünk abban, hogy idősorunk valóban helyhez kötött.

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

mivel nagy negatív ADF statisztikát és 0,05-nél kisebb P-értéket kapunk, elutasíthatjuk a nullhipotézist, és azt mondhatjuk, hogy idősorunk stacionárius.

most keressük meg a folyamat sorrendjét a PACF ábrázolásával:

plot_pacf(data);
plot_acf(data);

mint látható, miután lag 4, a pacf együtthatók már nem jelentős. Ezért feltételezzük a 4. rend autoregresszív folyamatát.

most ezt az információt fogjuk használni az együtthatók becsléséhez a Yule-Walker egyenlet:

# 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! Most már megérted, mi az autoregresszív modell, hogyan lehet felismerni az autoregresszív folyamatot, hogyan lehet meghatározni annak sorrendjét, és hogyan kell használni egy valós idősor modellezésére.

élesítse idősor-elemzési készségeit, és tanulja meg a legújabb legjobb gyakorlatokat az idősor-elemzéshez a Pythonban:

• alkalmazott idősor-elemzés Pythonban

Cheers