Décomposition Additive

La décomposition additive d’une série temporelle est une technique permettant de séparer les composantes de la série en trois parties distinctes : la tendance, la saisonnalité, et l’erreur ou bruit. Contrairement à la décomposition multiplicative, où les composants sont supposés être multipliés ensemble, la décomposition additive suppose que la série temporelle est la somme des composants.

Modèle de Décomposition Additive

La décomposition additive d’une série temporelle

$Y_t$

$Y_{t}$ est représentée par :

$Y_t = T_t + S_t + E_t$

$Y_{t} = T_{t} + S_{t} + E_{t}$

$Y_t$ $Y_{t}$ : la valeur observée de la série temporelle à un instant

$t$ $t$ ,
$T_t$ $T_{t}$ : la tendance ou tendance générale à l’instant

$t$ $t$ ,
$S_t$ $S_{t}$ : le composant saisonnier à l’instant

$t$ $t$ ,
$E_t$ $E_{t}$ : l’erreur ou composant aléatoire à l’instant

$t$ $t$ .

Intuition :

Tendance (T) : La direction générale de la série sur une longue période (exemple : une augmentation progressive des ventes au fil des années).
Saisonnalité (S) : Les variations régulières et périodiques qui se produisent à des intervalles réguliers (exemple : augmentation des ventes pendant les fêtes).
Erreur (E) : Les fluctuations aléatoires ou irrégulières qui ne peuvent pas être expliquées par la tendance et la saisonnalité.

Processus de Décomposition Additive

Identification de la tendance : On commence par lisser les données pour obtenir la tendance générale. Cela peut être fait à l’aide de méthodes comme la moyenne mobile ou la régression pour obtenir la composante de tendance.
Extraction de la saisonnalité : Après avoir isolé la tendance, la saisonnalité est identifiée en soustrayant la tendance lissée des données observées, pour obtenir un composant saisonnier.
Estimation de l’erreur : L’erreur est ensuite calculée en soustrayant la tendance et la saisonnalité de la série observée.

Fonctions :

seasonal_decompose()

La fonction seasonal_decompose() de statsmodels permet de décomposer une série temporelle en une composante de tendance, une composante saisonnière et des résidus. Cette décomposition est réalisée selon une approche additive (lorsque la série temporelle est supposée être la somme de ces trois composants). La décomposition peut être utilisée pour analyser les séries temporelles et mieux comprendre leurs structures sous-jacentes.

Importation :

from statsmodels.tsa.seasonal import seasonal_decompose

Attributs :

Nom	Type	Description
freq	int, optionnel	La fréquence des données (exprimée en nombre d'observations par période, par exemple 12 pour des données mensuelles avec une saisonnalité annuelle). Si non spécifiée, elle sera inférée automatiquement.
model	str	Le modèle de décomposition à utiliser : 'additive' ou 'multiplicative'. Par défaut, 'additive' est utilisé.
filter_width	int, optionnel	La largeur du filtre utilisé pour le lissage des composantes saisonnières. Par défaut, la largeur est fixée à 3.

Exemple de code :

from statsmodels.tsa.seasonal import seasonal_decompose
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Création d'une série temporelle d'exemple
np.random.seed(0)
dates = pd.date_range('2020-01-01', periods=100, freq='D')
data = np.sin(np.linspace(0, 20, 100)) + np.random.normal(size=100)  # Série avec une tendance et un bruit aléatoire

# Création d'une DataFrame
series = pd.Series(data, index=dates)

# Application de la décomposition saisonnière additive
result = seasonal_decompose(series, model='additive', period=30)

# Affichage des résultats
result.plot()
plt.show()

# Affichage des composantes
print(f"Tendance: \n{result.trend.head()}")
print(f"Saisonnalité: \n{result.seasonal.head()}")
print(f"Résidus: \n{result.resid.head()}")

Explication du code :

Les bibliothèques nécessaires sont importées :

seasonal_decompose de statsmodels.tsa.seasonal permet de décomposer une série temporelle en ses composantes de tendance, saisonnalité et résidus.
pandas est utilisé pour la gestion des données sous forme de DataFrame.
numpy permet d’effectuer des calculs mathématiques et de générer des données aléatoires.
matplotlib.pyplot est utilisé pour créer des visualisations graphiques.

Création d'une série temporelle d'exemple

D'abord, une graine aléatoire est fixée pour garantir la reproductibilité des résultats. Ensuite, une séquence de 100 dates est générée, allant du 1er janvier 2020 avec une fréquence journalière. Une série de données est créée à partir de la fonction sinus pour simuler une tendance saisonnière, à laquelle on ajoute un bruit aléatoire.

Création d'une DataFrame

La série de données est convertie en un objet pandas.Series avec les dates comme index.

Application de la décomposition saisonnière additive

La méthode seasonal_decompose est utilisée pour décomposer la série temporelle en ses composantes. Le paramètre model='additive' spécifie que la décomposition sera additive (c'est-à-dire, que la série est la somme de ses composantes : tendance + saisonnalité + résidus). Le paramètre period=30 définit la longueur du cycle saisonnier (ici, 30 jours).

Affichage des résultats

Un graphique est généré pour visualiser les trois composantes (tendance, saisonnalité, résidus). Ce graphique est ensuite affiché à l'écran.

Affichage des composantes

Les composantes de tendance, saisonnalité et résidus sont extraites du résultat de la décomposition et affichées. La méthode head() est utilisée pour afficher les 5 premières lignes de chaque composant.