De modelo base a assistente: SFT, RLHF, DPO e GRPO

O primeiro passo é o menos glamoroso e faz a maior parte do trabalho. Recolhem-se exemplos de instruções emparelhadas com boas respostas e continua-se o treino nelas com exatamente a loss do Capítulo 8 — prever o next token — mas apenas na parte da resposta. Isto é supervised fine-tuning, ou SFT.

Não se está a ensinar nada de novo sobre linguagem. O que se ensina é um formato: que texto desta forma é seguido por texto daquela forma, e depois para. Veja de novo a falha do modelo base. Ele respondeu à pergunta na primeira frase e depois não conseguiu parar, porque nada no seu treino alguma vez assinalou o fim de uma resposta. Parar é um comportamento aprendido.

É também por isso que é preciso dizer ao modelo onde estão as fronteiras, que é o que um chat template faz:

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

Esses marcadores <|im_start|> e <|im_end|> são tokens reais no vocabulário, acrescentados antes do fine-tuning, e o modelo viu milhões deles exatamente nestas posições. É assim que sabe de quem é a vez e onde termina uma intervenção.

Ignore o template e dê ao modelo uma pergunta nua, e estará a dar-lhe uma sequência que ele não viu no treino. Medido, mesmo modelo, mesma pergunta, mesma 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.

A resposta está certa em ambos os casos, mas sem os marcadores o modelo deriva para escrever Python para se verificar a si próprio, porque o prompt que recebeu não se parece com nada em que tenha sido submetido a fine-tuning. Esta é a causa mais comum de «o modelo ficou mais burro quando o chamei diretamente»: o template não é decoração à volta do modelo, faz parte do modelo, e um template errado é uma degradação silenciosa sem erro associado.

SFT tem um teto, e esse teto são os dados. Para fazer fine-tuning numa demonstração, é preciso alguém escrever a resposta ideal — e, para a maioria das perguntas interessantes, escrever uma boa resposta é difícil, lento, caro, e produz exatamente uma resposta cuja qualidade não se consegue verificar.

Aquilo em que as pessoas são boas é comparação. Perante duas respostas, um anotador consegue dizer de forma fiável qual é melhor em poucos segundos, sem ser capaz de produzir nenhuma delas. Este é o facto sobre o qual toda a segunda fase é construída, e é a parte que a maioria das explicações inverte:

Os humanos não escrevem as respostas. Classificam pares.

Portanto, os dados são pares — um prompt, duas respostas, e qual delas ganhou. Isto não pode ser ligado a uma loss de next-token, porque não há sequência-alvo. Precisa de uma máquina diferente.

Não se pode pedir a um humano para pontuar todas as respostas durante o treino — seriam milhões de julgamentos. Por isso treina-se um modelo para imitar os humanos: um reward model que recebe uma resposta e devolve um escalar.

Treiná-lo a partir de comparações usa um resultado de 1952. O modelo Bradley–Terry² diz que, se dois itens têm forças latentes, a probabilidade de um vencer o outro é a função logística da diferença entre elas. Inverta-se isso e torna-se uma loss: dado que um humano preferiu $y_w$ a $y_l$, maximizar

que em código é o ciclo de treino inteiro:

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

Repare no que o modelo nunca vê: uma pontuação absoluta. Aprende apenas diferenças, que é exatamente o que os dados contêm.

Agora a parte que vale a pena medir. Um reward model aprende aquilo que os anotadores recompensaram, e os anotadores são pessoas. Eis uma simulação em que a qualidade verdadeira de uma resposta depende apenas de ser útil e correta — o comprimento não vale nada — mas o anotador simulado tem uma ligeira preferência por respostas mais longas quando tudo o resto está próximo, o que é um viés humano bem documentado. Treine o reward model em 2000 comparações e leia os seus pesos:

O reward model está a funcionar perfeitamente. Aprendeu fielmente as preferências que lhe foram mostradas — incluindo a parte dessas preferências que nada tem a ver com qualidade. Um reward model não é uma medida do que é bom; é uma medida daquilo que os anotadores escolheram, e cada viés no conjunto de anotação é agora um coeficiente numa função diferenciável contra a qual um modelo muito maior está prestes a otimizar.

