Accueil › Glossaire › Récurrence

Récurrence : la mémoire des réseaux de neurones séquentiels

En deep learning, la récurrence est un mécanisme par lequel la sortie d’un réseau de neurones à un instant t est réinjectée comme entrée à l’instant t+1, créant une boucle de rétroaction qui donne au réseau une forme de « mémoire » des entrées passées. C’est le principe fondateur des réseaux de neurones récurrents (RNN), qui ont dominé le traitement des séquences (texte, audio, séries temporelles) avant l’ère des Transformers.

Le principe de la récurrence

Un réseau feed-forward classique traite chaque entrée indépendamment : l’image n°1 n’a aucune influence sur le traitement de l’image n°2. C’est parfait pour la classification d’images, mais inadapté aux données séquentielles où l’ordre compte.

Quand vous lisez la phrase « Le chat est assis sur le … », votre cerveau utilise les mots précédents pour prédire le mot suivant (« tapis »). La récurrence donne cette capacité aux réseaux de neurones : à chaque pas de temps, le réseau reçoit deux entrées : le token actuel et l’état caché (hidden state) du pas précédent, qui résume tout ce que le réseau a « vu » jusqu’ici.

Mathématiquement, un RNN simple s’exprime ainsi :

h_t = tanh(W_hh · h_{t-1} + W_xh · x_t + b_h)
y_t = W_hy · h_t + b_y

Où :
- h_t     = état caché au temps t (la « mémoire »)
- h_{t-1} = état caché au temps précédent
- x_t     = entrée au temps t
- y_t     = sortie au temps t
- W_hh    = poids de la connexion récurrente (état → état)
- W_xh    = poids de l'entrée
- W_hy    = poids de la sortie

Le point clé : les poids W_hh, W_xh et W_hy sont partagés à travers tous les pas de temps. Le réseau applique la même transformation à chaque étape, ce qui lui permet de traiter des séquences de longueur variable avec un nombre fixe de paramètres.

Déroulement dans le temps (unrolling)

Pour visualiser et entraîner un RNN, on le « déroule » dans le temps : chaque pas de temps est représenté comme une couche séparée, avec des connexions entre les états cachés successifs. Un RNN traitant une séquence de 5 tokens ressemble alors à un réseau feed-forward à 5 couches, où chaque couche partage les mêmes poids.

C’est ce déroulement qui permet l’entraînement par rétropropagation dans le temps (Backpropagation Through Time, BPTT) : les gradients sont calculés à chaque pas de temps, puis propagés en arrière à travers tous les pas précédents pour mettre à jour les poids partagés.

Le problème du gradient évanescent

Voici le talon d’Achille de la récurrence simple. Quand les gradients sont rétropropagés à travers de nombreux pas de temps, ils sont multipliés à chaque étape par la matrice de poids W_hh. Si les valeurs propres de cette matrice sont inférieures à 1, les gradients décroissent exponentiellement (vanishing gradient). Si elles sont supérieures à 1, ils explosent (exploding gradient).

En pratique, cela signifie qu’un RNN simple ne peut apprendre que des dépendances à court terme. Pour la phrase « Le chat qui avait été recueilli par la voisine du troisième étage était assis sur le … », le RNN a « oublié » que le sujet est « le chat » au moment de prédire la fin.

LSTM et GRU : la récurrence avec des portes

LSTM (Long Short-Term Memory)

Inventé par Hochreiter et Schmidhuber en 1997, le LSTM résout le problème du gradient évanescent en introduisant un « cell state » (état de cellule) protégé par trois portes :

Porte d’oubli (forget gate) : décide quelles informations de l’état précédent doivent être oubliées. Valeur entre 0 (oublier complètement) et 1 (conserver intégralement).

Porte d’entrée (input gate) : contrôle quelles nouvelles informations sont ajoutées à l’état de cellule.

Porte de sortie (output gate) : détermine quelle partie de l’état de cellule est exposée comme état caché pour le pas de temps suivant.

Le cell state fonctionne comme un « tapis roulant » d’information qui traverse le réseau avec des modifications minimales, permettant aux gradients de circuler sur des centaines de pas de temps sans s’évanouir. C’est cette innovation qui a fait du LSTM l’architecture RNN standard pendant près de 20 ans.

GRU (Gated Recurrent Unit)

Le GRU (Cho et al., 2014) est une version simplifiée du LSTM qui fusionne le cell state et le hidden state en un seul vecteur, et réduit les trois portes à deux (porte de réinitialisation et porte de mise à jour). Le GRU est plus rapide à entraîner que le LSTM grâce à son architecture plus légère, tout en offrant des performances comparables sur la plupart des tâches.

Configurations des réseaux récurrents

La configuration bidirectionnelle (BiRNN, BiLSTM) traite la séquence dans les deux sens simultanément, capturant le contexte passé et futur pour chaque position. C’est cette approche qui a inspiré BERT, même si BERT utilise l’attention plutôt que la récurrence.

Pourquoi les Transformers ont remplacé la récurrence

En 2017, le papier « Attention Is All You Need » (Vaswani et al.) démontre qu’un réseau basé uniquement sur le mécanisme d’self-attention, sans aucune récurrence, surpasse les meilleurs modèles récurrents en traduction automatique. Trois avantages décisifs expliquent cette transition :

Parallélisation : la récurrence est intrinsèquement séquentielle (chaque pas dépend du précédent). L’attention traite tous les tokens en parallèle, exploitant pleinement les GPU. Résultat : un entraînement bien plus rapide.

