Tokens: el alfabeto del modelo

BPE paso a paso

Sea un corpus de palabras con frecuencias $f(w)$ y un alfabeto inicial $V_0$. En cada vuelta se cuenta cuántas veces aparece cada pareja de piezas vecinas $(a,b)$, pesando por la frecuencia de la palabra:

Se elige $(a^*,b^*)=\arg\max_{(a,b)}\operatorname{cuenta}(a,b)$, se sustituye esa pareja por una pieza nueva en todo el corpus y se añade al vocabulario: $V_{t+1}=V_t\cup\{a^*b^*\}$. Tras $M$ fusiones, $|V|=|V_0|+M$. Para tokenizar un texto nuevo se aplican las fusiones en el orden en que se aprendieron. La idea viene de un algoritmo de compresión (Gage, 1994) que reemplazaba la pareja de bytes más frecuente por un byte sin usar; Sennrich, Haddow y Birch (2016) la adaptaron para partir las palabras raras en traducción automática, fusionando letras en lugar de bytes. No es el único método para armar un vocabulario, pero es el que usan GPT-2, Llama 2 y los tokenizadores de OpenAI (tiktoken es un tokenizador BPE).

En el ejemplo pequeño de la escena (gato ×5, gatos ×3, pato ×4, patos ×2, gatita ×1), la pareja «a t» suma $5+3+4+2+1=15$ y gana; después «at o» suma $14$; luego nacen gato (8), pato (6), gatos (3) y patos (2). «Gatita» se queda en g · at · i · t · a porque ninguna de sus parejas llega a aparecer dos veces.

Bytes: por qué nada queda fuera

Los tokenizadores de GPT-2 en adelante parten de los $256$ valores posibles de un byte. En la codificación UTF-8, una letra sin acento ocupa un byte, una letra con acento como «ó» o «ñ» ocupa dos y muchos emojis ocupan cuatro, así que cualquier texto se puede escribir con esas $256$ piezas: lo que el vocabulario no cubre baja a bytes sueltos. Por eso, en la escena, la «ó» de Quetzalcóatl aparece al principio como dos piezas (los bytes 195 y 179) unidas por un borde punteado. Antes de fusionar, GPT-2 corta el texto en trozos (una palabra con su espacio inicial, un número, unos signos) y las fusiones nunca cruzan de un trozo a otro, para no llenar el vocabulario de variantes como «dog.», «dog!» y «dog?». Por eso muchas piezas llevan pegado el espacio de delante: « gato» y «gato» son tokens distintos. En la escena omitimos ese espacio al dibujar los cortes de GPT-4o, para que se lean mejor.

El tokenizador de juguete de la lección es un BPE a nivel de bytes con esa misma pretokenización, entrenado con unas mil setecientas palabras escritas para el curso (casi todas en inglés): $|V_0|=256$ y $M=400$, así que $|V|=656$. GPT-2 usa $256$ bytes, $50\,000$ fusiones y un símbolo especial de fin de texto: $256+50\,000+1=50\,257$, la cifra que da su artículo.

Tamaño del vocabulario

Cada pieza necesita una fila en la tabla de embeddings $E\in\mathbb{R}^{|V|\times d}$, es decir, $|V|\cdot d$ parámetros, y la capa final del modelo produce una puntuación por pieza. Con $|V|=50\,257$ y $d=768$ (el GPT-2 más pequeño), la tabla tiene $50\,257\times 768\approx 38.6$ millones de parámetros. A cambio, un vocabulario mayor comprime más: el informe de Llama 3 dice que su vocabulario de 128 mil piezas (frente a las 32 mil de Llama 2) sube de 3.17 a 3.94 los caracteres por token en una muestra de inglés.

Costo

Con precios por millón de tokens distintos para entrada ($p_{\text{ent}}$) y salida ($p_{\text{sal}}$):

Para inglés, $n\approx \text{palabras}/0.75$. Ejemplo con un precio supuesto de 2 dólares por millón: un informe de 3 000 palabras son unos 4 000 tokens; mil informes, 4 millones de tokens y 8 dólares. En la lista de precios de Anthropic (consultada en octubre de 2026), los tokens de salida cuestan cinco veces los de entrada en todos los modelos de la tabla.

El idioma, medido

Con las 1 012 frases paralelas en inglés y español del conjunto FLORES-200 (devtest), contadas con tiktoken 0.14.0:

tokenizador	inglés	español	razón
GPT-2 (gpt2)	27 044	53 578	1.98
GPT-4 (cl100k_base)	27 182	41 974	1.54
GPT-4o (o200k_base)	26 873	35 415	1.32

Parte de la diferencia es que la traducción al español usa más palabras (26 081 frente a 21 901); el resto, que cada palabra en español se parte en más piezas. En inglés salen 0.81 palabras por token, cerca de la regla práctica de ¾. Petrov et al. (2023) midieron diferencias de hasta quince veces entre idiomas para un mismo texto traducido. Las cuatro frases del «tu turno» las escribimos nosotros: sirven para ilustrar, no para presupuestar.

Por qué fallan las letras y las cifras

El modelo recibe identificadores, no caracteres: tiene que haber aprendido de los datos cómo se escribe cada pieza. Con el tokenizador de GPT-4o, « carretera» y « strawberry» (con su espacio inicial, como aparecen dentro de una pregunta) son un solo token cada uno. Edman, Schmid y Fraser (2024) encontraron que la mayoría de los modelos parecen conocer la ortografía de sus tokens, pero no la usan bien para manipular texto. Con los números, GPT-3.5 y GPT-4 tienen tokens para cada número de una, dos y tres cifras y cortan de izquierda a derecha; Singh y Strouse (2024) encontraron que forzar el corte de derecha a izquierda (separando los miles con comas) mejora mucho la aritmética. Llama 2, en cambio, parte todos los números en cifras sueltas.

En código

Un BPE completo en veinte líneas de Python, sobre el corpus de la animación:

from collections import Counter

def entrenar_bpe(palabras, max_fusiones):
    """palabras: {palabra: frecuencia}. Devuelve las fusiones (a, b, cuenta) y cómo queda cada palabra."""
    piezas = {w: list(w) for w in palabras}
    fusiones = []
    for _ in range(max_fusiones):
        cuentas = Counter()
        for w, p in piezas.items():
            for a, b in zip(p, p[1:]):
                cuentas[(a, b)] += palabras[w]          # pesa por la frecuencia de la palabra
        if not cuentas or max(cuentas.values()) < 2:
            break
        a, b = min(cuentas, key=lambda par: (-cuentas[par], par))   # la más frecuente; empate: orden alfabético
        fusiones.append((a, b, cuentas[(a, b)]))
        for p in piezas.values():
            i = 0
            while i < len(p) - 1:
                if p[i] == a and p[i + 1] == b:
                    p[i:i + 2] = [a + b]
                else:
                    i += 1
    return fusiones, piezas

corpus = {"gato": 5, "gatos": 3, "pato": 4, "patos": 2, "gatita": 1}
fusiones, piezas = entrenar_bpe(corpus, 10)
for a, b, n in fusiones:
    print(f"{a} + {b} -> {a + b}  ({n} veces)")
print(piezas["gatos"], piezas["gatita"])
# a + t -> at  (15 veces)
# at + o -> ato  (14 veces)
# g + ato -> gato  (8 veces)
# p + ato -> pato  (6 veces)
# gato + s -> gatos  (3 veces)
# pato + s -> patos  (2 veces)
# ['gatos'] ['g', 'at', 'i', 't', 'a']

Y con un tokenizador real (pip install tiktoken; salida medida con la versión 0.14.0):

import tiktoken

enc = tiktoken.get_encoding("o200k_base")          # el tokenizador de GPT-4o
for texto in ["Mi gato se llama Quetzalcóatl.", "¿Cuántas erres tiene carretera?", "1234567"]:
    ids = enc.encode(texto)
    print(len(ids), ids, [enc.decode([i]) for i in ids])
print(enc.n_vocab)
# 10 [28716, 99767, 458, 69693, 3106, 21156, 27187, 531, 69282, 13] ['Mi', ' gato', ' se', ' llama', ' Qu', 'etz', 'alc', 'ó', 'atl', '.']
# 8 [102091, 41826, 288, 1111, 430, 10647, 96244, 30] ['¿Cu', 'ánt', 'as', ' er', 'res', ' tiene', ' carretera', '?']
# 3 [7633, 19354, 22] ['123', '456', '7']
# 200019

Lo que viene

Cada número de token selecciona una fila de la tabla de embeddings (lección 14); a partir de ahí el modelo solo ve vectores. En la lección 21 veremos cómo cada token decide a cuáles otros mirar (atención). El costo de generar token por token vuelve en la lección 26 (inferencia), y el tamaño del contexto, también medido en tokens, en la lección 30.