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.

// reto 01

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.

main.py
Ctrl/⌘ + Enter
¿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 fusiones
$ python main.py

    Codificar 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.

    // reto 02

    Ida y vuelta sin pérdidas

    Define codificar(texto, fusiones) y decodificar(ids, fusiones). El texto decodificado tiene que ser idéntico al original.

    main.py
    Ctrl/⌘ + Enter
    ¿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")
    $ python main.py

      ¿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.

      // reto 03

      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.

      main.py
      Ctrl/⌘ + Enter
      ¿Atascado? Ver pista
      fusiones = entrenar(corpus, 40)
      ids = codificar(corpus, fusiones)
      ratio = round(len(corpus.encode("utf-8")) / len(ids), 2)
      print(ratio)
      $ python main.py

        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.