Phase 09 - Lesson 09

Reward Modeling & RLHF

This lesson includes a graded coding exercise that runs in your browser, unlocked with lifetime access.

Humanos não conseguem escrever uma função de recompensa para uma "boa resposta de assistente", mas eles podem comparar duas respostas e escolher a melhor. Ajuste um modelo de recompensa a essas comparações e, em seguida, aplique RL no modelo de linguagem contra ele. Christiano 2017. InstructGPT 2022. A receita que transformou o GPT-3 no ChatGPT. Em 2026, ele está sendo majoritariamente substituído pelo DPO — mas o modelo mental permanece.

Tipo: Build Linguagens: Python Pré-requisitos: Phase 5 · 05 (Sentiment), Phase 9 · 08 (PPO) Tempo: ~45 minutos

O Problema

Você treinou um modelo de linguagem com o objetivo de previsão do próximo token. Ele escreve em inglês gramaticalmente correto. Ele também mente, divaga e se recusa a recusar. Você não pode consertar isso com mais pré-treinamento — o texto da web é o problema, não a cura.

Você quer uma recompensa escalar que diga "a resposta A é melhor do que a resposta B para a instrução X". Escrever essa função de recompensa manualmente é impossível. A "utilidade" não é uma expressão em formato fechado sobre tokens. Mas os humanos podem comparar duas saídas e marcar uma preferência. Isso é barato de se coletar em escala.

O RLHF (Christiano et al. 2017; Ouyang et al. 2022) converte preferências em um modelo de recompensa e, em seguida, otimiza o LM via PPO contra essa recompensa. Em três etapas: SFT → RM → PPO. É a receita que viabilizou o ChatGPT, Claude, Gemini e todos os outros LLMs alinhados em 2023–2025.

Em 2026, a etapa de PPO é majoritariamente substituída pelo DPO (Phase 10 · 08) porque é mais barato e quase tão bom para o ajuste de alinhamento. Mas a parte do modelo de recompensa ainda serve de base para todo amostrador Best-of-N, todo pipeline de RL a partir de recompensas verificáveis e todo modelo de raciocínio usando um modelo de recompensa de processo. Entenda o RLHF e você entenderá toda a pilha de alinhamento.

O Conceito

Etapa 1: Ajuste Fino Supervisionado (SFT). Comece a partir de um modelo base pré-treinado. Realize o ajuste fino em demonstrações escritas por humanos do comportamento alvo (respostas que seguem instruções, réplicas úteis, etc.). Resultado: um modelo π_SFT que é tendencioso para o bom comportamento, mas que ainda possui um espaço de ação ilimitado.

Etapa 2: Treinamento do Modelo de Recompensa.

• Colete pares de respostas (y_+, y_-) para prompts x, rotulados por humanos como "y_+ é preferido em relação a y_-."

• Treine um modelo de recompensa R_φ(x, y) para atribuir pontuações mais altas a y_+.

• Perda: a logística em pares de Bradley-Terry:

  L(φ) = -E[ log σ(R_φ(x, y_+) - R_φ(x, y_-)) ]

  σ é a sigmoide. A diferença na recompensa implica uma probabilidade logarítmica de preferência. BT tem sido o padrão desde 1952 (Bradley-Terry) e é a escolha dominante no RLHF moderno.

• R_φ é geralmente inicializado a partir do modelo SFT com uma cabeça escalar no topo. Mesmo backbone do transformer; uma única camada linear gera a recompensa.

Etapa 3: PPO contra o RM com penalidade KL.

• Inicialize a política treinável π_θ a partir de π_SFT. Mantenha uma referência congelada π_ref = π_SFT.

• Recompensa ao final de uma resposta y:

  r_total(x, y) = R_φ(x, y) - β · KL(π_θ(·|x) || π_ref(·|x))

  A penalidade KL impede que π_θ se desvie arbitrariamente de π_SFT — é um regularizador, não uma região de confiança rígida. β é normalmente 0.01-0.05.

