Lección 21 · 06 Tu mini modelo de lenguaje

Entrena un modelo de lenguaje

Entrenar un modelo es repetir millones de veces un gesto pequeño: predecir, medir cuánto te has equivocado y corregir un poco. Lo programas con un modelo que predice la siguiente letra.

El modelo más pequeño posible

Para ver el entrenamiento sin ruido usamos el modelo de lenguaje más sencillo: uno que predice la siguiente letra mirando solo la anterior (un modelo de bigramas). Guarda una tabla W con una fila por letra; en cada fila, una puntuación para cada letra que puede venir detrás. Softmax convierte la fila en probabilidades.

GPT hace lo mismo, pero sus puntuaciones salen de un Transformer en lugar de una tabla. El bucle de entrenamiento es idéntico.

La pérdida: cuánto te has equivocado

Si el modelo daba a la letra correcta una probabilidad p, la pérdida es -log(p). Si acierta con seguridad (p = 1), la pérdida es 0; si le daba poca probabilidad, la pérdida se dispara. Se llama entropía cruzada y es la que usan los LLM.

import math

for p in [1.0, 0.5, 0.1, 0.01]:
    print(p, "→", round(-math.log(p), 3))

Un modelo que no sabe nada reparte por igual entre las V letras posibles, así que su pérdida es log(V). Es la cifra que tiene que mejorar.

// reto 01

La pérdida

Define perdida(probs, objetivo) que devuelva -log de la probabilidad que probs da a la posición objetivo.

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

return -math.log(probs[objetivo])

$ python main.py

    El gradiente: hacia dónde corregir

    Con softmax y entropía cruzada, la corrección tiene una forma sorprendentemente simple: para cada letra, probabilidad − 1 si es la correcta y probabilidad − 0 si no. Es el gradiente. Para aprender, se resta a cada puntuación su gradiente multiplicado por una tasa de aprendizaje (lr): sube la puntuación de la correcta y baja las demás.

    // reto 02

    Un paso de descenso de gradiente

    Define paso(fila, objetivo, lr) que calcule softmax(fila) y devuelva una fila nueva en la que a cada puntuación se le resta lr por su gradiente.

    main.py
    Ctrl/⌘ + Enter
    ¿Atascado? Ver pista
    probs = softmax(fila)
    nueva = []
    for j, (w, p) in enumerate(zip(fila, probs)):
        gradiente = p - (1 if j == objetivo else 0)
        nueva.append(w - lr * gradiente)
    return nueva
    $ python main.py

      El bucle de entrenamiento

      Entrenar es recorrer el texto par a par (letra actual, letra siguiente) y dar un paso en la fila de la letra actual. Cada pasada completa se llama época.

      // reto 03

      Entrena tu modelo

      Recorre el corpus 30 épocas. En cada pareja de letras seguidas (a, b), sustituye la fila W[idx[a]] por paso(W[idx[a]], idx[b], 0.5). Al final guarda en perdida_final la pérdida media con perdida_media(W).

      main.py
      Ctrl/⌘ + Enter
      ¿Atascado? Ver pista
      for epoca in range(30):
          for a, b in zip(corpus, corpus[1:]):
              W[idx[a]] = paso(W[idx[a]], idx[b], 0.5)
      perdida_final = perdida_media(W)
      $ python main.py

        Lo que cambia a escala

        La pérdida bajó de 2,71 a unos 1,08. No llega a 0 porque detrás de una letra pueden venir varias: detrás de «e» viene «l», « », «r» o «.» según la palabra. Un modelo que solo mira una letra no puede saber más.

        Los LLM usan exactamente este bucle, con tres diferencias:

        • La tabla se sustituye por un Transformer (la atención de la lección anterior, apilada en capas) con millones o miles de millones de parámetros.
        • El gradiente de cada parámetro no se escribe a mano: lo calcula una librería (PyTorch, JAX) con diferenciación automática.
        • Los pasos no se dan ejemplo a ejemplo, sino en lotes, y con optimizadores como AdamW (el de los 16 bytes por parámetro de la sección anterior).

        Y, como con el tokenizador, la pérdida que importa es la de un texto que el modelo no ha visto al entrenar.