Self-attention, décodage, alignement et dimensions de modèle

La séance 2 répond à la question laissée ouverte par la séance précédente. Si les RNN et les LSTM ont montré comment traiter une séquence, qu’est-ce que le Transformer change réellement. La réponse tient en une idée forte. Au lieu de faire circuler l’information principalement à travers un état caché séquentiel, il calcule directement quelles parties du contexte sont pertinentes pour chaque token.

Le cœur du cours suit un ordre strict. D’abord le passage du goulot d’étranglement récurrent à la self-attention. Ensuite la distinction, trop souvent brouillée, entre attention, logits, softmax et décodage. Enfin l’articulation entre pré-entraînement, alignement et limites pratiques.

1. Expliquer ce que change la self-attention par rapport aux RNN et aux LSTM.
2. Définir query, key et value, puis relier ces termes à une formule d’attention pondérée.
3. Distinguer attention, logits, softmax et politique de décodage.
4. Expliquer l’apprentissage auto-régressif du token suivant et la logique de fenêtre glissante.
5. Différencier pré-entraînement, instruction tuning, préférences humaines et RLHF.
6. Distinguer nombre total de paramètres, dimension cachée, dimension d’embedding, nombre de têtes, profondeur, dimension FFN et paramètres actifs en MoE.

Prérequis utiles, avoir suivi la séance précédente sur tokens, embeddings, transformations matricielles, RNN et LSTM.

Dans une architecture récurrente classique, une partie importante du passé est compressée dans un état caché. Cette idée est puissante, mais elle crée un coût séquentiel fort et une difficulté structurelle quand l’information pertinente est lointaine. L’intuition historique de l’attention apparaît lorsque l’on cherche à éviter qu’un seul vecteur fixe porte à lui seul toute la charge de la phrase source.

Texte -> tokenisation -> IDs -> embeddings + information de position -> [bloc d'attention + FFN] répété plusieurs fois -> représentation finale -> logits sur le vocabulaire -> softmax -> probabilités -> sélection -> token suivant

Pour chaque token d’entrée, le modèle calcule trois vecteurs. Une query, une key et une value. La query du token i est comparée aux keys des autres tokens pour obtenir des scores de compatibilité. Ces scores sont normalisés par softmax pour produire une distribution d’attention. La sortie du token i est ensuite une somme pondérée des values.

Selon les conventions d’écriture, on peut aussi voir ces projections sous la forme \(W^Q x_i\), \(W^K x_i\), \(W^V x_i\). L’idée ne change pas. Ce sont des projections linéaires apprises.

Lecture mot à mot, on mesure la compatibilité entre ce que le token i cherche et ce que le token j annonce.

Le facteur \(\sqrt{d_k}\) n’est pas décoratif. Il stabilise l’échelle des scores lorsque la dimension augmente, ce qui évite un softmax excessivement pointu.

Dans un modèle causal, un token ne doit pas regarder le futur lorsqu’il est entraîné à prédire le prochain token. C’est le rôle du causal mask.

Pour bien lire cette matrice, chaque ligne représente la position qui pose la question et chaque colonne représente la position qu’elle peut consulter. La diagonale et toute la zone située en dessous restent accessibles. Un token peut donc regarder son passé ainsi que sa propre position. La zone située au-dessus de la diagonale correspond au futur. Cette zone doit rester invisible pendant le calcul.

Techniquement, le masque ne supprime pas les tokens futurs du texte d’entrée. Il agit sur les scores d’attention juste avant le softmax. Les cases interdites reçoivent une valeur extrêmement négative. Après la normalisation, leur poids devient pratiquement nul. Le modèle conserve donc tout le contexte déjà autorisé, mais il ne peut pas faire fuiter d’information depuis ce qui n’a pas encore été généré.

C’est ce mécanisme qui protège l’apprentissage auto-régressif. Quand le modèle apprend à prédire le token suivant à la position \(t_i\), il doit raisonner uniquement à partir des positions déjà disponibles. Sans ce verrou, il pourrait lire directement la réponse attendue et l’apprentissage du next token prediction perdrait sa validité.

Voici le contresens le plus fréquent de cette séance. L’attention ne choisit pas directement le prochain mot. Elle construit une représentation contextualisée. Le choix de sortie arrive après une projection finale sur le vocabulaire, qui produit des logits.

Lecture mot à mot, à partir de la représentation finale \(h_t\), le modèle calcule une note pour chaque token du vocabulaire, puis transforme ces notes en probabilités. Cette chaîne explique pourquoi un même état peut produire plusieurs sorties possibles si l’on échantillonne au lieu de prendre toujours le maximum.

Le décodage ne modifie pas ce que le modèle a appris. Il modifie la façon de choisir un token à partir d’une distribution déjà produite. C’est exactement la raison pour laquelle un même modèle peut sembler très conservateur ou plus diversifié sans que ses poids changent.

Le code ci-dessous est volontairement jouet. Il ne dépend d’aucun grand modèle et permet de faire comprendre la mécanique réelle logits → softmax → filtre éventuel → sampling.

import math
import random def softmax(logits): m = max(logits) exps = [math.exp(x - m) for x in logits] s = sum(exps) return [e / s for e in exps] def apply_temperature(logits, T): return [x / T for x in logits] def top_k_filter(tokens, probs, k): pairs = sorted(zip(tokens, probs), key=lambda x: x[1], reverse=True) kept = pairs[:k] total = sum(p for _, p in kept) return [(t, p / total) for t, p in kept] def top_p_filter(tokens, probs, p): pairs = sorted(zip(tokens, probs), key=lambda x: x[1], reverse=True) kept, cum = [], 0.0 for t, pr in pairs: kept.append((t, pr)) cum += pr if cum >= p: break total = sum(pr for _, pr in kept) return [(t, pr / total) for t, pr in kept] tokens = ["A", "B", "C", "D"]
logits = [2.0, 1.0, 0.1, -0.4]
probs = softmax(logits)

Le pré-entraînement apprend au modèle une compétence générale de prédiction du token suivant à grande échelle. L’alignement, lui, vise à rendre les sorties plus utiles, plus sûres ou plus conformes à des préférences humaines et à un format d’usage.

Vue d’ensemble du RLHF. Source Wikimedia Commons, PopoDameron, CC BY-SA 4.0.

Dans un modèle MoE, le nombre total de paramètres peut être très élevé, tout en gardant un coût par token plus limité, car seuls quelques experts sont activés pour ce token donné.

Présenté pédagogiquement, le MoE peut donc être lu comme une piste de réponse au dilemme classique de l’échelle : comment augmenter la capacité et la spécialisation d’un modèle sans faire croître de façon équivalente le coût de calcul à chaque pas. Dans cet esprit, on peut dire que les architectures à experts offrent peut-être une réponse partielle à une forme pratique de “malédiction de la dimension” : au lieu de mobiliser toute la largeur du système pour chaque token, elles essaient d’activer localement la bonne sous-partie du modèle.

Exemple réel d’architecture mixture-of-experts. Source Wikimedia Commons, DeepSeek, licence MIT/Expat telle qu’indiquée sur la page du fichier.

• Dire que la self-attention supprime le besoin d’information de position.
• Dire que l’attention choisit directement le prochain token.
• Présenter top-k, top-p ou température comme des mécanismes d’apprentissage plutôt que d’inférence.
• Présenter l’alignement comme une garantie de vérité.
• Réduire la taille d’un modèle à un seul chiffre sans distinguer paramètres, largeur interne, profondeur ou architecture sparse.