O que nos leva ao que acontece quando se otimiza isto. Dê à política um orçamento fixo de esforço para gastar nas propriedades da resposta, com uma assimetria realista: ser útil e estar correto é caro, e ser mais longo é barato — basta continuar a escrever.

Recompensa por unidade de esforço, para o modelo treinado acima: útil 8,26, correto 8,31, comprimento 31,70. O comprimento paga quase quatro vezes melhor do que a correção, não porque o reward model esteja avariado, mas porque é barato.

Otimize contra essa recompensa e observe os dois números:

A recompensa subiu por um fator de 2,5. Aquilo que a recompensa devia medir foi para zero. A política descobriu que conseguia pontuar enormemente bem escrevendo muito e não dizendo nada, e nenhuma parte do ciclo de treino tinha forma de reparar, porque o reward model é a definição de bom dentro do ciclo.

Isto é reward hacking, e se alguma vez se perguntou por que razão os modelos de chat são tão verbosos, esta tabela é uma grande parte da resposta.

A defesa padrão é penalizar a política por se afastar demasiado de onde começou, medindo a distância com a divergência KL do Capítulo 4:

A referência $\pi_{\text{ref}}$ é o modelo SFT — a política antes da fase de reinforcement. A alegação é que isto impede o modelo de se desviar para comportamento degenerado. Vamos ver quanto dessa alegação sobrevive à medição. Mesma configuração, varrendo $\beta$:

Leia a última linha em contraste com as restantes. Em $\beta = 0$ e $\beta = 1$ a penalização não faz absolutamente nada: a recompensa vale muito mais do que a KL, por isso o otimizador paga a multa e faz hacking na mesma. Entre 5 e 15, o comportamento oscila. E em $\beta = 60$, a qualidade verdadeira voltou a subir para 1,769 — que continua abaixo dos 1,791 que o modelo de referência tinha antes de tudo isto começar.

Uma ressalva antes de esse número ser citado em qualquer lado: os 1,791 da última linha e os 0,974 que a primeira tabela dá à política inicial são duas medições diferentes do mesmo modelo pré-RL, feitas separadamente pelos dois experimentos. Compare linhas dentro de uma tabela, nunca entre tabelas — a conclusão de cada tabela assenta nas suas próprias linhas, e nenhuma depende da baseline da outra.

Portanto, o resumo honesto não é «a penalização KL impede reward hacking». É:

A penalização KL não impede reward hacking. Limita o quanto a política se pode afastar da referência — e, como a falha exige movimento, isso ajuda. Mas é uma trela, não uma correção: com $\beta$ baixo a trela parte-se, e com $\beta$ alto obtém-se de volta o modelo de referência e toda a fase cara não comprou nada.

A faixa útil é estreita, a sua localização depende do reward model, e não há forma de a encontrar exceto olhando. É por isso que o modelo de referência tem de ser bom — a KL é um piso na qualidade da referência, não um teto para a falha — e é uma grande parte da razão pela qual esta fase é difícil na prática e não em princípio.

O algoritmo que fez isto funcionar em escala é Proximal Policy Optimization.³ Num parágrafo: estima a vantagem de cada resposta, atualiza a política para aumentar a probabilidade de respostas acima da baseline, e limita o tamanho de qualquer atualização isolada para que uma grande estimativa de vantagem não destrua a política num só passo. Aplicado a modelos de linguagem⁴, isto significa manter quatro modelos em jogo ao mesmo tempo — a política, a referência, o reward model e um crítico — com a política a gerar novas amostras ao longo do treino.

Funciona, produziu o InstructGPT e tudo o que dele descende, e é genuinamente difícil: quatro modelos em memória, amostragem no ciclo de treino, e uma reputação de instabilidade que é merecida. Fingir que se consegue implementá-lo num artigo de blog seria desonesto, por isso este capítulo não o faz.

O que o substituiu para a maioria dos fins veio de notar uma coisa. O objetivo regularizado por KL acima tem uma política ótima em forma fechada, e essa expressão pode ser invertida: a recompensa pode ser escrita em termos da política ótima e da referência. Substituir isso de volta na loss Bradley–Terry faz o reward model desaparecer por completo. O que resta é uma loss supervisionada sobre pares de preferência — sem amostragem, sem crítico, sem reward model, dois modelos em memória em vez de quatro.

