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.
La pérdida
Define perdida(probs, objetivo) que devuelva -log de la probabilidad que probs da a la posición objetivo.
¿Atascado? Ver pista
return -math.log(probs[objetivo])
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.
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.
¿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 nuevaEl 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.
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).
¿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)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.