Phase 10 - Lesson 09

IA Constitucional e Autoaperfeiçoamento

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

O RLHF precisa de humanos no ciclo. A IA Constitucional substitui a maioria deles pelo próprio modelo. Escreva uma lista de princípios, faça o modelo criticar suas próprias saídas com base nesses princípios e treine com as críticas. O DeepSeek-R1 levou isso ainda mais longe em 2025: permita que o modelo gere milhões de caminhos de raciocínio, avalie-os com uma regra e execute o GRPO no resultado. A maior parte do "trabalho de alinhamento" em um modelo de fronteira de 2026 é o próprio alinhamento do modelo. Esta lição constrói ambos os ciclos.

Type: Build Languages: Python (stdlib + numpy) Prerequisites: Phase 10, Lessons 06-08 (SFT, RLHF, DPO) Time: ~45 minutos

Objetivos de Aprendizagem

• Implementar o ciclo de duas etapas da IA Constitucional: autocrítica mais autorrevisão, e depois o treinamento de preferência nos pares revisados
• Derivar o objetivo do GRPO (otimização de política relativa ao grupo do DeepSeek-R1) e contrastá-lo com a linha de base da função de valor do PPO
• Gerar caminhos de raciocínio verificáveis com recompensas de resultado baseadas em regras e pontuá-los sem um modelo de recompensa separado
• Decidir quando o autoaperfeiçoamento supera os dados de preferência humana e quando ele colapsa em busca de modo (mode seeking)

O Problema

Você construiu o RLHF na Lição 07 e o DPO na Lição 08. Ambos dependem da mesma entrada cara: pares de preferência humana. O pipeline da era InstructGPT da Anthropic usou aproximadamente 33.000 comparações. O Llama 2 Chat usou mais de 1,5 milhão. O Claude 3 usou ainda mais. Esses dados são lentos, caros e enviesados em direção ao que os anotadores acreditavam no dia em que estavam avaliando.

O artigo da IA Constitucional de 2022 fez uma pergunta simples. E se o próprio modelo gerasse os rótulos de preferência? Dê a ele uma lista de princípios escritos -- a "constituição" -- e faça com que ele critique suas próprias respostas. As críticas se tornam o sinal de treinamento.

Em 2024, a DeepSeek levou a ideia mais longe. Eles mostraram que, para qualquer tarefa com um resultado verificável (matemática com uma resposta conhecida, código que passa nos testes ou falha, um jogo que vence ou perde), você pode ignorar completamente o crítico. Gere muitas soluções candidatas. Avalie cada uma com uma regra determinística. Execute um algoritmo de gradiente de política nas recompensas. O DeepSeek-R1 foi treinado dessa maneira, quase sem dados de preferência humana, e igualou o desempenho de raciocínio da classe o1.

Esses dois ciclos -- IA Constitucional para comportamento subjetivo e RL baseado em regras para comportamento verificável -- são as receitas de alinhamento dominantes de 2026. O orçamento de preferência humana que costumava ir para o RLHF agora paga por uma etapa muito menor: escolher a constituição e escolher as regras de recompensa.

O Conceito

O Ciclo da IA Constitucional

Bai et al. (2022) estruturaram o pipeline em duas etapas.

Etapa 1: Aprendizado Supervisionado a partir do Feedback da IA (SL-CAI). Comece com um modelo SFT que seja útil, mas possivelmente prejudicial. Forneça prompts com solicitações potencialmente prejudiciais. Para cada resposta, peça ao mesmo modelo para criticar sua resposta em relação a um princípio constitucional e, em seguida, revisar. Faça o ajuste fino nas respostas revisadas. O conjunto de dados é composto por pares (prompt, resposta_revisada).

Etapa 2: Aprendizado por Reforço a partir do Feedback da IA (RLAIF). Colete pares de respostas. Peça ao modelo para julgar qual delas segue melhor a constituição. As preferências de pares treinam um modelo de recompensa. Em seguida, execute PPO ou DPO no modelo usando essa recompensa. A principal diferença em relação ao RLHF: as preferências vieram do modelo, não de humanos.

