Sampling et décodage.

Vous l’avez découvert à la leçon 04 : un modèle de langage écrit un token à la fois. Il prédit une distribution, choisit un token, l’ajoute au texte, puis repart de ce texte un peu plus long. Cette boucle s’appelle la génération autorégressive (autoregressive generation) : chaque token produit devient une entrée pour le suivant.

texte = prompt
répéter :
    probabilités = modèle(texte)       # leçons 01 à 08
    token = choisir(probabilités)       # cette leçon
    texte = texte + token
    si on doit s’arrêter : sortir

La façon de choisir s’appelle la stratégie de décodage (decoding strategy). Le modèle ne décide rien à ce stade : il a déjà donné ses probabilités. C’est un petit algorithme, autour du modèle, qui fait le choix.

La stratégie la plus simple consiste à prendre à chaque fois le token le plus probable, celui que l’on note argmax. C’est le décodage glouton (greedy decoding), celui de la leçon 04. Il est déterministe : le même prompt donne toujours exactement la même réponse.

Son défaut est célèbre : il tourne en rond. Partez de « Phileas Fogg » avec notre modèle par comptage, et le glouton écrit :

Phileas Fogg et de la partout de la partout de la partout de la partout…

Chaque choix, pris isolément, est le meilleur. Mais une fois entré dans « de la partout », le modèle retombe toujours sur les mêmes favoris. Les grands modèles souffrent du même travers, en plus subtil : des réponses plates, répétitives, toujours formulées pareil. Une variante, la recherche en faisceau (beam search), suit plusieurs pistes à la fois pour trouver la phrase la plus probable dans son ensemble ; elle reste utile en traduction, mais elle est rarement utilisée pour les conversations.

L’autre approche est de tirer au sort le token, en respectant les probabilités. Imaginez une roue de loterie où chaque token occupe une part proportionnelle à sa probabilité : le « e », à 24 %, prend presque un quart de la roue ; un token à 1 % n’en a qu’une fine tranche. On lance la roue, et on écrit le token sur lequel elle s’arrête. C’est l’échantillonnage, en anglais sampling.

Le texte devient plus varié et plus naturel, mais deux lancers donnent deux réponses différentes. Pour pouvoir reproduire un résultat, on fixe la graine du générateur aléatoire, la seed : avec la même seed, le même prompt et les mêmes réglages, on retrouve le même tirage. L’API d’OpenAI propose d’ailleurs un paramètre seed dans ce but, sans garantir une reproductibilité parfaite.

Avant le tirage, on peut déformer la distribution. Le réglage le plus connu est la température (temperature), notée T. On divise chaque logit par T avant softmax. Une température basse creuse les écarts : le favori devient écrasant. Une température haute les aplatit : les outsiders reprennent des chances.

                 e      espace    a
T = 0,5  →     52 %     17 %    10 %    plus sûr
T = 1    →     24 %     14 %    10 %    la distribution d’origine
T = 1,5  →     15 %     10 %     9 %    plus audacieux

Pourquoi une température basse creuse-t-elle les écarts ? Diviser les logits par 0,5 revient à les multiplier par 2 : tous les écarts entre les notes doublent avant de passer dans l’exponentielle de softmax, qui les accentue encore. Le « e » passe ainsi de 24 % à 52 %. À l’inverse, diviser par 1,5 resserre les notes, et la distribution s’aplatit.

Quand T se rapproche de 0, le favori prend tout : on retrouve le décodage glouton. Et comme on ne peut pas diviser par zéro, le code traite T = 0 à part : il bascule directement sur le décodage glouton (argmax). Quand T grandit, le texte devient créatif, puis incohérent. À T = 2, notre modèle invente des mots comme « impagnal » ou « apportish ». Dans l’API d’OpenAI, la température va de 0 à 2 : une valeur basse convient aux réponses factuelles ou au code, une valeur plus haute à l’écriture créative.

Même improbables, les dizaines de tokens en bas du classement finissent par être tirés de temps en temps, et chacun de ces accidents peut faire dérailler la suite. On appelle cet ensemble de petits candidats la longue traîne (long tail). Deux réglages la coupent avant le tirage, puis redistribuent les probabilités entre les tokens restants pour que le total refasse 100 %.

