Accueil › Glossaire › Sequence-to-Sequence

Sequence-to-Sequence (Seq2Seq) : transformer une séquence en une autre

Un modèle sequence-to-sequence (Seq2Seq) est une architecture de deep learning conçue pour transformer une séquence d’entrée de longueur variable en une séquence de sortie de longueur potentiellement différente. Construit sur le principe encoder-decoder, il a été la base de la traduction automatique neuronale, du résumé de texte et de la génération de légendes d’images avant d’être supplanté par les Transformers, qui sont eux-mêmes une évolution de cette architecture.

Le problème que résout Seq2Seq

Avant Seq2Seq, les réseaux de neurones récurrents (RNN) pouvaient traiter des séquences, mais avec une contrainte forte : l’entrée et la sortie devaient avoir la même longueur, ou la sortie était un vecteur unique (classification). Or, de nombreuses tâches du monde réel impliquent des séquences d’entrée et de sortie de longueurs différentes :

Traduction automatique : « How are you today? » (4 mots) → « Comment allez-vous aujourd’hui ? » (4 mots, mais ce n’est pas toujours le cas entre langues)

Résumé de texte : un article de 500 mots → un résumé de 50 mots

Transcription vocale : un signal audio de 3 secondes → une phrase de longueur variable

Génération de légendes d’images : une image → une description textuelle

Le modèle Seq2Seq résout ce problème en séparant explicitement la compréhension de l’entrée (encodage) de la génération de la sortie (décodage).

Architecture Seq2Seq : encoder-decoder avec RNN

L’encoder : comprimer l’entrée

L’encoder est un RNN (typiquement un LSTM ou GRU) qui lit la séquence d’entrée token par token. À chaque pas de temps, il met à jour son état caché en intégrant le nouveau token et l’état précédent. Après avoir traité le dernier token, l’état caché final (appelé « vecteur de contexte ») constitue un résumé compressé de toute la séquence d’entrée.

Entrée : "Le chat dort"

Pas 1 : h₁ = LSTM("Le", h₀)
Pas 2 : h₂ = LSTM("chat", h₁)
Pas 3 : h₃ = LSTM("dort", h₂)

→ Vecteur de contexte : h₃ (résume toute la phrase)

Un détail technique important du papier original de Sutskever et al. : la séquence d’entrée est inversée avant d’être encodée (« dort chat Le » au lieu de « Le chat dort »). Cette astuce simple améliore les performances car elle rapproche les premiers mots de l’entrée des premiers mots de la sortie, facilitant le flux de gradients.

Le decoder : générer la sortie

Le decoder est un second RNN (LSTM/GRU) qui génère la séquence de sortie un token à la fois, de manière autorégressive. Il reçoit le vecteur de contexte comme état caché initial, puis à chaque pas de temps :

1. Il prend en entrée le token précédemment généré (ou un token spécial <BOS> au premier pas).

2. Il met à jour son état caché.

3. Il produit une distribution de probabilités sur le vocabulaire.

4. Il sélectionne le token suivant (par échantillonnage, greedy decoding, ou beam search).

5. Il s’arrête quand un token de fin <EOS> est généré.

