Comparaison des approches de sélection

Méthode des fonctions de corrélation

L'analyce des corrélations serielles constitue la première approche historique. L'autocorrélation mesure la dépendance linéaire entre observations à différents décalages, tandis que l'autocorrélation partielle isole la relation directe en éliminant les effets intermédiaires.

La bibliothèque statsmodels fournit des outils adaptés pour cette analyse :

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
from statsmodels.tsa.arima.model import ARIMA

# Génération d'une série synthétique pour illustration
np.random.seed(42)
serie_temporelle = np.cumsum(np.random.randn(200)) + 50

def tracer_correlations(serie):
    n_obs = len(serie)
    max_retards = min(30, n_obs // 3)  # Limite à 30 ou 33% des observations
    
    fig, axes = plt.subplots(2, 1, figsize=(12, 8))
    plot_acf(serie, lags=max_retards, ax=axes[0], title='Autocorrélation')
    plot_pacf(serie, lags=max_retards, ax=axes[1], title='Autocorrélation partielle')
    plt.tight_layout()
    plt.show()

tracer_correlations(serie_temporelle)

Protocole d'interprétation :

1. Identification du comporteemnt AR : Si le PACF s'annule brutalement après un décalage k tout en maintenant le ACF en décroissance progressive, un processus AR(k) est approprié.
2. Identification du comportement MA : Une coupure nette du ACF après k décalages avec un PACF décroissant suggère un MA(k).
3. Modèle mixte : Lorsque les deux fonctions présentent une décroissance progressive, un modèle ARMA est nécessaire.
4. Seuil de significativité : Les barres de confiance à 95% permettent de valider statistiquement les décalages significatifs.

Par exemple, un PACF s'annulant au-delà du 2ème décalage avec un ACF oscillant suggère une structure ARIMA(2, d, 0).

Approche par critères d'information

Les critères d'information offrent une solution plus objective en quantifiant le compromis entre qualité d'ajustement et parcimonie. L'AIC (Akaike Information Criterion) et le BIC (Bayesian Information Critreion) reposent sur la théorie de l'information et la maximisation de la vraisemblance.

Formulation mathématique :

• AIC = 2k - 2ln(L)
• BIC = ln(n)k - 2ln(L)

Où k représente le nombre de paramètres, n la taille d'échantillon, et L la valeur maximale de la fonction de vraisemblance.

Implémentation pratique :

import itertools
from statsmodels.tsa.arima.model import ARIMA

# Préparation des données
serie = pd.read_csv('donnees_temporelles.csv')['valeurs'].dropna().astype(float)

def optimisation_bic(serie, max_p=4, max_q=4, d=1):
    meilleur_score = float('inf')
    parametres_optimal = None
    
    for p, q in itertools.product(range(max_p + 1), range(max_q + 1)):
        try:
            modele = ARIMA(serie, order=(p, d, q))
            resultat = modele.fit()
            if resultat.bic < meilleur_score:
                meilleur_score = resultat.bic
                parametres_optimal = (p, d, q)
        except:
            continue
    
    return parametres_optimal, meilleur_score

# Recherche des ordres minimisant le BIC
ordres, bic_min = optimisation_bic(serie, max_p=3, max_q=3)
print(f"Ordres optimaux (p,d,q) : {ordres}")
print(f"Valeur BIC minimale : {bic_min:.2f}")

Pour comprendre les mécanismes sous-jacents, voici une implémentation manuelle du calcul des critères :

import numpy as np
from sklearn.linear_model import LinearRegression

def calculer_criteres(X, y, modele):
    n = len(y)
    k = X.shape[1] + 1  # Paramètres + terme constant
    
    y_pred = modele.predict(X)
    rss = np.sum((y - y_pred)  ** 2)
    vraisemblance = -n/2 * np.log(2*np.pi) - n/2 * np.log(rss/n) - n/2
    
    aic = 2*k - 2*vraisemblance
    bic = np.log(n)*k - 2*vraisemblance
    
    return aic, bic

# Exemple avec régression polynomiale
X_base = np.linspace(0, 10, 50).reshape(-1, 1)
y_cible = 3*X_base.flatten() + np.random.randn(50)*2

criteres = []
for degre in range(1, 6):
    X_poly = np.hstack([X_base  ** i for i in range(1, degre+1)])
    reg = LinearRegression().fit(X_poly, y_cible)
    
    aic, bic = calculer_criteres(X_poly, y_cible, reg)
    criteres.append((degre, aic, bic))
    print(f"Degré {degre}: AIC={aic:.2f}, BIC={bic:.2f}")

# Sélection du meilleur modèle
meilleur_aic = min(criteres, key=lambda x: x[1])
meilleur_bic = min(criteres, key=lambda x: x[2])
print(f"\nOrdre optimal selon AIC : {meilleur_aic[0]}")
print(f"Ordre optimal selon BIC : {meilleur_bic[0]}")

Cette approche évalue chaque configuration en calculant la somme des carrés des résidus, puis pénalise la complexité du modèle. La solution retenue minimise le critère choisi, garantissant un équilibre entre précision et simplicité.

Lors de la mise en œuvre, il est recommandé de combiner plusieurs approches : utiliser les fonctions de corrélation pour une première estimation, puis affiner avec les critères d'information pour une sélection robuste et reproductible.