Tokens

Cerca de 25 minutos min de leitura, com 7 exemplos em 9 seções.

Edição 2026.11.16 Exemplos aprovados em 19 de nov de 2026 86 de 86 exemplos passam O que mudou

Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros

Traduzido do livro em inglês, edição 2026.11.16. Leia o original

Ao final deste capítulo, você será capaz de construir um tokenizador de codificação por pares de bytes do zero, escolher o tamanho do seu vocabulário medindo o que cada tamanho custa e ler o tokenizador de um modelo de linguagem aberto com atenção suficiente para aplicar suas fusões à mão. Todo modelo do restante do livro lê o texto da loja por meio do tokenizador que você construir aqui.

A loja vende móveis e artigos para casa online, e seus nomes e descrições de produtos precisam ser divididos em pedaços antes que qualquer modelo possa lê-los. O capítulo 1 dividiu os nomes dos produtos em palavras, porque o texto já tem espaços entre as palavras e ao redor da pontuação. Essa escolha foi rápida e ficou aquém em dois aspectos. O modelo bigrama não conseguia atribuir probabilidade alguma a uma palavra que nunca tinha visto no treinamento, como barstools, e isso o inviabilizava. E ele tratava chair e chairs, ou 48 e 49, como palavras não relacionadas, sem que algo aprendido sobre uma passasse para a outra.

Um token é a unidade que um modelo de linguagem lê e prediz: aquilo em que o texto é dividido antes que o modelo o veja. O primeiro problema vem da escolha dos tokens, então este capítulo fixa os tokens. O segundo exige mais do que os tokens podem oferecer, e o capítulo 4 o aborda. O capítulo mede três maneiras de dividir o texto da loja em tokens: palavras, caracteres e o meio-termo que a maioria dos modelos generativos abertos usa, a codificação por pares de bytes. Em seguida, ele abre o tokenizador de um desses modelos e o desmonta.

Palavras deixam lacunas

Última alteração na edição 2026.11.11

Dividir o texto em palavras dá a um modelo tokens que carregam significado, e por isso o capítulo 1 começou por aí. O custo está no vocabulário. Um modelo só consegue prever tokens do seu vocabulário, o conjunto de tokens que ele aprendeu com o texto de treinamento, então qualquer palavra que surja pela primeira vez depois do treinamento está fora de alcance: uma palavra fora do vocabulário. Em textos com nomes, números e produtos novos, sempre há algumas.

Os nomes de validação são os 10% dos produtos da loja com os quais nenhum modelo aprende, separados para mostrar como um modelo lida com texto que não viu. Esses nomes mostram o quanto as palavras ficam aquém. Conte as palavras da validação que os nomes de treinamento nunca usam, e separe-as em palavras raras e palavras comuns:

unseen-words.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Counts the validation words that the training names never use, then sorts them into rare words and ordinary ones.The share never seen in training is the line to read."""from collections import Counterfrom lib.store import is_ordinary, load_products, wordstrain_words = Counter(w for name in load_products("train")["name"] for w in words(name))   # words() splits on spaces: the store's text is already spaced around punctuationvalidation = [w for name in load_products("validation")["name"] for w in words(name)]unseen = [w for w in validation if w not in train_words]print("different words in training names:", f"{len(train_words):,}")print("words seen once in training:", f"{sum(1 for n in train_words.values() if n == 1):,}")print("validation words:", f"{len(validation):,}")print("validation words never seen in training:", f"{len(unseen):,}")print("share never seen in training:", f"{len(unseen) / len(validation):.1%}")# is_ordinary, from lib.store: true for a word, or each part of a hyphenated one, used in at least 30 training descriptions; numbers and punctuation count as ordinaryprint("share of them that are rare words, most often product lines' names:",      f"{sum(not is_ordinary(w) for w in unseen) / len(unseen):.0%}")print("most frequent of the ordinary ones:", ", ".join(w for w, _ in Counter(w for w in unseen if is_ordinary(w)).most_common(6)))
Saídapython unseen-words.py
different words in training names: 25,907
words seen once in training: 17,242
validation words: 29,054
validation words never seen in training: 2,109
share never seen in training: 7.3%
share of them that are rare words, most often product lines' names: 92%
most frequent of the ordinary ones: neutral, noise-free, details, spacious, 52.4, houses

Das palavras de validação, 7.3% nunca aparecem no treinamento, e 92% dessas são palavras raras, na maioria das vezes nomes de linhas de produtos, que o capítulo 1 exibe como [name]. As demais são palavras comuns que, por acaso, não aparecem nos nomes de treinamento, como neutral e noise-free. Um modelo em nível de palavra não consegue prever nenhuma delas, não consegue pontuar um texto que as contenha sem tratamento especial, e não consegue relacionar noise-free com noise e free, que ele conhece bem.

Um conjunto de treinamento maior diminuiria a lacuna, mas nunca a fecharia, porque o catálogo continua acrescentando linhas de produtos. Das 25,907 palavras diferentes nos nomes de treinamento, 17,242 aparecem apenas uma vez, o que é comum em linhas de produtos e números de modelo, e uma palavra vista uma única vez dá a um modelo quase nada para aprender, de qualquer forma.

Regra prática: Meça a taxa de palavras fora do vocabulário do seu texto nos dados reservados antes de escolher tokens de palavra. Como regra geral, se mais de um ou dois por cento das palavras reservadas forem inéditas, como nos nomes da loja, não use palavras como tokens. Tokens de palavra continuam razoáveis para textos com vocabulário fechado, como um conjunto fixo de comandos.

Caracteres cobrem tudo

Última alteração na edição 2026.11.11

Ir ao outro extremo resolve a lacuna. Se cada caractere for um token, o vocabulário é minúsculo e quase nada fica fora dele: uma nova linha de produtos é escrita com as mesmas letras de uma antiga. O preço é o comprimento. Cada palavra vira vários tokens, então o modelo tem mais passos para prever, e o contexto de que precisa, como o início do nome de um produto, fica muitos tokens para trás.

Teste se os caracteres fecham a lacuna para os nomes da loja. Compare os caracteres nos nomes de treino e de validação e conte os tokens dos nomes de validação das duas formas:

character-tokens.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Compares the characters of the training names with those of the validation names, and counts the validation tokensboth ways. Its characters-per-word line is the one to read."""import unicodedatafrom lib.store import load_products, wordstrain_names, validation_names = load_products("train")["name"], load_products("validation")["name"]characters = {c for name in train_names for c in name}     # a set: each distinct character onceunseen = {c for name in validation_names for c in name} - charactersword_tokens = sum(len(words(name)) for name in validation_names)   # a word is a token here, as in chapter 1character_tokens = sum(len(name) for name in validation_names)     # len counts the spaces too, as charactersprint("different characters in training names:", len(characters))print("validation characters never seen in training:", len(unseen))print("they are:", ", ".join(unicodedata.name(c).lower() for c in sorted(unseen)))   # printed by Unicode name, because a soft hyphen itself prints as nothingprint("validation tokens as words:", f"{word_tokens:,}")print("validation tokens as characters:", f"{character_tokens:,}")print("characters per word:", round(character_tokens / word_tokens, 1))
Saídapython character-tokens.py
different characters in training names: 86
validation characters never seen in training: 2
they are: soft hyphen, latin small letter t with cedilla
validation tokens as words: 29,054
validation tokens as characters: 174,142
characters per word: 6.0

Caracteres raramente deixam algo de fora, mas tornam o texto longo. Apenas 2 caracteres nos nomes de validação nunca aparecem nos nomes de treino. Como palavras, os nomes de validação somam 29,054 tokens; como caracteres, 174,142, ou 6.0 caracteres por palavra, contando os espaços. Um modelo que lê caracteres precisa prever c, o, f, f, e, e antes de chegar ao ponto em que um modelo de palavras começa: saber que table é o provável próximo.

Os caracteres também deixam uma última lacuna, pequena. Os 2 caracteres não vistos são um hífen condicional e um t com cedilha, e um tokenizador de caracteres não consegue soletrar uma palavra que contenha algum deles. Modelos abertos fecham essa lacuna trabalhando com bytes: em UTF-8, a codificação de texto usual, cada caractere de qualquer idioma é armazenado em um a quatro bytes, e há apenas 256 valores possíveis de byte, de modo que um vocabulário que parte dos 256 consegue representar qualquer texto (Radford et al., 2019, seção 2.2). O tokenizador lido mais adiante neste capítulo faz exatamente isso.

Sequências mais longas custam de duas formas. Cada passo que um modelo dá é computação, então 6.0 vezes mais passos significam pelo menos 6.0 vezes o trabalho, e mais para os modelos dos capítulos seguintes, cujo custo cresce mais rápido que o comprimento. E todo modelo deste livro olha para trás em uma janela limitada de tokens; em caracteres, essa janela cobre muito menos palavras, na mesma proporção.

Regra prática: Use caracteres como tokens apenas em pequenos experimentos, ou como alternativa de reserva dentro de um esquema maior, como fazem as próximas seções. Verifique quantos caracteres por palavra o seu texto tem, pois esse fator multiplica cada comprimento de sequência e cada passo de treinamento.

Una o par mais frequente, de novo e de novo

Última alteração na edição 2026.11.11

