Transformer-XL

Transformer-XL est un Transformer modèle de langage qui conserve le contexte entre des segments de texte de longueur fixe : il met en cache les états cachés du segment précédent et permet au segment suivant de leur prêter attention. Zihang Dai, Zhilin Yang et leurs collègues de l’université Carnegie Mellon et de Google Brain l’ont présenté dans Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context, lors de la conférence ACL 2019. Un Transformer standard entraîné sur des segments fixes, chacun constituant une fenêtre de contexte distincte, ne peut rien voir avant le début du segment courant ; les auteurs ont appelé ce problème la fragmentation du contexte. Transformer-XL a appris des dépendances 80 % plus longues que celles des réseaux de neurones récurrents (RNNs) et 450 % plus longues que celles des Transformers standard.

Récurrence au niveau des segments#

Lorsqu’il traite un segment, chaque couche du modèle concatène les états cachés mis en cache du segment précédent avec ceux du segment courant. Les requêtes proviennent uniquement du segment courant, tandis que les clés et les valeurs couvrent les deux segments ; les gradients s’arrêtent donc au niveau du cache, ce qui maintient constant le coût d’entraînement par segment. Une seule couche d’attention dans PyTorch illustre ce principe :

import torch
from torch import nn

torch.manual_seed(0)
seg_len, dim = 4, 16
attn = nn.MultiheadAttention(dim, num_heads=2, batch_first=True)
hidden = torch.randn(1, 3 * seg_len, dim)  # hidden states for three consecutive segments

memory = torch.empty(1, 0, dim)  # nothing is cached before the first segment
for i, segment in enumerate(hidden.split(seg_len, dim=1), start=1):
    # Queries come from the current segment; keys and values also cover the cached one
    context = torch.cat([memory, segment], dim=1)
    out, weights = attn(segment, context, context)
    print(f"Segment {i}: {weights.shape[1]} queries attend over {weights.shape[2]} positions")
    # Cache this segment for the next one; detach() stops gradients as in Transformer-XL
    memory = segment.detach()

Les 4 requêtes du premier segment ne voient que ses 4 jetons, et les requêtes de chaque segment suivant en voient 8 : ses propres 4 jetons et les 4 jetons mis en cache. Comme la couche n d’un segment lit les états mis en cache de la couche n − 1 du segment précédent, la portée s’étend d’un segment supplémentaire à chaque couche, soit environ N × L jetons pour une longueur de segment N et L couches :

Le cache accélère également l’évaluation. Lorsqu’un Transformer standard prédit des jetons l’un après l’autre, il doit recalculer toute une fenêtre pour chaque nouveau jeton. Transformer-XL réutilise au contraire les états mis en cache, ce qui lui a permis d’être jusqu’à 1 800 fois plus rapide pendant l’évaluation. Le suivi Ultralytics YOLO26 rencontre le même problème de fragmentation lorsqu’un script transmet une vidéo à model.track() une image à la fois : persist=True conserve l’état du suiveur entre les appels, de sorte que chaque objet garde le même identifiant d’une image à l’autre.

Encodage positionnel relatif#

La réutilisation des états mis en cache rompt les positions absolues : le premier jeton du segment en cache et le premier jeton du segment courant porteraient le même plongement positionnel. Transformer-XL calcule plutôt chaque score d’attention à partir du contenu de la requête et de la clé, ainsi que d’un encodage sinusoïdal de la distance qui les sépare, avec deux vecteurs de biais appris et partagés entre les positions, l’un pour le contenu et l’autre pour la position. Comme les scores dépendent uniquement des distances, le modèle peut, lors de l’évaluation, porter son attention sur un cache plus long que celui qu’il a vu pendant l’entraînement. Les plongements positionnels rotatifs (RoPE), utilisés dans la plupart des grands modèles de langage (LLMs) actuels, rendent également les scores d’attention dépendants de la position relative.

Résultats et influence#

Transformer-XL a établi de nouveaux résultats de pointe sur cinq bancs d’essai : 0,99 bit par caractère sur enwik8, 1,08 sur text8 et une perplexité de 18,3 sur WikiText-103, de 21,8 sur One Billion Word et de 54,5 sur Penn Treebank, sans ajustement fin. Entraîné uniquement sur WikiText-103, il a généré des articles inédits assez cohérents de plusieurs milliers de jetons. XLNet, créé par plusieurs des mêmes auteurs, a fondé son préentraînement à la compréhension du langage naturel sur l’architecture Transformer-XL. Le Compressive Transformer de DeepMind a prolongé le cache en compressant les anciennes mémoires au lieu de les supprimer.

Transformer-XL et les modèles apparentés#

• Mémoire à long court terme (LSTM) : met à jour un état caché jeton après jeton ; les informations anciennes doivent donc passer par toutes les étapes intermédiaires.
• Longformer : lit simultanément un document entier de 4 096 jetons au moyen d’une attention par fenêtres et d’une attention globale, sans récurrence.
• Cache KV : stocke les clés et les valeurs des jetons précédents pendant la génération afin de ne pas les recalculer. La mémoire de Transformer-XL est également utilisée pendant l’entraînement, les gradients s’arrêtant à la limite du segment.
• Modèles d’espace d’états (SSMs) : compressent l’historique entier dans un état de taille fixe.