Logits et probabilités.

À la sortie du dernier bloc, chaque token a son vecteur. Mais pour deviner le token suivant, un seul nous intéresse : celui du dernier token. Grâce au masque causal de la leçon 06, c’est le seul qui a pu regarder tout le texte, du premier au dernier caractère. Il résume donc à lui seul tout le contexte.

Ce vecteur passe d’abord par une dernière normalisation, la LayerNorm finale (final layer norm, notée ln_f dans le code de GPT-2), que nous avions évoquée à la leçon 07. Elle remet les valeurs à une échelle comparable avant l’étape décisive.

Pendant l’entraînement, en revanche, on utilise les vecteurs de toutes les positions en même temps : chacun sert à deviner le token qui le suit. Nous y reviendrons dans la leçon sur l’entraînement.

Imaginez un jury de concours qui doit noter chacun des candidats. Ici, les candidats sont tous les tokens du vocabulaire : 111 dans notre laboratoire, 50 257 pour GPT-2. Le modèle donne à chacun une note brute, qui dit à quel point il lui semble être un bon token suivant.

Ces notes brutes s’appellent des logits. Ce sont des nombres quelconques : positifs, négatifs, petits ou grands. Ils ne sont pas encore des pourcentages. Seul compte leur classement : plus un logit est grand, plus le token est jugé probable.

Pour les calculer, on multiplie le vecteur final par une dernière matrice, la tête de langage (language modeling head, notée lm_head). Elle a une ligne par dimension et une colonne par token du vocabulaire : pour GPT-2, 768 × 50 257. On dit aussi que c’est une projection vers le vocabulaire, ou unembedding, car elle fait le chemin inverse de la table d’embeddings.

Beaucoup de modèles, dont GPT-2, font une économie astucieuse : leur tête de langage réutilise la table d’embeddings de la leçon 03. On parle de partage des poids (weight tying). Le logit d’un token est alors simplement le produit scalaire entre le vecteur final et l’embedding de ce token.

logit(token) = h · E[token]

h        : le vecteur final, après la LayerNorm finale
E[token] : la ligne du token dans la table d’embeddings

Vous reconnaissez le produit scalaire de l’attention : il mesure si deux vecteurs vont dans la même direction. Autrement dit, le modèle cherche quels tokens ont une fiche de sens proche de ce qu’il veut dire ensuite. C’est la proximité vectorielle de la leçon 03, utilisée cette fois pour choisir un mot. Notre laboratoire utilise ce partage des poids.

Pour transformer les logits en probabilités, on reprend la fonction softmax de la leçon 06. Chaque logit passe dans une exponentielle, ce qui rend tout positif et accentue les écarts, puis on divise par la somme. Le résultat est une distribution de probabilité (probability distribution) : un pourcentage par token, et le total fait 100 %.

logits      :  2,0     1,0     0,1
exponentielle:  7,39    2,72    1,11    (somme : 11,21)
÷ somme     :  66 %    24 %    10 %

Deux propriétés à connaître. D’abord, ajouter le même nombre à tous les logits ne change rien aux probabilités : seuls les écarts comptent. Ajoutez 10 partout : les logits [12,0 ; 11,0 ; 10,1] ont exactement les mêmes écarts que [2,0 ; 1,0 ; 0,1], et donnent donc exactement les mêmes probabilités : 66 %, 24 % et 10 %.

Ensuite, l’exponentielle d’un nombre ordinaire, même très négatif, reste toujours strictement supérieure à 0 : un token avec un logit de -1 000 garde une part infime, mais pas nulle. Le seul moyen d’obtenir exactement 0 % est de fixer son logit à moins l’infini (-∞). C’est ainsi qu’on rend un token totalement impossible.

Le laboratoire vous montre deux modèles côte à côte. Le premier est notre Transformer de démonstration, aux poids non entraînés. Après « Passepar », ses logits vont seulement de -0,89 à 0,89. Le token le plus probable, « Ä », n’obtient que 1,9 %, à peine plus qu’un tirage au hasard parmi 111 tokens (environ 0,9 %). Et le « e », pourtant évident pour un humain, n’arrive qu’en 65^e position. On dit que la distribution est plate : le modèle hésite partout.

Le second est le modèle par comptage de la leçon 04, qui a « appris » en lisant Jules Verne. On peut lui donner des logits : le logarithme de chaque compte. Après « r », le « e » a été vu 1 981 fois, d’où un logit de ln(1 981) ≈ 7,59. Le logarithme naturel (ln) est l’opération inverse de l’exponentielle : quand softmax passe ce logit dans l’exponentielle, les deux opérations s’annulent et redonnent exactement 1 981. Softmax redonne alors exactement les pourcentages de la leçon 04 : 24 % pour « e », 14 % pour l’espace, 10 % pour « a ». Les tokens jamais vus après « r » reçoivent un logit de moins l’infini, donc 0 %. Cette distribution est piquée : le modèle sait où regarder.

C’est tout l’enjeu de l’entraînement : passer de la première distribution à la seconde, et bien au-delà.

Les probabilités deviennent vite minuscules : 0,0001 %, 0,000001 %… Les ingénieurs préfèrent donc souvent leur logarithme, appelé log-probabilité ou logprob. Une probabilité de 100 % donne un logprob de 0 ; plus le token est improbable, plus son logprob est négatif.

probabilité   logprob
100 %     →    0
 50 %     →   -0,69
  1 %     →   -4,61

Attention à ne pas confondre les deux mots. Le logit est la note brute avant softmax : il peut être positif ou négatif. Le logprob est le logarithme de la probabilité après softmax : il est toujours inférieur ou égal à 0.

Vous retrouverez ce mot dans les vraies API. Celle d’OpenAI propose par exemple les paramètres logprobs et top_logprobs, qui renvoient, pour chaque token généré, son logprob et ceux des meilleurs candidats. C’est très utile pour mesurer la confiance du modèle dans sa réponse, ou pour repérer les passages où il hésitait.

Dans le laboratoire, tapez Passepar. Le dernier token est « r » : suivez son vecteur jusqu’aux logits, puis comparez les deux modèles avec les boutons « Transformer non entraîné » et « Modèle par comptage ».

Cliquez sur un token du classement pour voir le calcul de son logit, dimension par dimension. Puis, avec le modèle par comptage, augmentez le contexte jusqu’à 5 caractères : la distribution se resserre, jusqu’à donner 100 % au « t » de « Passepartout ».

Notre Transformer n’a qu’un bloc, 3 dimensions et des poids non entraînés : ses logits sont exacts, mais ils ne veulent encore rien dire. Le modèle par comptage, lui, a de vraies statistiques, mais il ne comprend rien au-delà des quelques caractères qui précèdent. Un vrai LLM combine les deux : l’architecture du Transformer et un long entraînement.

Il reste une question : nous avons maintenant une probabilité pour chaque token… mais lequel écrire ? Toujours le plus probable ? Tirer au sort ? Et comment savoir quand s’arrêter ? C’est le rôle du sampling et du décodage, le sujet de la prochaine leçon.