Un format pour converser

Premier article de la série Smallem, après le pré-entraînement : apprendre à répondre, qui prolonge Smallem : un LLM en Rust et CUDA, à partir de zéro.

À la fin de la première série, Smallem sait continuer un texte. Donnez-lui le début d'une phrase sur la photosynthèse, il en écrit la suite, dans le style d'une page web éducative. Posez-lui une question, il écrit... la suite de la question.

Un assistant fait autre chose : il répond. Entre les deux, il y a le post-entraînement, une part de la fabrication d'un LLM aussi importante que le pré-entraînement, et bien moins coûteuse en calcul. Cette série le construit, étape par étape : un format de conversation, un fine-tuning supervisé, des préférences, puis un apprentissage par essais et erreurs.

Avant d'apprendre quoi que ce soit au modèle, il faut deux choses : une façon d'écrire une conversation, et une façon de mesurer ce qu'il sait faire.

Des tokens qui disent qui parle

Une conversation alterne deux rôles. Pour que le modèle sache qui parle, chaque tour commence par un token réservé :

<|utilisateur|> What is 12 + 30? <|assistant|> 42 <|fin|>

Ces trois tokens n'existent pas dans le vocabulaire que le tokenizer a appris sur le texte : aucune suite d'octets ne les produit. Ils s'ajoutent après lui, avec les numéros 8 192, 8 193 et 8 194, et le modèle reçoit trois lignes de plus dans sa table d'embedding, qui sert aussi à sa sortie.

Avec quoi les remplir ? Chaque ligne de la table est un vecteur de 512 nombres, qui sert deux fois : en entrée, c'est ce que le modèle lit quand il rencontre le token et en sortie, le score du token, son logit, est le produit scalaire de cette ligne avec le dernier état du modèle. Des valeurs tirées au hasard, aussi petites qu'au début du pré-entraînement, seraient presque nulles à côté des lignes apprises : le modèle ne lirait presque rien, et le score du token resterait proche de zéro, sans rapport avec ceux des autres.

Nous prenons plutôt la moyenne de toutes les lignes existantes. Le produit scalaire étant linéaire, le score d'un token nouveau est alors exactement la moyenne des scores des autres : il n'est ni le plus probable ni impossible, et le fine-tuning peut le déplacer dans un sens ou dans l'autre. Ajouter des lignes ne touche pas aux anciennes : pour un texte sans tokens de rôle, les scores des 8 192 anciens tokens restent identiques au bit près, ce qu'un test vérifie.

Le fichier de poids n'a besoin de rien d'autre pour garder la trace de ce vocabulaire : sa configuration dit 8 195 tokens. Les tokens de rôle sont toujours les trois derniers.

Ce que l'assistant écrit

Une conversation devient une suite de tokens, et un masque qui dit lesquels l'assistant a écrits : sa réponse, et le <|fin|> qui la termine.

pub fn encode(tokenizer: &Bpe, roles: Roles, turn: &Turn) -> Encoded {
    let mut tokens = prompt(tokenizer, roles, &turn.question);
    let mut assistant = vec![false; tokens.len()];
    …
    assistant.extend(std::iter::repeat_n(true, answer.len()));

Ce masque servira à l'entraînement : la perte ne portera que sur ce que l'assistant écrit. Le modèle lit la question, mais n'apprend pas à la poser.

En génération, <|fin|> arrête la réponse. Le Batch de la série sur l'inférence sait déjà s'arrêter sur un token : il suffit de le lui donner.

Des tâches qu'un programme sait corriger

Pour mesurer, il faut savoir si une réponse est juste. Pour une conversation ouverte, c'est une question de goût. Ce plan commence donc par des tâches dont un programme connaît la réponse, chacune avec un générateur à graine et une vérification exacte. Quatre familles :

Les questions sont en anglais : c'est la langue des pages sur lesquelles le modèle a appris. Les additions portent sur des nombres de 2 ou 3 chiffres, les tris sur 3 à 5 nombres, la lecture sur trois modèles de phrase (une ville, une couleur de voiture, un animal).

Chaque famille a un jeu d'évaluation fixe de 200 questions, tiré avec une graine que l'entraînement n'utilise jamais. Pour la recopie à l'envers, les mots d'évaluation sont même pris dans une liste à part : le modèle ne pourra pas avoir appris par coeur les mots retournés.

Un programme, evaluate, mesure l'exactitude de chaque famille, en génération gloutonne, et la perte sur la validation de FineWeb-Edu. Le post-entraînement risque de faire oublier au modèle ce qu'il savait : c'est ainsi qu'on le verra.

La ligne de base

Comment interroger le modèle de départ, qui ne connaît pas les tokens de rôle ? Comme on interrogeait GPT-3 (Brown et al., 2020) : en lui montrant quelques exemples dans la consigne.

Question: <première question d'exemple>
Answer: <sa réponse>

Question: <deuxième question d'exemple>
Answer: <sa réponse>

Question: <troisième question d'exemple>
Answer: <sa réponse>

Question: What is 114 + 443?
Answer:

Les trois exemples sont tirés du générateur d'entraînement de la même famille. La réponse est ce que le modèle écrit jusqu'au saut de ligne suivant.

Zéro partout. Ce n'est pas une erreur de lecture des réponses : le modèle a bien compris la forme, et écrit après Answer: quelque chose qui a l'air d'une réponse.

What is 114 + 443?                          → 462   (attendu 557)
Write the word backwards: harbor            → Write the word backwards:
Sort from smallest to largest: 3 79 28      → 59 73
John lives in Paris. Where does John live?  → Lucy lives in London. What does John live?

Il additionne au hasard, recopie la consigne, invente des nombres, et quand on lui demande où vit John, il raconte une autre histoire. Avec 29 millions de paramètres, l'apprentissage « en contexte » que montrait GPT-3 à 175 milliards n'est pas là : quelques exemples ne suffisent pas à installer une tâche. Il faudra la lui apprendre. Sa perte sur FineWeb-Edu, elle, est de 0,8823 nat par octet : c'est ce qu'il ne faudra pas perdre.

Ce qu'il faut retenir

• Les tokens de rôle s'ajoutent au vocabulaire. Leurs lignes commencent à la moyenne des autres, sans changer aucun logit existant.
• Un masque désigne ce que l'assistant écrit : c'est sur lui seul que portera la perte.
• Des tâches vérifiables donnent une mesure exacte, sans juge ni goût.
• Le modèle de départ ne sait rien faire de ces tâches, même avec des exemples : 0 %.

Article suivant : Apprendre à répondre.