Palavras são granulares demais e caracteres são detalhados demais, então o método usado pela maioria dos modelos generativos abertos, entre eles o SmolLM2, fica entre os dois. Byte-pair encoding, ou BPE, começa a partir de caracteres e constrói tokens maiores a partir dos pares que ocorrem com mais frequência. Ele começou como um método de compressão de dados, que Sennrich, Haddow e Birch adaptaram para cortar palavras em pedaços para modelos de tradução (Sennrich et al., 2016). O algoritmo é curto:

  1. Escreva cada palavra do texto de treinamento como caracteres, e marque o fim dela com </w>, para que uma fusão nunca una uma palavra à seguinte.
  2. Conte cada par adjacente de símbolos, ponderando cada palavra pela frequência com que ela ocorre.
  3. Funda o par mais frequente em um novo símbolo em todas as ocorrências, e adicione-o ao vocabulário.
  4. Repita a partir do passo 2, tantas vezes quanto o tamanho de vocabulário que você quiser.

A lista de fusões, na ordem em que foram aprendidas, é o tokenizador. Para codificar uma palavra, escreva-a como caracteres e aplique as fusões na mesma ordem.

Oito fusões, executadas à mão sobre os nomes do texto de treinamento, são suficientes para mostrar cada passo. Cada fusão é impressa à medida que acontece, e a última linha mostra como table é escrita depois das oito:

merge-pairs-by-hand.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Runs the merge algorithm by hand on the training names for eight merges, printing each one and how table is spelledafterwards. Those eight merges are the ones to read; the example asserts they match lib.bpe.train."""from collections import Counterfrom lib import bpefrom lib.store import load_products, wordsword_counts = Counter(w for name in load_products("train")["name"] for w in words(name))spelled = {w: list(w) + ["</w>"] for w in word_counts}       # every word as characters, plus an end markerlearned = []for step in range(1, 9):    pairs = Counter()    for w, syms in spelled.items():                           # count every adjacent pair of symbols        for pair in zip(syms, syms[1:]):            pairs[pair] += word_counts[w]                     # each pair weighted by how often its word occurs    best = min(pairs, key=lambda p: (-pairs[p], p))           # the most frequent pair; ties go to the pair that sorts first    for w, syms in spelled.items():                           # replace it everywhere with one new symbol        merged, i = [], 0        while i < len(syms):            if syms[i:i + 2] == list(best):                   # the pair starting at position i is the one being merged                merged.append(syms[i] + syms[i + 1])          # its two symbols, joined into the one new symbol                i += 2            else:                merged.append(syms[i])                i += 1        spelled[w] = merged    learned.append(best)    print(f"merge {step}: {best[0]!r} + {best[1]!r} -> {best[0] + best[1]!r}  ({pairs[best]:,} times)")print("table spelled now:", spelled["table"])assert learned == bpe.train(word_counts, 8)                   # lib.bpe.train, the fast version, learns the same eight merges
Saídapython merge-pairs-by-hand.py
merge 1: 'e' + '</w>' -> 'e</w>'  (35,498 times)
merge 2: 'r' + '</w>' -> 'r</w>'  (24,635 times)
merge 3: 'i' + 'n' -> 'in'  (21,312 times)
merge 4: 'd' + '</w>' -> 'd</w>'  (20,216 times)
merge 5: 't' + '</w>' -> 't</w>'  (18,628 times)
merge 6: 'a' + 'n' -> 'an'  (15,697 times)
merge 7: 'e' + 'r</w>' -> 'er</w>'  (12,981 times)
merge 8: 's' + 't' -> 'st'  (12,781 times)
table spelled now: ['t', 'a', 'b', 'l', 'e</w>']

As primeiras fusões anexam o marcador de fim a finais comuns de palavras, como e com </w>, porque muitas palavras da loja terminam em e, r ou d. Depois surgem pedaços comuns dentro das palavras, como in, an e st. Após oito fusões, table é escrita como t a b l e</w>: ainda em sua maioria caracteres. Com milhares de fusões, palavras comuns como table tornam-se tokens únicos, enquanto palavras raras continuam divididas em pedaços que outras palavras compartilham.

Essa é a ideia que resolve o primeiro problema do capítulo 1. Palavras frequentes ganham tokens próprios, então as sequências ficam curtas. Palavras raras e novas são escritas a partir de pedaços que o modelo já viu, de modo que qualquer palavra escrita com caracteres presentes no texto de treinamento está ao alcance. O BPE não resolve o segundo problema: como a próxima seção mostra, uma palavra frequente e seu plural podem, cada um, tornar-se um token inteiro sem nada em comum.

Regra prática: Aprenda as fusões apenas a partir da divisão de treinamento, como faria com qualquer outro modelo, e mantenha a ordem das fusões, pois a codificação depende dela. Desempate pares igualmente frequentes por uma regra fixa, de modo que o mesmo texto sempre produza o mesmo tokenizador.

Treine o tokenizador da loja

Última alteração na edição 2026.11.11

O algoritmo da seção anterior recalcula todos os pares após cada fusão, o que é adequado para oito fusões e lento demais para milhares. O módulo compartilhado do livro, lib.bpe, executa o mesmo algoritmo, mas conta os pares uma única vez e, após cada fusão, atualiza apenas as palavras que a fusão alterou, mantendo as contagens em um heap, de modo que o par mais frequente esteja sempre no topo. Ele aprende milhares de fusões em segundos e produz as mesmas fusões que a versão simples: o exemplo escrito à mão verifica que suas oito fusões coincidem com as de lib.bpe.train.

O tokenizador da loja aprende 4,000 fusões a partir dos nomes e das descrições de treinamento juntos, porque os modelos do livro aprenderão com ambos. Cinco textos curtos, dois nomes de produtos e três pares de palavras, mostram o que ele faz com uma palavra não vista e com palavras parecidas:

store-tokenizer.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Learns 4,000 merges from the training names and descriptions, then encodes five short texts with the resultingtokenizer. Read the vocabulary size and the tokens of each text, which the prose cites."""from collections import Counterfrom lib import bpefrom lib.store import load_products, wordstrain = load_products("train")word_counts = Counter(w for text in train["name"] + " " + train["description"] for w in words(text))   # names and descriptions, read as one texttokenizer = bpe.Tokenizer(bpe.train(word_counts, merges=4000), bpe.alphabet(word_counts))   # the merges, then the characters they start fromprint("different words in training text:", f"{len(word_counts):,}")print("characters and the end marker:", len(bpe.alphabet(word_counts)))print("tokens in the vocabulary:", f"{len(tokenizer.vocabulary):,}")# an unseen word, a word and its plural, digits, and a hyphenated word, in that orderfor name in ["set of 2 barstools", "sled coffee table", "chair chairs", "48 49", "noise noise-free"]:    print(name, "->", " ".join(tokenizer.encode(name)))
Saídapython store-tokenizer.py
different words in training text: 49,315
characters and the end marker: 137
tokens in the vocabulary: 4,138
set of 2 barstools -> set</w> of</w> 2</w> bar stools</w>
sled coffee table -> sled</w> coffee</w> table</w>
chair chairs -> chair</w> chairs</w>
48 49 -> 48</w> 4 9</w>
noise noise-free -> noise</w> no i se -free</w>

