Deep Learning: comprendre et construire des réseaux de neurones

Auteur: Mohamed CHINY Durée necessaire pour le cours de Deep Learning: comprendre et construire des réseaux de neurones Niveau recommandé pour le cours de Deep Learning: comprendre et construire des réseaux de neurones Supports vidéo non disponibles pour ce cours Exercices de renforcement non disponibles pour ce cours Quiz non disponibles pour ce cours

Leçon 19: Apprentissage séquentiel avec LSTM pour comprendre la dynamique des températures

Toutes les leçons

Deep Learning: comprendre et construire des réseaux de neurones

Leçon 1
Deep Learning et réseaux de neurones: définition, utilité et histoire d'évolution
Leçon 2
Réseaux de neurones artificiels: la base du Deep Learning
Leçon 3
Feed Forward et Backpropagation: les pilliers de l'apprentissage des réseaux de neurones
Leçon 4
TensorFlow, PyTorch et Keras: les piliers actuels du Deep Learning
Leçon 5
Sequential, Input et Dense: construire un réseau de neurones pour la régression avec Keras
Leçon 6
Construire un réseau de neurones pour des données non linéaires avec Keras
Leçon 7
Training Loss et Validation Loss: détecter l'overfitting dans les réseaux de neurones
Leçon 8
Réseaux de neurones appliqués à la classification binaire
Leçon 9
Application des réseaux de neurones à la classification multiclasse sur Iris
Leçon 10
Prévenir l'overfitting grace à la régularisation: principes et techniques fondamentales
Leçon 11
Régularisation L1, L2, Dropout, Batch Normalization et Early Stopping - Mise en pratique
Leçon 12
Convolutional Neural Networks (CNN): réseaux de neurones dédiés aux images
Leçon 13
CNN et MNIST: reconnaissance et classification des chiffres manuscrits
Leçon 14
CNN et CIFAR-10: reconnaissance et classification d'images en couleur
Leçon 15
Recurrent Neural Networks (RNN): Réseaux de neurones dédiés aux séquences
Leçon 16
Apprendre à construire un RNN simple pour la prédiction séquentielle
Leçon 17
Limites des RNN face au vanishing gradient et aux dépendances longues: apports des LSTM et GRU
Leçon 18
LSTM: Long Short-Term Memory - une mémoire longue durée pour les séquences
Leçon 19
Apprentissage séquentiel avec LSTM pour comprendre la dynamique des températures

Séries temporelles et LSTM: comprendre l’évolution des températures

Prédire la température grâce aux séquences temporelles

L’objectif général de cet exemple est de montrer comment un réseau LSTM peut être utilisé pour traiter une série temporelle en transformant les données brutes en séquences exploitables.

L’idée est de prendre une fenêtre glissante de valeurs passées (par exemple les températures des 30 derniers jours) et d’apprendre à prédire la valeur suivante. Ce type de modèle illustre la capacité des LSTM à capturer des dépendances plus longues et des tendances dans le temps, là où des architectures plus simples comme les SimpleRNN perdent rapidement l’information.

En résumé, cet exemple met en évidence l’intérêt des LSTM pour la modélisation séquentielle et la prédiction de séries temporelles.

De la donnée brute à la prévision: modéliser la température avec LSTM

Comme c'est souvent le cas, je vais vous donner le code entier puis j'expliquerai de manière détaillée les points essentiels.

Je propose ce code:
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

# Exemple de données simulées (100 jours)
data = np.sin(np.arange(100) * 0.1) * 10 + 20

# Création des séquences (30 jours → prédiction du 31e)
X, y = [], []
window = 30
for i in range(len(data)-window):
   X.append(data[i:i+window])
   y.append(data[i+window])

X = np.array(X)
y = np.array(y)

# Reshape pour LSTM : (samples, timesteps, features)
X = X.reshape((X.shape[0], X.shape[1], 1))

# Construction du modèle LSTM
model = Sequential()
model.add(
   LSTM(64, activation='relu', input_shape=(window,1))
)
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')