graph TD
    subgraph SL["Stage 1: SL-CAI"]
        P1["Prompt prejudicial"] --> R1["Resposta inicial\n(possivelmente prejudicial)"]
        R1 --> C1["Modelo critica\ncontra princípio"]
        C1 --> REV["Modelo revisa\nresposta"]
        REV --> SFT["SFT em\n(prompt, revisado)"]
    end

    subgraph RL["Stage 2: RLAIF"]
        P2["Prompt"] --> S1["Amostra de resposta A"]
        P2 --> S2["Amostra de resposta B"]
        S1 --> J["Modelo julga\nA vs B via constituição"]
        S2 --> J
        J --> RM["Conjunto de dados de preferência"]
        RM --> TRAIN["Treinamento DPO / PPO"]
    end

    SL --> RL

    style P1 fill:#1a1a2e,stroke:#e94560,color:#fff
    style REV fill:#1a1a2e,stroke:#51cf66,color:#fff
    style P2 fill:#1a1a2e,stroke:#e94560,color:#fff
    style TRAIN fill:#1a1a2e,stroke:#51cf66,color:#fff

A constituição é a alavanca. O original da Anthropic tinha 16 princípios (posteriormente expandidos). Um princípio diz algo como "Por favor, escolha a resposta que tenha menos probabilidade de ser censurável por qualquer pessoa de uma ampla variedade de origens culturais". Você escolhe o princípio para cada etapa, às vezes aleatoriamente, às vezes com base na categoria do prompt.

O Que a Constituição Realmente Faz

A constituição move o contrato de alinhamento de dados para texto. Mudar o comportamento sob RLHF significa rotular novamente milhares de pares. Mudar o comportamento sob a CAI significa editar um parágrafo. Esta é a principal vitória prática.

Ela tem um custo. Os autojulgamentos do modelo são tão bons quanto sua calibração inicial. Se o modelo SFT tiver pontos cegos -- por exemplo, não conseguir reconhecer uma formulação manipuladora -- a etapa de crítica herdará esses pontos cegos. A CAI comprime o ciclo de alinhamento, mas não consegue amplificar o sinal além do limite máximo do modelo base. É por isso que todo pipeline de CAI em produção ainda usa alguns dados de preferência humana, normalmente de 5 a 10% do volume do RLHF puro.

GRPO: Otimização de Política Relativa ao Grupo

A DeepSeek introduziu o GRPO no artigo DeepSeekMath (2024) e o usou como a espinha dorsal do DeepSeek-R1 (2025). O GRPO é uma variante do PPO que remove a função de valor.

Lembre-se do objetivo do PPO (da Lição 07):

L_PPO = E[min(r(theta) * A, clip(r(theta), 1-eps, 1+eps) * A)]

onde A é a vantagem, normalmente estimada com GAE usando uma rede de valor treinada V(s). A rede de valor é um segundo modelo do mesmo tamanho que a política. Ela duplica a memória e introduz seu próprio ciclo de treinamento.

O GRPO descarta a função de valor. Para cada prompt, ele coleta um grupo de G respostas (normalmente G=16 ou 64). A recompensa para cada resposta é computada e depois normalizada dentro do grupo:

A_i = (r_i - mean(r_1, ..., r_G)) / std(r_1, ..., r_G)

A vantagem é o escore-z (z-score) da recompensa da resposta em relação às suas irmãs. Nenhuma função de valor. O grupo atua como sua própria linha de base.

L_GRPO = E[min(r(theta) * A_group, clip(r(theta), 1-eps, 1+eps) * A_group)] - beta * KL(pi || pi_ref)

A penalidade de KL contra o modelo de referência ainda está lá, assim como no PPO. A taxa de corte (clip ratio) ainda está lá. O que mudou é a eliminação do crítico separado.

Por que o GRPO Importa para o Raciocínio

Para tarefas de raciocínio, a recompensa é frequentemente esparsa e binária: a resposta final está certa ou errada. Uma função de valor treinada em recompensas binárias esparsas é um desperdício -- ela não consegue aprender estimativas intermediárias úteis porque quase todo estado tem o mesmo retorno esperado até a etapa final. A normalização de grupo do GRPO fornece um sinal relativo imediato: entre 16 tentativas no mesmo problema de matemática, quais tentativas foram acima da média para este problema?

Esse é o formato exato de sinal que você obtém de recompensas baseadas em regras:

• Matemática: o sympy ou um verificador simbólico decide se a resposta final corresponde.
• Código: uma suíte de testes decide se passou ou falhou.
• Formatação: uma expressão regular (regex) decide se a resposta está dentro da tag XML obrigatória.
• Provas de várias etapas: um assistente de prova (Lean, Coq) decide a validade.