• Execute o PPO (Lição 08) com esta recompensa. As vantagens são computadas na trajetória a nível de token, mas o RM pontua apenas a resposta completa.

Por que a KL? Sem ela, o PPO encontrará alegremente estratégias de trapaça de recompensa (reward-hacking) — o RM só foi treinado em conclusões dentro da distribuição. Uma resposta fora da distribuição pode ter uma pontuação maior do que qualquer uma escrita por humanos. A KL mantém π_θ próxima do manifold onde o RM foi treinado. É o botão de ajuste mais importante no RLHF.

Status em 2026:

• DPO (Rafailov 2023): a álgebra de forma fechada colapsa as Etapas 2 e 3 em uma única perda supervisionada sobre dados de preferência. Sem RM, sem PPO. Mesma qualidade em benchmarks de alinhamento por uma fração do poder computacional. Coberto na Phase 10 · 08.
• GRPO (DeepSeek 2024–2025): PPO com uma linha de base relativa ao grupo em vez de um crítico, recompensa de um verificador (código executando / resposta matemática correta) em vez de um RM treinado por humanos. Dominante para modelos de raciocínio. Coberto na Phase 9 · 12.
• Modelos de recompensa de processo (PRMs): pontuam soluções parciais (cada etapa do raciocínio), usados em variantes de RLHF e GRPO para raciocínio.
• Constitutional AI / RLAIF: usa um LLM alinhado para gerar preferências em vez de humanos. Escala o orçamento de preferências.

Implemente

Esta lição usa "prompts" e "respostas" sintéticas minúsculas representadas como strings. O RM é um pontuador linear sobre uma representação de saco de palavras (bag-of-tokens). Nenhum LLM real — o formato do pipeline importa, não a escala. Veja code/main.py.

Passo 1: dados de preferência sintéticos

PROMPTS = ["help me", "answer me", "explain this"]
GOOD_WORDS = {"clear", "specific", "kind", "thorough"}
BAD_WORDS = {"vague", "rude", "wrong", "short"}

def make_pair(rng):
    x = rng.choice(PROMPTS)
    y_good = rng.choice(list(GOOD_WORDS)) + " " + rng.choice(list(GOOD_WORDS))
    y_bad = rng.choice(list(BAD_WORDS)) + " " + rng.choice(list(BAD_WORDS))
    return (x, y_good, y_bad)

No RLHF real, isso é substituído por rotuladores humanos. O formato — (prompt, preferred_response, rejected_response) — é idêntico.

Passo 2: modelo de recompensa Bradley-Terry

Pontuação linear: R(x, y) = w · bag(y). Treine para minimizar a perda logarítmica em pares do BT:

def rm_train_step(w, x, y_pos, y_neg, lr):
    r_pos = dot(w, bag(y_pos))
    r_neg = dot(w, bag(y_neg))
    p = sigmoid(r_pos - r_neg)
    for tok, cnt in bag(y_pos).items():
        w[tok] += lr * (1 - p) * cnt
    for tok, cnt in bag(y_neg).items():
        w[tok] -= lr * (1 - p) * cnt

Depois de algumas centenas de atualizações, w atribui pesos positivos a tokens de palavras boas e negativos a palavras ruins.

Passo 3: política semelhante ao PPO sobre o RM

Nossa política de brinquedo produz um único token a partir de um vocabulário. Pontuamos o token sob o RM, computamos log π_θ(token | prompt), adicionamos uma penalidade KL em relação à referência e aplicamos o substituto do PPO clipado.

def rlhf_step(theta, ref, w, prompt, rng, eps=0.2, beta=0.1, lr=0.05):
    logits_theta = policy_logits(theta, prompt)
    probs = softmax(logits_theta)
    token = sample(probs, rng)
    logits_ref = policy_logits(ref, prompt)
    probs_ref = softmax(logits_ref)
    reward = dot(w, bag([token])) - beta * kl(probs, probs_ref)
    # ppo-style update on theta, treating reward as the return
    ...

