Que se passe-t-il quand un tout petit modèle de langage apprend à partir de poids aléatoires?

L’article détaillé sur nanoGPT et nanochat vous dit quels projets prêts à l’emploi lancer et à quoi ressemble le chemin plus long. Ce projet diffère sur un point : vous lisez chaque ligne d’un petit modèle, puis vous vérifiez ce qui arrive par rapport à des prédictions que vous pouvez calculer sur papier.

Le texte est le roman de L. M. Montgomery paru en 1908, Anne of Green Gables, que le projet Gutenberg indique comme étant du domaine public aux États-Unis. Une fois retirés l’en-tête et le pied de page de Gutenberg, il compte 559 087 caractères et 68 symboles différents. Vérifiez les règles de votre pays avant de publier quoi que ce soit qui a été entraîné sur un livre.

Chaque caractère reçoit un numéro, et les « jetons » de ce modèle sont donc de simples caractères. Les vrais modèles utilisent de plus grands morceaux, comme l’explique l’article sur la construction de votre propre segmenteur.

Le modèle, en une cinquantaine de lignes

Le fichier compagnon mini_gpt.py contient le modèle au complet. Voici la partie qui compte : le bloc d’attention, où chaque position regarde les positions précédentes et décide quoi utiliser, suivi d’un petit réseau qui traite le résultat.

class Block(nn.Module):
    def __init__(self, d, heads, drop):
        super().__init__()
        self.n1, self.n2 = nn.LayerNorm(d), nn.LayerNorm(d)
        self.attn = nn.MultiheadAttention(d, heads, dropout=drop, batch_first=True)
        self.ff = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(), nn.Linear(4 * d, d), nn.Dropout(drop))

    def forward(self, x, mask):
        h = self.n1(x)
        x = x + self.attn(h, h, h, attn_mask=mask, need_weights=False)[0]
        return x + self.ff(self.n2(x))

Le masque (mask) cache les caractères suivants, pour que le modèle ne puisse pas tricher en regardant la réponse. Quatre de ces blocs, avec 128 nombres pour décrire chaque caractère et une fenêtre de 128 caractères, donnent 818 432 paramètres. Lancez python 06_tiny_language_model.py pour télécharger le texte et entraîner le modèle. Il faut PyTorch et aucun compte.

Prédisez le premier chiffre avant de lancer le code

Avec des poids aléatoires, le modèle devrait donner à peu près la même probabilité à chaque symbole. La perte quand on devine uniformément parmi 68 symboles est le logarithme naturel de 68, soit 4,220. Mesuré à l’étape 0 : 4,218 sur le texte d’entraînement et 4,216 sur le texte de validation. Cette vérification de départ ne coûte rien. Si elle avait affiché 9, quelque chose serait déjà brisé.

Seconde prédiction : que pourrait donner le simple comptage? Notez quel caractère suit quel autre, sans aucun réseau de neurones. Cette table a obtenu une perte de validation de 2,444. Votre modèle doit la battre, sinon le réseau de neurones n’a rien ajouté.

Ce qu’il écrit à mesure que la perte baisse

Mesuré ici sur le GPU intégré d’un Apple M5 Max (PyTorch 2.15, lot de 64, taux d’apprentissage de 0,0003, une graine).

Et voici ce que le même modèle a produit, à partir de la lettre A chaque fois, sur un roman anglais :

Étape 0, poids aléatoires :

A Dq”Lfe[C c‘yptbt?tvCU.aHsJXP”PBu

Étape 200, à peu près le niveau de la table de comptage. Il a trouvé les espaces et les paires de lettres courantes :

Annnt fese cay tone tofor se aree has f avewonge. g Mre y, I theeree ame

Étape 1 000, de vrais mots, avec un rythme de dialogue :

Anne well to you, every. I’m see use so as with hard they,

Étape 6 000, un texte qui a la forme de la grammaire, une voix, et aucun sens :

Anne was encouraging at all. And what did not give such a dismalet have been so many sorry.

Personne ne lui a dit qu’« Anne » est un prénom ni ce qu’est une phrase. Il a réduit un seul nombre. Il a aussi inventé « dismalet », une belle illustration : les morceaux ressemblent à de l’anglais, mais aucun dictionnaire n’est intervenu.

Ce que disent les chiffres

Lisez les deux colonnes de perte ensemble. À l’étape 1 000, elles sont proches. À l’étape 6 000, la perte d’entraînement a encore baissé de 0,59, alors que la perte de validation n’a baissé que de 0,34, et de seulement 0,012 pendant les 1 000 dernières étapes. Le modèle s’améliore maintenant surtout sur le livre qu’il a vu. Un réseau plus gros ou plus d’étapes creuseraient cet écart avec si peu de texte. Le remède, c’est plus de texte, d’où le saut d’un roman à des centaines de millions de caractères.

La perte de validation de 1,339 équivaut à 1,93 bit par caractère. La table de comptage, à 2,444, équivaut à 3,53 bits. Cette mesure permet de comparer des modèles tant que les jetons sont les mêmes.

Le fichier entraîné pèse 3,29 Mo. La vitesse révèle autre chose. Sur cette machine, 100 étapes d’entraînement ont pris 1,2 seconde sur le GPU et 30,7 secondes sur le processeur avec tous ses fils. L’exécution complète sur le processeur durerait environ 31 minutes (calculé, non exécuté). Le projet fonctionne donc sur un portable sans GPU si vous réduisez les réglages ou si vous attendez, mais ce n’est plus un travail qu’on relance à la légère. Sur processeur, les petits réglages documentés de nanoGPT sont un bon guide : moins de couches et une fenêtre plus courte.

Comment distinguer l’apprentissage de la copie?

Un modèle peut avoir l’air brillant tout en récitant. Le script mesure donc la plus longue suite d’un extrait généré qui apparaît telle quelle dans le texte d’entraînement. Pour l’extrait final de 221 caractères, c’était 15 caractères. Les expressions courantes correspondront toujours, et 15 caractères représentent environ trois mots courts. Ce n’est pas une garantie : un extrait prouve peu de chose et, avec un plus gros modèle ou un texte plus petit, ce nombre monterait.

La colonne de validation est l’autre test. Un texte que le modèle n’a jamais vu contient des régularités qu’il ne peut exploiter que s’il a appris quelque chose de général. La perte de validation est passée de 4,216 à 1,339, bien au-delà de la table de comptage : il a donc appris une structure, soit des mots, de l’orthographe et un peu de grammaire.

Aucun de ces tests ne montre une compréhension. Ce modèle n’a pas de faits et n’a aucun moyen de savoir qu’il écrit n’importe quoi. Il illustre le mécanisme de l’apprentissage. Tout ce qu’ajoute un grand modèle de langage, comme de meilleurs jetons, beaucoup plus de données, plus de couches et, plus tard, l’ajustement fin, repose sur cette même boucle. La question suivante est de savoir quelle mémoire exige cette boucle quand les modèles grossissent, ce que mesure le projet sept.