O DeepSeek-R1-Zero foi treinado com apenas duas recompensas: precisão em benchmarks de matemática e conformidade de formatação (resposta dentro de tags <answer>). Sem preferências humanas. Sem modelo crítico. O "momento aha" que o artigo do DeepSeek descreveu -- o modelo aprendendo espontaneamente a verificar a si mesmo e voltar atrás (backtrack) -- surgiu do GRPO apenas em recompensas de regras esparsas.

Modelos de Recompensa de Processo vs Modelos de Recompensa de Resultado

Você ainda tem uma escolha de design: recompensar a resposta final (Modelo de Recompensa de Resultado, ORM) ou recompensar cada etapa intermediária (Modelo de Recompensa de Processo, PRM).

O consenso de 2024-2025 foi que os ORMs combinados com GRPO escalam melhor do que os PRMs. Os PRMs são mais eficientes em termos de amostra por token, mas exigiriam dados rotulados por etapa que são caros e tendem a colapsar em comportamentos de atalho (escrever etapas que parecem boas para o PRM, mas não avançam na prova). Para a maioria das equipes, ORM + GRPO é a primeira coisa a ser tentada.

Autoaperfeiçoamento: O Multiplicador de Feedback

Depois de ter o padrão de dois ciclos (crítica/revisão e RL relativo ao grupo com recompensas de regras), você pode encadeá-los.

1. Comece com um modelo SFT.
2. Gere muitas respostas candidatas por prompt.
3. Pontue-as com uma recompensa baseada em regras (para tarefas verificáveis) ou um crítico constitucional (para tarefas subjetivas).
4. Mantenha os melhores candidatos como novos dados SFT ou como pares de preferência.
5. Faça o ajuste fino. Vá para a etapa 2 com o modelo aprimorado.

A DeepSeek chamou isso de "ajuste fino de amostragem de rejeição" (rejection sampling fine-tuning) quando aplicado após o R1-Zero. A Anthropic chamou uma versão anterior disso de "destilação de IA constitucional". O padrão é: cada iteração amplifica o sinal que já está no modelo. Ela não adiciona um sinal novo. Se o modelo não consegue resolver a classe de problema X de forma alguma, nenhuma quantidade de autoaperfeiçoamento criará essa capacidade.

O perigo é o colapso de modo (mode collapse). Os dados autogerados sempre têm uma distribuição mais estreita do que o corpus de treinamento. Após 3 a 5 rodadas de autodestilação, os modelos normalmente perdem diversidade em tarefas criativas, tornam-se excessivamente confiantes e exibem uma "voz de IA" característica (frases repetidas, estrutura formulada). Os pipelines de produção misturam dados autogerados com uma pequena fração de dados humanos frescos para manter a distribuição íntegra.

graph LR
    M0["Modelo SFT v0"] --> G["Gerar G respostas\npor prompt"]
    G --> S["Pontuar com regra\nou constituição"]
    S --> F["Filtrar / classificar"]
    F --> T["Ajuste fino\n(SFT ou GRPO)"]
    T --> M1["Modelo SFT v1"]
    M1 -.-->|iterar| G

    H["Dados humanos\n(pequena fração)"] --> T

    style M0 fill:#1a1a2e,stroke:#e94560,color:#fff
    style M1 fill:#1a1a2e,stroke:#51cf66,color:#fff
    style H fill:#1a1a2e,stroke:#0f3460,color:#fff

Quando Usar O Quê

• CAI Pura: Comportamento subjetivo (tom, segurança, estilo de recusa). Você tem uma constituição bem definida. Você não tem resultados verificáveis claros.
• GRPO + ORM: Tarefas verificáveis (matemática, código, extração estruturada). Você pode verificar a exatidão de forma barata. A recompensa é esparsa e binária.
• DPO em pares autogerados: Híbrido. Use a constituição para produzir pares de preferência e, em seguida, treine com DPO (Lição 08) em vez de PPO/GRPO.
• RLHF Completo: Ainda é apropriado quando você precisa de compensações de múltiplos objetivos que nem uma regra nem uma constituição curta podem expressar.

A maioria dos pipelines de fronteira de 2026 executa os quatro. CAI para camadas de segurança. GRPO para a etapa de pós-treinamento de raciocínio. DPO para o polimento de preferência. Pequenas passagens de RLHF para comportamentos residuais que resistem aos outros métodos.

Construa

O código implementa três coisas em Python puro + numpy. Um ciclo de autocrítica de IA Constitucional. Um verificador de recompensa baseado em regras para aritmética simples. Um treinador minimalista de GRPO que roda em um modelo de linguagem minúsculo da Lição 04.

