Lección 18 · 05 Por dentro de un LLM
Entrena tu propio tokenizador
Juntas las piezas de la lección anterior en un tokenizador completo: lo entrenas con un texto, lo usas para codificar y decodificar y mides cuánto acorta las secuencias.
Entrenar es repetir
Entrenar un tokenizador BPE es repetir la misma vuelta un número fijo de veces: buscar la pareja más frecuente, fusionarla y apuntarla. La lista de fusiones apuntadas, en orden, es el tokenizador.
from collections import Counter
ids = list("aaab".encode("utf-8"))
print("inicio:", ids)
cuenta = Counter(zip(ids, ids[1:]))
print("parejas:", cuenta)La pareja (97, 97) («aa») gana: se convierte en el token 256.
El bucle de entrenamiento
Define entrenar(texto, n_fusiones) que pase el texto a bytes y repita n_fusiones veces: busca la pareja más frecuente, apúntala en la lista fusiones y fusiónala con el número 256 + vuelta. Si ya no quedan parejas, para. Devuelve fusiones.
¿Atascado? Ver pista
ids = list(texto.encode("utf-8"))
fusiones = []
for vuelta in range(n_fusiones):
par = par_mas_frecuente(ids)
if par is None:
break
fusiones.append(par)
ids = fusionar(ids, par, 256 + vuelta)
return fusionesCodificar y decodificar
Para codificar un texto nuevo, pásalo a bytes y aplica las fusiones en el mismo orden en que se aprendieron. Para decodificar, construye una tabla que diga qué bytes representa cada número: los 256 primeros son ellos mismos y cada token nuevo es la unión de los dos que fusiona.
Lo importante es que el viaje de ida y vuelta no pierde nada, ni con emojis ni con palabras que el tokenizador no vio al entrenar: en el peor caso, se queda en bytes sueltos.
Ida y vuelta sin pérdidas
Define codificar(texto, fusiones) y decodificar(ids, fusiones). El texto decodificado tiene que ser idéntico al original.
¿Atascado? Ver pista
def codificar(texto, fusiones):
ids = list(texto.encode("utf-8"))
for i, par in enumerate(fusiones):
ids = fusionar(ids, par, 256 + i)
return ids
def decodificar(ids, fusiones):
tabla = [bytes([b]) for b in range(256)]
for izquierda, derecha in fusiones:
tabla.append(tabla[izquierda] + tabla[derecha])
return b"".join(tabla[t] for t in ids).decode("utf-8")¿Cuánto comprime?
La medida más sencilla es cuántos bytes caben, de media, en cada token: bytes del texto entre número de tokens. Cuanto más alto, más corto le llega el texto al modelo y menos cuesta procesarlo.
Mide la compresión
Entrena con corpus 40 fusiones, codifica el mismo corpus y guarda en ratio los bytes por token, redondeado a 2 decimales. Imprime ratio.
¿Atascado? Ver pista
fusiones = entrenar(corpus, 40)
ids = codificar(corpus, fusiones)
ratio = round(len(corpus.encode("utf-8")) / len(ids), 2)
print(ratio)Trampa: medir con los datos de entrenamiento
Ese 2.05 es optimista: mides con el mismo texto con el que entrenaste, así que el tokenizador ya conoce sus palabras. Para una medida honesta, entrena con un texto y mide con otro distinto. Es la misma regla que en cualquier modelo: no se evalúa con los datos de entrenamiento.
Los tokenizadores de los LLM reales hacen esto mismo a lo grande: aprenden de decenas de miles a unos 200.000 tokens con muchísimo texto, y antes trocean por palabras y espacios con expresiones regulares. Por eso en texto normal salen unos 4 caracteres por token, y por eso en español o con código la cuenta cambia.