Palavras comuns saem inteiras, e uma palavra não vista ainda recebe uma grafia. sled coffee table são três tokens, um para cada palavra. A palavra barstools, que o modelo de bigramas do capítulo 1 não conseguia tratar porque os nomes de treinamento nunca a contêm, sai como bar e stools</w>, dois pedaços que o tokenizador conhece bem. O texto de treinamento tem 49,315 palavras diferentes, e o vocabulário do tokenizador tem 4,138 tokens: os 137 caracteres do texto de treinamento e o marcador de fim, mais um novo token para cada uma das 4,000 fusões, e <unk>, que representa qualquer caractere que o texto de treinamento nunca continha.

As três últimas linhas da saída mostram o que o BPE não faz. chair e chairs são ambas comuns, então cada uma virou um token inteiro, e os dois tokens não compartilham nada. 48 é um token, e 49 são dois, 4 e 9</w>. E noise-free se divide em pedaços que não compartilham nada com noise. Os tokens dão a cada palavra uma grafia, não um significado; relacioná-los é tarefa do capítulo 4.

Ainda é preciso que um modelo aprenda o que é uma nova linha de produtos, mas ele pode pelo menos prever uma e atribuir a ela uma probabilidade.

Regra prática: Treine o tokenizador com o mesmo texto do qual o seu modelo vai aprender, aqui nomes e descrições juntos, de modo que as palavras frequentes desse texto virem tokens únicos. Construa-o uma vez e use-o para todo modelo que você comparar; todos os modelos do livro leem o texto da loja por meio de lib.bpe.store_tokenizer().

Escolha quantos merges usar

Última alteração na edição 2026.11.16

A seção anterior usou 4,000 merges; esta mostra o motivo. O número de merges define o tamanho do vocabulário, e é a única escolha real em um tokenizador BPE. Mais merges tornam as sequências mais curtas, o que economiza computação. Mas cada novo token cobre um texto mais raro, e um token que o texto de treino mostra apenas algumas vezes dá ao modelo muito pouco para aprender: o mesmo problema das palavras raras, em outro lugar.

Aprender 16,000 merges uma vez e ler os primeiros 0, 1,000, 2,000, 4,000, 8,000 e 16,000 deles gera seis tokenizers. Os primeiros k merges de uma execução mais longa são exatamente os merges que uma execução de k merges aprenderia. Cada um recebe três medidas: os diferentes tokens que o texto de treino usa, os tokens em que cada palavra de validação se transforma e a parcela desses diferentes tokens que o texto de treino mostra menos de 20 vezes. Os diferentes tokens que um texto usa são seus tipos de token. Antes de ler a tabela, decida o que cada extremo deve mostrar:

vocabulary-size.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 Aprovado
"""Learns 16,000 merges once, then reads the first 0, 1,000, 2,000, 4,000, 8,000 and 16,000 of them as six tokenizers.Each row of the table measures one of them; the printed lines at the ends and at 4,000 merges are what the prose cites."""from collections import Counterfrom lib import bpefrom lib.store import load_products, wordstraining, validation = load_products("train"), load_products("validation")counts = Counter(w for text in training["name"] + " " + training["description"] for w in words(text))merges = bpe.train(counts, merges=16000)             # the first k merges of a longer run are a k-merge tokenizervalidation_words = [w for text in validation["name"] + " " + validation["description"] for w in words(text)]results = {}print(f"{'merges':>6}  {'tokens used':>11}  {'tokens per word':>15}  {'rare types':>10}")for k in [0, 1000, 2000, 4000, 8000, 16000]:    tokenizer = bpe.Tokenizer(merges[:k], bpe.alphabet(counts)) if k else None   # with no merges, a word is just its characters    encode = tokenizer.encode_word if k else bpe.symbols    seen = Counter(t for w, n in counts.items() for t in encode(w) for _ in range(n))   # each word's tokens, counted as often as the word occurs    per_word = sum(len(encode(w)) for w in validation_words) / len(validation_words)    rare = sum(1 for n in seen.values() if n < 20) / len(seen)   # rare: seen fewer than 20 times in the training text    print(f"{k:>6,}  {len(seen):>11,}  {per_word:>15.2f}  {rare:>10.0%}")    results[k] = per_word, rareprint("tokens per word at 4,000 merges:", f"{results[4000][0]:.2f}")print("rare token types with characters only:", f"{results[0][1]:.0%}")print("rare token types at 4,000 merges:", f"{results[4000][1]:.0%}")print("rare token types at 16,000 merges:", f"{results[16000][1]:.0%}")
Saídapython vocabulary-size.py
merges  tokens used  tokens per word  rare types
     0          137             5.61         49%
 1,000        1,130             1.71          7%
 2,000        2,123             1.42          5%
 4,000        4,099             1.22          6%
 8,000        8,007             1.10         13%
16,000       15,517             1.05         53%
tokens per word at 4,000 merges: 1.22
rare token types with characters only: 49%
rare token types at 4,000 merges: 6%
rare token types at 16,000 merges: 53%

O tokenizador da loja fica onde as sequências são curtas e poucos tokens são raros. Com 4,000 merges, uma palavra de validação ocupa, em média, 1.22 tokens, e 6% dos tipos de token são raros, quase tão poucos quanto com 2,000.

Sem merges, cada token é um caractere, então os tokens são frequentes, mas as palavras são longas: uma palavra ocupa mais de cinco tokens, e 49% dos tipos de token são raros, porque as descrições contêm caracteres incomuns. Com muitos merges, as palavras ficam curtas, mas os tipos raros se acumulam: a partir de 8,000 merges a parcela de raros sobe, e em 16,000 chega a 53%, porque a maioria dos merges extras cobre palavras que o texto de treino quase não contém.

O tamanho do vocabulário também define parte do tamanho do modelo. Um modelo de linguagem neural, a partir do capítulo 5, armazena um vetor de números para cada token do seu vocabulário e pontua todos os tokens do vocabulário a cada passo em que faz uma previsão. Um vocabulário quatro vezes maior significa quatro vezes mais vetores para aprender e quatro vezes mais pontuações a calcular a cada passo, qualquer que seja o texto. Para os modelos pequenos que este livro treina em um notebook, esse custo pesa tanto quanto o comprimento das sequências.

Por isso o tokenizador da loja usa 4,000 merges: além disso, cada merge rende pouco em comprimento e acrescenta um token que os pequenos modelos do livro não conseguem aprender bem. Grandes modelos abertos usam vocabulários de dezenas de milhares de tokens ou mais; o do SmolLM2 tem 49,152, porque aprendem a partir de muito mais texto, de modo que até os tokens mais raros ocorrem com frequência suficiente.

Regra prática: Escolha o número de merges medindo, no seu texto de treino, a parcela de tipos de token raros, e, em texto separado (held-out), os tokens por palavra; pare onde os tokens por palavra deixam de cair de forma significativa e os tipos raros começam a subir. Dimensione o vocabulário conforme o texto de treino; como regra geral, um modelo pequeno treinado com alguns milhões de palavras precisa de milhares de merges, não de dezenas de milhares.

Leia o tokenizer de um modelo aberto

Última alteração na edição 2026.11.12

Modelos de linguagem abertos distribuem o seu tokenizer como um arquivo ao lado dos pesos. Lê-lo mostra as mesmas ideias em uma escala maior, além de algumas escolhas que o tokenizer da loja não precisou fazer. Este livro usa o SmolLM2, um modelo de linguagem aberto da Hugging Face cujos pesos e tokenizer qualquer pessoa pode baixar, sob a licença Apache 2.0 (cartão do modelo). O livro mantém uma cópia do arquivo do tokenizer em examples/data/smollm2-tokenizer/, obtida em uma revisão fixada por prep/smollm2_tokenizer.py, de modo que os exemplos rodam offline. Os exemplos leem o arquivo com a biblioteca tokenizers, 0.23.3, a biblioteca para a qual o arquivo foi feito.