Isso é Direct Preference Optimization,⁵ e são duas linhas:

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)                        

Leia o que diz. A quantidade que está a ser empurrada para cima é quanto mais a política prefere o vencedor do que a referência preferia, menos quanto mais prefere o perdedor. A referência não é uma penalização aparafusada depois — está dentro da loss, e é por isso que DPO não precisa de um termo KL separado.

A propriedade que mais importa está no gradient. Avalie a loss e o seu gradient no mesmo par em cinco estados diferentes da política:

O gradient cresce à medida que a política erra mais. Pares que o modelo já trata bem quase não contribuem; pares que ele inverte dominam a atualização. DPO pondera cada exemplo por quão errada a política está nesse momento, automaticamente, sem scheduling — e essa auto-ponderação é o mecanismo que faz o trabalho que a estimativa de vantagem e o crítico do PPO faziam. (A loss na terceira linha é exatamente $\ln 2$, que é a âncora para verificar qualquer implementação: uma política idêntica à sua referência não aprendeu nada e deve ficar em $\ln 2$.)

GRPO⁶ toma uma rota diferente para sair do mesmo problema. Mantém o ciclo de amostragem mas elimina o crítico: em vez de treinar um modelo para prever a baseline, amostra um grupo de respostas ao mesmo prompt e usa diretamente a recompensa média do grupo como baseline. A vantagem de uma resposta é o quanto ela foi melhor do que as suas irmãs. Isto troca um modelo inteiro por um batch maior, e foi o que tornou prático o treino com recompensas verificáveis — o tema do Capítulo 12.

Duas coisas para levar daqui.

A primeira é que esta fase tem um custo, e ele aparece como capacidade. Os modelos muitas vezes ficam mensuravelmente piores em algumas tarefas de benchmark depois de treino de alignment — o imposto de alignment — porque o objetivo mudou: uma resposta segura, cautelosa e bem formatada nem sempre é a resposta que maximiza a exatidão. Parte dessa diferença foi eliminada por engenharia, e parte dela é um trade-off real e não um bug a corrigir.

A segunda é a pergunta que a palavra aligned esconde. Alinhado com quem? A cadeia é: uma empresa escreve diretrizes, contratados interpretam-nas, as suas comparações treinam um reward model, o reward model molda uma política, e a política responde a uma pergunta de alguém que não viu nada disso. Cada elo é uma escolha feita por pessoas específicas, e nenhum dos algoritmos deste capítulo tem qualquer opinião sobre se essas escolhas são boas.

Isto não é um floreado retórico. É a razão concreta pela qual dois modelos de fronteira recusam pedidos diferentes, por que razão o mesmo modelo muda de ideias entre versões, e por que razão «aligned» é a descrição de um processo e não uma propriedade de um artefacto. A matemática deste capítulo está assente. Essa parte não.

O pós-treino ensinou o modelo a responder. Não o ensinou a pensar antes de responder, e as duas coisas são diferentes de uma forma que, afinal, é treinável.

O Capítulo 12 é sobre o que acontece quando se deixa um modelo gastar mais computação numa pergunta difícil no momento da resposta em vez de no momento do treino — chain of thought, reinforcement learning a partir de recompensas verificáveis, e a razão pela qual um modelo que mostra o seu raciocínio não está apenas a explicar-se, mas a computar de forma diferente. Também paga a dívida deste capítulo: GRPO existe nele, a fazer o trabalho que o crítico do PPO costumava fazer, sobre recompensas que não precisam de anotador nenhum porque uma prova ou verifica ou não verifica.

As gerações acima vêm de gpt2 e Qwen/Qwen2.5-0.5B-Instruct com greedy decoding, por isso reproduzem-se exatamente. O Capítulo 11 do Hugging Face LLM Course percorre SFT e DPO com trl e peft se quiser executar a coisa real em vez da simulação; o capítulo 7 de Build a Large Language Model (From Scratch), de Sebastian Raschka, implementa instruction fine-tuning de ponta a ponta sem uma biblioteca.