Etapa 1: A Constituição

Uma lista de princípios. Em produção, cada linha seria mais rica e marcada por categoria. Para a lição, mantenha curta.

CONSTITUTION = [
    "The response must directly answer the question asked, without hedging.",
    "The response must not include unnecessary filler or padding.",
    "If the question has a single numeric answer, state the number plainly.",
    "The response must not refuse a reasonable, benign request.",
]

Etapa 2: Autocrítica e Revisão

Em um sistema real, o próprio modelo critica. Na lição, simulamos um crítico com uma rubrica escrita à mão para que o pipeline funcione sem uma chamada de LLM.

def critique(response: str, principle: str) -> dict:
    problems = []
    if len(response.split()) > 40 and "plainly" in principle:
        problems.append("answer buried in extra prose")
    if response.strip().lower().startswith(("i can't", "i cannot", "as an ai")):
        problems.append("unwarranted refusal")
    if response.count(",") > 4:
        problems.append("too much hedging")
    return {"principle": principle, "problems": problems}

def revise(response: str, critique_result: dict) -> str:
    if "answer buried" in " ".join(critique_result["problems"]):
        return response.split(".")[-2].strip() + "."
    if "unwarranted refusal" in " ".join(critique_result["problems"]):
        return "Here is the answer: " + response.split(":")[-1].strip()
    return response

A função de revisão é um substituto temporário. Com um LLM real, seria um segundo prompt: "Dada a crítica, reescreva a resposta."

Etapa 3: Recompensas Baseadas em Regras

Para tarefas verificáveis, substitua completamente o crítico. Este verificador pontua respostas aritméticas.

import re

def reward_math(prompt: str, response: str) -> float:
    try:
        expected = eval(prompt.replace("What is ", "").replace("?", "").strip())
    except Exception:
        return 0.0
    numbers = re.findall(r"-?\d+", response)
    if not numbers:
        return 0.0
    return 1.0 if int(numbers[-1]) == expected else 0.0

def reward_format(response: str) -> float:
    return 1.0 if re.search(r"<answer>.*</answer>", response) else 0.0

Duas regras determinísticas. Sem dados de treinamento. Sem rótulos humanos. A recompensa combinada é reward_math + 0.1 * reward_format, penalizando a falta de formato sem ofuscar a exatidão.

Etapa 4: Vantagem Relativa ao Grupo

Dada uma lista de recompensas para um grupo de respostas ao mesmo prompt, calcule o escore-z:

import numpy as np

def group_relative_advantage(rewards: list[float]) -> np.ndarray:
    r = np.array(rewards, dtype=float)
    if r.std() < 1e-8:
        return np.zeros_like(r)
    return (r - r.mean()) / (r.std() + 1e-8)

Se cada amostra no grupo tiver a mesma recompensa, a vantagem será zero e nenhum sinal de gradiente fluirá. Esta é uma característica. Ela informa que o prompt é trivialmente resolvido ou impossivelmente difícil para a política atual, e a etapa deve ignorá-lo.

Etapa 5: Atualização do GRPO

Uma etapa, gradiente simbólico. Na produção, isso seria uma passagem de torch autograd. Aqui mostramos a regra de atualização diretamente.

def grpo_step(policy_logprobs: np.ndarray, ref_logprobs: np.ndarray,
              advantages: np.ndarray, beta: float = 0.01, clip_eps: float = 0.2) -> dict:
    ratios = np.exp(policy_logprobs - ref_logprobs)
    unclipped = ratios * advantages
    clipped = np.clip(ratios, 1 - clip_eps, 1 + clip_eps) * advantages
    policy_loss = -np.minimum(unclipped, clipped).mean()
    kl = (ref_logprobs - policy_logprobs).mean()
    total_loss = policy_loss + beta * kl
    return {
        "policy_loss": float(policy_loss),
        "kl": float(kl),
        "total_loss": float(total_loss),
        "mean_ratio": float(ratios.mean()),
    }

Este é o substituto cortado (clipped surrogate) do PPO com uma mudança: as vantagens vieram de escores-z relativos ao grupo, não de uma função de valor. Nenhum V(s) para treinar. Sem GAE. O grupo é a linha de base.

Etapa 6: Rodada de Autoaperfeiçoamento

Junte as peças. Colete amostras de um grupo, pontue cada resposta com a regra, calcule as vantagens e relate as métricas que você alimentaria em um otimizador real.

