Sequence-to-Sequence Models

Les modèles séquence-à-séquence (seq2seq) transforment une séquence en une autre dont la longueur peut différer, par exemple une phrase anglaise en sa traduction française, un long article en résumé ou un extrait audio en transcription. La plupart reposent sur une architecture encodeur-décodeur : l’encodeur lit l’entrée entière pour en produire des représentations internes, puis le décodeur génère la sortie un jeton à la fois, en fonction de ces représentations et des jetons déjà produits. L’approche a pris sa forme moderne en 2014, lorsque Sutskever, Vinyals et Le, chez Google, ont publié Sequence to Sequence Learning with Neural Networks et que Cho et al. ont décrit un encodeur-décodeur RNN pour la traduction automatique. Depuis 2017, la plupart des modèles seq2seq reposent sur des transformeurs.

Fonctionnement des modèles Seq2Seq#

Dans les modèles de 2014, un réseau à mémoire à long et court terme (LSTM) encodeur lisait la phrase source mot par mot et la compressait en un vecteur de longueur fixe ; un décodeur LSTM déroulait ensuite ce vecteur pour produire la traduction. Sutskever et al. ont utilisé des LSTM à quatre couches, constaté que l’inversion de l’ordre des mots de la source facilitait l’entraînement et obtenu un score BLEU de 34.8 sur l’ensemble de test anglais-français WMT'14. La compression de chaque phrase en un seul vecteur pénalisait les longues entrées ; Bahdanau, Cho et Bengio ont donc ajouté un mécanisme d’attention dans Neural Machine Translation by Jointly Learning to Align and Translate, permettant au décodeur de consulter chaque état de l’encodeur à chaque étape. Le transformeur a conservé cette structure encodeur-décodeur, remplacé la récurrence par l’auto-attention et relié les deux parties par l’attention croisée. À l’inférence, le décodeur s’exécute dans une boucle :

Comme la boucle s’arrête lorsque le décodeur émet un jeton de fin, la longueur de sortie est apprise pour chaque exemple. Le décodage conserve généralement plusieurs sorties candidates grâce à la recherche par faisceau, le choix standard pour la traduction et la reconnaissance vocale.

Entraînement avec forçage de l’enseignant#

Pendant l’entraînement, le décodeur n’a pas besoin de fonctionner en boucle. Avec le forçage de l’enseignant, il reçoit la séquence cible correcte décalée d’une position vers la droite et prédit tous les jetons suivants en un seul passage parallèle, à l’aide d’un masque causal pour que chaque position ne voie que les cibles précédentes. La perte est l’entropie croisée entre ces prédictions et les vrais jetons suivants. nn.Transformer de PyTorch implémente l’architecture encodeur-décodeur d’origine :

import torch
from torch import nn

torch.manual_seed(0)
src_vocab, tgt_vocab, d_model = 1000, 800, 64
embed_src, embed_tgt = nn.Embedding(src_vocab, d_model), nn.Embedding(tgt_vocab, d_model)
model = nn.Transformer(d_model, nhead=4, num_encoder_layers=2, num_decoder_layers=2, batch_first=True)
to_logits = nn.Linear(d_model, tgt_vocab)

source = torch.randint(0, src_vocab, (1, 9))  # a 9-token source sentence
target = torch.randint(0, tgt_vocab, (1, 7))  # start token + a 6-token translation

# Teacher forcing: the decoder reads the correct previous tokens and predicts every next token in parallel
decoder_input, labels = target[:, :-1], target[:, 1:]
causal_mask = nn.Transformer.generate_square_subsequent_mask(decoder_input.size(1))
logits = to_logits(model(embed_src(source), embed_tgt(decoder_input), tgt_mask=causal_mask))
loss = nn.functional.cross_entropy(logits.flatten(0, 1), labels.flatten())

print(f"Source tokens: {source.shape[1]} -> decoder logits: {tuple(logits.shape)}")
print(f"Training loss: {loss.item():.2f}")

Le code affiche Source tokens: 9 -> decoder logits: (1, 6, 800), soit une prédiction sur le vocabulaire cible de 800 jetons pour chacune des 6 positions cibles, calculée à partir d’une source de 9 jetons en un seul passage. La perte de 6.73 du modèle non entraîné est proche de ln(800) ≈ 6.68, la perte d’une prédiction uniforme. Comme l’entraînement fournit toujours les jetons précédents corrects alors que l’inférence fournit les propres prédictions du modèle, les erreurs peuvent s’accumuler à l’inférence ; cet effet s’appelle le biais d’exposition.

Seq2Seq et architectures connexes#

• Modèles uniquement encodeurs comme BERT : Ces modèles lisent l’entrée dans les deux sens et produisent une représentation par jeton, ce qui convient à la classification et à l’étiquetage.
• Grands modèles de langage (LLM) uniquement décodeurs : Des modèles comme GPT regroupent l’entrée et la sortie en une seule séquence et traitent les tâches seq2seq en poursuivant l’invite ; c’est ainsi que fonctionne aujourd’hui la plupart de la génération de texte.
• Réseaux de neurones récurrents (RNN) et GRU : Les couches récurrentes des encodeurs et décodeurs d’origine de 2014. Cho et al. ont présenté l’unité récurrente à portes dans le même article que leur encodeur-décodeur.

Applications#

Google a transféré Google Translate vers son système GNMT en 2016, un encodeur-décodeur LSTM à 8 couches avec attention ; la traduction reste la tâche seq2seq emblématique. Le T5 de Google a présenté chaque tâche de traitement automatique du langage naturel (NLP) comme une conversion de texte en texte, notamment le résumé de texte et les questions-réponses. Whisper d’OpenAI est un Transformer encodeur-décodeur pour la reconnaissance vocale, entraîné sur 680 000 heures d’audio. Les modèles de vision suivent la même approche pour la légende d’image et la reconnaissance optique de caractères (OCR). Florence-2 de Microsoft gère la légende, l’ancrage et la détection comme des sorties textuelles d’un seul modèle seq2seq ; sa version Large s’exécute sur Ultralytics Platform pour l’annotation automatique. Le Pix2Seq de Google transforme la détection d’objets en seq2seq en représentant chaque objet par cinq jetons discrets : quatre coordonnées quantifiées et une classe. RT-DETR, le détecteur en temps réel de Baidu disponible dans le paquet Ultralytics, conserve l’encodeur et le décodeur à attention croisée, mais fait affiner 300 requêtes d’objet en parallèle par son décodeur ; chaque boîte est ainsi produite en une seule passe.