Codifique três nomes de produtos com os dois tokenizers e conte os tokens de cada tokenizer por nome de validação:

smollm2-tokens.py Python 3.12.15 · numpy 2.5.5 · pandas 3.1.1 · tokenizers 0.23.3 Aprovado
"""Encodes three product names with SmolLM2's tokenizer and with the store's, then counts the tokens per validation nameand per word each way. Read the tokens per validation name, which the prose cites."""from tokenizers import Tokenizerfrom lib import bpefrom lib.store import load_productssmollm2 = Tokenizer.from_file("data/smollm2-tokenizer/tokenizer.json")   # the book's pinned copy of the file, read from examples/store = bpe.store_tokenizer()print("SmolLM2 vocabulary:", f"{smollm2.get_vocab_size():,}")for name in ["set of 2 barstools", "6.5 qt . slow cooker", "48 '' wide genuine leather wingback chair"]:    print(name)    print("  SmolLM2:", " ".join(smollm2.encode(name).tokens))   # .tokens gives the pieces as text; .ids would give their numbers    print("  store:  ", " ".join(store.encode(name)))names = load_products("validation")["name"]print("tokens per validation name, SmolLM2:", round(sum(len(smollm2.encode(n).ids) for n in names) / len(names), 2))print("tokens per validation name, store:", round(sum(len(store.encode(n)) for n in names) / len(names), 2))print("tokens per validation name, words:", round(sum(len(n.split()) for n in names) / len(names), 2))   # split() on spaces: the store's wordsprint("sled at the start of a text:", " ".join(smollm2.encode("sled coffee table").tokens))print("sled after a space:", " ".join(smollm2.encode(" sled coffee table").tokens))   # the same name, after a spacewords_total = sum(len(n.split()) for n in names)print("SmolLM2 tokens per word:", round(sum(len(smollm2.encode(n).ids) for n in names) / words_total, 2))
Saídapython smollm2-tokens.py
SmolLM2 vocabulary: 49,152
set of 2 barstools
  SmolLM2: set Ġof Ġ 2 Ġbar st ools
  store:   set</w> of</w> 2</w> bar stools</w>
6.5 qt . slow cooker
  SmolLM2: 6 . 5 Ġq t Ġ. Ġslow Ġcooker
  store:   6.5</w> qt</w> .</w> slow</w> cooker</w>
48 '' wide genuine leather wingback chair
  SmolLM2: 4 8 Ġ'' Ġwide Ġgenuine Ġleather Ġwing back Ġchair
  store:   48</w> ''</w> wide</w> genuine</w> leather</w> wingback</w> chair</w>
tokens per validation name, SmolLM2: 10.53
tokens per validation name, store: 9.91
tokens per validation name, words: 6.79
sled at the start of a text: s led Ġcoffee Ġtable
sled after a space: Ġsled Ġcoffee Ġtable
SmolLM2 tokens per word: 1.55

O vocabulário do SmolLM2 tem 49,152 tokens, contra os 4,138 do tokenizer da loja, porque ele foi treinado com muito mais texto do que nomes de móveis. Três diferenças na saída merecem ser destacadas:

  • Espaços fazem parte dos tokens. Ġ representa um espaço: Ġtable é "table" com o espaço antes dela. Em vez de marcar onde a palavra termina, como faz o </w> do tokenizer da loja, este tokenizer mantém o espaço inicial de cada palavra, de modo que o texto pode ser reconstruído exatamente, com os espaços.
  • Cada dígito é um token próprio. 48 vira 4 e 8, e 6.5 vira 6, . e 5. Separar os dígitos impede que o vocabulário se encha de números, cada um visto poucas vezes, e trata todos os números do mesmo modo.
  • Uma palavra no início do texto não tem espaço antes, por isso é outro token. O vocabulário do SmolLM2 tem Ġsled como um único token, mas não sled sem o espaço, e assim um nome que começa com sled recebe s e led, como mostram as últimas linhas da saída. E barstools, que o vocabulário do SmolLM2 não tem como palavra inteira, se divide em bar, st e ools, como mostram as primeiras linhas.

Um tokenizer treinado com o seu próprio texto se sai um pouco melhor nele. O tokenizer da loja usa 9.91 tokens por nome de validação, e o do SmolLM2 usa 10.53, contra 6.79 palavras. A vantagem do tokenizer da loja se deve em parte ao fato de ele não separar números em dígitos, e em parte ao fato de o SmolLM2 gastar um token Ġ separado antes de cada número que segue um espaço, além de dividir a primeira palavra de cada nome, que não tem espaço antes.

