Les tokens : comment un modèle découpe le texte

Un modèle de langage ne lit ni lettres ni mots. Avant toute chose, ton texte passe par un tokenizer, qui le découpe en morceaux, les tokens, et donne à chacun un numéro. Ce découpage fixe la facture d'un appel, ce qui tient dans la fenêtre de contexte, et une bonne partie des erreurs étranges des modèles : compter les lettres d'un mot, calculer, ou réagir à une espace en trop.

Pour qui : si tu as déjà posé une question à un assistant en ligne, tu as tout ce qu'il faut. Aucune notion d'IA n'est nécessaire, on part de zéro.

Au programme, avec des figures à manipuler : le trajet complet d'une phrase, de ton texte jusqu'à la réponse ; une estimation de coût que tu fais toi-même ; la boucle du BPE, qui construit le vocabulaire ; le choix de sa taille ; qui paie le plus de tokens selon la langue ; les pièges du découpage ; et les tokens spéciaux, qui mettent une conversation à plat. Trois figures te demandent de parier, d'estimer ou de deviner à l'aveugle avant de regarder : c'est là que ça s'apprend.

Le trajet d'une phrase, de ton texte à la réponse

Un modèle de langage ne manipule que des nombres. Entre ta phrase et sa réponse, il y a donc une chaîne de conversions, et le tokenizer en occupe les deux bouts. Il découpe le texte en tokens, puis traduit chaque token en son numéro dans le vocabulaire, une liste fixe apprise avant le modèle. Chaque numéro est ensuite remplacé par un vecteur, une ligne de la table d'embeddings (voir les embeddings). Le modèle calcule alors, pour chaque numéro du vocabulaire, la probabilité que ce soit le suivant ; on en retient un, et le tokenizer, en sens inverse, le retransforme en texte. On recommence avec ce nouveau token ajouté, jusqu'à la fin de la réponse (la mécanique du calcul est celle des transformers).

Avant de lancer le jeton : à quels moments du trajet le tokenizer intervient-il, et que reçoit exactement le modèle ? Fais avancer la figure pas à pas, ou laisse-la jouer.

Le tokenizer apparaît deux fois : à l'entrée, pour passer du texte aux numéros, et à la sortie, pour repasser des numéros au texte. Entre les deux, le modèle ne voit jamais une lettre : il reçoit des numéros, et il ne produit qu'un numéro à la fois, plus exactement un score pour chaque numéro du vocabulaire. Le vocabulaire est donc la frontière de tout ce que le modèle peut lire ou écrire, et le découpage décide de la place que prend ton texte dans la fenêtre de contexte.

Ni lettres, ni mots : des morceaux

Pourquoi ne pas donner les lettres au modèle ? Parce que les séquences seraient très longues, et que chaque lettre porte peu de sens. Pourquoi pas les mots ? Parce qu'il y en a trop (conjugaisons, noms propres, fautes de frappe, mots inventés), et qu'un mot jamais vu deviendrait illisible. Les tokenizers modernes prennent le meilleur des deux : les mots fréquents deviennent un seul token, les mots rares se reconstruisent à partir de morceaux plus courts. Rien n'est inconnu, et les séquences restent courtes.

Combien de tokens fait une phrase ? C'est la question qu'on se pose devant une facture. Tape une phrase (ou prends une des trois proposées), estime son nombre de tokens, puis regarde : la figure te dit si tu es trop bas, trop haut ou juste. Essaie la même idée dans deux langues.

Presque tout le monde se trompe dans le même sens : on pense « un token, un mot », alors qu'un mot courant vaut un token et qu'un mot rare en vaut plusieurs. Le tokenizer de cette figure est un jouet : ses 520 symboles ne contiennent que quelques mots entiers, là où les vrais tokenizers en ont de 50 000 à plus de 200 000 et découpent donc bien moins fin. Retiens la règle plutôt que le chiffre : une phrase coûte plus de tokens que de mots, et l'écart dépend de la langue. Sur un vrai tokenizer (cl100k_base, celui de GPT-4, relevé avec tiktoken 0.14.0 le 21 octobre 2026), la phrase anglaise proposée fait 11 tokens, sa traduction française 16 et la russe 28.

Le BPE : fusionner ce qui revient souvent

L'algorithme le plus répandu s'appelle BPE (byte pair encoding), adapté au langage par Sennrich, Haddow et Birch (2016). Il part des caractères, compte toutes les paires voisines dans un grand corpus, fusionne la plus fréquente en un nouveau symbole, et recommence, des dizaines de milliers de fois. À chaque tour, le vocabulaire gagne un symbole.

