Del modelo base al asistente: SFT, RLHF, DPO y GRPO

El primer paso es el menos vistoso y el que hace la mayor parte del trabajo. Reúne ejemplos de instrucciones emparejadas con buenas respuestas y continúa entrenando con exactamente la loss del capítulo 8 —predecir el siguiente token—, pero solo sobre la parte de la respuesta. Esto es fine-tuning supervisado, o SFT.

No se está enseñando nada nuevo sobre el lenguaje. Lo que se enseña es un formato: que un texto con esta forma va seguido de un texto con aquella forma, y luego se detiene. Mira de nuevo el fallo del modelo base. Respondió a la pregunta en la primera frase y después no pudo parar, porque nada en su entrenamiento había marcado jamás el final de una respuesta. Detenerse es un comportamiento aprendido.

Por eso también hay que decirle al modelo dónde están los límites, que es lo que hace una plantilla de chat:

<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>
<|im_start|>user
What is the capital of France?<|im_end|>
<|im_start|>assistant

Esos marcadores <|im_start|> y <|im_end|> son tokens reales del vocabulario, añadidos antes del fine-tuning, y el modelo vio millones de ellos exactamente en esas posiciones. Así sabe de quién es el turno y dónde termina un turno.

Omite la plantilla y entrega al modelo una pregunta desnuda, y le estás dando una secuencia que no ha visto durante el entrenamiento. Medido, mismo modelo, misma pregunta, mismo greedy decoding:

 The capital of France is Paris.

To verify this, I will use a simple
Python code snippet to confirm that
Paris is indeed the capital city of
France.

[...and then it starts writing a
Python script to check its own answer]

The capital of France is Paris.

La respuesta es correcta en ambos casos, pero sin los marcadores el modelo deriva hacia escribir Python para comprobarse a sí mismo, porque el prompt que ha recibido no se parece a nada de aquello con lo que se le hizo fine-tuning. Esta es la causa más común de «el modelo se volvió más tonto cuando lo llamé directamente»: la plantilla no es decoración alrededor del modelo, forma parte del modelo, y una plantilla incorrecta es una degradación silenciosa sin ningún error asociado.

SFT tiene un techo, y ese techo son los datos. Para hacer fine-tuning con una demostración necesitas que alguien escriba la respuesta ideal; y, para la mayoría de las preguntas interesantes, escribir una buena respuesta es difícil, lento, caro y produce exactamente una respuesta cuya calidad no puedes verificar.

Lo que la gente hace bien es comparar. Si se le muestran dos respuestas, un anotador puede decir de forma fiable cuál es mejor en pocos segundos, sin ser capaz de producir ninguna de las dos. Este es el hecho sobre el que se construye toda la segunda fase, y es la parte que la mayoría de las explicaciones cuentan al revés:

Los humanos no escriben las respuestas. Ordenan pares.

Así que los datos son pares: un prompt, dos respuestas y cuál ganó. Eso no puede enchufarse a una loss de siguiente token, porque no hay secuencia objetivo. Necesita otra máquina.

No puedes pedir a un humano que puntúe cada respuesta durante el entrenamiento: serían millones de juicios. Así que entrenas un modelo para imitar a los humanos: un modelo de recompensa que toma una respuesta y devuelve un escalar.

Entrenarlo a partir de comparaciones usa un resultado de 1952. El modelo Bradley–Terry² dice que, si dos elementos tienen fuerzas latentes, la probabilidad de que uno venza al otro es la función logística de su diferencia. Dale la vuelta y se convierte en una loss: dado que un humano prefirió $y_w$ a $y_l$, maximiza

que en código es todo el bucle de entrenamiento:

loss = -F.logsigmoid(reward(chosen) - reward(rejected)).mean()   

Fíjate en lo que el modelo nunca ve: una puntuación absoluta. Solo aprende diferencias, que es exactamente lo que contienen los datos.

Ahora la parte que merece medirse. Un modelo de recompensa aprende lo que recompensaron los anotadores, y los anotadores son personas. Aquí hay una simulación en la que la calidad real de una respuesta depende solo de ser útil y correcta —la longitud no vale nada—, pero el anotador simulado tiene una ligera preferencia por respuestas más largas cuando todo lo demás está cerca, que es un sesgo humano bien documentado. Entrena el modelo de recompensa con 2000 comparaciones y lee sus pesos:

El modelo de recompensa funciona perfectamente. Ha aprendido fielmente las preferencias que se le mostraron, incluida la parte de esas preferencias que no tiene nada que ver con la calidad. Un modelo de recompensa no mide lo bueno; mide lo que eligieron los anotadores, y cada sesgo del conjunto de anotación es ahora un coeficiente en una función diferenciable contra la que un modelo mucho mayor está a punto de optimizar.

Lo que nos lleva a lo que ocurre cuando optimizas contra él. Dale a la política un presupuesto fijo de esfuerzo para repartir entre las propiedades de la respuesta, con una asimetría realista: ser útil y ser correcto es caro, y ser más largo es barato; simplemente sigues escribiendo.

Recompensa por unidad de esfuerzo, para el modelo entrenado arriba: útil 8,26, correcto 8,31, longitud 31,70. La longitud paga casi cuatro veces mejor que la corrección, no porque el modelo de recompensa esté roto, sino porque es barata.

Optimiza contra esa recompensa y observa ambos números:

La recompensa subió por un factor de 2,5. Aquello que la recompensa debía medir cayó a cero. La política descubrió que podía puntuar enormemente bien escribiendo largo y no diciendo nada, y ninguna parte del bucle de entrenamiento tenía forma alguna de darse cuenta, porque el modelo de recompensa es la definición de lo bueno dentro del bucle.

Esto es reward hacking, y si alguna vez te has preguntado por qué los modelos de chat son tan verbosos, esta tabla es una gran parte de la respuesta.

La defensa estándar consiste en penalizar a la política por alejarse demasiado de donde empezó, midiendo la distancia con la divergencia KL del capítulo 4:

La referencia $\pi_{\text{ref}}$ es el modelo SFT: la política antes de la fase de refuerzo. La afirmación es que esto evita que el modelo derive hacia comportamientos degenerados. Veamos cuánto de esa afirmación sobrevive a la medición. Mismo montaje, barriendo $\beta$:

Lee la última fila frente al resto. En $\beta = 0$ y $\beta = 1$ la penalización no hace absolutamente nada: la recompensa vale tanto más que la KL que el optimizador paga la multa y hackea igualmente. Entre 5 y 15 el comportamiento oscila. Y en $\beta = 60$, la calidad real ha vuelto a subir hasta 1,769, que sigue estando por debajo del 1,791 que tenía el modelo de referencia antes de que nada de esto empezara.

Una advertencia antes de que ese número se cite en ningún sitio: el 1,791 de la última fila y el 0,974 que la primera tabla da a la política inicial son dos mediciones distintas del mismo modelo pre-RL, tomadas por los dos experimentos por separado. Compara filas dentro de una tabla, nunca entre tablas: la conclusión de cada tabla se sostiene sobre sus propias filas, y ninguna depende del baseline de la otra.

Así que el resumen honesto no es «la penalización KL evita el reward hacking». Es:

La penalización KL no evita el reward hacking. Limita cuánto puede alejarse la política de la referencia y, como el fallo requiere moverse, eso ayuda. Pero es una correa, no una corrección: con $\beta$ bajo la correa se rompe, y con $\beta$ alto recuperas el modelo de referencia y toda la fase cara no ha comprado nada.

La franja útil es estrecha, su ubicación depende del modelo de recompensa, y no hay forma de encontrarla salvo mirando. Por eso el modelo de referencia debe ser bueno: la KL es un suelo en la calidad de la referencia, no un techo sobre el fallo, y esto explica en gran parte por qué esta fase es difícil en la práctica más que en principio.

El algoritmo que hizo que esto funcionara a escala es Proximal Policy Optimization.³ En un párrafo: estima la ventaja de cada respuesta, actualiza la política para aumentar la probabilidad de las respuestas por encima del baseline y recorta el tamaño de cada actualización individual para que una estimación de ventaja grande no pueda destruir la política de un solo paso. Aplicado a modelos de lenguaje⁴, significa mantener cuatro modelos en juego a la vez: la política, la referencia, el modelo de recompensa y un crítico, con la política generando muestras nuevas durante todo el entrenamiento.

Funciona, produjo InstructGPT y todo lo que desciende de él, y es genuinamente difícil: cuatro modelos en memoria, muestreo dentro del bucle de entrenamiento y una reputación de inestabilidad que se ha ganado. Fingir que puedes implementarlo en una entrada de blog sería deshonesto, así que este capítulo no lo hace.

Lo que lo reemplazó para la mayoría de usos vino de darse cuenta de algo. El objetivo regularizado con KL de arriba tiene una política óptima en forma cerrada, y esa expresión puede invertirse: la recompensa puede escribirse en términos de la política óptima y la referencia. Sustituir eso de nuevo en la loss Bradley–Terry hace que el modelo de recompensa desaparezca por completo. Lo que queda es una loss supervisada sobre pares de preferencias: sin muestreo, sin crítico, sin modelo de recompensa, dos modelos en memoria en lugar de cuatro.