Regra prática: Use o tokenizer de um modelo aberto exatamente como foi distribuído, sempre que usar um; um modelo só entende os tokens com que foi treinado. Conte tokens com esse tokenizer, não palavras, sempre que estimar o limite de contexto ou o custo. Quando treinar o seu próprio modelo com um texto restrito, treine o seu próprio tokenizer com esse texto.

Aplique os merges do SmolLM2 à mão

Última alteração na edição 2026.11.11

O arquivo de tokenizer do SmolLM2 parece uma caixa-preta até você perceber que ele guarda a mesma coisa que o tokenizer da loja: uma lista de merges, em ordem. O arquivo tokenizer.json tem três partes que importam aqui. Um pre-tokenizer divide o texto em pedaços antes de qualquer merge: seus passos, que o exemplo imprime pelo nome, separam os dígitos um a um e depois separam as palavras com seus espaços iniciais e mapeiam cada byte para um caractere imprimível, e é daí que vem Ġ. Esse mapeamento é o bytes_to_unicode do encoder do GPT-2 (encoder do GPT-2). Depois vem uma lista de merges, ordenada pelo momento em que foram aprendidos. E o vocabulário, que dá a cada token o seu número.

Confira os merges do arquivo: faça à mão o merge dos pedaços do pre-tokenizer da biblioteca de três nomes de produtos, começando sempre pelo par aprendido mais cedo, como faz o tokenizer da loja, e compare o resultado com os tokens da biblioteca:

merges-by-hand.py Python 3.12.15 · tokenizers 0.23.3 Aprovado
"""Applies SmolLM2's learned merges by hand, earliest first, to the pieces its pre-tokenizer makes of three product names.The example asserts that the tokens match the library's, which the prose cites."""import jsonfrom tokenizers import Tokenizersmollm2 = Tokenizer.from_file("data/smollm2-tokenizer/tokenizer.json")   # the book's pinned copy, read from examples/spec = json.load(open("data/smollm2-tokenizer/tokenizer.json", encoding="utf-8"))rank = {tuple(m.split(" ")): i for i, m in enumerate(spec["model"]["merges"])}   # lower rank: learned earlier; the file stores each merge as "a b"def merge(piece):                                    # apply the learned merges, earliest first, until none applies    syms = list(piece)    while len(syms) > 1:        pairs = [(rank.get(p, len(rank)), i) for i, p in enumerate(zip(syms, syms[1:]))]   # a pair with no merge ranks after all of them        best, i = min(pairs)                         # the earliest-learned pair; on a tie, the leftmost        if best == len(rank):            break        syms[i:i + 2] = [syms[i] + syms[i + 1]]      # the symbols at i and i + 1, joined into one    return symsfor name in ["set of 2 barstools", "sled coffee table", "6.5 qt . slow cooker"]:    # pre_tokenize_str returns (piece, offsets) pairs; only the pieces are merged    pieces = [p for p, _ in smollm2.pre_tokenizer.pre_tokenize_str(name)]       # split into words, digits and bytes    by_hand = [token for piece in pieces for token in merge(piece)]    print(name, "->", " ".join(by_hand))    assert by_hand == smollm2.encode(name).tokens    # the library's tokens for the same namesteps = [step["type"] for step in spec["pre_tokenizer"]["pretokenizers"]]assert spec["pre_tokenizer"]["pretokenizers"][0]["individual_digits"]   # the Digits step comes first, and splits digits one at a timeprint("pre-tokenizer steps:", ", ".join(steps))
Saídapython merges-by-hand.py
set of 2 barstools -> set Ġof Ġ 2 Ġbar st ools
sled coffee table -> s led Ġcoffee Ġtable
6.5 qt . slow cooker -> 6 . 5 Ġq t Ġ. Ġslow Ġcooker
pre-tokenizer steps: Digits, ByteLevel

Os tokens feitos à mão coincidem com os da biblioteca nos três nomes, o que o exemplo verifica com uma asserção. Isso é tudo o que o tokenizer do SmolLM2 faz com esses nomes; ele também define tokens especiais, que são reconhecidos antes de qualquer um desses passos. Ele difere do tokenizer da loja no pre-tokenizer e no texto de treinamento, mas codifica o texto aplicando repetidamente o merge do par aprendido mais cedo, como faz o da loja.

Vale conferir essa coincidência, porque diferenças sutis na forma como o texto é dividido têm consequências adiante. Um modelo treinado com um tokenizer e alimentado com os tokens de outro lê absurdos sem gerar nenhum erro, já que todo número de token é válido. O mesmo acontece, e é mais difícil de notar, quando uma versão de um tokenizer difere de outra na forma como trata espaços ou dígitos.