Voici l'exemple du cours de Hugging Face, en miniature : cinq mots avec leur fréquence dans le corpus, écrits lettre par lettre. La paire « u + g » revient 20 fois, elle sera donc fusionnée en premier. Une fois « ug » créé, quelle paire sera collée ensuite ? Réponds avant de regarder : les mots les plus gros ne gagnent pas forcément.

Le gagnant du deuxième tour n'est pas la paire du mot le plus fréquent : « u + n » (16 fois, dans « pun » et « bun ») bat « h + ug » (15 fois, dans « hug » et « hugs »). Le BPE ne connaît ni les mots ni le sens : il compte des paires, rien d'autre. Tu as aussi vu pourquoi aucun mot n'est jamais inconnu : « bugs », absent du corpus, se reconstruit en trois morceaux déjà appris, « b », « ug » et « s ». Dans les vrais tokenizers, la boucle tourne des dizaines de milliers de fois sur des milliards de mots, et l'espace est collée au début du mot qui suit, ce que montre le petit point « · » de la figure précédente.

Deux variantes à connaître. Le BPE par octets (GPT-2 et ses successeurs) part des octets plutôt que des caractères : aucun texte, emoji compris, n'est jamais impossible à découper. SentencePiece (Kudo et Richardson, 2018) traite l'espace comme un caractère comme un autre, ce qui marche aussi pour les langues qui n'en mettent pas entre les mots, comme le japonais ou le chinois.

Combien de fusions ? La taille du vocabulaire

Le nombre de fusions est un réglage : c'est la taille du vocabulaire. Plus il y a de fusions, moins un texte compte de tokens, donc plus de texte tient dans la fenêtre de contexte et plus la réponse est rapide. Mais chaque token du vocabulaire a sa propre ligne dans la table d'embeddings, et un token rare n'est vu qu'un petit nombre de fois pendant l'entraînement : il est mal appris. Le compromis donne des tailles très différentes : 50 257 tokens pour GPT-2, environ 128 000 pour Llama 3, environ 200 000 pour o200k_base, le tokenizer de GPT-4o (chiffres relevés le 21 octobre 2026).

Pointe un point de la courbe : à partir de quelle taille une fusion de plus ne change-t-elle presque plus rien ? Surveille la case « 100 fusions suivantes », qui dit ce qu'elles feraient gagner.

La courbe plonge puis s'aplatit : les 100 premières fusions raccourcissent le paragraphe anglais de 59 tokens, les 100 dernières d'un seul. Les premières collent des paires extrêmement fréquentes (« he », « ·the »), qui servent dans presque toutes les phrases ; les dernières ne servent plus qu'à de rares mots. Dans un vrai tokenizer la courbe est bien plus longue, mais elle a la même allure. Et ce n'est pas gratuit : chaque token de plus ajoute une ligne à la table d'embeddings.

paramètres = taille du vocabulaire × d

128 000 × 4 096 = 524 288 000

Pour Llama 3, l'article annonce 3,94 caractères par token sur de l'anglais, contre 3,17 pour Llama 2 : c'est ce que rapporte un vocabulaire de 128 000 tokens, dont 28 000 ajoutés pour mieux couvrir les langues autres que l'anglais.

Qui paie le plus de tokens ?

Tout se compte en tokens : la taille de la fenêtre de contexte, le prix d'un appel, la vitesse de réponse. Or un tokenizer fusionne ce qui est fréquent dans son corpus. Voici la même phrase dite en cinq langues, mesurée en tokens pour 100 mots par deux tokenizers jouets : l'un a appris sur un corpus à parts égales entre les cinq langues, l'autre sur un corpus surtout anglais, comme le web. Les titres sont masqués. À la forme des barres, lequel est lequel ? Parie, puis regarde ce que ça donne pour la langue de ton choix.

Le tokenizer nourri d'anglais est celui où l'anglais est le plus bas et le russe, de loin, le plus haut : 573 tokens pour 100 mots contre 300, presque deux fois plus. À parts égales, l'écart se resserre (455 contre 336) sans disparaître. Un mot n'est pourtant pas la même unité d'une langue à l'autre : la phrase russe dit la même chose en 11 mots là où l'anglaise en emploie 14. La comparaison la plus honnête porte sur la phrase entière, et la figure te la donne sous les barres : 63 tokens contre 42 d'un côté, 50 contre 47 de l'autre. C'est le corpus qui décide, pas la langue.

