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:
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.