Passo 4: monitore a KL

Monitore a média de KL(π_θ || π_ref) a cada atualização. Se ela passar de ~5-10, a política se desviou muito de π_SFT — o β baixo está subindo ou o reward-hacking está começando. Este é o principal diagnóstico no RLHF real.

Passo 5: a receita de produção com TRL

Depois de entender o pipeline de brinquedo, aqui está o mesmo loop da forma que um usuário de biblioteca real o escreve. A biblioteca TRL da Hugging Face é a implementação de referência — RewardTrainer para a Etapa 2 e PPOTrainer (com um KL-em-relação-à-referência integrado) para a Etapa 3.

# Stage 2: reward model from pairwise preferences
from trl import RewardTrainer, RewardConfig
from transformers import AutoModelForSequenceClassification, AutoTokenizer

tok = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B-Instruct")
rm = AutoModelForSequenceClassification.from_pretrained(
    "meta-llama/Llama-3.1-8B-Instruct", num_labels=1
)

# dataset rows: {"prompt", "chosen", "rejected"} — Bradley-Terry format
trainer = RewardTrainer(
    model=rm,
    tokenizer=tok,
    train_dataset=preference_data,
    args=RewardConfig(output_dir="./rm", num_train_epochs=1, learning_rate=1e-5),
)
trainer.train()

# Stage 3: PPO against the RM with KL penalty to the SFT reference
from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead

policy = AutoModelForCausalLMWithValueHead.from_pretrained("./sft-checkpoint")
ref    = AutoModelForCausalLMWithValueHead.from_pretrained("./sft-checkpoint")  # frozen

ppo = PPOTrainer(
    config=PPOConfig(learning_rate=1.41e-5, batch_size=64, init_kl_coef=0.05,
                     target_kl=6.0, adap_kl_ctrl=True),
    model=policy, ref_model=ref, tokenizer=tok,
)

for batch in dataloader:
    responses = ppo.generate(batch["query_ids"], max_new_tokens=128)
    rewards   = rm(torch.cat([batch["query_ids"], responses], dim=-1)).logits[:, 0]
    stats     = ppo.step(batch["query_ids"], responses, rewards)
    # stats includes: mean_kl, clip_frac, value_loss — the three PPO diagnostics

Três coisas que a biblioteca faz por você. adap_kl_ctrl=True implementa a programação de β adaptativa: se o KL observado exceder target_kl, o β dobra; se cair para menos da metade, o β cai pela metade. O modelo de referência é congelado por convenção — você não deve compartilhar parâmetros acidentalmente com policy. E a cabeça de valor vive no mesmo backbone que a política (AutoModelForCausalLMWithValueHead anexa uma cabeça MLP escalar), razão pela qual o TRL relata policy/kl e value/loss separadamente.

Armadilhas

• Superotimização / reward hacking. O RM é imperfeito; π_θ encontra conclusões adversárias que pontuam alto, mas são ruins. Sintomas: a recompensa sobe indefinidamente enquanto a pontuação de avaliação humana se estabiliza ou cai. Solução: pare cedo, aumente o β, amplie os dados de treinamento do RM.
• Length hacking (trapaça de tamanho). RMs treinados em respostas úteis frequentemente recompensam implicitamente o tamanho do texto. A política aprende a preencher as respostas com palavras desnecessárias. Remediação: recompensa normalizada pelo comprimento ou RLAIF com um RM ciente do comprimento.
• RM muito pequeno. O RM precisa ser pelo menos tão grande quanto a política. Um RM minúsculo não consegue pontuar fielmente as saídas da política.
• Ajuste de KL. β muito baixo → desvio e reward-hacking. β muito alto → a política quase não muda. O truque padrão é um β adaptativo que visa um KL fixo por etapa.
• Ruído nos dados de preferência. ~30% dos rótulos humanos são ruidosos ou ambíguos. Calibre treinando o RM em dados filtrados por concordividade ou use uma temperatura no BT.
• Problemas fora de política. Os dados do PPO tornam-se ligeiramente fora de política após a primeira época. Monitore a fração de corte como na Lição 08.