Dans le monde réel, l'écart a été mesuré : Petrov et ses collègues (2023) trouvent des différences allant jusqu'à 15 fois plus de tokens pour un même texte selon la langue. Et il bouge avec les générations de tokenizers. Relevé le 21 octobre 2026 avec tiktoken 0.14.0 sur la phrase de la figure : GPT-2 donne 15 tokens en anglais, 32 en français et 80 en russe ; le tokenizer de GPT-4 (cl100k_base), 16, 24 et 37 ; celui de GPT-4o (o200k_base), 15, 18 et 22. Le russe passe de 5,3 fois l'anglais à 1,5 fois : un vocabulaire plus grand et plus multilingue réduit l'inégalité, il ne la supprime pas. Concrètement, un même message coûte plus cher à écrire en russe, remplit plus vite la fenêtre de contexte et prend plus de temps à répondre.

Les pièges du découpage

Le modèle ne reçoit que des numéros de tokens. Il ne « voit » ni lettres, ni chiffres, ni espaces : seulement ce que chaque token est devenu pendant l'entraînement. Quatre pièges en découlent, que tu peux provoquer à la main. Dans la console, commence par chercher un mot long qui ne coûte qu'un seul token, puis fais coûter plus cher le même mot en changeant seulement une espace, puis seulement sa casse, et enfin écris un nombre qui se casse en morceaux. Quelle combinaison coûte le plus ?

Voici les mêmes pièges sur de vrais tokenizers (tiktoken 0.14.0, relevé le 21 octobre 2026). Compter les lettres : « strawberry », avec une espace devant, est un seul token dans cl100k_base comme dans o200k_base. Le modèle reçoit donc un symbole opaque, et il doit avoir appris comment il s'écrit pour y compter les « r ». Les espaces : sans l'espace devant, « strawberry » est coupé en trois morceaux ; l'espace est collée au mot, si bien que « model » et « ·model » sont deux tokens différents, et qu'une espace en trop à la fin d'un prompt change la suite que le modèle prédit. Les majuscules : avec cl100k_base, « ·elephant » est un token, « ·ELEPHANT » en coûte quatre. Les nombres : cl100k_base les coupe par groupes de trois chiffres en partant de la gauche, si bien que 1234567 devient 123 | 456 | 7, alors qu'un humain regroupe depuis la droite (1 234 567) ; GPT-2 les coupait de façon irrégulière (123 | 45 | 678 | 90 pour 1234567890). C'est une des raisons pour lesquelles le calcul est difficile pour un modèle de langage.

Les tokens spéciaux : une conversation mise à plat

Un assistant semble gérer une conversation, avec un système, un utilisateur et lui-même. Pour le modèle, il n'y a qu'une suite de tokens. Les rôles y sont marqués par des tokens spéciaux : des balises réservées, chacune étant un seul token avec son propre numéro, que le tokenizer n'a jamais fabriqué à partir de lettres. La documentation de Hugging Face le résume ainsi : la conversation n'est qu'une suite de tokens, avec des tokens de contrôle qui laissent voir sa structure. Chaque famille de modèles a son format. Compare les deux formats de la figure sur la même conversation : combien de balises spéciales chacun ajoute-t-il, et que marque chacune ?

Llama 3 ajoute 9 balises spéciales à cette conversation, ChatML 5. Chaque balise coûte un token, mais son numéro est réservé : 128 000 pour le début du texte chez Llama 3, 128 009 pour la fin d'un tour. Les outils suivent le même principe : le format de Llama 3.1 réserve <|python_tag|> pour marquer un appel d'outil, <|eom_id|> pour dire « j'attends le résultat » et le rôle ipython pour renvoyer ce résultat. Deux conséquences pratiques. D'abord, changer de modèle, c'est changer de format : envoyer à un modèle les balises d'une autre famille dégrade ses réponses, d'où les modèles de conversation fournis avec chaque tokenizer. Ensuite, ce que tape un utilisateur ne doit jamais devenir une balise : si le texte <|eot_id|> saisi par quelqu'un était traduit en vrai token de fin de tour, il pourrait fermer le message à sa guise et se faire passer pour le système. Les bibliothèques sérieuses l'empêchent : tiktoken refuse par défaut un texte qui ressemble à un token spécial, et le code de Llama 3 le traite comme du texte ordinaire.

