Tokens
Unos 21 minutos de lectura, con 7 ejemplos en 9 secciones.
Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros
Traducido del libro en inglés, edición 2026.11.16. Lee el original
En esta página
Al final de este capítulo podrás construir desde cero un tokenizador de codificación por pares de bytes, elegir su tamaño de vocabulario midiendo lo que cuesta cada tamaño, y leer el tokenizador de un modelo de lenguaje abierto lo bastante bien como para aplicar sus fusiones a mano. Cada modelo del resto del libro lee el texto de la tienda a través del tokenizador que construirás aquí.
La tienda vende muebles y artículos para el hogar en línea, y sus nombres de producto y descripciones tienen que dividirse en piezas antes de que cualquier modelo pueda leerlos. El capítulo 1 dividió los nombres de producto en palabras, porque el texto ya tiene espacios entre palabras y alrededor de los signos de puntuación. Esa elección fue rápida y se quedó corta en dos aspectos. El modelo de bigramas no podía asignar ninguna probabilidad a una palabra que nunca había visto durante el entrenamiento, como barstools, y eso lo rompía. Además, trataba chair y chairs, o 48 y 49, como palabras sin relación, sin que lo aprendido sobre una se trasladara a la otra.
Un token es la unidad que un modelo de lenguaje lee y predice: aquello en que se divide el texto antes de que el modelo lo vea. El primer problema proviene de la elección de los tokens, así que este capítulo fija los tokens. El segundo requiere más de lo que los tokens pueden ofrecer, y el capítulo 4 lo aborda. El capítulo mide tres maneras de dividir el texto de la tienda en tokens: palabras, caracteres y el punto intermedio que usan la mayoría de los modelos generativos abiertos, la codificación por pares de bytes. Después abre el tokenizador de uno de esos modelos y lo desmonta.
Las palabras dejan huecos
Dividir el texto en palabras da al modelo tokens que llevan significado, por eso el capítulo 1 empezó por ahí. El costo está en el vocabulario. Un modelo solo puede predecir tokens de su vocabulario, el conjunto de tokens que aprendió del texto de entrenamiento, así que cualquier palabra que aparece por primera vez después del entrenamiento queda fuera de su alcance: una palabra fuera de vocabulario. En un texto con nombres, números y productos nuevos, siempre hay algunas.
Los nombres de validación son el 10% de los productos de la tienda que ningún modelo aprende, apartados para mostrar cómo maneja un modelo un texto que no ha visto. Esos nombres muestran cuánto se quedan cortas las palabras. Cuenta las palabras de validación que los nombres de entrenamiento nunca usan, y sepáralas en palabras raras y palabras corrientes:
1"""Counts the validation words that the training names never use, then sorts them into rare words and ordinary ones.2The share never seen in training is the line to read."""3from collections import Counter45from lib.store import is_ordinary, load_products, words67train_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 punctuation8validation = [w for name in load_products("validation")["name"] for w in words(name)]9unseen = [w for w in validation if w not in train_words]1011print("different words in training names:", f"{len(train_words):,}")12print("words seen once in training:", f"{sum(1 for n in train_words.values() if n == 1):,}")13print("validation words:", f"{len(validation):,}")14print("validation words never seen in training:", f"{len(unseen):,}")15print("share never seen in training:", f"{len(unseen) / len(validation):.1%}")16# 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 ordinary17print("share of them that are rare words, most often product lines' names:",18 f"{sum(not is_ordinary(w) for w in unseen) / len(unseen):.0%}")19print("most frequent of the ordinary ones:", ", ".join(w for w, _ in Counter(w for w in unseen if is_ordinary(w)).most_common(6)))
python unseen-words.pydifferent 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
De las palabras de validación, 7.3% nunca aparecen en el entrenamiento, y 92% de ellas son palabras raras, casi siempre nombres de líneas de productos, que el capítulo 1 imprime como [name]. El resto son palabras corrientes que casualmente no aparecen en los nombres de entrenamiento, como neutral y noise-free. Un modelo a nivel de palabra no puede predecir ninguna de ellas, no puede puntuar un texto que las contenga sin un tratamiento especial, y no puede relacionar noise-free con noise y free, que sí conoce bien.
Un conjunto de entrenamiento más grande reduciría la brecha pero nunca la cerraría, porque el catálogo sigue añadiendo líneas de productos. De las 25,907 palabras distintas de los nombres de entrenamiento, 17,242 aparecen una sola vez, lo cual es habitual en líneas de productos y números de modelo, y una palabra vista una sola vez le da a un modelo casi nada que aprender de todos modos.
Regla práctica: Mide la tasa de palabras fuera de vocabulario de tu texto con datos reservados antes de elegir tokens de palabra. Como regla orientativa, si más de uno o dos por ciento de las palabras reservadas son desconocidas, como en los nombres de la tienda, no uses palabras como tokens. Los tokens de palabra siguen siendo razonables para textos con vocabulario cerrado, como un conjunto fijo de comandos.
Los caracteres lo cubren todo
Ir al otro extremo cierra el hueco. Si cada carácter es un token, el vocabulario es minúsculo y casi nada queda fuera de él: una nueva línea de productos se escribe con las mismas letras que una antigua. El precio es la longitud. Cada palabra se convierte en varios tokens, de modo que el modelo tiene más pasos que predecir, y el contexto que necesita, como el inicio del nombre de un producto, queda muchos más tokens atrás.
Comprueba si los caracteres cierran el hueco para los nombres de la tienda. Compara los caracteres de los nombres de entrenamiento y de validación, y cuenta los tokens de los nombres de validación de las dos maneras:
1"""Compares the characters of the training names with those of the validation names, and counts the validation tokens2both ways. Its characters-per-word line is the one to read."""3import unicodedata45from lib.store import load_products, words67train_names, validation_names = load_products("train")["name"], load_products("validation")["name"]8characters = {c for name in train_names for c in name} # a set: each distinct character once910unseen = {c for name in validation_names for c in name} - characters11word_tokens = sum(len(words(name)) for name in validation_names) # a word is a token here, as in chapter 112character_tokens = sum(len(name) for name in validation_names) # len counts the spaces too, as characters1314print("different characters in training names:", len(characters))15print("validation characters never seen in training:", len(unseen))16print("they are:", ", ".join(unicodedata.name(c).lower() for c in sorted(unseen))) # printed by Unicode name, because a soft hyphen itself prints as nothing17print("validation tokens as words:", f"{word_tokens:,}")18print("validation tokens as characters:", f"{character_tokens:,}")19print("characters per word:", round(character_tokens / word_tokens, 1))
python character-tokens.pydifferent 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
Los caracteres casi nunca fallan, pero hacen que el texto sea largo. Solo 2 caracteres de los nombres de validación no aparecen nunca en los nombres de entrenamiento. Como palabras, los nombres de validación son 29,054 tokens; como caracteres, 174,142, o 6.0 caracteres por palabra, contando los espacios. Un modelo que lee caracteres tiene que predecir c, o, f, f, e, e antes de llegar al punto en que empieza un modelo de palabras: saber que table es lo más probable a continuación.
Los caracteres también dejan un último hueco, pequeño. Los 2 caracteres no vistos son un guion blando y una t con cedilla, y un tokenizador de caracteres no puede escribir una palabra que contenga alguno de ellos. Los modelos abiertos cierran ese hueco trabajando en cambio con bytes: en UTF-8, la codificación de texto habitual, cada carácter de cualquier idioma se guarda como uno a cuatro bytes, y solo hay 256 valores de byte posibles, de modo que un vocabulario que parte de los 256 puede representar cualquier texto (Radford et al., 2019, sección 2.2). El tokenizador que lees más adelante en este capítulo hace exactamente eso.
Las secuencias más largas cuestan de dos maneras. Cada paso que da un modelo es cómputo, así que 6.0 veces más pasos significan al menos 6.0 veces más trabajo, y más para los modelos de capítulos posteriores, cuyo coste crece más rápido que la longitud. Y cada modelo de este libro mira hacia atrás en una ventana limitada de tokens; en caracteres, esa ventana cubre muchas veces menos palabras (en la misma proporción).
Regla práctica: Usa caracteres como tokens solo para experimentos pequeños, o como alternativa de respaldo dentro de un esquema más grande, como hacen las secciones siguientes. Comprueba cuántos caracteres por palabra tiene tu texto, ya que ese factor multiplica cada longitud de secuencia y cada paso de entrenamiento.
Fusiona el par más frecuente, una y otra vez
Las palabras son demasiado gruesas y los caracteres demasiado finos, así que el método que usan la mayoría de los modelos generativos abiertos, SmolLM2 entre ellos, se sitúa entre ambos. Byte-pair encoding, o BPE, parte de los caracteres y construye tokens más grandes a partir de los pares que aparecen con más frecuencia. Nació como un método de compresión de datos, que Sennrich, Haddow y Birch adaptaron para cortar palabras en fragmentos destinados a modelos de traducción (Sennrich et al., 2016). El algoritmo es breve:
- Escribe cada palabra del texto de entrenamiento como caracteres, y marca su final con
</w>, para que una fusión nunca una una palabra con la siguiente. - Cuenta cada par adyacente de símbolos, ponderando cada palabra según la frecuencia con que aparece.
- Fusiona el par más frecuente en un nuevo símbolo en todas partes, y añádelo al vocabulario.
- Repite desde el paso 2, tantas veces como tamaño de vocabulario quieras.
La lista de fusiones, en el orden en que se aprendieron, es el tokenizador. Para codificar una palabra, escríbela como caracteres y aplica las fusiones en el mismo orden.
Ocho fusiones, ejecutadas a mano sobre los nombres de entrenamiento, bastan para mostrar cada paso. Cada fusión se imprime cuando ocurre, y la última línea muestra cómo se escribe table después de las ocho:
1"""Runs the merge algorithm by hand on the training names for eight merges, printing each one and how table is spelled2afterwards. Those eight merges are the ones to read; the example asserts they match lib.bpe.train."""3from collections import Counter45from lib import bpe6from lib.store import load_products, words78word_counts = Counter(w for name in load_products("train")["name"] for w in words(name))9spelled = {w: list(w) + ["</w>"] for w in word_counts} # every word as characters, plus an end marker1011learned = []12for step in range(1, 9):13 pairs = Counter()14 for w, syms in spelled.items(): # count every adjacent pair of symbols15 for pair in zip(syms, syms[1:]):16 pairs[pair] += word_counts[w] # each pair weighted by how often its word occurs17 best = min(pairs, key=lambda p: (-pairs[p], p)) # the most frequent pair; ties go to the pair that sorts first18 for w, syms in spelled.items(): # replace it everywhere with one new symbol19 merged, i = [], 020 while i < len(syms):21 if syms[i:i + 2] == list(best): # the pair starting at position i is the one being merged22 merged.append(syms[i] + syms[i + 1]) # its two symbols, joined into the one new symbol23 i += 224 else:25 merged.append(syms[i])26 i += 127 spelled[w] = merged28 learned.append(best)29 print(f"merge {step}: {best[0]!r} + {best[1]!r} -> {best[0] + best[1]!r} ({pairs[best]:,} times)")30print("table spelled now:", spelled["table"])31assert learned == bpe.train(word_counts, 8) # lib.bpe.train, the fast version, learns the same eight merges
python merge-pairs-by-hand.pymerge 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>']
Las primeras fusiones unen la marca de final a las últimas letras comunes, como e con </w>, porque muchas palabras de la tienda terminan en e, r o d. Después aparecen fragmentos comunes dentro de las palabras, como in, an y st. Tras ocho fusiones, table se escribe t a b l e</w>: todavía en su mayoría caracteres. Con miles de fusiones, palabras comunes como table se convierten en tokens únicos, mientras las palabras raras siguen divididas en fragmentos que otras palabras comparten.
Esa es la idea que resuelve el primer problema del capítulo 1. Las palabras frecuentes obtienen sus propios tokens, así que las secuencias son cortas. Las palabras raras y nuevas se escriben con fragmentos que el modelo ya ha visto, así que cualquier palabra escrita con caracteres que aparecen en el texto de entrenamiento está al alcance. BPE no resuelve el segundo problema: como muestra la siguiente sección, una palabra frecuente y su plural pueden convertirse cada una en un token completo sin nada en común.
Regla práctica: Aprende las fusiones solo a partir de la partición de entrenamiento, como con cualquier otro modelo, y conserva el orden de las fusiones, ya que la codificación depende de él. Desempata los pares igual de frecuentes mediante una regla fija, para que el mismo texto siempre dé el mismo tokenizador.
Entrena el tokenizador de la tienda
El algoritmo de la sección anterior vuelve a contar cada par después de cada fusión, lo cual está bien para ocho fusiones y es demasiado lento para miles. El módulo compartido del libro lib.bpe ejecuta el mismo algoritmo, pero cuenta los pares una sola vez y, después de cada fusión, actualiza solo las palabras que la fusión cambió, manteniendo los recuentos en un montículo para que el par más frecuente siempre quede arriba. Aprende miles de fusiones en segundos y produce las mismas fusiones que la versión simple: el ejemplo escrito a mano afirma que sus ocho fusiones coinciden con lib.bpe.train.
El tokenizador de la tienda aprende 4,000 fusiones a partir de los nombres y las descripciones de entrenamiento juntos, porque los modelos del libro aprenderán de ambos. Cinco textos cortos, dos nombres de productos y tres pares de palabras, muestran qué hace con una palabra no vista y con palabras parecidas:
1"""Learns 4,000 merges from the training names and descriptions, then encodes five short texts with the resulting2tokenizer. Read the vocabulary size and the tokens of each text, which the prose cites."""3from collections import Counter45from lib import bpe6from lib.store import load_products, words78train = load_products("train")9word_counts = Counter(w for text in train["name"] + " " + train["description"] for w in words(text)) # names and descriptions, read as one text10tokenizer = bpe.Tokenizer(bpe.train(word_counts, merges=4000), bpe.alphabet(word_counts)) # the merges, then the characters they start from1112print("different words in training text:", f"{len(word_counts):,}")13print("characters and the end marker:", len(bpe.alphabet(word_counts)))14print("tokens in the vocabulary:", f"{len(tokenizer.vocabulary):,}")15# an unseen word, a word and its plural, digits, and a hyphenated word, in that order16for name in ["set of 2 barstools", "sled coffee table", "chair chairs", "48 49", "noise noise-free"]:17 print(name, "->", " ".join(tokenizer.encode(name)))
python store-tokenizer.pydifferent 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>
Las palabras frecuentes salen completas, y una palabra no vista sigue recibiendo una representación escrita. sled coffee table son tres tokens, uno por palabra. La palabra barstools, que el modelo de bigramas del capítulo 1 no podía manejar porque los nombres de entrenamiento nunca la contienen, sale como bar y stools</w>, dos fragmentos que el tokenizador conoce bien. El texto de entrenamiento contiene 49,315 palabras distintas, y el vocabulario del tokenizador tiene 4,138 tokens: los 137 caracteres del texto de entrenamiento y la marca de fin, más un token nuevo por cada una de las 4,000 fusiones, y <unk>, que representa cualquier carácter que el texto de entrenamiento nunca contuvo.
Las últimas tres líneas de la salida muestran lo que BPE no hace. chair y chairs son ambas comunes, así que cada una se convirtió en un token completo, y los dos tokens no comparten nada. 48 es un token y 49 son dos, 4 y 9</w>. Y noise-free se divide en fragmentos que no comparten nada con noise. Los tokens dan a cada palabra una forma escrita, no un significado; relacionarlos es el trabajo del capítulo 4.
Un modelo aún tiene que aprender qué es una nueva línea de productos, pero al menos puede predecirla y asignarle una probabilidad.
Regla práctica: Entrena el tokenizador con el mismo texto del que aprenderá tu modelo, aquí nombres y descripciones juntos, para que las palabras frecuentes de ese texto se conviertan en tokens individuales. Constrúyelo una sola vez y úsalo para cada modelo que compares; los modelos del libro leen el texto de la tienda a través de lib.bpe.store_tokenizer().
Elige cuántas fusiones usar
La sección anterior usó 4,000 fusiones; esta muestra por qué. El número de fusiones fija el tamaño del vocabulario, y es la única decisión real en un tokenizador BPE. Más fusiones hacen las secuencias más cortas, lo que ahorra cómputo. Pero cada nuevo token cubre texto más raro, y un token que el texto de entrenamiento muestra solo unas pocas veces da al modelo muy poco de lo que aprender: el mismo problema de las palabras raras, en otro lugar.
Aprender 16,000 fusiones una vez y leer las primeras 0, 1,000, 2,000, 4,000, 8,000 y 16,000 de ellas da seis tokenizadores. Las primeras k fusiones de una ejecución más larga son exactamente las fusiones que aprendería una ejecución de k fusiones. Cada una recibe tres medidas: los distintos tokens que usa el texto de entrenamiento, los tokens en que se convierte cada palabra de validación, y la proporción de esos distintos tokens que el texto de entrenamiento muestra menos de 20 veces. Los distintos tokens que usa un texto son sus tipos de token. Antes de leer la tabla, decide qué debería mostrar cada extremo:
1"""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.2Each row of the table measures one of them; the printed lines at the ends and at 4,000 merges are what the prose cites."""3from collections import Counter45from lib import bpe6from lib.store import load_products, words78training, validation = load_products("train"), load_products("validation")9counts = Counter(w for text in training["name"] + " " + training["description"] for w in words(text))10merges = bpe.train(counts, merges=16000) # the first k merges of a longer run are a k-merge tokenizer11validation_words = [w for text in validation["name"] + " " + validation["description"] for w in words(text)]1213results = {}14print(f"{'merges':>6} {'tokens used':>11} {'tokens per word':>15} {'rare types':>10}")15for k in [0, 1000, 2000, 4000, 8000, 16000]:16 tokenizer = bpe.Tokenizer(merges[:k], bpe.alphabet(counts)) if k else None # with no merges, a word is just its characters17 encode = tokenizer.encode_word if k else bpe.symbols18 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 occurs19 per_word = sum(len(encode(w)) for w in validation_words) / len(validation_words)20 rare = sum(1 for n in seen.values() if n < 20) / len(seen) # rare: seen fewer than 20 times in the training text21 print(f"{k:>6,} {len(seen):>11,} {per_word:>15.2f} {rare:>10.0%}")22 results[k] = per_word, rare23print("tokens per word at 4,000 merges:", f"{results[4000][0]:.2f}")24print("rare token types with characters only:", f"{results[0][1]:.0%}")25print("rare token types at 4,000 merges:", f"{results[4000][1]:.0%}")26print("rare token types at 16,000 merges:", f"{results[16000][1]:.0%}")
python vocabulary-size.pymerges 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%
El tokenizador de la tienda se sitúa donde las secuencias son cortas y pocos tokens son raros. Con 4,000 fusiones, una palabra de validación ocupa 1.22 tokens de media, y 6% de los tipos de token son raros, casi tan pocos como con 2,000.
Sin fusiones, cada token es un carácter, así que los tokens son frecuentes pero las palabras son largas: una palabra ocupa más de cinco tokens, y 49% de los tipos de token son raros, porque las descripciones contienen caracteres poco comunes. Con muchas fusiones, las palabras son cortas pero los tipos raros se acumulan: a partir de 8,000 fusiones la proporción de raros sube, y con 16,000 llega a 53%, porque la mayoría de las fusiones adicionales cubren palabras que el texto de entrenamiento apenas contiene.
El tamaño del vocabulario también fija parte del tamaño del modelo. Un modelo de lenguaje neuronal, desde el capítulo 5 en adelante, almacena un vector de números para cada token de su vocabulario, y puntúa todos los tokens del vocabulario en cada paso que predice. Un vocabulario cuatro veces mayor significa cuatro veces más vectores que aprender y cuatro veces más puntuaciones que calcular en cada paso, sea cual sea el texto. Para los modelos pequeños que este libro entrena en un portátil, ese coste importa tanto como la longitud de las secuencias.
Por eso el tokenizador de la tienda usa 4,000 fusiones: más allá de eso, cada fusión acorta muy poco las secuencias y añade un token que los modelos pequeños del libro no pueden aprender bien. Los grandes modelos abiertos usan vocabularios de decenas de miles de tokens o más; el de SmolLM2 tiene 49,152, porque aprenden de mucho más texto, así que incluso sus tokens más raros aparecen con suficiente frecuencia.
Regla práctica: Elige el número de fusiones midiendo, en tu texto de entrenamiento, la proporción de tipos de token raros, y, en texto reservado, los tokens por palabra; detente donde los tokens por palabra dejen de bajar de forma notable y los tipos raros empiecen a subir. Escala el vocabulario con el texto de entrenamiento; como regla orientativa, un modelo pequeño con unos pocos millones de palabras necesita miles de fusiones, no decenas de miles.
Lee el tokenizador de un modelo abierto
Los modelos de lenguaje abiertos distribuyen su tokenizador como un archivo junto a sus pesos. Leerlo muestra las mismas ideas a mayor escala, además de algunas decisiones que el tokenizador de la tienda no tuvo que tomar. Este libro usa SmolLM2, un modelo de lenguaje abierto de Hugging Face cuyos pesos y tokenizador cualquiera puede descargar, bajo la licencia Apache 2.0 (ficha del modelo). El libro guarda una copia de su archivo de tokenizador en examples/data/smollm2-tokenizer/, obtenida en una revisión fijada por prep/smollm2_tokenizer.py, de modo que los ejemplos se ejecutan sin conexión. Los ejemplos leen el archivo con la biblioteca tokenizers, 0.23.3, la biblioteca para la que fue creado el archivo.
Codifica tres nombres de productos de ambas formas y cuenta los tokens por nombre de validación de cada tokenizador:
1"""Encodes three product names with SmolLM2's tokenizer and with the store's, then counts the tokens per validation name2and per word each way. Read the tokens per validation name, which the prose cites."""3from tokenizers import Tokenizer45from lib import bpe6from lib.store import load_products78smollm2 = Tokenizer.from_file("data/smollm2-tokenizer/tokenizer.json") # the book's pinned copy of the file, read from examples/9store = bpe.store_tokenizer()1011print("SmolLM2 vocabulary:", f"{smollm2.get_vocab_size():,}")12for name in ["set of 2 barstools", "6.5 qt . slow cooker", "48 '' wide genuine leather wingback chair"]:13 print(name)14 print(" SmolLM2:", " ".join(smollm2.encode(name).tokens)) # .tokens gives the pieces as text; .ids would give their numbers15 print(" store: ", " ".join(store.encode(name)))1617names = load_products("validation")["name"]18print("tokens per validation name, SmolLM2:", round(sum(len(smollm2.encode(n).ids) for n in names) / len(names), 2))19print("tokens per validation name, store:", round(sum(len(store.encode(n)) for n in names) / len(names), 2))20print("tokens per validation name, words:", round(sum(len(n.split()) for n in names) / len(names), 2)) # split() on spaces: the store's words21print("sled at the start of a text:", " ".join(smollm2.encode("sled coffee table").tokens))22print("sled after a space:", " ".join(smollm2.encode(" sled coffee table").tokens)) # the same name, after a space23words_total = sum(len(n.split()) for n in names)24print("SmolLM2 tokens per word:", round(sum(len(smollm2.encode(n).ids) for n in names) / words_total, 2))
python smollm2-tokens.pySmolLM2 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
El vocabulario de SmolLM2 tiene 49,152 tokens, frente a los 4,138 del tokenizador de la tienda, porque se entrenó con mucho más texto que los nombres de muebles. Vale la pena señalar tres diferencias en su salida:
- Los espacios forman parte de los tokens.
Ġrepresenta un espacio:Ġtablees "table" con el espacio delante. En lugar de marcar dónde termina una palabra, como hace el</w>del tokenizador de la tienda, este tokenizador conserva el espacio inicial de cada palabra, de modo que el texto puede reconstruirse exactamente, con sus espacios. - Cada dígito es un token propio.
48se convierte en4y8, y6.5en6,.y5. Separar los dígitos evita que el vocabulario se llene de números, cada uno visto unas pocas veces, y trata todos los números de la misma manera. - Una palabra al inicio de un texto no tiene espacio delante, así que es un token distinto. El vocabulario de SmolLM2 tiene
Ġsledcomo un solo token, pero nosledsin espacio, por lo que un nombre que empieza porsledse divide ensyled, como muestran las últimas líneas de la salida. Ybarstools, que el vocabulario de SmolLM2 no tiene como palabra completa, se divide enbar,styools, como muestran las primeras líneas.
Un tokenizador entrenado con tu propio texto lo trata un poco mejor. El tokenizador de la tienda usa 9.91 tokens por nombre de validación y el de SmolLM2 usa 10.53, frente a 6.79 palabras. La ventaja se debe en parte a que el tokenizador de la tienda no separa los números en dígitos, y en parte a que SmolLM2 gasta un token Ġ aparte antes de cada número que sigue a un espacio y divide la primera palabra de cada nombre, que no tiene espacio delante.
Regla práctica: Usa el tokenizador de un modelo abierto tal como se distribuye, siempre que lo uses; un modelo solo entiende los tokens con los que fue entrenado. Cuenta los tokens con ese tokenizador, no las palabras, cada vez que calcules el límite de contexto o el coste. Cuando entrenes tu propio modelo con un texto específico, entrena tu propio tokenizador con ese texto.
Aplica a mano los merges de SmolLM2
El archivo del tokenizador de SmolLM2 parece una caja negra hasta que notas que contiene lo mismo que el tokenizador de la tienda: una lista de merges, en orden. El archivo, tokenizer.json, tiene tres partes que importan aquí. Un pre-tokenizador divide el texto en fragmentos antes de cualquier fusión: sus pasos, que el ejemplo imprime por nombre, separan los dígitos uno a uno, luego separan las palabras junto con sus espacios iniciales y asignan cada byte a un carácter imprimible, que es de donde proviene Ġ. Ese mapeo es bytes_to_unicode de GPT-2 (el codificador de GPT-2). Después, una lista de merges, ordenada según el momento en que se aprendieron. Y el vocabulario, que asigna a cada token su número.
Comprueba los merges del archivo: fusiona a mano los fragmentos del pre-tokenizador de la biblioteca de tres nombres de productos, primero el par aprendido antes, como lo hace el tokenizador de la tienda, y compara el resultado con los tokens de la biblioteca:
1"""Applies SmolLM2's learned merges by hand, earliest first, to the pieces its pre-tokenizer makes of three product names.2The example asserts that the tokens match the library's, which the prose cites."""3import json45from tokenizers import Tokenizer67smollm2 = Tokenizer.from_file("data/smollm2-tokenizer/tokenizer.json") # the book's pinned copy, read from examples/8spec = json.load(open("data/smollm2-tokenizer/tokenizer.json", encoding="utf-8"))9rank = {tuple(m.split(" ")): i for i, m in enumerate(spec["model"]["merges"])} # lower rank: learned earlier; the file stores each merge as "a b"101112def merge(piece): # apply the learned merges, earliest first, until none applies13 syms = list(piece)14 while len(syms) > 1:15 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 them16 best, i = min(pairs) # the earliest-learned pair; on a tie, the leftmost17 if best == len(rank):18 break19 syms[i:i + 2] = [syms[i] + syms[i + 1]] # the symbols at i and i + 1, joined into one20 return syms212223for name in ["set of 2 barstools", "sled coffee table", "6.5 qt . slow cooker"]:24 # pre_tokenize_str returns (piece, offsets) pairs; only the pieces are merged25 pieces = [p for p, _ in smollm2.pre_tokenizer.pre_tokenize_str(name)] # split into words, digits and bytes26 by_hand = [token for piece in pieces for token in merge(piece)]27 print(name, "->", " ".join(by_hand))28 assert by_hand == smollm2.encode(name).tokens # the library's tokens for the same name29steps = [step["type"] for step in spec["pre_tokenizer"]["pretokenizers"]]30assert spec["pre_tokenizer"]["pretokenizers"][0]["individual_digits"] # the Digits step comes first, and splits digits one at a time31print("pre-tokenizer steps:", ", ".join(steps))
python merges-by-hand.pyset 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
Los tokens hechos a mano coinciden con los de la biblioteca en los tres nombres, lo que el ejemplo verifica. Eso es todo lo que hace el tokenizador de SmolLM2 con estos nombres; también define tokens especiales, que se buscan antes de cualquiera de estos pasos. Se diferencia del de la tienda en su pre-tokenizador y en su texto de entrenamiento, pero codifica el texto fusionando repetidamente el par aprendido antes, como lo hace el de la tienda.
Vale la pena comprobar la coincidencia, porque las diferencias sutiles en la forma de dividir el texto importan más adelante. Un modelo entrenado con un tokenizador y alimentado con los tokens de otro lee sinsentidos sin mostrar ningún error, ya que cada número de token es válido. Lo mismo ocurre, y es más difícil de detectar, cuando una versión de un tokenizador difiere de otra en cómo trata los espacios o los dígitos.
Regla práctica: trata un tokenizador como parte de un modelo: versiónalo junto con el modelo, cárgalo desde los archivos propios del modelo y pruébalo con tu propio texto cada vez que actualices cualquiera de los dos. Cuando dos tokenizadores discrepen en siquiera un token para el mismo texto, averigua por qué antes de confiar en lo que diga un modelo construido sobre ellos.
Qué sale mal en producción
Los tokens determinan lo que un modelo puede ver, y la mayoría de los problemas con el tokenizador aparecen lejos del propio tokenizador:
- Un tokenizador que no coincide falla en silencio. Un modelo al que se le dan los números de token de otro tokenizador lee números válidos que significan cosas incorrectas, y produce disparates con total seguridad. Distribuye el archivo del tokenizador junto con el modelo, y pruébalos juntos.
- Los costos se cuentan en tokens. Los límites de contexto y los precios por token se aplican a tokens, no a palabras. Los nombres de la tienda ocupan 1.55 tokens por palabra en el tokenizador de SmolLM2; un texto lleno de números, códigos u otro idioma ocupa más. Mide tu propio texto.
- Los números son difíciles. Un tokenizador que separa los dígitos hace que un modelo razone sobre
48como dos tokens; uno que no los separa da48y49tokens sin relación entre sí. En cualquier caso, espera que los modelos manejen peor los tamaños y las cantidades que las palabras, y compruébalos por separado. - Los tokens especiales pueden escribirse. Los modelos abiertos marcan el inicio o el final de un texto, o un turno en una conversación, con tokens especiales escritos como cadenas de texto, por ejemplo
<|endoftext|>. Si el texto que escribió un usuario contiene una de esas cadenas y el tokenizador la convierte en el token especial, el modelo lee una señal de control que el usuario no debería poder enviar. Revisa cómo trata tu tokenizador las cadenas de tokens especiales en texto no confiable. - El texto nuevo se aleja del texto de entrenamiento. Un tokenizador entrenado con el catálogo del año pasado divide las líneas de productos de este año en más fragmentos. Mide los tokens por palabra en texto nuevo de vez en cuando; un aumento constante significa que el tokenizador se está quedando atrás de su texto.
Lo que decidió este capítulo
- Los modelos del libro leen el texto de la tienda como tokens de codificación por pares de bytes (BPE). Las palabras dejaban 7.3% de las palabras de validación fuera del vocabulario, y los caracteres hacían que las secuencias fueran 6.0 veces más largas que las palabras. BPE evita ambos problemas: cualquier palabra escrita con caracteres que aparecen en el texto de entrenamiento puede codificarse, y las palabras comunes son tokens únicos. No relaciona palabras entre sí, como
chairychairs; eso le corresponde al capítulo 4. - El tokenizador de la tienda aprende 4,000 fusiones a partir de los nombres y descripciones de la división de entrenamiento, en
lib.bpe.store_tokenizer(). Con ese tamaño, una palabra promedia 1.22 tokens, y pocos tipos de token son demasiado raros para aprenderse. Más fusiones acortan un poco las secuencias y añaden muchos tokens poco frecuentes. - Cada palabra termina en
</w>, así que las fusiones nunca cruzan palabras. Modelos abiertos como SmolLM2, en cambio, adjuntan el espacio a la palabra siguiente; ambos enfoques mantienen visibles los límites de palabra para el modelo. - Los modelos abiertos siempre se usan con sus propios tokenizadores. Un modelo solo entiende los números de token con los que fue entrenado, así que el capítulo 10 lee el modelo de SmolLM2 con el tokenizador que este capítulo desmenuzó, y cada registro de un modelo abierto en este libro indica el tokenizador que utilizó.
- Las perplejidades de tokenizadores distintos no son comparables. Un modelo que predice más tokens, más pequeños, da más pasos y tiene una perplejidad diferente sobre el mismo texto; por eso, cada comparación de modelos en este libro usa el tokenizador de la tienda, y el capítulo 3 vuelve a empezar esa comparación con sus tokens.
Este capítulo, en esta edición
Edición 2026.11.16Ejemplos verificados el 19 de nov de 2026Superan la prueba 7 de 7 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.16.