w tym praktycznym samouczku omówimy temat modelowania szeregów czasowych z procesami autoregresyjnymi.

w tym artykule omówione zostaną następujące kluczowe elementy analizy szeregów czasowych:

• proces autoregresji
• równanie Yule ’ a-Walkera
• stationarity
• rozszerzony test Dickera-Fullera

upewnij się, że masz gotowy Notatnik Jupyter. Kod i zbiór danych są dostępne tutaj.

zaczynajmy!

Dowiedz się, jak pracować z bardziej złożonymi modelami, takimi jak SARIMAX, VARMAX i stosować modele głębokiego uczenia (LSTM, CNN, ResNet, autoregressive LSTM) do analizy szeregów czasowych z zastosowaną analizą szeregów czasowych w Pythonie!

proces Autoregresywny

model autoregresywny wykorzystuje liniową kombinację przeszłych wartości celu do tworzenia prognoz. Oczywiście regresja odbywa się w stosunku do samego celu. Matematycznie model AR(p) jest wyrażony jako:

gdzie:

• p: jest porządkiem
• C: jest stałą
• Epsilon: szum

model AR(p) jest niezwykle elastyczny i może modelować wiele różnych typów wzorców szeregów czasowych. Jest to łatwo wizualizowane, gdy symulujemy procesy autorskie.

zazwyczaj modele autoregresyjne są stosowane tylko do stacjonarnych szeregów czasowych. Ogranicza to zakres parametrów phi.

na przykład model AR(1) ograniczy phi między -1 a 1. Ograniczenia te stają się bardziej złożone wraz ze wzrostem kolejności modelu, ale są automatycznie brane pod uwagę podczas modelowania w Pythonie.

symulacja procesu AR(2)

symulacja procesu AR(2) w Pythonie.

zaczynamy od zaimportowania niektórych bibliotek. Nie wszystkie zostaną wykorzystane do symulacji, ale będą wymagane do dalszej części tego samouczka.

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

użyjemy Biblioteki ArmaProcess do symulacji szeregów czasowych. Wymaga od nas zdefiniowania naszych parametrów.

będziemy symulować następujący proces:

ponieważ mamy do czynienia z modelem autoregresyjnym rzędu 2, musimy zdefiniować Współczynnik w opóźnieniach 0, 1 i 2.

również anulujemy efekt procesu średniej ruchomej.

wreszcie wygenerujemy 10 000 punktów danych.

w kodzie:

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

możemy wykreślić szereg czasowy:

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

widać, że współczynnik powoli się zmniejsza. Oznacza to, że jest mało prawdopodobne, proces średniej ruchomej i sugeruje, że szeregi czasowe mogą być prawdopodobnie modelowane z procesem autoregresyjnym (co ma sens, ponieważ to, co symulujemy).

aby upewnić się, że jest to właściwe, narysujmy Wykres częściowej autokorelacji:

plot_pacf(simulated_AR2_data);

jak widać współczynniki nie są znaczące po opóźnieniu 2. Dlatego też Wykres częściowej autokorelacji jest przydatny do określenia kolejności procesu AR (p).

Możesz również sprawdzić wartości poszczególnych współczynników, uruchamiając:

pacf_coef_AR2 = pacf(simulated_AR2_data)
print(pacf_coef_AR2)

teraz, w prawdziwym ustawieniu projektu, może być łatwo znaleźć kolejność procesu AR(p), ale musimy znaleźć sposób na oszacowanie współczynników phi.

aby to zrobić, używamy równania Yule-Walkera. Równania te pozwalają nam oszacować współczynniki modelu AR(p), biorąc pod uwagę, że znamy kolejność.

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

jak widać, równanie Yule-Walkera wykonało przyzwoitą pracę przy szacowaniu naszych współczynników i zbliżyło się do 0,33 i 0,5.

symulacja procesu AR(3)

teraz zasymulujmy proces AR(3). W szczególności będziemy symulować:

podobnie jak poprzednio, zdefiniujmy nasze współczynniki i wygenerujmy 10 000 punktów danych:

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

następnie możemy wizualizować szeregi czasowe:

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

i powinieneś zobaczyć coś podobnego do:

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

ponownie szacunki są dość zbliżone do rzeczywistych wartości.

projekt — Prognozowanie kwartalnego EPS dla Johnsona& Johnson

teraz wykorzystajmy naszą wiedzę na temat procesów autoregresyjnych w kontekście projektu.

celem jest modelowanie kwartalnego zysku na akcję (EPS) firmy Johnson& Johnson w latach 1960-1980.

najpierw przeczytajmy zbiór danych:

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

teraz pierwsze pięć wierszy nie jest dla nas zbyt użyteczne. Narysujmy cały zestaw danych, aby uzyskać lepszą reprezentację wizualną.

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

niesamowite! Teraz możemy tam jest wyraźny trend wzrostowy w danych. Chociaż może to być dobry znak dla firmy, nie jest to dobre pod względem modelowania szeregów czasowych, ponieważ oznacza to, że szeregi czasowe nie są stacjonarne.

jak już wspomniano, proces AR(p) działa tylko dla serii stacjonarnych.

dlatego musimy zastosować pewne przekształcenia do naszych danych, aby stały.

w tym przypadku weźmie różnicę logów. Jest to równoważne wzięciu logarytmu każdej wartości i odjęciu poprzedniej wartości.

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

:

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

wydaje się, że usunęliśmy trend. Musimy jednak mieć pewność, że nasza seria jest stacjonarna przed modelowaniem za pomocą procesu AR(p).

użyjemy więc rozszerzonego testu Dickera-Fullera. To da nam statystyczną pewność, że nasze szeregi czasowe są rzeczywiście nieruchome.

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

ponieważ otrzymujemy dużą ujemną statystykę adf i wartość p mniejszą niż 0,05, możemy odrzucić hipotezę zerową i powiedzieć, że nasz szereg czasowy jest stacjonarny.

teraz znajdźmy kolejność procesu, rysując PACF:

plot_pacf(data);
plot_acf(data);

jak widać, po opóźnieniu 4, współczynniki pacf nie są już znaczące. Dlatego przyjmiemy autoregresyjny proces zamówienia 4.

teraz wykorzystamy te informacje do oszacowania współczynników za pomocą równania Yule ’ a-Walkera:

# 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! Teraz rozumiesz, czym jest model autoregresywny, jak rozpoznać proces autoregresywny, jak określić jego kolejność i jak wykorzystać go do modelowania rzeczywistych szeregów czasowych.

wyostrz swoje umiejętności analizy szeregów czasowych i poznaj najnowsze najlepsze praktyki analizy szeregów czasowych w Pythonie:

• Applied Time Series Analysis in Python

Cheers 🍺