Ce qu'on oublie souvent

• Compter avec le bon tokenizer. Chaque famille de modèles a le sien : la phrase française de la figure vaut 24 tokens avec cl100k_base et 18 avec o200k_base. Changer de modèle, c'est changer de découpage, et un prompt réglé au plus juste pour une fenêtre de contexte peut déborder avec un autre modèle. Certains fournisseurs publient leur tokenizer (tiktoken, par exemple) pour qu'on compte soi-même.
• Les tokens cachés. Les balises de rôle, l'instruction système, la définition des outils et tout l'historique de la conversation sont renvoyés et comptés à chaque appel. À la dixième question, tu repaies les neuf premières.
• Les caractères rares coûtent plusieurs tokens. Avec cl100k_base, l'emoji « visage souriant » vaut 2 tokens et l'emoji « famille » à quatre personnages 18 ; o200k_base ramène le premier à 1 et le second à 11.
• Un mot inventé se paie en morceaux. « supercalifragilisticexpialidocious » fait 11 tokens avec cl100k_base : le mot n'est pas inconnu, il est reconstruit.
• La règle « 4 caractères par token » est une moyenne. Llama 3 annonce 3,94 caractères par token sur de l'anglais. Avec cl100k_base, la phrase anglaise de la figure compte 83 caractères pour 16 tokens, plus de 5 par token ; la phrase russe, 70 caractères pour 37 tokens, moins de 2.
• Les embeddings viennent après. Le tokenizer donne des numéros ; c'est le modèle qui apprend ce que chaque numéro veut dire.

Teste-toi

Quelques questions sur les idées qu'on vient de croiser. La raison s'affiche après chaque réponse : c'est elle qui compte.

Le vocabulaire en un coup d'œil

Ce qu'il faut retenir

• Un modèle de langage lit et écrit des numéros de tokens, pas des lettres ni des mots ; le tokenizer sert à l'entrée et à la sortie.
• Le BPE compte des paires et fusionne la plus fréquente : mots fréquents entiers, mots rares en morceaux, aucun mot inconnu.
• La taille du vocabulaire est un compromis : les premières fusions raccourcissent beaucoup, les dernières presque plus, et chaque token de plus ajoute une ligne à la table d'embeddings.
• Le découpage est appris sur un corpus : les langues mal représentées paient plus de tokens pour la même phrase, et un vocabulaire plus multilingue réduit l'écart sans le supprimer.
• Lettres, nombres, espaces et majuscules sont des pièges qui viennent du découpage, pas du raisonnement.
• Une conversation est une suite de tokens où des balises spéciales marquent les rôles ; chaque famille de modèles a son format, et un texte tapé ne doit jamais devenir une balise.
• On compte toujours avec le tokenizer du modèle utilisé, et on n'oublie pas les tokens cachés.

Pour aller plus loin

• Sennrich, Haddow & Birch (2016), Neural Machine Translation of Rare Words with Subword Units, ACL : le BPE appliqué au langage.
• Kudo & Richardson (2018), SentencePiece: A simple and language independent subword tokenizer and detokenizer for Neural Text Processing, EMNLP.
• Radford et al. (2019), Language Models are Unsupervised Multitask Learners : GPT-2, son BPE par octets et son vocabulaire de 50 257 tokens (consulté le 21 octobre 2026).
• Petrov, La Malfa, Torr & Bibi (2023), Language Model Tokenizers Introduce Unfairness Between Languages, NeurIPS : jusqu'à 15 fois plus de tokens selon la langue (consulté le 21 octobre 2026).
• Grattafiori et al. (2024), The Llama 3 Herd of Models : vocabulaire de 128 000 tokens, largeur de 4 096 pour la version 8B, 3,94 caractères par token (consulté le 21 octobre 2026).
• OpenAI, tiktoken et son code d'encodage : compter ses propres textes, et refuser par défaut le texte d'un token spécial (consultés le 21 octobre 2026).
• Hugging Face, Byte-Pair Encoding tokenization : le BPE pas à pas, avec le corpus de cinq mots (consulté le 21 octobre 2026).
• Hugging Face, Chat templates : une conversation n'est qu'une suite de tokens, et chaque modèle a son format (consulté le 21 octobre 2026).
• Meta, tokenizer.py de Llama 3 et format de prompt de Llama 3.1 : les balises spéciales et leurs rôles (consultés le 21 octobre 2026).