Séries temporelles

L’analyse de séries temporelles consiste à étudier des données organisées dans le temps afin de comprendre leur évolution, identifier des tendances et produire des prévisions. L’objectif est d’extraire des informations utiles à partir d’observations chronologiques pour anticiper les comportements futurs.

Le principe repose sur l’examen de composantes temporelles telles que les tendances, la saisonnalité, les cycles ou l’aléa. Selon la complexité des données, on peut utiliser des méthodes classiques comme ARIMA et Exponential Smoothing, ou des approches modernes basées sur les réseaux de neurones, notamment LSTM, GRU ou Transformers spécialisés.

L’analyse de séries temporelles est utilisée en finance pour prévoir les prix, en énergie pour anticiper la consommation, en météorologie pour estimer les conditions futures, et dans de nombreux domaines nécessitant des prévisions basées sur le temps.

En résumé, l’étude des séries temporelles permet de modéliser l’évolution d’une variable dans le temps et de fournir des prévisions adaptées aux dynamiques temporelles.

Fonctions :

Séries temporelles (exemple)

Les LSTM (Long Short-Term Memory) sont des réseaux de neurones récurrents conçus pour modéliser des séquences de données, comme les séries temporelles. Ils permettent de prédire les valeurs futures en tenant compte des dépendances passées à long terme.

Importation :

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

Attributs :

Paramètre	Type	Description	Valeur par défaut
`texts`	list[str]	Liste des textes à analyser ou à prédire.	—
`max_length`	int	Longueur maximale des séquences de tokens après padding.	`100`
`model`	`tf.keras.Model`	Modèle de deep learning entraîné pour la tâche NLP (ex : classification de texte).	—

Exemple de code :

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

# Génération d'une sinusoïde
t = np.linspace(0, 10, 100)
data = np.sin(t)

# Création d'un dataset glissant
def create_dataset(series, window_size=5):
    X, y = [], []
    for i in range(len(series) - window_size):
        X.append(series[i:i+window_size])
        y.append(series[i+window_size])
    return np.array(X), np.array(y)

window_size = 5
X, y = create_dataset(data, window_size)
X = X.reshape((X.shape[0], X.shape[1], 1))

# Construction du modèle
model = Sequential()
model.add(LSTM(units=50, input_shape=(window_size, 1)))
model.add(Dense(1))

model.compile(optimizer='adam', loss='mse')
model.fit(X, y, epochs=50, verbose=0)

# Prédiction d'une valeur
last_sequence = data[-window_size:].reshape(1, window_size, 1)
predicted = model.predict(last_sequence)

print(f"Valeur prédite : {predicted[0][0]}")

Explication du code :

Importation des bibliothèques

import numpy as np : Manipulation de tableaux numériques. import tensorflow as tf : Framework de deep learning. from tensorflow.keras.models import Sequential : Création d’un modèle séquentiel. from tensorflow.keras.layers import LSTM, Dense : Couches LSTM et entièrement connectées.

Génération de données

t = np.linspace(0, 10, 100) : Crée un vecteur temps. data = np.sin(t) : Génère une sinusoïde simulant une série cyclique.

Préparation des données

create_dataset() : Crée des paires (X, y) où X = séquence de 5 pas et y = valeur suivante. reshape() : Redimensionne X pour l’adapter au format (samples, time_steps, features) requis par LSTM.

Création du modèle

Sequential() : Empile les couches. LSTM(50) : 50 neurones mémoire pour apprendre la dynamique temporelle. Dense(1) : Neurone de sortie pour prédire une valeur unique. compile() : Spécifie l’optimiseur (Adam) et la fonction de perte (MSE). fit() : Entraîne le modèle pendant 50 époques.

Prédiction

last_sequence : Derniers points de la série pour prédiction. predict() : Calcule la valeur suivante attendue.