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 : portes Oubli (f), Entrée (i), Candidat cellulaire (c̃), Sortie (o)

</>

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

class="tok-comment"># ── Données séquentielles dclass="tok-str">'exemple ────────────────────────────────────
class="tok-comment"># Forme : (n_échantillons, longueur_seq, caractéristiques)
X_seq = torch.randn(class="tok-num">500, class="tok-num">20, class="tok-num">10)
y_seq = torch.randn(class="tok-num">500)
chargeur_donnees = DataLoader(TensorDataset(X_seq, y_seq),
                               batch_size=class="tok-num">32, shuffle=True)

class PrevisionLSTM(nn.Module):
    def __init__(self, dim_entree, dim_cachee, nb_couches, dim_sortie, dropout=class="tok-num">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):
        class="tok-comment"># x : (lot, longueur_seq, caracteristiques)
        sortie, (hn, cn) = self.lstm(x, (h0, c0) if h0 is not None else None)
        class="tok-comment"># Utiliser la sortie du dernier pas de temps
        return self.fc(self.dropout(sortie[:, -class="tok-num">1, :]))

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

class="tok-comment"># 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=class="tok-num">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 ingénieur IA ou data scientist ?

Je conçois des modèles ML sur mesure, des agents IA, de la vision par ordinateur et de l'automatisation — de l'idée à la production.

Me contacter Voir les services