# Les Modèles de Forecasting à une Variable
Le forecasting, ou prévision, est une compétence fondamentale en Data Science qui consiste à prédire des événements futurs basés sur des données historiques. Que ce soit pour anticiper les ventes de produits, prévoir la demande en énergie, ou estimer le trafic réseau, la capacité à faire des prévisions précises est cruciale pour la prise de décision stratégique et opérationnelle.
> [!definition] Qu'est-ce que le Forecasting ?
> Le forecasting est l'art et la science de prédire des événements futurs en analysant les tendances et les motifs des données passées. Contrairement à la classification ou la régression (que vous avez pu voir en *Data Mining avec Python*), le forecasting s'applique spécifiquement aux **séries temporelles**, où l'ordre des observations est primordial.
## Séries Temporelles : La Base du Forecasting
Une série temporelle est une séquence d'observations mesurées à des intervalles de temps successifs et ordonnés. L'ordre chronologique des données est une caractéristique essentielle qui distingue les séries temporelles des autres types de jeux de données.
> [!example] Exemples de Séries Temporelles
> - Le cours de clôture quotidien d'une action en bourse.
> - La température moyenne mensuelle d'une ville.
> - Le nombre de passagers aériens par mois.
> - La consommation électrique horaire d'un foyer.
## Objectifs de ce Chapitre
Dans ce chapitre, nous allons nous concentrer sur les modèles de forecasting à **une variable (univariate)**, c'est-à-dire les modèles qui utilisent uniquement les valeurs passées de la variable à prédire pour faire des prévisions futures. Nous explorerons les concepts théoriques, les méthodes d'implémentation en Python et les techniques d'évaluation.
# Fondamentaux des Séries Temporelles
Avant de plonger dans les modèles, il est essentiel de comprendre les caractéristiques intrinsèques des séries temporelles.
## Composantes d'une Série Temporelle
Une série temporelle $Y_t$ peut souvent être décomposée en plusieurs composantes :
- **Tendance ($T_t$)** : La direction générale à long terme de la série (croissance, décroissance, stabilité).
- **Saisonalité ($S_t$)** : Des motifs répétitifs et prévisibles qui se produisent à des intervalles de temps fixes (par exemple, quotidien, hebdomadaire, mensuel, annuel).
- **Résidus / Bruit ($R_t$)** : La composante aléatoire ou irrégulière qui reste après avoir retiré la tendance et la saisonnalité. C'est ce qui n'est pas expliqué par les autres composantes.
Ces composantes peuvent interagir de deux manières principales :
> [!definition] Modèles de Décomposition
> - **Modèle Additif** : $Y_t = T_t + S_t + R_t$
> Utilisé lorsque l'amplitude des variations saisonnières et l'erreur ne changent pas avec le niveau de la série.
> - **Modèle Multiplicatif** : $Y_t = T_t \times S_t \times R_t$
> Utilisé lorsque l'amplitude des variations saisonnières et l'erreur augmentent ou diminuent proportionnellement avec le niveau de la série.
## Stationnarité
La stationnarité est une propriété cruciale pour de nombreux modèles de séries temporelles, notamment les modèles ARIMA.
> [!definition] Série Temporelle Stationnaire
> Une série temporelle est dite **stationnaire** si ses propriétés statistiques (moyenne, variance, autocorrélation) ne changent pas au cours du temps.
> Plus formellement, une série $Y_t$ est stationnaire si :
> 1. Sa moyenne est constante : $E[Y_t] = \mu$
> 2. Sa variance est constante : $Var[Y_t] = \sigma^2$
> 3. Sa covariance entre deux points dépend uniquement de l'écart de temps $k$ et non de $t$ : $Cov[Y_t, Y_{t+k}] = \gamma_k$
> [!note] Pourquoi la Stationnarité est Importante ?
> Les modèles basés sur l'autocorrélation supposent que les relations statistiques observées dans les données passées continueront à se maintenir dans le futur. Si la série n'est pas stationnaire, ces relations peuvent changer, rendant les prévisions non fiables.
Les séries non stationnaires peuvent souvent être rendues stationnaires par des transformations, la plus courante étant la **différenciation**.
La différenciation d'ordre 1 est définie par : $Y'_t = Y_t - Y_{t-1}$.
## Autocorrélation (ACF) et Autocorrélation Partielle (PACF)
Ces fonctions sont des outils graphiques essentiels pour identifier la structure sous-jacente d'une série temporelle et pour aider à choisir les paramètres de certains modèles.
> [!definition] Fonction d'Autocorrélation (ACF)
> L'ACF mesure la corrélation entre une observation $Y_t$ et les observations passées $Y_{t-k}$ à différents décalages (lags) $k$.
> $ \rho_k = \frac{Cov(Y_t, Y_{t-k})}{\sqrt{Var(Y_t)Var(Y_{t-k})}} = \frac{\gamma_k}{\gamma_0} $
> où $\gamma_k$ est la covariance au décalage $k$ et $\gamma_0$ est la variance.
> [!definition] Fonction d'Autocorrélation Partielle (PACF)
> La PACF mesure la corrélation entre $Y_t$ et $Y_{t-k}$ après avoir supprimé l'effet des observations intermédiaires $Y_{t-1}, Y_{t-2}, \dots, Y_{t-k+1}$.
> Elle aide à identifier la relation directe entre une observation et une observation passée, en isolant l'influence des décalages intermédiaires.
En Python, les fonctions `plot_acf` et `plot_pacf` de `statsmodels.graphics.tsaplots` sont utilisées pour visualiser ces fonctions.
# Modèles de Base (Naïfs)
Avant d'utiliser des modèles complexes, il est toujours bon d'établir une *baseline* avec des modèles simples. Ils sont faciles à comprendre et à implémenter, et servent de référence pour évaluer la performance de modèles plus sophistiqués.
## Modèle Naïf (Last Value)
> [!definition] Modèle Naïf
> La prévision pour la prochaine période est simplement la valeur de la période précédente.
> $ \hat{Y}_{t+1} = Y_t $
## Modèle Naïf Saisonnier
> [!definition] Modèle Naïf Saisonnier
> La prévision pour la prochaine période est la valeur de la même période de la saison précédente.
> Si la saisonnalité est de période $m$ (par exemple, $m=12$ pour des données mensuelles annuelles) :
> $ \hat{Y}_{t+1} = Y_{t+1-m} $
## Modèle de Moyenne Simple
> [!definition] Modèle de Moyenne Simple
> La prévision pour toute période future est la moyenne de toutes les observations passées.
> $ \hat{Y}_{t+h} = \frac{1}{t} \sum_{i=1}^{t} Y_i $
> [!note] Importance des Modèles Naïfs
> Un modèle de forecasting ne peut être considéré comme bon que s'il surpasse un modèle naïf approprié. Ils sont d'excellents points de comparaison.
# Lissage Exponentiel (Exponential Smoothing)
Les méthodes de lissage exponentiel sont une famille de modèles populaires qui génèrent des prévisions en pondérant les observations passées, en donnant plus de poids aux observations récentes.
## Lissage Exponentiel Simple (Simple Exponential Smoothing - SES)
Ce modèle est adapté aux séries temporelles sans tendance ni saisonnalité.
> [!theorem] Formules du SES
> - **Équation de Lissage** : $L_t = \alpha Y_t + (1 - \alpha) L_{t-1}$
> où $L_t$ est le niveau lissé à la période $t$, $Y_t$ est l'observation réelle à la période $t$, et $\alpha$ est le paramètre de lissage du niveau ($0 \le \alpha \le 1$).
> - **Équation de Prévision** : $\hat{Y}_{t+h} = L_t$ pour $h \ge 1$
> La prévision pour toute période future est simplement le dernier niveau lissé.
> [!note] Le Paramètre $\alpha$
> $\alpha$ détermine la vitesse à laquelle les observations passées sont "oubliées". Une valeur de $\alpha$ proche de 1 signifie que les observations récentes ont beaucoup plus de poids. Une valeur proche de 0 signifie que les observations passées ont une influence plus longue.
## Lissage Exponentiel Double (Double Exponential Smoothing - Méthode de Holt)
La méthode de Holt étend le SES en ajoutant une composante de tendance. Elle est adaptée aux séries avec une tendance mais sans saisonnalité.
> [!theorem] Formules de Holt
> - **Équation de Lissage (Niveau)** : $L_t = \alpha Y_t + (1 - \alpha) (L_{t-1} + B_{t-1})$
> - **Équation de Lissage (Tendance)** : $B_t = \beta (L_t - L_{t-1}) + (1 - \beta) B_{t-1}$
> où $B_t$ est la tendance lissée à la période $t$, et $\beta$ est le paramètre de lissage de la tendance ($0 \le \beta \le 1$).
> - **Équation de Prévision** : $\hat{Y}_{t+h} = L_t + h B_t$ pour $h \ge 1$
> La prévision inclut le dernier niveau lissé et la tendance projetée.
## Lissage Exponentiel Triple (Triple Exponential Smoothing - Méthode de Holt-Winters)
La méthode de Holt-Winters étend la méthode de Holt en ajoutant une composante saisonnière. Elle est adaptée aux séries avec tendance et saisonnalité. Il existe des variantes additives et multiplicatives pour la saisonnalité.
> [!theorem] Formules de Holt-Winters (Additif)
> Soit $m$ la période saisonnière (ex: 12 pour des données mensuelles annuelles).
> - **Équation de Lissage (Niveau)** : $L_t = \alpha (Y_t - S_{t-m}) + (1 - \alpha) (L_{t-1} + B_{t-1})$
> - **Équation de Lissage (Tendance)** : $B_t = \beta (L_t - L_{t-1}) + (1 - \beta) B_{t-1}$
> - **Équation de Lissage (Saisonnalité)** : $S_t = \gamma (Y_t - L_{t-1} - B_{t-1}) + (1 - \gamma) S_{t-m}$
> où $S_t$ est l'indice saisonnier à la période $t$, et $\gamma$ est le paramètre de lissage de la saisonnalité ($0 \le \gamma \le 1$).
> - **Équation de Prévision** : $\hat{Y}_{t+h} = L_t + h B_t + S_{t+h-m(\lfloor (h-1)/m \rfloor + 1)}$ pour $h \ge 1$
> [!note] Choix Additif ou Multiplicatif
> - **Additif** si l'amplitude des variations saisonnières est relativement constante au fil du temps.
> - **Multiplicatif** si l'amplitude des variations saisonnières augmente ou diminue avec le niveau de la série.
## Implémentation en Python avec `statsmodels`
La bibliothèque `statsmodels` en Python offre une implémentation robuste des méthodes de lissage exponentiel via la classe `ExponentialSmoothing`.
```python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from statsmodels.tsa.api import ExponentialSmoothing, SimpleExpSmoothing, Holt
# Génération de données d'exemple (à remplacer par vos propres données)
np.random.seed(42)
data = np.random.rand(50) * 10 + np.linspace(0, 20, 50) + np.sin(np.linspace(0, 3*np.pi, 50)) * 5
index = pd.date_range(start='2020-01-01', periods=50, freq='M')
ts = pd.Series(data, index=index)
# Division en jeu d'entraînement et de test
train = ts[:-10]
test = ts[-10:]
plt.figure(figsize=(12, 6))
plt.plot(train.index, train, label='Train')
plt.plot(test.index, test, label='Test')
plt.title('Série Temporelle d\'Exemple')
plt.legend()
plt.show()
# --- 1. Simple Exponential Smoothing (SES) ---
# Adapté aux séries sans tendance ni saisonnalité
fit1 = SimpleExpSmoothing(train, initialization_method="estimated").fit()
forecast_ses = fit1.forecast(len(test))
plt.figure(figsize=(12, 6))
plt.plot(train.index, train, label='Train')
plt.plot(test.index, test, label='Test')
plt.plot(forecast_ses.index, forecast_ses, label='SES Forecast')
plt.title('SES Forecasting')
plt.legend()
plt.show()
# --- 2. Holt's Method (Double Exponential Smoothing) ---
# Adapté aux séries avec tendance mais sans saisonnalité
fit2 = Holt(train, initialization_method="estimated").fit()
forecast_holt = fit2.forecast(len(test))
plt.figure(figsize=(12, 6))
plt.plot(train.index, train, label='Train')
plt.plot(test.index, test, label='Test')
plt.plot(forecast_holt.index, forecast_holt, label='Holt Forecast')
plt.title('Holt\'s Method Forecasting')
plt.legend()
plt.show()
# --- 3. Holt-Winters' Method (Triple Exponential Smoothing) ---
# Adapté aux séries avec tendance et saisonnalité
# Pour cet exemple, supposons une saisonnalité annuelle (m=12)
# Les données d'exemple sont trop courtes pour une saisonnalité de 12.
# Créons un exemple plus adapté.
data_hw = np.random.rand(100) * 5 + np.linspace(0, 30, 100) + np.sin(np.linspace(0, 8*np.pi, 100)) * 10 + np.cos(np.linspace(0, 4*np.pi, 100)) * 7
index_hw = pd.date_range(start='2015-01-01', periods=100, freq='M')
ts_hw = pd.Series(data_hw, index=index_hw)
train_hw = ts_hw[:-20]
test_hw = ts_hw[-20:]
# Utilisation d'ExponentialSmoothing pour Holt-Winters
# trend='add' pour tendance additive, seasonal='add' ou 'mul' pour saisonnalité additive ou multiplicative
# seasonal_periods est la longueur de la saison (ex: 12 pour données mensuelles annuelles)
fit3 = ExponentialSmoothing(train_hw, trend='add', seasonal='add', seasonal_periods=12, initialization_method="estimated").fit()
forecast_hw = fit3.forecast(len(test_hw))
plt.figure(figsize=(12, 6))
plt.plot(train_hw.index, train_hw, label='Train HW')
plt.plot(test_hw.index, test_hw, label='Test HW')
plt.plot(forecast_hw.index, forecast_hw, label='Holt-Winters Forecast')
plt.title('Holt-Winters Method Forecasting')
plt.legend()
plt.show()
# On peut aussi obtenir les paramètres optimisés
print(f"Paramètres SES: alpha={fit1.params['smoothing_level']:.3f}")
print(f"Paramètres Holt: alpha={fit2.params['smoothing_level']:.3f}, beta={fit2.params['smoothing_trend']:.3f}")
print(f"Paramètres Holt-Winters: alpha={fit3.params['smoothing_level']:.3f}, beta={fit3.params['smoothing_trend']:.3f}, gamma={fit3.params['smoothing_seasonal']:.3f}")
```
# Modèles ARIMA (AutoRegressive Integrated Moving Average)
Les modèles ARIMA sont une classe puissante de modèles statistiques pour l'analyse et la prévision de séries temporelles. Ils sont basés sur l'idée que les valeurs futures d'une série peuvent être prédites en fonction de ses propres valeurs passées et des erreurs de prévision passées.
## Composantes d'ARIMA
Un modèle ARIMA est caractérisé par 3 paramètres : $p$, $d$, $q$.
- **AR ($p$) : AutoRégressif**
La composante AR indique que la variable d'intérêt dépend linéairement de ses propres valeurs passées. Le paramètre $p$ est l'ordre de la partie auto-régressive, représentant le nombre de termes précédents à inclure.
Un modèle AR($p$) est défini par :
$ Y_t = c + \phi_1 Y_{t-1} + \phi_2 Y_{t-2} + \dots + \phi_p Y_{t-p} + \epsilon_t $
où $\phi_i$ sont les coefficients AR et $\epsilon_t$ est le terme d'erreur.
- **I ($d$) : Intégré**
La composante "Intégrée" fait référence au nombre de fois où les observations brutes sont différenciées pour rendre la série stationnaire. Le paramètre $d$ est l'ordre de différenciation.
Si $d=0$, la série est déjà stationnaire. Si $d=1$, on différencie une fois ($Y'_t = Y_t - Y_{t-1}$). Si $d=2$, on différencie deux fois ($Y''_t = Y'_t - Y'_{t-1}$).
- **MA ($q$) : Moyenne Mobile**
La composante MA indique que l'erreur de prévision d'une observation dépend linéairement des erreurs de prévision passées. Le paramètre $q$ est l'ordre de la partie moyenne mobile, représentant le nombre de termes d'erreur de prévision à inclure.
Un modèle MA($q$) est défini par :
$ Y_t = c + \epsilon_t + \theta_1 \epsilon_{t-1} + \theta_2 \epsilon_{t-2} + \dots + \theta_q \epsilon_{t-q} $
où $\theta_i$ sont les coefficients MA et $\epsilon_t$ sont les erreurs de prévision passées (bruit blanc).
> [!definition] Modèle ARIMA($p, d, q$)
> Un modèle ARIMA($p, d, q$) combine les composantes AR, I et MA.
> Si $Y'_t$ est la série différenciée $d$ fois, alors un modèle ARIMA($p, d, q$) est un modèle ARMA($p, q$) appliqué à $Y'_t$.
> $ Y'_t = c + \phi_1 Y'_{t-1} + \dots + \phi_p Y'_{t-p} + \epsilon_t + \theta_1 \epsilon_{t-1} + \dots + \theta_q \epsilon_{t-q} $
## Processus de Box-Jenkins
Le processus de Box-Jenkins est une méthodologie systématique pour construire un modèle ARIMA :
1. **Identification** : Examiner les graphes de la série, de l'ACF et de la PACF pour déterminer les ordres $p, d, q$ (et $P, D, Q, s$ pour SARIMA).
- $d$ est déterminé par le nombre de différenciations nécessaires pour rendre la série stationnaire.
- $p$ est souvent suggéré par le décalage où la PACF s'annule brusquement.
- $q$ est souvent suggéré par le décalage où l'ACF s'annule brusquement.
2. **Estimation** : Estimer les coefficients du modèle choisi.
3. **Diagnostic** : Vérifier si les résidus du modèle sont du bruit blanc (non corrélés, moyenne nulle, variance constante). Si non, revenir à l'étape d'identification.
4. **Prévision** : Une fois le modèle validé, l'utiliser pour faire des prévisions.
> [!tip] Identification des Paramètres avec ACF/PACF
> - **Série non stationnaire** : L'ACF décroît lentement. Appliquer la différenciation.
> - **AR($p$)** : La PACF a des pics significatifs jusqu'au décalage $p$ et s'annule ensuite. L'ACF décroît exponentiellement ou sinusoïdalement.
> - **MA($q$)** : L'ACF a des pics significatifs jusqu'au décalage $q$ et s'annule ensuite. La PACF décroît exponentiellement ou sinusoïdalement.
## Modèles SARIMA (Seasonal ARIMA)
Les modèles SARIMA étendent les modèles ARIMA pour gérer la saisonnalité. Ils sont caractérisés par 7 paramètres : ARIMA($p, d, q$)(P, D, Q)$_s$.
- ($p, d, q$) sont les ordres non saisonniers (comme pour ARIMA).
- ($P, D, Q$) sont les ordres saisonniers.
- $P$ : Ordre auto-régressif saisonnier.
- $D$ : Ordre de différenciation saisonnière (différenciation par rapport à la même période de la saison précédente).
- $Q$ : Ordre de moyenne mobile saisonnière.
- $s$ : La période de la saisonnalité (ex: 12 pour des données mensuelles annuelles).
## Implémentation en Python avec `statsmodels`
```python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from statsmodels.tsa.arima.model import ARIMA
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
from statsmodels.tsa.stattools import adfuller # Pour le test de stationnarité
# Génération de données d'exemple avec tendance et saisonnalité
np.random.seed(42)
n_points = 120 # 10 ans de données mensuelles
index_arima = pd.date_range(start='2010-01-01', periods=n_points, freq='M')
data_arima = np.linspace(0, 50, n_points) + \
10 * np.sin(np.linspace(0, 3 * np.pi, n_points)) + \
5 * np.cos(np.linspace(0, 10 * np.pi, n_points)) + \
np.random.normal(0, 2, n_points)
ts_arima = pd.Series(data_arima, index=index_arima)
train_arima = ts_arima[:-24] # 8 ans pour l'entraînement
test_arima = ts_arima[-24:] # 2 ans pour le test
plt.figure(figsize=(12, 6))
plt.plot(train_arima.index, train_arima, label='Train')
plt.plot(test_arima.index, test_arima, label='Test')
plt.title('Série Temporelle pour ARIMA/SARIMA')
plt.legend()
plt.show()
# --- 1. Vérification de la stationnarité et différenciation ---
# Test de Dickey-Fuller Augmenté (ADF)
def adf_test(series):
result = adfuller(series, autolag='AIC')
print(f'ADF Statistic: {result[0]:.2f}')
print(f'p-value: {result[1]:.2f}')
for key, value in result[4].items():
print(f'Critical Value ({key}): {value:.2f}')
if result[1] <= 0.05:
print("La série est stationnaire (rejette H0)")
else:
print("La série n'est pas stationnaire (ne rejette pas H0)")
print("Test ADF sur la série originale:")
adf_test(train_arima)
# Si non stationnaire, appliquer la différenciation
# Exemple de différenciation d'ordre 1
diff_ts = train_arima.diff().dropna()
plt.figure(figsize=(12, 6))
plt.plot(diff_ts.index, diff_ts, label='Série Différenciée')
plt.title('Série Temporelle Différenciée (d=1)')
plt.legend()
plt.show()
print("\nTest ADF sur la série différenciée:")
adf_test(diff_ts)
# --- 2. Identification des ordres p, q, P, Q avec ACF/PACF ---
# Après différenciation, analyser les graphes ACF et PACF
fig, axes = plt.subplots(1, 2, figsize=(16, 6))
plot_acf(diff_ts, ax=axes[0], lags=30)
plot_pacf(diff_ts, ax=axes[1], lags=30)
plt.suptitle('ACF et PACF de la Série Différenciée')
plt.show()
# Basé sur l'analyse des graphes (simplifié pour l'exemple)
# Supposons que d=1, et que les graphes suggèrent p=1, q=1, P=1, Q=1 et s=12 (saisonnalité mensuelle)
# C'est une étape subjective qui demande de l'expérience.
# --- 3. Entraînement et prédiction avec SARIMA ---
# (p, d, q) = (1, 1, 1)
# (P, D, Q, s) = (1, 1, 1, 12)
order = (1, 1, 1)
seasonal_order = (1, 1, 1, 12) # s=12 pour la saisonnalité mensuelle
# Utilisation de ARIMA pour SARIMA (il gère la saisonnalité via seasonal_order)
model_sarima = ARIMA(train_arima, order=order, seasonal_order=seasonal_order, enforce_stationarity=False, enforce_invertibility=False)
fit_sarima = model_sarima.fit()
print(fit_sarima.summary())
# Prédiction
forecast_sarima = fit_sarima.forecast(steps=len(test_arima))
plt.figure(figsize=(12, 6))
plt.plot(train_arima.index, train_arima, label='Train')
plt.plot(test_arima.index, test_arima, label='Test')
plt.plot(forecast_sarima.index, forecast_sarima, label='SARIMA Forecast')
plt.title('SARIMA Forecasting')
plt.legend()
plt.show()
```
> [!warning] Choix des Paramètres ARIMA/SARIMA
> L'identification des ordres $p, d, q, P, D, Q, s$ est souvent la partie la plus délicate. Elle nécessite une bonne compréhension des fonctions ACF/PACF et parfois des essais-erreurs. Des approches automatiques comme `pmdarima.auto_arima` peuvent aider, mais il est crucial de comprendre la logique sous-jacente.
# Évaluation des Modèles de Forecasting
Évaluer la performance d'un modèle de forecasting est essentiel pour choisir le meilleur modèle et comprendre sa fiabilité.
## Métriques d'Erreur Courantes
Pour une série $Y_t$ et des prévisions $\hat{Y}_t$, l'erreur de prévision est $e_t = Y_t - \hat{Y}_t$.
- **Erreur Absolue Moyenne (MAE - Mean Absolute Error)**
Mesure la magnitude moyenne des erreurs sans tenir compte de leur direction.
$ MAE = \frac{1}{n} \sum_{t=1}^{n} |e_t| = \frac{1}{n} \sum_{t=1}^{n} |Y_t - \hat{Y}_t| $
*Avantage* : Facile à interpréter, robuste aux valeurs aberrantes.
*Inconvénient* : Ne pénalise pas plus les grandes erreurs.
- **Erreur Quadratique Moyenne (MSE - Mean Squared Error)**
Pénalise plus fortement les grandes erreurs.
$ MSE = \frac{1}{n} \sum_{t=1}^{n} e_t^2 = \frac{1}{n} \sum_{t=1}^{n} (Y_t - \hat{Y}_t)^2 $
*Avantage* : Pénalise les grandes erreurs.
*Inconvénient* : Sensible aux valeurs aberrantes, unités au carré.
- **Racine Carrée de l'Erreur Quadratique Moyenne (RMSE - Root Mean Squared Error)**
La RMSE est la racine carrée du MSE, ce qui la rend dans la même unité que la série originale, facilitant l'interprétation.
$ RMSE = \sqrt{MSE} = \sqrt{\frac{1}{n} \sum_{t=1}^{n} (Y_t - \hat{Y}_t)^2} $
*Avantage* : Dans la même unité que la variable à prédire, pénalise les grandes erreurs.
*Inconvénient* : Sensible aux valeurs aberrantes.
- **Erreur Absolue Moyenne en Pourcentage (MAPE - Mean Absolute Percentage Error)**
Utile pour comparer la précision des prévisions sur différentes séries avec des échelles différentes.
$ MAPE = \frac{1}{n} \sum_{t=1}^{n} \left| \frac{Y_t - \hat{Y}_t}{Y_t} \right| \times 100\% $
*Avantage* : Indépendante de l'échelle, facile à comprendre.
*Inconvénient* : Problématique si $Y_t$ est proche de zéro, asymétrique (pénalise plus les erreurs négatives).
- **Erreur Absolue Moyenne en Pourcentage Symétrique (SMAPE - Symmetric Mean Absolute Percentage Error)**
Une alternative au MAPE qui tente de résoudre le problème d'asymétrie.
$ SMAPE = \frac{1}{n} \sum_{t=1}^{n} \frac{|Y_t - \hat{Y}_t|}{(|Y_t| + |\hat{Y}_t|)/2} \times 100\% $
*Avantage* : Plus symétrique que le MAPE.
*Inconvénient* : Peut être problématique si $Y_t$ et $\hat{Y}_t$ sont tous deux proches de zéro.
## Validation Croisée pour Séries Temporelles
La validation croisée standard (k-fold) n'est pas adaptée aux séries temporelles car elle brise l'ordre chronologique. Pour les séries temporelles, on utilise des techniques comme la **validation croisée glissante (rolling forecast origin)**.
> [!definition] Validation Croisée Glissante
> 1. Entraîner le modèle sur un ensemble de données initiales.
> 2. Faire une prévision pour la période suivante.
> 3. Ajouter cette période à l'ensemble d'entraînement.
> 4. Répéter les étapes 2 et 3, en faisant avancer la "fenêtre" d'entraînement et de test.
> Cette méthode simule la façon dont le modèle serait utilisé en production.
## Implémentation en Python pour l'évaluation
```python
from sklearn.metrics import mean_absolute_error, mean_squared_error
import numpy as np
# Supposons que 'test' contient les vraies valeurs et 'forecast_sarima' les prédictions
# Assurez-vous que les indices sont alignés et que les longueurs sont identiques
y_true = test_arima.values
y_pred = forecast_sarima.values
# Calcul des métriques
mae = mean_absolute_error(y_true, y_pred)
mse = mean_squared_error(y_true, y_pred)
rmse = np.sqrt(mse)
def mape(y_true, y_pred):
return np.mean(np.abs((y_true - y_pred) / y_true)) * 100
def smape(y_true, y_pred):
return np.mean(2 * np.abs(y_pred - y_true) / (np.abs(y_true) + np.abs(y_pred))) * 100
print(f"MAE: {mae:.2f}")
print(f"MSE: {mse:.2f}")
print(f"RMSE: {rmse:.2f}")
print(f"MAPE: {mape(y_true, y_pred):.2f}%")
print(f"SMAPE: {smape(y_true, y_pred):.2f}%")
```
# ➡️ C'est la fin !
Ce chapitre vous a introduit aux modèles de forecasting à une variable, des méthodes naïves aux techniques de lissage exponentiel et aux puissants modèles ARIMA/SARIMA. Vous avez appris les concepts fondamentaux des séries temporelles, comment identifier leurs composantes, et comment implémenter et évaluer ces modèles en Python.
> [!note] Quand utiliser quel modèle ?
> - **Modèles Naïfs** : Toujours comme *baseline*.
> - **SES** : Séries sans tendance ni saisonnalité.
> - **Holt** : Séries avec tendance, sans saisonnalité.
> - **Holt-Winters** : Séries avec tendance et saisonnalité.
> - **ARIMA** : Séries sans saisonnalité, mais avec autocorrélation dans la série différenciée.
> - **SARIMA** : Séries avec tendance, saisonnalité et autocorrélation.
Le choix du modèle dépend fortement des caractéristiques de votre série temporelle et de la complexité des motifs que vous souhaitez capturer. Une analyse exploratoire approfondie (visualisation, décomposition, ACF/PACF) est toujours la première étape cruciale.
Les modèles univariés sont un excellent point de départ, mais ils ont leurs limites. Ils ne peuvent pas intégrer d'autres variables explicatives (exogènes) qui pourraient améliorer la précision des prévisions. Les prochains modules exploreront des techniques plus avancées, y compris les modèles multivariés et l'application de techniques de Machine Learning et Deep Learning au forecasting.
---
- Cours précèdent: [[Cours 1 - Forecasting]]
- Prochain cours: [[Cours 3 - Forecasting]]
- Page d'accueil de la compétence: [[Forecasting]]
# 🗓️ Historique
- Dernière MAJ: `20-Octobre-2025`
- Rédigé par: [[Hamilton DE ARAUJO]]