In questo tutorial tratteremo il tema del tempo analisi delle serie storiche con autoregressivo processi.

Questo articolo tratterà i seguenti elementi chiave nell’analisi delle serie temporali:

• processo autoregressivo
• Equazione di Yule-Walker
• stationarity
• Augmented Dicker-Fuller test

Assicurati di avere un notebook Jupyter pronto per seguirlo. Il codice e il set di dati sono disponibili qui.

Cominciamo!

Scopri come lavorare con modelli più complessi come SARIMAX, VARMAX e applicare modelli di deep learning (LSTM, CNN, ResNet, autoregressive LSTM) per l’analisi delle serie temporali con l’analisi delle serie temporali applicate in Python!

Processo autoregressivo

Un modello autoregressivo utilizza una combinazione lineare di valori passati del target per fare previsioni. Naturalmente, la regressione è fatta contro il bersaglio stesso. Matematicamente, un AR(p) modello è espresso come:

Dove:

• p: è l’ordine
• c: è una costante
• epsilon: rumore

Il modello AR(p) è incredibilmente flessibile e può modellare diversi tipi di modelli di serie temporali. Questo è facilmente visualizzato quando simuliamo processi autoregressivi.

Di solito, i modelli autoregressivi vengono applicati solo alle serie temporali stazionarie. Ciò limita l’intervallo dei parametri phi.

Ad esempio, un modello AR(1) vincolerà phi tra -1 e 1. Questi vincoli diventano più complessi all’aumentare dell’ordine del modello, ma vengono automaticamente considerati durante la modellazione in Python.

Simulazione di un processo AR(2)

Simuliamo un processo AR(2) in Python.

Iniziamo importando alcune librerie. Non tutti saranno utilizzati per la simulazione, ma saranno necessari per il resto di questo 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

Useremo la libreria ArmaProcess per simulare le serie temporali. Ci impone di definire i nostri parametri.

Simuleremo il seguente processo:

Dal momento che abbiamo a che fare con un modello autoregressivo di ordine 2, abbiamo bisogno di definire il coefficiente di lag 0, 1 e 2.

Inoltre, annulleremo l’effetto di un processo di media mobile.

Infine, genereremo 10 000 punti dati.

Nel codice:

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

Possiamo tracciare le serie temporali:

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

Si può vedere che il coefficiente sta lentamente decadendo. Ciò significa che è improbabile un processo di media mobile e suggerisce che le serie temporali possono probabilmente essere modellate con un processo autoregressivo (che ha senso dal momento che ciò che stiamo simulando).

Per assicurarsi che questo sia giusto, tracciamo la trama di autocorrelazione parziale:

plot_pacf(simulated_AR2_data);

Come si può vedere i coefficienti non sono significativi dopo gal 2. Pertanto, il grafico di autocorrelazione parziale è utile per determinare l’ordine di un processo AR(p).

È anche possibile controllare i valori di ciascun coefficiente eseguendo:

pacf_coef_AR2 = pacf(simulated_AR2_data)
print(pacf_coef_AR2)

Ora, in un ambiente di progetto reale, può essere facile trovare l’ordine di un processo AR(p), ma dobbiamo trovare un modo per stimare i coefficienti phi.

Per fare ciò, usiamo l’equazione di Yule-Walker. Questa equazione ci permette di stimare i coefficienti di un modello AR (p), dato che conosciamo l’ordine.

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

Come si può vedere, il Yule-Walker equazione ha fatto un lavoro decente a stimare il nostro coefficienti e andato molto vicino a 0,33 e 0.5.

Simulazione di un processo AR(3)

Ora, simuliamo un processo AR(3). In particolare, simuleremo:

allo stesso modo di ciò che è stato fatto in precedenza, definiamo i nostri coefficienti e generare 10 000 punti di dati:

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

si può visualizzare il tempo a serie:

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

E si dovrebbe vedere qualcosa di simile:

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

di Nuovo, le stime sono abbastanza vicino ai valori effettivi.

Project — Forecasting the quarterly EPS for Johnson&Johnson

Ora, applichiamo la nostra conoscenza dei processi autoregressivi in un ambiente di progetto.

L’obiettivo è quello di modellare l’utile trimestrale per azione (EPS) della società Johnson& Johnson tra il 1960 e il 1980.

in Primo luogo, andiamo a leggere i dati:

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

Ora, le prime cinque righe non sono molto utili per noi. Tracciamo l’intero set di dati per ottenere una migliore rappresentazione visiva.

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

Fantastico!!! Ora possiamo il c’è chiara tendenza al rialzo nei dati. Sebbene questo possa essere un buon segno per l’azienda, non è buono in termini di modellazione delle serie temporali, poiché significa che le serie temporali non sono stazionarie.

Come già detto, il processo AR(p) funziona solo per serie stazionarie.

Pertanto, dobbiamo applicare alcune trasformazioni ai nostri dati per renderlo stazionario.

In questo caso, prenderà la differenza di registro. Ciò equivale a prendere il registro di ciascun valore e sottrarre il valore precedente.

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

Stampa della serie temporale trasformata:

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

Ora, sembra che abbiamo rimosso la tendenza. Tuttavia, dobbiamo essere sicuri che la nostra serie sia stazionaria prima di modellare con un processo AR(p).

Useremo quindi il test augmented Dicker-Fuller. Questo ci darà la certezza statistica che le nostre serie temporali sono davvero stazionarie.

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

Dal momento che abbiamo un grande negativo ADF statistica e il p-value minore di 0.05, possiamo rifiutare l’ipotesi nulla e dire che il nostro tempo la serie è stazionaria.

Ora, troviamo l’ordine del processo tracciando il PACF:

plot_pacf(data);
plot_acf(data);

Come potete vedere, dopo gal 4, la PACF i coefficienti non sono più significativi. Pertanto, assumeremo un processo autoregressivo dell’ordine 4.

Ora, useremo queste informazioni per stimare i coefficienti usando l’equazione di 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! Ora capisci cos’è un modello autoregressivo, come riconoscere un processo autoregressivo, come determinarne l’ordine e come usarlo per modellare una serie temporale reale.

Affina le tue capacità di analisi delle serie temporali e impara le ultime best practice per l’analisi delle serie temporali in Python:

• Analisi delle serie temporali applicate in Python

Cheers Cheers