# Entrainement du modèle
model.fit(X, y, epochs=50, verbose=1)

# Prédiction du dernier jour
test_input = data[-window:].reshape((1, window, 1))
prediction = model.predict(test_input, verbose=0)
print(f"Température prédite: {prediction[0][0]:.2f} °C")
Passons aux explications:

On commence par importer les modules nécessaire (dont LSTM):
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
Le module numpy sera utilisé pour générer artificiellement nos données concernant la température quotidienne.
On génère ensuite nos données:
data = np.sin(np.arange(100) * 0.1) * 10 + 20
En effet, cette instruction sert à générer une série temporelle artificielle de températures. On crée ici 100 valeurs qui oscillent autour de 20°C, avec une variation sinusoïdale d’amplitude 10. Autrement dit, c’est une simulation de données climatiques présentant une tendance périodique (comme des cycles journaliers ou saisonniers).

Si on affiche la courbe correspondante à data avec plt.plot(data), on aura ceci:
LSTM - modélisation de la température journalière
On crée nos séquences exactement comme on l'a fait pour l'exemple avec SimpleRNN (cette fois, on fixe une fenêtre glissante de 30 jours):
X, y = [], []
window = 30
for i in range(len(data)-window):
   X.append(data[i:i+window])
   y.append(data[i+window])

X = np.array(X)
y = np.array(y)
Il ne faut pas oublier de réorganiser les données afin qu’elles soient compatibles avec l’entrée attendue par un LSTM:
X = X.reshape((X.shape[0], X.shape[1], 1))
En effet, un LSTM dans Keras attend des données sous la forme: (samples,timesteps,feature).

A ce stade, il est temps de construie notre modèle:
model = Sequential()
model.add(
   LSTM(64, activation='relu', input_shape=(window,1))
)
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')
Ce bloc de code définit et compile notre modèle séquentiel LSTM destiné à la prédiction de la température. La première couche est un LSTM avec 64 unités et une fonction d’activation relu capable de capturer les dépendances dans une séquence de 30 jours. La couche finale Dense(1) produit une valeur unique qui correspond à la température prédite du jour suivant. Enfin, le modèle est compilé avec l’optimiseur adam et la fonction de perte mse (erreur quadratique moyenne), adaptée aux problèmes de régression.
Le paramètre input_shape=(window,1) précise la forme des données que le réseau LSTM doit recevoir. Ici, chaque séquence correspond à une fenêtre temporelle de 30 jours et chaque jour est représenté par une seule variable qui est la température.
La prochaine étape consiste à l'entrainement du modèle:
model.fit(X, y, epochs=50, verbose=1)
En effet, on a lancé l’entraînement du modèle LSTM sur les séquences de température, en répétant 50 fois le processus d’apprentissage (50 épochs) pour que le réseau ajuste ses paramètres et améliore sa capacité à prédire la valeur du jour suivant.

Il est temps de prédire la température du jour suivant:
test_input = data[-window:].reshape((1, window, 1))
prediction = model.predict(test_input, verbose=0)
print(f"Température prédite: {prediction[0][0]:.2f} °C")
On prend la dernière séquence de 30 jours de températures à partir du tableau data (data[-window:]), on la met au bon format pour le LSTM (reshape((1, window, 1)), puis on utilise le modèle entraîné pour prédire la température du jour suivant (model.predict).

L'exécution de ce dernier code produit le résultat suivant:
Température prédite: 14.78 °C
Notre modèle LSTM a prédit une température de 14.78°C pour le jour suivant à partir des 30 derniers jours de données simulées.

Ce résultat montre que le réseau a appris à exploiter la structure séquentielle de la série et à fournir une estimation cohérente. Bien sûr, comme les données sont artificielles (sinusoïde autour de 20°C), la valeur prédite reflète simplement la tendance calculée par le modèle.          
         
         
Leçon 19
Apprentissage séquentiel avec LSTM pour comprendre la dynamique des températures