Dans ce tutoriel pratique, nous aborderons le sujet de la modélisation des séries chronologiques avec des processus autorégressifs.

Cet article couvrira les éléments clés suivants dans l’analyse des séries chronologiques:

• processus autorégressif
• Équation de Yule-Walker
• stationnarité
• Test de Dicker-Fuller augmenté

Assurez-vous d’avoir un cahier Jupyter prêt à suivre. Le code et le jeu de données sont disponibles ici.

Commençons!

Apprenez à travailler avec des modèles plus complexes tels que SARIMAX, VARMAX et à appliquer des modèles d’apprentissage profond (LSTM, CNN, ResNet, LSTM autorégressif) pour l’analyse de séries temporelles avec une analyse de séries temporelles appliquée en Python!

Processus autorégressif

Un modèle autorégressif utilise une combinaison linéaire des valeurs passées de la cible pour faire des prévisions. Bien sûr, la régression est faite contre la cible elle-même. Mathématiquement, un modèle AR(p) est exprimé comme suit :

div>

Où:

• p: est l’ordre
• c: est une constante
• epsilon: noise

Le modèle AR(p) est incroyablement flexible et peut modéliser de nombreux types de modèles de séries chronologiques. Ceci est facilement visualisé lorsque nous simulons des processus autorégressifs.

Habituellement, les modèles autorégressifs sont appliqués uniquement aux séries chronologiques stationnaires. Cela limite la plage des paramètres phi.

Par exemple, un modèle AR(1) va contraindre phi entre -1 et 1. Ces contraintes deviennent plus complexes à mesure que l’ordre du modèle augmente, mais elles sont automatiquement prises en compte lors de la modélisation en Python.

Simulation d’un processus AR(2)

Simulons un processus AR(2) en Python.

Nous commençons par importer certaines bibliothèques. Tous ne seront pas utilisés pour la simulation, mais ils seront nécessaires pour le reste de ce tutoriel.

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

Nous utiliserons la bibliothèque ArmaProcess pour simuler les séries chronologiques. Cela nous oblige à définir nos paramètres.

Nous allons simuler le processus suivant:

Puisque nous avons affaire à un modèle autorégressif d’ordre 2, nous devons définir le coefficient au décalage 0, 1 et 2.

De plus, nous annulerons l’effet d’un processus de moyenne mobile.

Enfin, nous générerons 10 000 points de données.

Dans le code:

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

Nous pouvons tracer la série temporelle:

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

Vous pouvez voir que le coefficient se décompose lentement. Cela signifie qu’il est peu probable qu’il s’agisse d’un processus de moyenne mobile et cela suggère que la série temporelle peut probablement être modélisée avec un processus autorégressif (ce qui est logique puisque ce que nous simulons).

Pour vous assurer que cela est correct, tracons le tracé d’autocorrélation partielle:

plot_pacf(simulated_AR2_data);

Comme vous pouvez le voir, les coefficients ne sont pas significatifs après le décalage 2. Par conséquent, le tracé d’autocorrélation partielle est utile pour déterminer l’ordre d’un processus AR(p).

Vous pouvez également vérifier les valeurs de chaque coefficient en exécutant:

pacf_coef_AR2 = pacf(simulated_AR2_data)
print(pacf_coef_AR2)

Maintenant, dans un cadre de projet réel, il peut être facile de trouver l’ordre d’un processus AR(p), mais nous devons trouver un moyen d’estimer les coefficients phi.

Pour ce faire, nous utilisons l’équation de Yule-Walker. Ces équations nous permettent d’estimer les coefficients d’un modèle AR(p), étant donné que nous connaissons l’ordre.

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

Comme vous pouvez le voir, l’équation de Yule-Walker a fait un travail décent pour estimer nos coefficients et s’est rapprochée de 0,33 et 0,5.

Simulation d’un processus AR(3)

Maintenant, simulons un processus AR(3). Plus précisément, nous allons simuler:

De manière similaire à ce qui a été fait précédemment, définissons nos coefficients et générons 10 000 points de données:

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

Ensuite, nous pouvons visualiser la série temporelle:

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

Et vous devriez voir quelque chose de similaire à:

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

Encore une fois, les estimations sont assez proches des valeurs réelles.

Projet – Prévision du BPA trimestriel pour Johnson &Johnson

Maintenant, appliquons nos connaissances des processus autorégressifs dans un cadre de projet.

L’objectif est de modéliser le bénéfice trimestriel par action (BPA) de la société Johnson&Johnson entre 1960 et 1980.

Tout d’abord, lisons l’ensemble de données :

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

Maintenant, les cinq premières lignes ne sont pas très utiles pour nous. Tracons l’ensemble des données pour obtenir une meilleure représentation visuelle.

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

Génial! Maintenant, nous pouvons constater une tendance claire à la hausse dans les données. Bien que cela puisse être un bon signe pour l’entreprise, ce n’est pas bon en termes de modélisation de séries chronologiques, car cela signifie que la série chronologique n’est pas stationnaire.

Comme mentionné ci-dessus, le processus AR(p) ne fonctionne que pour les séries stationnaires.

Par conséquent, nous devons appliquer quelques transformations à nos données pour les rendre stationnaires.

Dans ce cas, prendra la différence de journal. Cela équivaut à prendre le journal de chaque valeur et à soustraire la valeur précédente.

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

Tracer la série temporelle transformée:

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

Maintenant, il semble que nous ayons supprimé la tendance. Cependant, nous devons nous assurer que notre série est stationnaire avant de modéliser avec un processus AR(p).

Nous utiliserons ainsi le test de Dicker-Fuller augmenté. Cela nous donnera la certitude statistique que notre série chronologique est effectivement stationnaire.

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

Puisque nous obtenons une grande statistique négative ADF et une valeur p inférieure à 0,05, nous pouvons rejeter l’hypothèse nulle et dire que notre série temporelle est stationnaire.

Maintenant, trouvons l’ordre du processus en traçant le PACF:

plot_pacf(data);
plot_acf(data);

Comme vous pouvez le voir, après le décalage 4, les coefficients PACF ne sont plus significatifs. Par conséquent, nous supposerons un processus autorégressif d’ordre 4.

Maintenant, nous allons utiliser ces informations pour estimer les coefficients en utilisant l’équation de 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! Vous comprenez maintenant ce qu’est un modèle autorégressif, comment reconnaître un processus autorégressif, comment déterminer son ordre et comment l’utiliser pour modéliser une série temporelle réelle.

Affinez vos compétences en analyse de séries chronologiques et apprenez les dernières meilleures pratiques pour l’analyse de séries chronologiques en Python :

• Analyse de séries chronologiques appliquée en Python

SantéChe