Le top-k garde seulement les k tokens les plus probables. Avec k = 3, après « r », il ne reste que « e », l’espace et « a », qui pesaient 24 %, 14 % et 10 %. Ensemble, ils ne totalisent qu’environ 48 % de la roue. On les renormalise : on divise chaque probabilité par ce total de 48 %, pour que les trois survivants se partagent à nouveau 100 %. On obtient 50 %, 28 % et 22 %.

          avant    ÷ 48 %    après
e         24 %   →          50 %
espace    14 %   →          28 %
a         10 %   →          22 %
          ────               ────
          48 %              100 %

Le top-p, ou échantillonnage par noyau (nucleus sampling), garde les meilleurs tokens jusqu’à ce que leurs probabilités cumulées atteignent p. Avec p = 0,5, les trois premiers tokens ne cumulent que 24 + 14 + 10 = 48 % : c’est encore sous le seuil. Il faut donc inclure le 4^e, le « i » à 8 %, pour atteindre et dépasser 50 % (environ 56 % au total). On coupe alors après ces 4 tokens, puis on renormalise : le « e » passe à 43 %. Son avantage : il s’adapte. Quand le modèle est sûr de lui, le noyau est petit ; quand il hésite, le noyau s’élargit. OpenAI recommande en général de régler soit la température, soit top-p, mais pas les deux à la fois.

Vous croiserez aussi des pénalités de répétition, comme frequency_penalty et presence_penalty chez OpenAI : elles baissent les logits des tokens déjà écrits, pour limiter les redites du décodage glouton.

Tous ces réglages s’enchaînent toujours dans le même ordre, à chaque token généré :

La boucle pourrait tourner sans fin. Trois mécanismes l’arrêtent. D’abord, un token de fin (end-of-sequence, ou EOS) : un token spécial du vocabulaire que le modèle a appris à produire quand sa réponse est terminée. Chez GPT-2, il s’écrit <|endoftext|>. Ensuite, une limite de longueur, max_tokens : au-delà, on coupe, même au milieu d’une phrase. Enfin, des séquences d’arrêt (stop sequences), des textes choisis par le développeur qui interrompent la génération dès qu’ils apparaissent.

Les API indiquent toujours pourquoi la génération s’est arrêtée. Chez OpenAI, le champ finish_reason vaut stop pour un arrêt naturel ou une séquence d’arrêt, et length quand la limite de tokens a coupé la réponse. Notre modèle par comptage n’a pas de token de fin : le laboratoire utilise le point comme séquence d’arrêt, avec une limite de 80 tokens.

Dans le laboratoire, tapez Phileas Fogg (avec l’espace final). Le laboratoire génère une suite avec une température de 0,8 et un top-p de 0,9, et affiche à côté le résultat du décodage glouton : la boucle « de la partout » saute aux yeux.

Changez la seed : le texte change, mais revient à l’identique si vous reprenez une seed déjà essayée. Montez la température à 2, puis descendez-la à 0 : vous retrouvez exactement le texte glouton. Enfin, observez la carte de la distribution : avec top-p, les tokens grisés ne peuvent plus être tirés.

Notre laboratoire tire ses tokens dans le modèle par comptage de la leçon 04, car notre Transformer de démonstration n’est pas entraîné : ses tirages seraient du pur hasard. Avec seulement quelques caractères de contexte, le texte ressemble à du Jules Verne de loin, mais n’a pas de sens. Les réglages, eux, agissent exactement comme dans un vrai LLM.

Vous connaissez maintenant tout le chemin d’un token, de l’entrée du modèle jusqu’au texte généré. Mais une question est restée en suspens depuis la leçon 03 : tous nos poids sont « non entraînés ». D’où viennent les vrais poids, ceux qui font qu’un modèle sait écrire ? C’est le sujet de la prochaine leçon : l’entraînement, ou comment le modèle apprend ses poids à partir de ses propres erreurs.