Eso es Direct Preference Optimization,⁵ y son dos líneas:

def dpo_loss(pi_w, pi_l, ref_w, ref_l, beta=0.1):
    """pi_* and ref_* are summed log-probabilities of a full response."""
    logits = beta * ((pi_w - ref_w) - (pi_l - ref_l))   
    return -F.logsigmoid(logits)                        

Lee lo que dice. La cantidad que se empuja hacia arriba es cuánto más prefiere la política al ganador que la referencia, menos cuánto más prefiere al perdedor. La referencia no es una penalización atornillada después: está dentro de la loss, que es por lo que DPO no necesita un término KL separado.

La propiedad que más importa está en el gradient. Evalúa la loss y su gradient sobre el mismo par en cinco estados distintos de la política:

El gradient crece a medida que la política se equivoca más. Los pares que el modelo ya maneja no aportan casi nada; los pares que tiene al revés dominan la actualización. DPO pondera cada ejemplo por lo equivocada que está la política en ese momento, automáticamente, sin programación; y esa autoponderación es el mecanismo que hace el trabajo que hacían la estimación de ventaja y el crítico de PPO. (La loss en la tercera fila es exactamente $\ln 2$, que es el ancla con la que comprobar cualquier implementación: una política idéntica a su referencia no ha aprendido nada y debería quedarse en $\ln 2$.)

GRPO⁶ toma una ruta distinta para salir del mismo problema. Mantiene el bucle de muestreo pero elimina el crítico: en lugar de entrenar un modelo para predecir el baseline, muestrea un grupo de respuestas al mismo prompt y usa directamente la recompensa media del grupo como baseline. La ventaja de una respuesta es cuánto mejor fue que sus hermanas. Eso cambia un modelo entero por un lote más grande, y es lo que hizo práctico el entrenamiento con recompensas verificables, el tema del capítulo 12.

Dos cosas que conviene llevarse.

La primera es que esta fase tiene un coste, y se manifiesta como capacidad. Los modelos suelen empeorar de forma medible en algunas tareas de benchmark después del entrenamiento de alignment —el impuesto de alignment— porque el objetivo cambió: una respuesta segura, cautelosa y bien formateada no siempre es la respuesta que maximiza la precisión. Parte de esa brecha se ha eliminado con ingeniería, y parte es una compensación real, no un bug que arreglar.

La segunda es la pregunta que esconde la palabra alineado. ¿Alineado con quién? La cadena es: una empresa escribe directrices, contratistas las interpretan, sus comparaciones entrenan un modelo de recompensa, el modelo de recompensa moldea una política, y la política responde a una pregunta de alguien que no vio nada de eso. Cada eslabón es una elección hecha por personas concretas, y ninguno de los algoritmos de este capítulo tiene opinión alguna sobre si esas elecciones son buenas.

No es un adorno retórico. Es la razón concreta por la que dos modelos de frontera rechazan solicitudes distintas, por la que el mismo modelo cambia de opinión entre versiones y por la que «alineado» describe un proceso más que una propiedad de un artefacto. Las matemáticas de este capítulo están resueltas. Esa parte no.

El postentrenamiento enseñó al modelo a responder. No le enseñó a pensar antes de responder, y las dos cosas son distintas de una forma que resulta ser entrenable.

El capítulo 12 trata sobre lo que ocurre cuando dejas que un modelo gaste más computación en una pregunta difícil en el momento de responder en lugar de en el momento de entrenar: chain of thought, aprendizaje por refuerzo a partir de recompensas verificables y la razón por la que un modelo que muestra su trabajo no solo se está explicando, sino que está computando de otra manera. También salda la deuda de este capítulo: GRPO existe ahí, haciendo el trabajo que antes hacía el crítico de PPO, con recompensas que no necesitan ningún anotador porque una prueba se verifica o no se verifica.

Las generaciones anteriores vienen de gpt2 y Qwen/Qwen2.5-0.5B-Instruct con greedy decoding, así que se reproducen exactamente. El capítulo 11 del Hugging Face LLM Course recorre SFT y DPO con trl y peft si quieres ejecutar lo real en lugar de la simulación; el capítulo 7 de Build a Large Language Model (From Scratch), de Sebastian Raschka, implementa instruction fine-tuning de extremo a extremo sin una biblioteca.