Vecteur de contexte : h₃ (issu de l'encoder)

Pas 1 : y₁ = LSTM(<BOS>, h₃)   → "The"
Pas 2 : y₂ = LSTM("The", h'₁)   → "cat"
Pas 3 : y₃ = LSTM("cat", h'₂)   → "sleeps"
Pas 4 : y₄ = LSTM("sleeps", h'₃) → <EOS>

→ Sortie : "The cat sleeps"

Teacher forcing : l’entraînement supervisé

Pendant l’entraînement, le decoder ne reçoit pas ses propres prédictions comme entrée du pas suivant. À la place, il reçoit le token correct issu de la séquence cible (la « vérité terrain »). Cette technique, appelée teacher forcing, accélère considérablement la convergence et stabilise l’entraînement.

Le revers : à l’inférence, le decoder n’a plus accès à la vérité terrain et doit se baser sur ses propres prédictions. Si une erreur survient tôt dans la séquence, elle se propage et s’amplifie (problème d’exposure bias). Des techniques comme le scheduled sampling (mélange aléatoire de teacher forcing et d’auto-prédiction pendant l’entraînement) atténuent ce problème.

Le problème du goulot d’étranglement

La faiblesse fondamentale du Seq2Seq original est le vecteur de contexte de taille fixe. Toute l’information de l’entrée, quelle que soit sa longueur, doit être compressée dans un seul vecteur. Pour une phrase de 5 mots, c’est raisonnable. Pour un paragraphe de 200 mots, l’information des premiers tokens est inévitablement diluée, voire perdue.

C’est ce problème qui a motivé l’invention du mécanisme d’attention.

L’attention : la révolution de Bahdanau (2014)

Le mécanisme d’attention (Bahdanau et al., 2014) résout le goulot d’étranglement en permettant au decoder d’accéder à tous les états cachés de l’encoder, pas seulement au dernier. À chaque pas de décodage, le mécanisme calcule un score de pertinence entre l’état actuel du decoder et chaque état caché de l’encoder, puis produit un vecteur de contexte pondéré spécifique à ce pas.

Concrètement, pour générer le mot « cat » dans la traduction, le decoder peut « regarder » (attend to) le mot « chat » dans l’entrée française, plutôt que de s’appuyer sur un résumé global de toute la phrase.

Attention à chaque pas de décodage :

Pour générer y₂ ("cat") :
  score("Le") = 0.05     score("chat") = 0.85
  score("dort") = 0.10

  → contexte₂ = 0.05·h₁ + 0.85·h₂ + 0.10·h₃
  → Le decoder se concentre sur "chat"

L’ajout de l’attention a transformé les performances de la traduction automatique et a ouvert la voie au Transformer, qui généralise l’attention comme seul mécanisme de traitement séquentiel.

Du Seq2Seq RNN au Transformer encoder-decoder

Le Transformer (Vaswani et al., 2017) conserve l’architecture encoder-decoder du Seq2Seq mais remplace les RNN par des couches de self-attention et de feed-forward. Les améliorations sont fondamentales :

Parallélisation : plus de traitement séquentiel. Tous les tokens de l’entrée sont traités simultanément, exploitant pleinement les GPU.

Self-attention dans l’encoder : chaque token de l’entrée « voit » tous les autres, capturant des dépendances à longue portée dès la première couche.

Cross-attention dans le decoder : le decoder attend aux sorties de l’encoder via un mécanisme d’attention croisée, remplaçant l’attention de Bahdanau par une version multi-têtes plus expressive.

Positions encodées explicitement : des embeddings positionnels remplacent la notion implicite d’ordre séquentiel des RNN.

Modèles Seq2Seq actuels

Les modèles encoder-decoder Transformer restent très utilisés pour les tâches Seq2Seq, en complément des modèles decoder-only (GPT) qui dominent la génération de texte :

Applications concrètes du Seq2Seq

Traduction automatique : l’application historique. Google Translate a basculé d’un système statistique à un Seq2Seq avec attention (GNMT) fin 2016, avec une amélioration massive de la qualité. Aujourd’hui, la traduction utilise des Transformers encoder-decoder (NLLB, mBART).

Résumé de texte : l’encoder traite le document complet, le decoder génère un résumé condensé. BART et Pegasus excellent dans ce domaine.

Reconnaissance vocale : Whisper (OpenAI) utilise un encoder Transformer pour traiter le spectrogramme audio, puis un decoder pour générer la transcription texte. C’est un Seq2Seq pur, fonctionnel dans plus de 90 langues.

Génération de légendes d’images : un CNN ou un Vision Transformer encode l’image en un vecteur, puis un decoder génère la description textuelle.

Chatbots et dialogue : les premiers chatbots neuronaux étaient des Seq2Seq (contexte → réponse). Les LLM decoder-only ont depuis pris le relais pour cette tâche.

Génération de code : convertir une description en langage naturel en code source est fondamentalement une tâche Seq2Seq.

Stratégies de décodage

Le decoder produit à chaque pas une distribution de probabilités sur le vocabulaire. La manière de sélectionner le token suivant a un impact majeur sur la qualité de la sortie :

Greedy decoding : sélectionne le token le plus probable à chaque pas. Rapide mais sous-optimal : il peut manquer des séquences globalement meilleures en faisant des choix localement gourmands.

Beam search : maintient les k meilleures hypothèses en parallèle (k = taille du beam, typiquement 4 à 10). À chaque pas, chaque hypothèse est étendue avec tous les tokens possibles, et seules les k meilleures combinaisons sont conservées. C’est le standard en traduction automatique car il produit des séquences plus cohérentes que le greedy.

Échantillonnage (sampling) : tire aléatoirement un token selon la distribution de probabilités. Avec température, top-k, ou top-p (nucleus sampling), on contrôle le compromis entre diversité et cohérence. Préféré pour les tâches créatives.

Limites historiques et solutions

Goulot d’étranglement du vecteur de contexte : résolu par l’attention (Bahdanau, 2014), puis par le Transformer qui généralise l’attention à toute l’architecture.

Exposure bias : le décalage entre teacher forcing (entraînement) et auto-prédiction (inférence) dégrade les performances sur les longues séquences. Solutions : scheduled sampling, reinforcement learning pour l’entraînement (MIXER, Self-critical Sequence Training), et les architectures decoder-only qui entraînent et inférent de la même manière.

Traitement séquentiel : les RNN ne peuvent pas être parallélisés, rendant l’entraînement lent sur les longues séquences. Le Transformer résout ce problème par le traitement parallèle de tous les tokens via l’attention.

Erreurs en cascade : une prédiction erronée du decoder se propage aux pas suivants. Le beam search atténue ce risque en explorant plusieurs hypothèses simultanément.

Évaluer un modèle Seq2Seq

L’évaluation des modèles Seq2Seq repose sur des métriques comparant la séquence générée à une ou plusieurs séquences de référence :

BLEU : mesure la correspondance de n-grammes entre la sortie et la référence. Score standard en traduction automatique (0 = mauvais, 100 = parfait). Limites : ne capture pas la sémantique, pénalise les reformulations correctes.

ROUGE : mesure le rappel des n-grammes de la référence dans la sortie. Standard pour le résumé de texte.

METEOR : tient compte des synonymes et de la morphologie, plus corrélé au jugement humain que BLEU.

BERTScore : utilise des embeddings de BERT pour mesurer la similarité sémantique, au-delà de la correspondance lexicale exacte.

Implémentation simplifiée en PyTorch

import torch
import torch.nn as nn

class Encoder(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, n_layers):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.rnn = nn.LSTM(embed_dim, hidden_dim, n_layers,
                           batch_first=True, bidirectional=True)
        # Projection pour compatibilité avec le decoder unidirectionnel
        self.fc = nn.Linear(hidden_dim * 2, hidden_dim)

    def forward(self, src):
        embedded = self.embedding(src)
        outputs, (hidden, cell) = self.rnn(embedded)
        # Combiner les directions forward/backward
        hidden = self.fc(torch.cat([hidden[-2], hidden[-1]], dim=1))
        return outputs, hidden.unsqueeze(0), cell[-1].unsqueeze(0)

class Decoder(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, n_layers):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.rnn = nn.LSTM(embed_dim, hidden_dim, n_layers,
                           batch_first=True)
        self.fc_out = nn.Linear(hidden_dim, vocab_size)

    def forward(self, input_token, hidden, cell):
        embedded = self.embedding(input_token.unsqueeze(1))
        output, (hidden, cell) = self.rnn(embedded, (hidden, cell))
        prediction = self.fc_out(output.squeeze(1))
        return prediction, hidden, cell

Ce code illustre le principe fondamental. En production, on ajouterait le mécanisme d’attention, du dropout, du beam search pour le décodage, et des techniques comme le label smoothing pour la régularisation.

Avec la bibliothèque Hugging Face Transformers, un modèle Seq2Seq Transformer s’utilise en quelques lignes :

from transformers import T5ForConditionalGeneration, T5Tokenizer

model = T5ForConditionalGeneration.from_pretrained("t5-base")
tokenizer = T5Tokenizer.from_pretrained("t5-base")

# T5 traite toutes les tâches comme du texte-à-texte
input_text = "translate English to French: The cat sleeps on the mat."
inputs = tokenizer(input_text, return_tensors="pt")

outputs = model.generate(**inputs, max_length=50, num_beams=4)
result = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(result)  # "Le chat dort sur le tapis."

L’approche « text-to-text » de T5 unifie toutes les tâches NLP dans un cadre Seq2Seq unique : traduction, résumé, classification, Q&A. Il suffit de préfixer l’entrée avec une instruction (« translate English to French: », « summarize: ») pour indiquer la tâche. Cette unification a démontré que l’architecture encoder-decoder est remarquablement polyvalente.