Casos de Uso

O RLHF em 2026 é estruturado em camadas:

O RLHF foi o método em 2022–2024. Em 2026, os pipelines de alinhamento em produção são focados primeiro em DPO, restando o PPO apenas para etapas com uso intensivo de RM ou críticas para a segurança.

Publique

Salve como outputs/skill-rlhf-architect.md:

---
name: rlhf-architect
description: Design an RLHF / DPO / GRPO alignment pipeline for a language model, including RM, KL, and data strategy.
version: 1.0.0
phase: 9
lesson: 9
tags: [rl, rlhf, alignment, llm]
---

Given a base LM, a target behavior (alignment / reasoning / refusal / agent), and a preference or verifier budget, output:

1. Stage. SFT? RM? DPO? GRPO? With justification.
2. Preference or verifier source. Humans, AI feedback, rule-based, unit-test-pass, or reward distillation.
3. KL strategy. Fixed β, adaptive β, or DPO (implicit KL).
4. Diagnostics. Mean KL, reward stability, over-optimization guard (holdout human eval).
5. Safety gate. Red-team set, refusal rate, safety RM separate from helpfulness RM.

Refuse to ship RLHF-PPO without a KL monitor. Refuse to use an RM smaller than the target policy. Refuse length-only rewards. Flag any pipeline that does not hold back a blind human-eval set as lacking over-optimization protection.

Exercícios

1. Fácil. Treine o modelo de recompensa Bradley-Terry em code/main.py em 500 pares de preferência sintéticos. Meça a acurácia em pares em 100 pares reservados. Deve exceder 90%.
2. Médio. Execute o loop PPO-RLHF de brinquedo com β ∈ {0.0, 0.1, 1.0}. Para cada um, plote a pontuação do RM vs. KL em relação à referência ao longo das atualizações. Quais execuções sofrem reward-hack?
3. Difícil. Implemente DPO (perda de verossimilhança de preferência em formato fechado) nos mesmos dados de preferência e compare com o pipeline RLHF-PPO em poder computacional utilizado e pontuação final de RM alcançada.

Termos-Chave

Leitura Adicional

• Christiano et al. (2017). Deep Reinforcement Learning from Human Preferences — o artigo que deu início ao RLHF.
• Ouyang et al. (2022). InstructGPT — Training language models to follow instructions with human feedback — a receita por trás do ChatGPT.
• Stiennon et al. (2020). Learning to summarize with human feedback — RLHF inicial para sumarização.
• Rafailov et al. (2023). Direct Preference Optimization — DPO; o padrão pós-RLHF em 2026.
• Bai et al. (2022). Constitutional AI: Harmlessness from AI Feedback — RLAIF e o loop de autocrítica.
• Anthropic RLHF paper (Bai et al. 2022). Training a Helpful and Harmless Assistant — o artigo de HH.
• Hugging Face TRL library — RewardTrainer e PPOTrainer de produção. Leia o código fonte do trainer para detalhes sobre o KL adaptativo e a cabeça de valor.
• Hugging Face — Illustrating Reinforcement Learning from Human Feedback por Lambert, Castricato, von Werra, Havrilla — o passo a passo canônico do pipeline de três etapas com diagramas.
• von Werra et al. (2020). TRL: Transformer Reinforcement Learning — a biblioteca; examples/ contém scripts de RLHF de ponta a ponta para Llama, Mistral e Qwen.
• Sutton & Barto (2018). Ch. 17.4 — Designing Reward Signals — a visão da hipótese de recompensa; pré-requisito essencial para pensar sobre reward-hacking.