def self_improvement_round(prompts: list[str], policy_sampler, group_size: int = 8) -> dict:
    metrics = []
    for prompt in prompts:
        responses = [policy_sampler(prompt) for _ in range(group_size)]
        rewards = [reward_math(prompt, r) + 0.1 * reward_format(r) for r in responses]
        advantages = group_relative_advantage(rewards)
        best = responses[int(np.argmax(rewards))]
        metrics.append({
            "prompt": prompt,
            "mean_reward": float(np.mean(rewards)),
            "best_reward": float(np.max(rewards)),
            "std_reward": float(np.std(rewards)),
            "best_response": best,
            "advantages": advantages.tolist(),
        })
    return {"per_prompt": metrics,
            "overall_mean": float(np.mean([m["mean_reward"] for m in metrics]))}

Use

Executar code/main.py roda ambos os ciclos de ponta a ponta. O ciclo de CAI produz um pequeno conjunto de pares (inicial, revisado) nos quais você poderia fazer o ajuste fino. O ciclo de GRPO produz estatísticas de recompensa por prompt para problemas aritméticos, mostrando como as vantagens relativas ao grupo permitem que um amostrador fraco melhore sem uma função de valor ou rótulos humanos.

Os números não são o objetivo. Em uma execução real com um modelo treinado, a média da recompensa deve subir ao longo das rodadas, o desvio padrão da recompensa deve permanecer positivo (se colapsar para zero, a política sofreu colapso de modo e você deve parar) e o KL em relação à referência deve crescer lentamente. Essas três curvas -- média da recompensa subindo, desvio padrão estável, KL limitado -- são a verificação de integridade de produção para um pipeline de GRPO ou CAI.

Envie

Esta lição produz outputs/skill-self-improvement-auditor.md. Forneça a ele um pipeline de autoaperfeiçoamento proposto e ele aplicará os portões não negociáveis: uma regra de recompensa que seja realmente verificável, um limite de KL contra a referência, um piso de diversidade e uma cota de dados humanos. Ele se recusa a aprovar um ciclo que alega ser "puro autoaperfeiçoamento" sem qualquer fundamentação externa.

Exercícios

1. Substitua o crítico manual na Etapa 2 por uma chamada de LLM. Use qualquer modelo de chat local. Meça com que frequência a crítica e a revisão realmente melhoram a resposta versus deixá-la inalterada.

2. Adicione um terceiro princípio constitucional sobre factualidade. Execute o pipeline em prompts que exigem afirmações factuais (capitais, datas) e meça quantas revisões removem erros factuais versus introduzem novos erros.

3. Implemente DPO nos pares de preferência produzidos pela etapa 2 da CAI. Pegue 20 prompts, gere duas respostas para cada um, faça o crítico escolher um vencedor por par e, em seguida, execute a perda de DPO da Lição 08. Compare com o caminho do GRPO nos mesmos dados.

4. Adicione regularização de entropia ao objetivo do GRPO. O termo -alpha * entropy(policy) com alpha=0.01 incentiva a amostragem diversa. Meça se isso retarda o colapso de modo ao longo de 5 rodadas de autoaperfeiçoamento.

5. Construa um pontuador de recompensa de processo para um problema aritmético de duas etapas. Dado "Qual é (3+4)*5?", o modelo deve mostrar a etapa intermediária 3+4=7. Avalie a etapa intermediária separadamente da resposta final e compare o GRPO ponderado por PRM com o GRPO ponderado apenas por ORM ao longo de 10 rodadas.

Termos-Chave

Leitura Adicional

• Bai et al., 2022 -- "Constitutional AI: Harmlessness from AI Feedback" -- o artigo original de CAI da Anthropic com o pipeline de duas etapas SL-CAI + RLAIF
• Shao et al., 2024 -- "DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models" -- introduz o GRPO
• DeepSeek-AI, 2025 -- "DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning" -- R1 e R1-Zero, GRPO + recompensas de regras em escala
• Lightman et al., 2023 -- "Let's Verify Step by Step" -- PRM800K da OpenAI e o caso dos modelos de recompensa de processo
• Wang et al., 2024 -- "Math-Shepherd: Verify and Reinforce LLMs Step-by-step without Human Annotations" -- PRM auto-rotulado via rollouts de Monte Carlo
• Huang et al., 2024 -- "Large Language Models Cannot Self-Correct Reasoning Yet" -- o contraponto cético sobre o autoaperfeiçoamento sem fundamentação externa