Transformer : définition, mécanisme d'attention et architecture

Le Transformer est une architecture de réseau de neurones conçue pour traiter des séquences : phrases, lignes de code, signaux audio ou suites de patchs d'image. Son idée centrale tient en une phrase : pour comprendre un élément, il faut regarder tous les autres et décider lesquels comptent. Ce mécanisme, l'attention, remplace la lecture mot à mot des architectures précédentes par une vue d'ensemble de la séquence, calculée en parallèle.

L'architecture a été présentée en 2017 dans l'article « Attention Is All You Need », signé par Ashish Vaswani et sept coauteurs, chercheurs de Google pour la plupart. Elle visait la traduction automatique et se composait d'un encodeur, qui lit la phrase source, et d'un décodeur, qui génère la traduction. Ses résultats, et surtout sa capacité à s'entraîner beaucoup plus vite que les réseaux récurrents sur GPU, l'ont rapidement imposée. Dès 2018, Google publie BERT et OpenAI publie GPT, deux modèles qui n'en conservent chacun qu'une moitié.

Le Transformer est l'architecture des LLM et, plus largement, de la plupart des modèles de fondation. Il intervient après la tokenisation : le modèle ne voit jamais du texte brut, mais une suite d'identifiants de tokens qu'il transforme en vecteurs.

À retenir : le Transformer est un plan de construction, pas un modèle. GPT, BERT, Llama ou Whisper sont des modèles différents, entraînés sur des données différentes, mais bâtis sur cette même architecture.

Prenons la phrase « Le chat n'a pas mangé sa pâtée car il était malade ». Pour représenter correctement « il », le modèle doit le relier à « chat » et non à « pâtée ». La self-attention permet ce lien direct, quelle que soit la distance entre les mots.

Pour chaque token, le modèle calcule trois vecteurs par projection linéaire de son embedding :

• une requête (query, Q) : ce que le token cherche ;
• une clé (key, K) : ce que le token offre aux autres ;
• une valeur (value, V) : l'information qu'il transmet s'il est sélectionné.

Le score entre deux tokens est le produit scalaire de la requête de l'un et de la clé de l'autre. Ces scores sont normalisés par une fonction softmax, puis servent à calculer une moyenne pondérée des valeurs :

Attention(Q, K, V) = softmax( Q · Kᵀ / √d_k ) · V

La division par la racine de la dimension des clés (d_k) évite que les scores deviennent trop grands et saturent la softmax. Le résultat est une nouvelle représentation de chaque token, enrichie du contexte qui lui est utile.

L'attention multi-têtes répète ce calcul plusieurs fois en parallèle, avec des projections différentes : l'article original utilise 8 têtes dans son modèle de base. Une tête peut suivre les accords grammaticaux, une autre les coréférences, une autre la proximité thématique. Leurs sorties sont concaténées puis projetées.

Dans un décodeur, un masque causal interdit à chaque token de regarder les tokens qui le suivent. C'est ce qui permet d'entraîner le modèle à prédire le token suivant sur toutes les positions d'un texte en une seule passe, puis de générer token par token à l'inférence.

L'architecture originale associait un encodeur et un décodeur. Les modèles qui ont suivi ont souvent gardé une seule des deux parties, selon la tâche visée.

Les LLM actuels sont dans leur immense majorité des décodeurs seuls : cette famille passe le mieux à l'échelle et une seule tâche, prédire la suite, suffit à couvrir la traduction, le résumé ou la classification par simple consigne. Les encodeurs restent très utilisés pour produire des embeddings, par exemple dans un RAG.

La bibliothèque transformers de Hugging Face charge un modèle pré-entraîné en une ligne et donne accès à ses représentations internes. Ce script montre deux propriétés clés de l'architecture : les représentations contextuelles et les matrices d'attention.

import torch
from transformers import AutoModel, AutoTokenizer

name = "google-bert/bert-base-uncased"  # encodeur : 12 couches, 12 têtes, vecteurs de 768
tokenizer = AutoTokenizer.from_pretrained(name)
model = AutoModel.from_pretrained(name, attn_implementation="eager")
model.eval()

def encode(sentence: str, word: str):
    inputs = tokenizer(sentence, return_tensors="pt")
    with torch.no_grad():
        outputs = model(**inputs, output_attentions=True)
    tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
    vector = outputs.last_hidden_state[0, tokens.index(word)]
    return vector, outputs

money, outputs = encode("I deposited cash at the bank.", "bank")
loan, _ = encode("The bank approved my loan.", "bank")
river, _ = encode("We had a picnic on the river bank.", "bank")

print(outputs.last_hidden_state.shape)  # (1, nombre de tokens, 768)
print(len(outputs.attentions))          # 12 matrices d'attention, une par couche
print(outputs.attentions[0].shape)      # (1, 12 têtes, nombre de tokens, nombre de tokens)

cos = torch.nn.functional.cosine_similarity
print("banque / banque :", cos(money, loan, dim=0).item())
print("banque / berge  :", cos(money, river, dim=0).item())

Le même mot « bank » reçoit un vecteur différent selon la phrase : les deux occurrences au sens financier sont en général nettement plus proches entre elles que de l'occurrence au sens de berge. C'est l'attention qui injecte ce contexte. Pour un décodeur, la logique est la même ; seule la tête de sortie change :

from transformers import pipeline

generator = pipeline("text-generation", model="openai-community/gpt2")
result = generator("The Transformer architecture", max_new_tokens=25)
print(result[0]["generated_text"])

Avant 2017, le traitement du langage reposait sur les réseaux récurrents (RNN) et leurs variantes LSTM et GRU. Ils lisent la séquence un élément après l'autre et résument tout ce qui précède dans un état caché. Ce fonctionnement a deux défauts majeurs : il empêche de paralléliser le calcul sur la longueur de la séquence, et l'information des premiers mots s'estompe au fil de la lecture.

Le seul point où le RNN garde l'avantage, le coût linéaire, explique les nombreuses optimisations apportées depuis au Transformer : noyaux d'attention optimisés comme FlashAttention, attention à fenêtre glissante, partage des clés et valeurs entre têtes, ou mélange d'experts (MoE) pour augmenter le nombre de paramètres sans augmenter le calcul par token. Notre dossier sur les Transformers en deep learning revient sur ces évolutions.