Regra prática: Trate o tokenizer como parte do modelo: versione-o junto com o modelo, carregue-o a partir dos arquivos do próprio modelo e teste-o com o seu próprio texto sempre que atualizar um dos dois. Quando dois tokenizers discordarem em sequer um token para o mesmo texto, descubra o motivo antes de confiar em qualquer coisa que um modelo construído sobre eles diga.

O que dá errado em produção

Os tokens decidem o que um modelo consegue ver, e a maioria dos problemas com o tokenizador aparece bem longe dele:

  • Um tokenizador incompatível falha em silêncio. Um modelo que recebe números de token de outro tokenizador lê números válidos que significam coisas erradas, e produz absurdos com total confiança. Entregue o arquivo do tokenizador junto com o modelo e teste os dois em conjunto.
  • Os custos são contados em tokens. Os limites de contexto e os preços por token se aplicam a tokens, não a palavras. Os nomes da loja ocupam 1.55 tokens por palavra no tokenizador do SmolLM2; textos cheios de números, códigos ou de outro idioma ocupam mais. Meça o seu próprio texto.
  • Números são difíceis. Um tokenizador que separa os dígitos faz o modelo raciocinar sobre 48 como dois tokens; um que não separa produz 48 e 49 como tokens sem relação entre si. Em ambos os casos, espere que os modelos lidem com tamanhos e quantidades pior do que com palavras, e verifique esses casos separadamente.
  • Tokens especiais podem ser digitados. Modelos abertos marcam o início ou o fim de um texto, ou a vez de uma fala em uma conversa, com tokens especiais escritos como strings, como <|endoftext|>. Se um texto digitado pelo usuário contém uma dessas strings e o tokenizador a transforma no token especial, o modelo lê um sinal de controle que o usuário não deveria conseguir enviar. Verifique como o seu tokenizador trata strings de tokens especiais em textos não confiáveis.
  • Textos novos se afastam do texto de treinamento. Um tokenizador treinado com o catálogo do ano passado divide as linhas de produtos deste ano em mais pedaços. Meça tokens por palavra em textos novos de tempos em tempos; uma alta constante significa que o tokenizador está ficando para trás em relação ao seu texto.

O que este capítulo decidiu

  • Os modelos do livro leem o texto da loja como tokens de codificação por pares de bytes (BPE). Palavras deixaram 7.3% das palavras de validação fora do vocabulário, e caracteres tornaram as sequências 6.0 vezes mais longas que as palavras. O BPE evita os dois problemas: qualquer palavra escrita com caracteres que aparecem no texto de treinamento pode ser codificada, e palavras comuns são tokens únicos. Ele não relaciona palavras entre si, como chair e chairs; isso é tarefa do capítulo 4.
  • O tokenizador da loja aprende 4,000 fusões a partir dos nomes e descrições da divisão de treinamento, em lib.bpe.store_tokenizer(). Nesse tamanho, uma palavra tem em média 1.22 tokens, e poucos tipos de token são raros demais para serem aprendidos. Mais fusões encurtam um pouco as sequências e acrescentam muitos tokens raros.
  • Cada palavra termina com </w>, de modo que as fusões nunca cruzam palavras. Modelos abertos, como o SmolLM2, anexam o espaço à palavra seguinte; ambos os esquemas mantêm as fronteiras de palavras visíveis para o modelo.
  • Modelos abertos são sempre usados com os próprios tokenizadores. Um modelo só entende os números de token com os quais foi treinado; por isso, o capítulo 10 lê o modelo SmolLM2 com o tokenizador que este capítulo desmontou, e toda execução de um modelo aberto neste livro informa o tokenizador que usou.
  • Perplexidades de tokenizadores diferentes não são comparáveis. Um modelo que prevê mais tokens menores dá mais passos e tem perplexidade diferente sobre o mesmo texto; por isso, toda comparação de modelos neste livro usa o tokenizador da loja, e o capítulo 3 recomeça essa comparação com base nos seus tokens.

Este capítulo, nesta edição

Edição 2026.11.16Exemplos aprovados em 19 de nov de 20267 de 7 exemplos exemplos deste capítulo passam

Traduzido do livro em inglês, edição 2026.11.16.

Citar esta seção

Formato

Cada formato cita o livro em inglês, que esta tradução acompanha.

Todos os formatos citam esta edição. Seu link abre a edição atual, em que o título de cada seção indica quando seu texto foi alterado pela última vez. As datas de acesso e de recuperação são o dia em que você abre esta página.

Nesta página

Capítulo 2 de 11: Tokens

  1. Palavras deixam lacunas
  2. Caracteres cobrem tudo
  3. Una o par mais frequente, de novo e de novo
  4. Treine o tokenizador da loja
  5. Escolha quantos merges usar
  6. Leia o tokenizer de um modelo aberto
  7. Aplique os merges do SmolLM2 à mão
  8. O que dá errado em produção
  9. O que este capítulo decidiu

Voltar ao topoTodos os capítulos