Dépendances longue portée : l’attention accède directement à n’importe quel token de la séquence en une seule opération, sans passer par une chaîne d’états cachés. Les relations entre le premier et le dernier mot sont aussi faciles à capturer que celles entre deux mots adjacents.

Scalabilité : les Transformers scalent mieux avec la taille du modèle et des données. C’est ce qui a permis l’émergence des LLM à des échelles de milliards de paramètres.

Cependant, les Transformers ont leur propre faiblesse : la complexité quadratique de l’attention par rapport à la longueur de la séquence. C’est ce qui a motivé le retour de la récurrence sous une forme modernisée.

Le retour de la récurrence : State Space Models et Mamba

Depuis 2023, une nouvelle famille d’architectures remet la récurrence au centre du jeu : les State Space Models (SSM), dont Mamba est le représentant le plus influent.

Mamba : la récurrence sélective

Mamba (Gu et Dao, 2023) combine le meilleur des deux mondes. Comme un RNN, il maintient un état caché compact qu’il met à jour à chaque token, ce qui donne une complexité linéaire en longueur de séquence. Mais contrairement aux RNN classiques, ses paramètres de récurrence sont fonction de l’entrée (récurrence « sélective ») : le modèle décide dynamiquement quelles informations conserver et lesquelles oublier, similairement aux portes d’un LSTM mais de manière plus efficace.

L’innovation technique clé : Mamba peut être entraîné en mode parallèle (comme un Transformer) grâce à un algorithme de scan parallèle, puis basculer en mode récurrent pour l’inférence, où il traite un token à la fois avec un coût constant en mémoire (pas de cache KV croissant comme les Transformers).

Mamba en production

Les SSM ne sont plus une curiosité de recherche. Des modèles de production les utilisent déjà :

Jamba (AI21) : architecture hybride Mamba + attention, fenêtre de contexte de 256K tokens sur un seul GPU.

Granite 4.0 (IBM) : modèle d’entreprise construit sur une architecture SSM.

Codestral Mamba (Mistral) : modèle de génération de code SSM pur (sans attention), qui surpasse CodeLlama 34B.

Mamba-3 (2025) : dernière version avec récurrence plus expressive, états complexes, et suppression de la convolution causale séparée. Performances comparables aux Transformers sur de nombreux benchmarks.

Récurrence vs Attention : tableau récapitulatif

Où la récurrence est-elle encore utilisée ?

Malgré la domination des Transformers, la récurrence classique (LSTM/GRU) reste pertinente dans plusieurs contextes :

Séries temporelles : pour la prédiction financière, la détection d’anomalies dans les capteurs IoT, ou les prévisions météorologiques, les LSTM restent compétitifs et plus légers que les Transformers.

Embarqué et edge : les modèles récurrents nécessitent peu de mémoire (un seul état caché à stocker), ce qui les rend adaptés aux microcontrôleurs et aux systèmes avec des contraintes mémoire sévères.

Traitement audio en temps réel : la récurrence est naturelle pour les flux continus (reconnaissance vocale en streaming, synthèse audio), où les données arrivent token par token.

NLP léger : pour des tâches simples comme la classification de texte ou l’analyse de sentiment sur des textes courts, un BiLSTM avec attention reste un excellent rapport performance/coût.

Implémentation : RNN simple vs LSTM en PyTorch

Voici la différence concrète entre un RNN simple et un LSTM :

import torch
import torch.nn as nn

# RNN simple (vanilla)
rnn = nn.RNN(
    input_size=256,    # dimension de l'embedding
    hidden_size=512,   # dimension de l'état caché
    num_layers=2,      # empilement de 2 couches RNN
    batch_first=True,
    dropout=0.3
)

# LSTM
lstm = nn.LSTM(
    input_size=256,
    hidden_size=512,
    num_layers=2,
    batch_first=True,
    dropout=0.3,
    bidirectional=True  # BiLSTM
)

# Entrée : batch de 32 séquences de 100 tokens, embedding dim 256
x = torch.randn(32, 100, 256)

# RNN simple : h_0 = état caché initial (zeros par défaut)
out_rnn, h_n = rnn(x)
# out_rnn shape: (32, 100, 512) - sortie à chaque pas
# h_n shape: (2, 32, 512) - dernier état caché par couche

# LSTM : retourne aussi le cell state
out_lstm, (h_n, c_n) = lstm(x)
# out_lstm shape: (32, 100, 1024) - 1024 car bidirectionnel (2×512)
# h_n shape: (4, 32, 512) - 4 = 2 couches × 2 directions

En pratique, pour une classification de texte avec un LSTM, on récupère le dernier état caché (h_n) et on le passe à une couche linéaire pour la prédiction. Pour des tâches sequence-to-sequence, on utilise l’intégralité des sorties out_lstm.

Conseils pratiques

Gradient clipping : pour éviter l’explosion des gradients, appliquez systématiquement un clipping (typiquement torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)). C’est quasi obligatoire avec les RNN.

Initialisation : initialisez les poids récurrents avec une matrice orthogonale pour stabiliser l’entraînement. PyTorch le fait par défaut pour les RNN et LSTM.

Bidirectionnel quand possible : si vous avez accès à toute la séquence à l’avance (classification, étiquetage), utilisez un BiLSTM. La prise en compte du contexte futur améliore significativement les performances.

Pack/pad les séquences : les séquences de longueurs variables doivent être paddées (complétées avec des zéros) pour former des batchs. Utilisez pack_padded_sequence et pad_packed_sequence de PyTorch pour éviter que le réseau ne traite les tokens de padding.