omdat we te maken hebben met een autoregressief model van orde 2, moeten we de coëfficiënt definiëren op lag 0, 1 en 2.

ook zullen we het effect van een voortschrijdend gemiddelde proces annuleren.

ten slotte zullen we 10 000 datapunten genereren.

In code:

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

We kunnen de tijdreeks plotten:

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

U kan zien dat de coëfficiënt is langzaam vervallen. Dit betekent dat het onwaarschijnlijk is een voortschrijdend gemiddelde proces en het suggereert dat de tijdreeksen waarschijnlijk kan worden gemodelleerd met een autoregressief proces (wat zinvol is omdat dat wat we simuleren).

om er zeker van te zijn dat dit juist is, laten we de gedeeltelijke autocorrelatieplot plotten:

plot_pacf(simulated_AR2_data);

Zoals je kan zien zijn de coëfficiënten zijn niet significant na lag 2. Daarom is de gedeeltelijke autocorrelatieplot nuttig om de Orde van een AR(p) proces te bepalen.

u kunt ook de waarden van elke coëfficiënten controleren door het uitvoeren van:

pacf_coef_AR2 = pacf(simulated_AR2_data)
print(pacf_coef_AR2)

nu, in een echte project instelling, kan het gemakkelijk zijn om de volgorde van een AR(p) proces te vinden, maar we moeten een manier vinden om de coëfficiënten phi te schatten.

hiervoor gebruiken we de Yule-Walker vergelijking. Met deze vergelijkingen kunnen we de coëfficiënten van een AR(p) model schatten, gegeven dat we de volgorde kennen.

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

Zoals u kunt zien, de Joel-Walker vergelijking heb een fatsoenlijke baan bij het schatten van onze coëfficiënten en kreeg zeer dicht 0,33 en 0,5.

simulatie van een AR (3) proces

laten we nu een AR(3) proces simuleren. Specifiek zullen we simuleren:

net als wat eerder is gedaan, laten we definiëren onze coëfficiënten en het genereren van 10 000 gegevens punten:

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

Dan kunnen we visualiseren de tijdreeks:

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

En je ziet iets als:

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

Nogmaals, de schattingen zijn redelijk dicht bij de werkelijke waarden.

Project-Forecasting the quarterly EPS for Johnson&Johnson

laten we nu onze kennis van autoregressieve processen toepassen in een project setting.het doel is de kwartaalwinst per aandeel (EPS) van de onderneming Johnson&Johnson tussen 1960 en 1980 te modelleren.

ten Eerste, laten we het lezen van de dataset:

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

Nu, de eerste vijf rijen zijn niet erg nuttig voor ons. Laten we de hele dataset plotten om een betere visuele representatie te krijgen.

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

Awesome! Nu kunnen we de er is duidelijke opwaartse trend in de gegevens. Hoewel dit een goed teken voor het bedrijf kan zijn, is het niet goed in termen van tijdreeksmodellering, omdat het betekent dat de tijdreeks niet stilstaat.

zoals eerder vermeld werkt het AR (p) – proces alleen voor stationaire reeksen.

daarom moeten we een aantal transformaties toepassen op onze gegevens om het stationair te maken.

zal in dit geval het logverschil nemen. Dit is gelijk aan het nemen van de log van elke waarde, en aftrekken van de vorige waarde.

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

het plotten van de getransformeerde tijdreeks:

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

Nu, het lijkt erop dat we verwijderd van de trend. We moeten er echter zeker van zijn dat onze serie stilstaat voordat we modelleren met een AR(p) proces.

We zullen dus de augmented Dicker-Fuller test gebruiken. Dit zal ons het statistische vertrouwen geven dat onze tijdreeksen inderdaad stationair zijn.

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

Sinds we krijgen een grote negatieve ADI statistiek en de p-waarde kleiner dan 0,05, kunnen we verwerpen de nulhypothese en zeggen dat onze tijdreeks is stationair.

nu, laten we de volgorde van het proces vinden door het PACF te plotten:

plot_pacf(data);
plot_acf(data);

Zoals je kan zien, nadat lag 4, de PACF coëfficiënten zijn niet significant meer. Daarom gaan we uit van een autoregressief proces van orde 4.

nu zullen we deze informatie gebruiken om de coëfficiënten te schatten met behulp van de Yule-Walker vergelijking:

# 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! Je begrijpt nu wat een autoregressief model is, hoe je een autoregressief proces herkent, hoe je de volgorde ervan bepaalt en hoe je het gebruikt om een real-life tijdreeks te modelleren.

verscherp uw tijdreeksanalyse vaardigheden en leer de nieuwste best practices voor tijdreeksanalyse in Python:

• Toegepaste tijdreeksanalyse in Python

Cheers Cheers