Deep Learningavancé

RNN, LSTM & GRU — Modélisation de Séquences

“Apprendre aux réseaux à se souvenir — de l'oubli catastrophique à la mémoire sélective à portes”

RNN pour séquences : BPTT, gradient explosif/vanissant, LSTM (portes, état cellulaire), GRU (portes simplifiées), Bi-LSTM.

70 min

8 diagrammes

7 Concepts Couverts

Prérequis

→Neural Networks

→Deep Learning Optimization

Concepts Couverts

BPTTVanishing GradientLSTM GatesCell StateGRUBi-LSTMSequence-to-Sequence

Précédent: Architectures CNN : Classic → ResNet → ViT Suivant: Détection d'Objets : YOLO & Faster-RCNN

∑Formules Clés

État Caché RNN

Combine la mémoire précédente avec l'entrée actuelle — souffre de l'oubli catastrophique sur de longues séquences

État de Cellule LSTM

État de cellule mis à jour par la porte d'oubli et la porte d'entrée — la 'autoroute à gradient'

Sortie LSTM

La porte de sortie contrôle ce qui est exposé depuis l'état de cellule — sélection sélective de mémoire

Mise à Jour GRU

Une seule porte de mise à jour interpole l'ancien et le nouvel état caché — plus simple que LSTM, souvent aussi bon

▶Simulation Interactive

Loading visualization…

⬡Architecture du Modèle

Loading visualization…

🎯

Pourquoi les Séquences Sont Difficiles

motivation

Le langage, les séries temporelles, l'audio, l'ADN — tous ont des dépendances temporelles. 'Il a dit qu'il viendrait' — 'il' et 'viendrait' sont séparés de 5 mots mais étroitement liés. Un réseau de propagation vers l'avant traite chaque pas de temps indépendamment. Les RNN partagent les paramètres à travers le temps et maintiennent un état caché qui résume les entrées passées — permettant un contexte illimité. Le défi : rendre cette mémoire sélective et à longue portée.

💡

Le Gradient Évanescent dans le Temps

intuition

Dans BPTT (Backpropagation Through Time), les gradients sont multipliés par la matrice de poids W à chaque pas de temps. Si la plus grande valeur propre de W est < 1, les gradients s'évanouissent exponentiellement. Pour une séquence de 100 pas de temps, un gradient du pas 1 est multiplié par W¹⁰⁰. Les LSTM résolvent cela avec l'état cellulaire — une 'autoroute' qui transporte l'information avec uniquement des mises à jour additives (non multiplicatives).

Les gradients LSTM circulent à travers c_t = f_t ⊙ c_{t-1} + i_t ⊙ c̃_t. La porte d'oubli f_t empêche les gradients de c de s'évanouir — ce sont des additions conditionnées, pas des multiplications matricielles.

∑

Équations des Portes LSTM

math

Quatre calculs de portes déterminent ce qu'il faut oublier, apprendre et produire à chaque étape. Toutes les portes utilisent sigmoid (sortie 0-1 = 'combien laisser passer'). L'état cellulaire candidat utilise tanh (sortie -1 à 1 = contenu réel).

</>

LSTM pour la Prévision de Séries Temporelles

code

python40 lines

import torch
import torch.nn as nn
from torch.utils.data import TensorDataset, DataLoader

# ── Données séquentielles d'exemple ────────────────────────────────────
# Forme : (n_échantillons, longueur_seq, caractéristiques)
X_seq = torch.randn(500, 20, 10)
y_seq = torch.randn(500)
chargeur_donnees = DataLoader(TensorDataset(X_seq, y_seq),
                               batch_size=32, shuffle=True)

class PrevisionLSTM(nn.Module):
    def __init__(self, dim_entree, dim_cachee, nb_couches, dim_sortie, dropout=0.2):
        super().__init__()
        self.lstm = nn.LSTM(
            dim_entree, dim_cachee, nb_couches,
            batch_first=True, dropout=dropout,
            bidirectional=False
        )
        self.fc = nn.Linear(dim_cachee, dim_sortie)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, h0=None, c0=None):
        # x : (lot, longueur_seq, caracteristiques)
        sortie, (hn, cn) = self.lstm(x, (h0, c0) if h0 is not None else None)
        # Utiliser la sortie du dernier pas de temps
        return self.fc(self.dropout(sortie[:, -1, :]))

# Entraînement avec teacher forcing + scheduled sampling
modele = PrevisionLSTM(dim_entree=10, dim_cachee=128, nb_couches=2, dim_sortie=1)
optimiseur = torch.optim.Adam(modele.parameters(), lr=1e-3)

# L'écrêtage des gradients est ESSENTIEL pour l'entraînement RNN
for x, y in chargeur_donnees:
    pred = modele(x)
    perte = nn.MSELoss()(pred.squeeze(), y)
    optimiseur.zero_grad()
    perte.backward()
    nn.utils.clip_grad_norm_(modele.parameters(), max_norm=1.0)
    optimiseur.step()

?Vérification des Connaissances

La progression est sauvegardée dans votre navigateur — aucun compte requis.

Architectures CNN : Classic → ResNet → ViT

Détection d'Objets : YOLO & Faster-RCNN

Besoin d'un Data Scientist ou Ingénieur IA ?

Je construis des modèles ML sur mesure, des chatbots RAG, des pipelines de données et des APIs en production — de l'analyse au déploiement.

Me contacter Voir les services