Qué lee de verdad una IA: los tokens, explicados con código
En esta página
- Una pregunta de niño de seis años
- Por qué no letras, y por qué no palabras
- BPE: el algoritmo que fabrica los tokens
- Un tokenizador de verdad
- Cuatro consecuencias que puedes comprobar
- 1. Contar letras es difícil
- 2. Los números no se ven como números
- 3. No todos los idiomas cuestan lo mismo
- 4. Dos textos idénticos para ti, distintos para el modelo
- Lo que hemos visto
Una pregunta de niño de seis años#
Pregúntale a un niño cuántas erres tiene strawberry y las contará con el dedo: tres. Durante una temporada, esa misma pregunta fue una de las formas más fáciles de hacer fallar a un modelo de lenguaje, el tipo de IA que hay detrás de los asistentes de chat. Modelos capaces de escribir código o resumir un contrato contestaban "dos" con total seguridad.
No era falta de inteligencia. Era un problema de vista: el modelo nunca vio las letras de strawberry. Vio esto:
['st', 'raw', 'berry']Tres trozos, y ninguno es una letra. Esos trozos se llaman tokens, y son lo único que un modelo de lenguaje lee y lo único que escribe. Todo lo demás (lo que entiende, lo que cuesta usarlo, cuánto texto le cabe, algunos de sus fallos más raros) parte de aquí.
Esta es la primera parte de una serie para entender la IA por dentro, poco a poco y sin magia: cada pieza se explica con código pequeño que puedes ejecutar tú. Empezamos por la entrada del modelo: cómo se convierte un texto en números.
Un modelo de lenguaje no lee letras ni palabras: lee tokens, trozos de texto de tamaño variable, cada uno con un número de identificación. Primero se trocea el texto y luego el modelo trabaja solo con esos números.
Por qué no letras, y por qué no palabras#
Un modelo de lenguaje necesita un vocabulario: una lista cerrada de piezas, cada una con su número. Hay dos opciones obvias, y las dos son malas.
Usar letras. El vocabulario sería diminuto (unas pocas decenas de símbolos) y cualquier texto se podría escribir. Pero cada frase se convertiría en una secuencia larguísima, y la longitud es justo lo que más le cuesta a un modelo: tiene que relacionar cada pieza con las demás, así que el trabajo crece muy deprisa con cada símbolo extra. Además, una letra sola no significa nada; el modelo gastaría buena parte de su esfuerzo en reconstruir palabras.
Usar palabras. Las secuencias serían cortas y cada pieza tendría significado. Pero el vocabulario sería inmenso: gato, gatos, gata, gatas, gatito... En español, cada verbo tiene decenas de formas. Y siempre aparecería una palabra que no está en la lista (un nombre propio, una errata, un término técnico nuevo) y el modelo no tendría forma de representarla.
| Letras | Palabras | Tokens (subpalabras) | |
|---|---|---|---|
| Tamaño del vocabulario | Decenas | Millones | Decenas o cientos de miles |
| Longitud de un texto | Muy larga | Corta | Intermedia |
| Palabras desconocidas | Nunca | Constantemente | Nunca |
| Cada pieza significa algo | No | Sí | Casi siempre |
La solución que usan hoy prácticamente todos los modelos está en el medio: subpalabras. Las palabras frecuentes son un solo token; las raras se parten en trozos más pequeños; y en el peor caso, cualquier cosa se puede escribir con piezas mínimas. Se gana lo bueno de las dos opciones. La pregunta es cómo se decide qué trozos entran en el vocabulario.
BPE: el algoritmo que fabrica los tokens#
El método más usado se llama BPE (Byte Pair Encoding). Nació en 1994 como algoritmo de compresión de datos, publicado por Philip Gage, y en 2016 un grupo de la Universidad de Edimburgo lo adaptó para partir palabras en traducción automática. La idea cabe en una línea:
Empieza con letras sueltas y, una y otra vez, junta la pareja de símbolos vecinos que más se repite.
Nadie decide a mano que gat o mente sean tokens: salen solos de las estadísticas del texto de entrenamiento. Lo que más se repite acaba siendo una pieza.
Este programa lo implementa desde cero, sin librerías, y lo entrena con un corpus de juguete de tres frases:
# python3 bpe.py
from collections import Counter
def entrenar(texto: str, fusiones: int):
# Cada palabra empieza partida en letras sueltas
palabras = Counter(tuple(p) for p in texto.split())
reglas = []
for _ in range(fusiones):
# Contar qué pareja de símbolos vecinos aparece más
parejas = Counter()
for palabra, n in palabras.items():
for a, b in zip(palabra, palabra[1:]):
parejas[a, b] += n
if not parejas:
break
(a, b), n = parejas.most_common(1)[0]
reglas.append((a, b))
print(f"{len(reglas):>2}. {a!r} + {b!r} -> {a + b!r} ({n} veces)")
# Sustituir esa pareja por un símbolo nuevo en todo el corpus
palabras = Counter({fusionar(p, a, b): n
for p, n in palabras.items()})
return reglas
def fusionar(palabra, a, b):
salida, i = [], 0
while i < len(palabra):
if palabra[i:i + 2] == (a, b):
salida.append(a + b)
i += 2
else:
salida.append(palabra[i])
i += 1
return tuple(salida)
def tokenizar(palabra: str, reglas):
simbolos = tuple(palabra)
for a, b in reglas: # mismas fusiones, mismo orden
simbolos = fusionar(simbolos, a, b)
return list(simbolos)
corpus = """el gato come pescado el gato duerme la gata come
los gatos comen pescado las gatas duermen el perro come
los perros comen carne el perro duerme mucho"""
reglas = entrenar(corpus, 10)
for p in ["gatos", "perras", "comemos", "garaje"]:
print(f"{p:>8} -> {tokenizar(p, reglas)}")$ python3 bpe.py
1. 'm' + 'e' -> 'me' (8 veces)
2. 'e' + 'r' -> 'er' (6 veces)
3. 'g' + 'a' -> 'ga' (5 veces)
4. 'ga' + 't' -> 'gat' (5 veces)
5. 'c' + 'o' -> 'co' (5 veces)
6. 'co' + 'me' -> 'come' (5 veces)
7. 'e' + 'l' -> 'el' (4 veces)
8. 'o' + 's' -> 'os' (4 veces)
9. 'c' + 'a' -> 'ca' (3 veces)
10. 'd' + 'u' -> 'du' (3 veces)
gatos -> ['gat', 'os']
perras -> ['p', 'er', 'r', 'a', 's']
comemos -> ['come', 'm', 'os']
garaje -> ['ga', 'r', 'a', 'j', 'e']Merece la pena leer la salida despacio, porque ahí está todo:
- El vocabulario se construye solo. Con diez fusiones, el algoritmo ha descubierto la raíz
gat, el verbocomey la terminaciónos. Nadie le ha explicado gramática; simplemente son las secuencias que más se repiten. - Las fusiones se encadenan. La regla 4 (
ga+t) solo existe porque antes la regla 3 creóga. Así, a base de repetir, aparecen piezas cada vez más largas. - No hay palabras desconocidas. Perras y comemos no estaban en el corpus, y aun así se tokenizan: se aprovechan los trozos conocidos (
come,os,er) y el resto queda en letras sueltas. - Lo raro sale caro. Garaje no se parece a nada del corpus y acaba en cinco tokens. Lo frecuente es barato y lo raro, caro; vas a ver esta regla en cada sección de esta entrada.
Los tokenizadores de los modelos reales no empiezan por letras sino por bytes: los 256 valores posibles. Como cualquier texto (en cualquier idioma, con emojis o con caracteres raros) se puede escribir en bytes, no existe ningún texto que no se pueda tokenizar. Además se entrenan con cantidades enormes de texto y hacen cientos de miles de fusiones, no diez. Pero el mecanismo es exactamente este.
Un tokenizador de verdad#
Para ver uno real usaremos tiktoken, la librería abierta con la que OpenAI publica los tokenizadores de sus modelos. Trae, entre otros, o200k_base, un vocabulario de unos 200.000 tokens que, según la propia librería, usan GPT-4o, GPT-4.1, GPT-5 y los modelos de la serie o. La primera vez que lo usas, tiktoken descarga el vocabulario; todo lo de esta entrada está probado con tiktoken 0.14.0.
No todos los fabricantes publican el suyo. Anthropic, por ejemplo, no ofrece su tokenizador para descargar, sino un servicio de su API que cuenta los tokens de un texto para un modelo concreto. Los detalles cambian de un fabricante a otro, pero la idea de fondo es la misma.
# pip install tiktoken · python3 tokens.py
import tiktoken
enc = tiktoken.get_encoding("o200k_base")
def ver(texto: str):
ids = enc.encode(texto)
trozos = [enc.decode([i]) for i in ids]
print(f"{texto!r:>12} n={len(ids)} {ids} {trozos}")
for t in ["strawberry", "fresa", "hola", " hola", "Hola", "HOLA"]:
ver(t)$ python3 tokens.py
'strawberry' n=3 [302, 1618, 19772] ['st', 'raw', 'berry']
'fresa' n=2 [69, 17351] ['f', 'resa']
'hola' n=1 [122845] ['hola']
' hola' n=1 [171847] [' hola']
'Hola' n=1 [49864] ['Hola']
'HOLA' n=2 [39, 87254] ['H', 'OLA']La columna de números es lo que el modelo recibe de verdad. No recibe "hola": recibe 122845.
Y fíjate en las cuatro últimas líneas. Para una persona, hola, Hola, HOLA y hola con un espacio delante son la misma palabra. Para el modelo son números distintos sin ninguna relación entre sí: 122845 no se parece a 49864 más que a cualquier otro número. El espacio forma parte del token ( hola es la forma que aparece en mitad de una frase) y las mayúsculas cambian el trozo entero.
Entonces, ¿cómo sabe un modelo que todas son la misma palabra? Lo aprende durante el entrenamiento, viéndolas aparecer en los mismos contextos millones de veces. Cómo guarda ese parecido un modelo cuyo único material son números es el tema de la siguiente parte de la serie.
Cuatro consecuencias que puedes comprobar#
1. Contar letras es difícil#
Volvamos a strawberry. El modelo recibe [302, 1618, 19772]. Para contar las erres tendría que saber de memoria qué letras forman el token 1618 (raw) y el 19772 (berry). Esa información no está en el número: solo la ha podido aprender de forma indirecta, de textos donde alguien deletrea esas palabras.
Por eso las preguntas sobre la forma de las palabras (contar letras, invertir una palabra, hacer rimas o anagramas) son más difíciles para un modelo que para una persona, aunque las preguntas sobre su significado le resulten fáciles. Los modelos actuales fallan mucho menos, sobre todo los que pueden "pensar" en voz alta antes de responder: suelen deletrear la palabra letra por letra, y cada letra pasa a ser su propio token. Esto no cambia cómo ven el texto; han aprendido a rodear el problema.
2. Los números no se ven como números#
import tiktoken
enc = tiktoken.get_encoding("o200k_base")
for t in ["2+2=4", "12345+67890", "1000000", "1.000.000"]:
print(f"{t:>12} -> {[enc.decode([i]) for i in enc.encode(t)]}") 2+2=4 -> ['2', '+', '2', '=', '4']
12345+67890 -> ['123', '45', '+', '678', '90']
1000000 -> ['100', '000', '0']
1.000.000 -> ['1', '.', '000', '.', '000']Este tokenizador agrupa las cifras de tres en tres, empezando por la izquierda. Para el modelo, un millón escrito sin puntos es "cien, cero cero cero, cero". Y en 12345 + 67890 las cifras quedan desalineadas: las unidades de un número caen en un token de dos cifras (45) y las del otro, en otro (90). Sumar así es como hacer una suma en papel con los números mal colocados en columna.
Por eso, para cálculos exactos, lo correcto es que el modelo no calcule "de cabeza", sino que use una herramienta (una calculadora o un fragmento de código) y lea el resultado. Veremos cómo funciona eso en la parte de la serie dedicada a los agentes.
3. No todos los idiomas cuestan lo mismo#
Los tokens son la unidad con la que se mide todo en un modelo de lenguaje: las APIs cobran por token, el texto máximo que admite un modelo (su ventana de contexto) se mide en tokens y la velocidad de respuesta, también. Así que importa cuántos tokens ocupa lo que escribes.
Para medirlo he cogido los dos primeros párrafos de otra entrada de este blog, De Ring 3 a Ring 0, en español y en su versión en inglés, y he contado los tokens con dos tokenizadores de OpenAI: cl100k_base, el de GPT-4 y GPT-3.5, y o200k_base, el de sus modelos actuales. Son los párrafos que abren esa entrada en cada idioma, copiados tal cual (sin el formato Markdown) en dos archivos de texto.
import tiktoken
es = open("parrafo_es.txt", encoding="utf-8").read()
en = open("parrafo_en.txt", encoding="utf-8").read()
for nombre in ["cl100k_base", "o200k_base"]:
enc = tiktoken.get_encoding(nombre)
n_es, n_en = len(enc.encode(es)), len(enc.encode(en))
print(f"{nombre:<12} vocabulario={enc.n_vocab:>7,} "
f"ES={n_es} EN={n_en} ES/EN={n_es / n_en:.2f}")cl100k_base vocabulario=100,277 ES=129 EN=102 ES/EN=1.26
o200k_base vocabulario=200,019 ES=111 EN=103 ES/EN=1.08Con el tokenizador antiguo, el mismo contenido en español ocupaba un 26 % más de tokens que en inglés: era un 26 % más caro y más lento de procesar, y en la misma ventana de contexto cabía un 21 % menos de texto. La razón es BPE: si en los textos de entrenamiento hay mucho más inglés, las fusiones favorecen las palabras inglesas, y el español queda más troceado. Con un vocabulario del doble de tamaño hay sitio para más piezas en español, y la diferencia en estos párrafos baja al 8 %.
Son dos párrafos, no un estudio. Pero la tendencia es real y está medida. Un trabajo de 2023 de la Universidad de Oxford tokenizó la misma traducción en cerca de doscientos idiomas. Con el tokenizador de GPT-4 (cl100k_base), el español necesitaba un 55 % más de tokens que el inglés, e incluso los idiomas más baratos, como el portugués o el alemán, rondaban el 50 % más. En el otro extremo, el shan, una lengua de Myanmar, llegaba a necesitar 15 veces más. Mis párrafos salen por debajo de ese 55 % porque son texto técnico, lleno de palabras que ya están en inglés: CPU, kernel, Ctrl+S.
Y el tokenizador no es para siempre: cambia entre generaciones de modelos. Anthropic avisa en su documentación de que, desde Claude Opus 4.7, el mismo texto produce alrededor de un 30 % más de tokens que con sus modelos anteriores, y recomienda volver a contar los prompts con el modelo que vayas a usar en lugar de reutilizar cifras antiguas. Con el mismo precio por token, eso cambia lo que pagas y cuánto texto cabe. Ojo, la comparación es entre tokenizadores de una misma empresa: no dice nada de si un fabricante sale más caro que otro.
4. Dos textos idénticos para ti, distintos para el modelo#
Este es el lado que interesa en seguridad. Mira estas tres palabras:
import tiktoken
enc = tiktoken.get_encoding("o200k_base")
variantes = {
"normal": "contraseña",
"espacio invisible": "contra\u200bseña", # U+200B
"'o' cirílica": "c\u043entraseña", # U+043E
}
for nombre, t in variantes.items():
trozos = [enc.decode([i]) for i in enc.encode(t)]
print(f"{nombre:<18} {t} -> {trozos}")normal contraseña -> ['contr', 'aseña']
espacio invisible contraseña -> ['contra', '\u200b', 'se', 'ña']
'o' cirílica cоntraseña -> ['c', 'о', 'n', 'tr', 'aseña']En pantalla, las tres dicen contraseña. Pero la segunda lleva dentro un carácter invisible (U+200B, un espacio de ancho cero) y la tercera cambia la o latina por una о cirílica, que se dibuja igual. Para el tokenizador son tres secuencias completamente distintas.
Las consecuencias en seguridad son directas:
- Un filtro de palabras prohibidas que compara texto no ve ninguna de las dos variantes. Si un sistema bloquea la palabra contraseña buscándola tal cual, el carácter invisible o la letra cirílica se la saltan, y el texto sigue siendo legible para una persona.
- El modelo, en cambio, a menudo sí entiende la variante. Ha visto suficientes textos con erratas y caracteres raros como para reconstruir el significado. El resultado es una situación incómoda: el filtro no detecta nada y el modelo puede entender el mensaje igualmente.
- No es un truco nuevo. Es el mismo que usan los dominios falsos con letras parecidas para hacerse pasar por un banco, y el propio Consorcio Unicode documenta cómo detectarlo.
La primera defensa que se le ocurre a casi todo el mundo es normalizar el texto: Unicode define formas estándar (NFC, NFKC) para que caracteres equivalentes se escriban igual. Pero no basta. Este programa lo comprueba:
import unicodedata
def limpiar(texto: str) -> str:
texto = unicodedata.normalize("NFKC", texto)
# Quitar caracteres de formato invisibles (categoría Cf)
return "".join(c for c in texto
if unicodedata.category(c) != "Cf")
def alfabetos(texto: str) -> set[str]:
# Primera palabra del nombre Unicode: LATIN, CYRILLIC...
return {unicodedata.name(c).split()[0]
for c in texto if c.isalpha()}
for t in ["contraseña", "contraseña", "cоntraseña"]:
nfkc = unicodedata.normalize("NFKC", t)
print(f"{t!r:<20} NFKC={nfkc == 'contraseña'!s:<5} "
f"limpio={limpiar(t) == 'contraseña'!s:<5} "
f"{sorted(alfabetos(t))}")'contraseña' NFKC=True limpio=True ['LATIN']
'contra\u200bseña' NFKC=False limpio=True ['LATIN']
'cоntraseña' NFKC=False limpio=False ['CYRILLIC', 'LATIN']La normalización no arregla ninguna de las dos variantes: la о cirílica es una letra distinta, no una forma alternativa de la latina, y el espacio invisible sobrevive. Hacen falta dos medidas más:
- Quitar los caracteres de formato invisibles (la categoría
Cfde Unicode) arregla el primer caso. Con cuidado: algunos de esos caracteres son legítimos, por ejemplo los que unen emojis compuestos o los que necesitan escrituras como el árabe o el hindi. - Detectar palabras que mezclan alfabetos delata el segundo caso. Una palabra con letras latinas y cirílicas a la vez casi nunca es legítima. El estándar de seguridad de Unicode (UTS #39) va más allá: incluye una tabla de caracteres que se confunden entre sí para comparar textos por su aspecto.
Si construyes algo encima de un modelo de lenguaje, recuerda que el modelo procesa los tokens, no lo que se ve en pantalla. Cualquier control que dependa de comparar texto (palabras prohibidas, listas de comandos permitidos, detección de datos sensibles) tiene que limpiar el texto antes: normalizarlo, quitar los caracteres invisibles y vigilar los alfabetos mezclados. Y aun así, un filtro de palabras es una defensa débil: tómalo como una capa más, nunca como la única.
Lo que hemos visto#
- Un modelo de lenguaje no lee letras ni palabras: lee tokens, trozos de texto con un número asignado. Su entrada y su salida son, literalmente, listas de números.
- Los tokens se fabrican con BPE: empezar con piezas mínimas y juntar una y otra vez la pareja más frecuente. Lo que más se repite en el texto de entrenamiento acaba siendo un solo token.
- Lo frecuente es barato y lo raro, caro. Eso explica que a los modelos les cueste contar letras y operar con números, y que algunos idiomas ocupen más tokens que otros.
- Dos textos idénticos en pantalla pueden ser distintos para el tokenizador, y eso tiene consecuencias de seguridad.
Queda una pregunta abierta: si para el modelo hola es el 122845 y Hola es el 49864, ¿cómo llega a saber que son la misma palabra, o que gato se parece más a perro que a contrato? La respuesta son los embeddings: la forma en que cada número se convierte en un punto en un espacio donde las palabras parecidas quedan cerca. Es la siguiente parte de la serie.
Referencias
- Neural Machine Translation of Rare Words with Subword Units (Sennrich, Haddow y Birch, 2016)arXiv · arxiv.org
- Language Models are Unsupervised Multitask Learners (Radford et al., 2019)OpenAI · cdn.openai.com
- tiktoken: a fast BPE tokeniser for use with OpenAI's modelsGitHub · github.com
- Language Model Tokenizers Introduce Unfairness Between Languages (Petrov et al., 2023)arXiv · arxiv.org
- tiktoken/model.py: qué codificación usa cada modeloGitHub · github.com
- Token counting (Claude API)Anthropic · platform.claude.com
- A New Algorithm for Data Compression (Gage, 1994)The C Users Journal · jacobfilipp.com
- Unicode Technical Standard #39: Unicode Security MechanismsUnicode Consortium · unicode.org
- Unicode Standard Annex #15: Unicode Normalization FormsUnicode Consortium · unicode.org
Compartir
¿Quieres formar a tu equipo en IA?
Diseño formaciones prácticas en IA para equipos y directivos, adaptadas a vuestro sector y a las herramientas que ya usáis, con materiales y seguimiento posterior.
Hablemos→
Comentarios
Para comentar necesitas una cuenta de GitHub. Los comentarios se guardan en GitHub Discussions (SoftDryzz/blog-comments) y se moderan: no se publican enlaces promocionales.