RNN et LSTM : Modéliser les Séquences

Pourquoi les réseaux classiques échouent sur les séquences

Un MLP (Multi-Layer Perceptron) traite chaque entrée de manière indépendante. Il n'a aucune notion d'ordre ou de dépendance temporelle. Or, de nombreux problèmes sont séquentiels :

• "Je ne suis pas content" : le "pas" change tout ce qui précède
• Une série temporelle de températures : demain dépend des jours passés
• Une mélodie : chaque note s'inscrit dans une progression harmonique

RNN : la boucle récurrente

Le Recurrent Neural Network ajoute un état caché h_t qui se propage d'un pas temporel au suivant.

L'équation centrale :

h_t = tanh(W_hh · h_{t-1} + W_xh · x_t + b)

h_t encode tout ce que le réseau a "vu" jusqu'ici. En théorie, il peut capturer des dépendances arbitrairement longues. En pratique, c'est là que le problème commence.

Le vanishing gradient : pourquoi les RNN oublient

Lors de la rétropropagation dans le temps (BPTT), le gradient doit traverser chaque pas temporel, multiplié à chaque fois par la dérivée de tanh et les poids W_hh.

Gradient au pas t=0 ≈ gradient × W_hh^T
Pour T=100, W_hh=0.9 : 0.9^100 ≈ 0.000027  ← pratiquement zéro

LSTM : les 3 portes qui changent tout

Le Long Short-Term Memory introduit deux vecteurs distincts :

• h_t : état caché (court terme)
• c_t : état de cellule (long terme : la vraie mémoire)

Et trois portes qui contrôlent le flux d'information :

Forget gate : "Que faut-il oublier ?"

f_t = σ(W_f · [h_{t-1}, x_t] + b_f)   → entre 0 (tout oublier) et 1 (tout garder)

Input gate : "Quelle nouvelle information stocker ?"

i_t = σ(W_i · [h_{t-1}, x_t] + b_i)
g_t = tanh(W_g · [h_{t-1}, x_t] + b_g)
c_t = f_t ⊙ c_{t-1} + i_t ⊙ g_t

Output gate : "Que révéler de la mémoire ?"

o_t = σ(W_o · [h_{t-1}, x_t] + b_o)
h_t = o_t ⊙ tanh(c_t)

Pourquoi les LSTM résolvent le vanishing gradient : c_t est mis à jour par addition (pas seulement multiplication), créant une autoroute pour les gradients qui traversent de nombreux pas sans disparaître.

GRU : la version allégée

Micro-exercice : prédiction de série temporelle avec LSTM PyTorch

import torch
import torch.nn as nn
import numpy as np

class LSTMPredictor(nn.Module):
    def __init__(self, input_size=1, hidden_size=32, num_layers=2):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, 1)

    def forward(self, x):
        out, _ = self.lstm(x)
        return self.fc(out[:, -1, :])  # Dernier pas temporel

# Données synthétiques : sinusoïde + bruit
t = np.linspace(0, 4 * np.pi, 1000)
temps = np.sin(t) * 10 + 20 + np.random.normal(0, 0.5, 1000)

# Créer les séquences
seq_len = 30
X = torch.FloatTensor([temps[i:i+seq_len] for i in range(len(temps)-seq_len)]).unsqueeze(-1)
y = torch.FloatTensor([temps[i+seq_len] for i in range(len(temps)-seq_len)]).unsqueeze(-1)

model = LSTMPredictor()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.MSELoss()

for epoch in range(50):
    pred = model(X)
    loss = criterion(pred, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if epoch % 10 == 0:
        print(f"Epoch {epoch:3d} | Loss: {loss.item():.4f}")

Pourquoi les Transformers ont remplacé les RNN

LSTM reste pertinent pour :

• Séries temporelles sur ressources limitées (edge, microcontrôleurs)
• Streaming temps réel avec causalité stricte
• Petits datasets (les Transformers nécessitent beaucoup de données)