Lección 17 · 05 Por dentro de un LLM

Las piezas de un tokenizador

Un LLM no lee letras, lee números. En esta lección programas las tres piezas con las que se fabrica un tokenizador BPE, el mismo método que usan los modelos de verdad.

Del texto a los números

En la sección anterior usaste contar_tokens(), que estima un token cada 4 caracteres. Es una aproximación. Lo que hace de verdad un modelo es pasar el texto por un tokenizador: un programa que lo trocea en piezas y le da a cada pieza un número.

El primer paso es convertir el texto en bytes con UTF-8. Cada byte es un número entre 0 y 255:

texto = "Hola, ñu 🌍"
datos = texto.encode("utf-8")
print(list(datos))
print(len(texto), "caracteres →", len(datos), "bytes")

Las letras normales ocupan 1 byte, la ñ ocupa 2 y el emoji, 4. Con solo 256 números ya puedes escribir cualquier texto en cualquier idioma: nunca aparece una palabra «desconocida».

// reto 01

Caracteres frente a bytes

Guarda en n_caracteres cuántos caracteres tiene texto y en n_bytes cuántos bytes ocupa en UTF-8.

main.py
Ctrl/⌘ + Enter
¿Atascado? Ver pista

len(texto) cuenta caracteres y len(texto.encode("utf-8")) cuenta bytes.

$ python main.py

    El problema: demasiados números

    Trabajar byte a byte funciona, pero las secuencias salen larguísimas, y un modelo cuesta más cuanto más largas son. La idea de BPE (Byte Pair Encoding) es sencilla:

    1. Busca la pareja de números vecinos que más se repite.
    2. Sustitúyela por un número nuevo (256, 257, 258…).
    3. Repite.

    Cada vuelta, el texto se acorta un poco y el vocabulario gana una pieza. Contar parejas es fácil con zip y Counter:

    from collections import Counter
    
    ids = list("abab c".encode("utf-8"))
    print(ids)
    print(Counter(zip(ids, ids[1:])).most_common(3))

    zip(ids, ids[1:]) empareja cada número con el siguiente.

    // reto 02

    La pareja más frecuente

    Define par_mas_frecuente(ids) que devuelva la pareja de vecinos que más se repite. Si hay empate, la menor (la que sale primero al ordenar). Si no hay parejas, None.

    main.py
    Ctrl/⌘ + Enter
    ¿Atascado? Ver pista
    cuenta = Counter(zip(ids, ids[1:]))
    if not cuenta:
        return None
    maximo = max(cuenta.values())
    return min(par for par, n in cuenta.items() if n == maximo)

    El desempate con min hace que el resultado sea siempre el mismo: el tokenizador sale idéntico cada vez que lo entrenas.

    $ python main.py

      Fusionar

      La segunda pieza recorre la lista de izquierda a derecha y cambia cada aparición de la pareja por el número nuevo. Ojo con los solapes: en [1, 1, 1] la pareja (1, 1) se fusiona una vez y sobra un 1.

      // reto 03

      Fusionar una pareja

      Define fusionar(ids, par, nuevo) que devuelva una lista nueva en la que cada aparición de par (de izquierda a derecha, sin solapes) se cambia por nuevo.

      main.py
      Ctrl/⌘ + Enter
      ¿Atascado? Ver pista
      resultado = []
      i = 0
      while i < len(ids):
          if i + 1 < len(ids) and (ids[i], ids[i + 1]) == par:
              resultado.append(nuevo)
              i += 2
          else:
              resultado.append(ids[i])
              i += 1
      return resultado
      $ python main.py

        Con estas tres piezas (bytes, pareja más frecuente y fusión) ya tienes todo lo necesario. En la lección siguiente las juntas para entrenar tu propio tokenizador.