Construire un tokenizer BPE depuis zéro

Le Byte Pair Encoding est le schéma de tokenisation derrière GPT-2, GPT-3, GPT-4 et la plupart des LLM ouverts modernes. L'algorithme est assez simple pour être implémenté en un après-midi. Ce guide le déroule depuis les premiers principes, avec une cellule exécutable dans le navigateur et une implémentation Python locale.

1. Pourquoi le BPE

Tokeniser du texte est plus difficile qu'il n'y paraît. L'approche naïve — découper sur les espaces, construire un vocabulaire — échoue sur du texte réel :

• les fautes de frappe et les mots rares font exploser le vocabulaire
• la structure en sous-mots (par exemple chantions = chant + ions) est perdue
• les mots jamais vus à l'inférence n'ont aucune représentation

Le BPE résout ça avec un vocabulaire appris, qui compresse les motifs fréquents et retombe sur les caractères pour les cas rares. C'était à l'origine un algorithme de compression de données de 1994 ; Sennrich et al. (2016) l'ont adapté à la traduction automatique, et OpenAI l'a repris pour GPT-2.

2. L'algorithme

L'algorithme d'entraînement tient en quatre lignes :

1. Partir d'un vocabulaire contenant chaque caractère du corpus.
2. Trouver la paire de tokens adjacents la plus fréquente.
3. Fusionner cette paire en un nouveau token. L'ajouter au vocabulaire.
4. Répéter jusqu'à avoir fait N fusions.

N est ton seul bouton. Pour GPT-2, il est réglé pour que le vocabulaire final fasse environ 50 000 tokens.

Le chapitre 3 — entraîne tes propres tokens l'implémente avec des cellules interactives que tu peux dérouler pas à pas.

3. Entraîner sur ton propre corpus

Une fois entraîné, le tokenizer n'est qu'une liste de fusions (dans l'ordre) plus un vocabulaire. Tu peux sérialiser les deux en JSON et les recharger plus tard.

merges = [("t", "h"), ("th", "e"), ...]   # liste ordonnée de paires
vocab = ["a", "b", ..., "th", "the", ...] # tous les tokens connus

L'encodage est itératif : on part des caractères, puis on applique chaque fusion dans l'ordre partout où la paire apparaît. Le décodage se réduit à "".join(tokens).

4. Encoder et décoder

Un encodeur qui fonctionne doit gérer :

• l'ordre glouton des fusions (appliquer d'abord les fusions les plus anciennes)
• octets contre caractères (le BPE moderne travaille souvent sur les octets, pour couvrir tout Unicode)
• les conventions d'espaces (GPT-2 préfixe la plupart des tokens d'une espace pour préserver les frontières de mots)

Le chapitre 3 couvre les deux premiers points. La convention d'espaces est un détail propre à GPT-2 : il vaut la peine de la comprendre, mais elle ne change pas l'algorithme.

5. Comparer au tokenizer de GPT-2

Une fois ton BPE en marche, passe la même chaîne dans ton tokenizer et dans celui de GPT-2. Tu verras que :

• le nombre de tokens est à peu près comparable
• les découpes diffèrent — GPT-2 a vu infiniment plus de texte, donc ses fusions capturent davantage de morphologie
• les deux produisent une représentation de taille fixe et décodable

Ce qu'il faut retenir : le tien est une version réduite exactement de la même chose.

6. La suite

La tokenisation est la première pièce d'un LLM. À partir d'ici :

• Le chapitre 4 — donner du sens aux mots transforme les identifiants de tokens en vecteurs denses que le modèle peut apprendre.
• Le chapitre 1 — le modèle le plus idiot utilise ton tokenizer dans un compteur de bigrammes, le modèle de langage fonctionnel le plus simple.
• Le programme complet emmène ce tokenizer jusqu'à un chatbot qui fonctionne.