Phase 09 - Lesson 12

RL para Jogos — AlphaZero, MuZero e a Era do Raciocínio de LLMs

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

1992: TD-Gammon venceu campeões humanos no gamão com TD puro. 2016: AlphaGo venceu Lee Sedol. 2017: AlphaZero dominou o xadrez, shogi e Go do zero. 2024: DeepSeek-R1 provou que a mesma receita, com GRPO substituindo o PPO, funciona para raciocínio. Os jogos são o benchmark que impulsiona cada avanço nesta fase.

Tipo: Build Linguagens: Python Pré-requisitos: Phase 9 · 05 (DQN), Phase 9 · 08 (PPO), Phase 9 · 09 (RLHF), Phase 9 · 10 (MARL) Tempo: ~120 minutos

O Problema

Os jogos têm tudo o que o RL deseja. Recompensa limpa (vitória/derrota). Episódios infinitos (reinicializações de auto-jogo). Simulação perfeita (o jogo é o simulador). Espaços de ação discretos ou contínuos pequenos. Estrutura multiagente que força a robustez adversarial.

E os jogos são como cada grande avanço de RL foi testado. TD-Gammon (gamão, 1992). Atari-DQN (2013). AlphaGo (2016). AlphaZero (2017). OpenAI Five (Dota 2, 2019). AlphaStar (StarCraft II, 2019). MuZero (modelo aprendido, 2019). AlphaTensor (multiplicação de matrizes, 2022). AlphaDev (algoritmos de ordenação, 2023). DeepSeek-R1 (raciocínio matemático, 2025) — a demonstração mais recente de que as técnicas de RL para jogos funcionam em texto.

Este projeto de conclusão examina as três arquiteturas de referência — AlphaZero, MuZero e GRPO — sob uma única lente unificadora: auto-jogo + busca + melhoria de política. Cada uma generaliza a anterior; o GRPO, em particular, é a receita do AlphaZero aplicada ao raciocínio de LLMs, com tokens como ações e a verificação matemática como sinal de vitória.

O Conceito

O loop unificador.

while True:
    trajectory = self_play(current_policy, search)     # play game against self
    policy_target = search.improved_policy(trajectory) # search improves raw policy
    policy_net.update(policy_target, value_target)     # supervised on search output

AlphaZero (2017). Silver et al. Dado um jogo (xadrez, shogi, Go) com regras conhecidas:

• Rede de política-valor: uma torre f_θ(s) → (p, v). p é uma prior sobre movimentos legais. v é o resultado esperado do jogo.
• Monte Carlo Tree Search (MCTS): a cada movimento, expande uma árvore de possíveis continuações. Usa (p, v) como prior + bootstrap. Seleciona nós por UCB (PUCT): a* = argmax Q(s, a) + c · p(a|s) · √N(s) / (1 + N(s, a)).
• Auto-jogo: joga partidas agente-contra-agente. No movimento t, a distribuição de visitas do MCTS π_t torna-se o alvo de treinamento da política.
• Perda: L = (v - z)² - π · log p + c · ||θ||². z é o resultado do jogo (+1 / 0 / -1).

Zero conhecimento humano. Zero heurísticas manuais. Uma única receita que dominou xadrez, shogi e Go após algumas dezenas de milhões de partidas de auto-jogo cada.

MuZero (2019). Schrittwieser et al. Remove a exigência de que as regras sejam conhecidas.

• Em vez de um ambiente fixo, aprende um modelo de dinâmica latente (h, g, f):
  • h(s): codifica a observação para o estado latente.
  • g(s_latent, a): prevê o próximo estado latente + recompensa.
  • f(s_latent): prevê a prior da política + valor.
• O MCTS é executado no espaço latente aprendido. Mesma busca, mesmo loop de treinamento.
• Funciona em Go, xadrez, shogi e Atari — um algoritmo, sem conhecimento das regras.

Stochastic MuZero (2022). Adiciona dinâmicas estocásticas e nós de chance; estende-se para jogos da classe do gamão.

Muesli, Gumbel MuZero (2022-2024). Melhorias na eficiência de amostragem e busca determinística.

GRPO (2024-2025). Receita do DeepSeek-R1. Mesmo loop no estilo AlphaZero, aplicado ao raciocínio de modelos de linguagem:

• "Jogo": responder a um problema de matemática / programação / raciocínio. "Vitória" = verificador (caso de teste passa, resposta numérica corresponde) retorna 1.

• Política: a LLM. Ações: tokens. Estado: prompt + resposta até o momento.

• Sem crítico (estilo PPO V_φ). Em vez disso, para cada prompt, amostra G conclusões da política. Calcula a recompensa para cada uma. Usa a vantagem relativa ao grupo A_i = (r_i - mean_r) / std_r como o sinal para a atualização no estilo REINFORCE.

• Penalidade KL em relação à política de referência para evitar desvio (como no RLHF).

• Perda completa:

  L_GRPO(θ) = -E_{q, {o_i}} [ (1/G) Σ_i A_i · log π_θ(o_i | q) ] + β · KL(π_θ || π_ref)

Sem modelo de recompensa, sem crítico, sem MCTS. A linha de base relativa ao grupo substitui os três. Iguala ou supera a qualidade do PPO-RLHF em benchmarks de raciocínio com uma fração do custo computacional.

A receita do R1 completa. O DeepSeek-R1 (DeepSeek 2025) consiste em dois modelos em um único artigo:

• R1-Zero. Começa a partir do modelo base DeepSeek-V3. Sem SFT. Aplica o GRPO diretamente com dois componentes de recompensa: recompensa de acurácia (baseada em regras — a resposta final foi analisada para o número correto / o código passou nos testes unitários) e recompensa de formato (a conclusão envolveu sua cadeia de pensamento nas tags <think>…</think>). Ao longo de milhares de etapas, o comprimento médio da resposta cresce de ~100 para ~10.000 tokens e as pontuações de benchmark de matemática sobem para níveis próximos ao o1-preview. O modelo aprende a raciocinar do zero. O lado negativo: suas cadeias de pensamento são frequentemente ilegíveis, misturam idiomas e carecem de polimento estilístico.
• R1. Corrige os problemas de legibilidade do R1-Zero com um pipeline de quatro estágios:
  1. SFT de partida a frio (Cold-start). Coleta alguns milhares de demonstrações de CoT longa com formatação limpa. Realiza o ajuste fino supervisionado (SFT) do modelo base nelas. Isso fornece um ponto de partida legível.
  2. GRPO orientado a raciocínio. Aplica o GRPO com as recompensas de acurácia+formato, além de uma recompensa de consistência de idioma para evitar a alternância de código (code-switching).
  3. Amostragem de rejeição + SFT rodada 2. Amostra ~600K trajetórias de raciocínio a partir do checkpoint de RL, mantém apenas aquelas com respostas finais corretas e CoT legível, e as combina com ~200K exemplos de SFT que não são de raciocínio (escrita, perguntas e respostas, autoconhecimento). Ajusta finamente o modelo base novamente.
  4. GRPO de espectro completo. Mais uma rodada de RL abrangendo tanto raciocínio (recompensas baseadas em regras) quanto alinhamento geral (recompensas baseadas em preferências de utilidade/inocuidade).

O resultado iguala o o1 no AIME e MATH-500 com pesos abertos, e é pequeno o suficiente para destilação. O mesmo artigo também lança seis modelos densos destilados (Qwen-1.5B até Llama-70B) fazendo SFT nos traços de raciocínio do R1 — sem RL no modelo estudante. A destilação de um professor de RL forte supera consistentemente o RL do zero na escala do estudante.

Por que o GRPO em vez do PPO para raciocínio. Três razões no artigo do DeepSeekMath (Fev 2024): (1) nenhum modelo de valor para treinar, cortando a memória pela metade; (2) a linha de base do grupo lida naturalmente com a recompensa esparsa de fim de trajetória que as tarefas de raciocínio produzem; (3) a normalização por prompt torna as vantagens comparáveis entre problemas de dificuldades muito diferentes, o que o crítico único do PPO não consegue fazer.

Sem busca vs baseado em busca. Os jogos se ramificaram:

• Jogos de informação perfeita com horizontes longos (Go, xadrez): ainda baseados em busca. AlphaZero / MuZero dominam.
• Raciocínio de LLMs: sem MCTS em produção ainda; GRPO em rollouts completos, best-of-N para computação de inferência. Modelos de recompensa de processo (PRMs) sugerem que a busca no nível de etapas está sendo adicionada de volta.

Construa

O código em code/main.py implementa o GRPO em miniatura — um bandit com múltiplos grupos de amostras. O algoritmo é o mesmo de uma LLM; apenas a política e o ambiente são mais simples. Ele ensina a perda (loss) e a vantagem relativa ao grupo, que é a inovação de 2025.

Passo 1: um ambiente verificador minúsculo

QUESTIONS = [
    {"prompt": "q1", "correct": 3},
    {"prompt": "q2", "correct": 1},
]

def verify(prompt_idx, answer_token):
    return 1.0 if answer_token == QUESTIONS[prompt_idx]["correct"] else 0.0

No GRPO real, o verificador executa testes unitários ou verifica a igualdade matemática.

Passo 2: política: softmax sobre K tokens de resposta por prompt

def policy_probs(theta, p_idx):
    return softmax(theta[p_idx])

Equivalente à saída da camada final de uma LLM condicionada a um prompt.

Passo 3: amostragem de grupo e vantagem relativa ao grupo

def grpo_step(theta, p_idx, G=8, beta=0.01, lr=0.1, rng=None):
    probs = policy_probs(theta, p_idx)
    samples = [sample(probs, rng) for _ in range(G)]
    rewards = [verify(p_idx, s) for s in samples]
    mean_r = sum(rewards) / G
    std_r = stddev(rewards) + 1e-8
    advs = [(r - mean_r) / std_r for r in rewards]

    for a, A in zip(samples, advs):
        grad = onehot(a) - probs
        for i in range(len(probs)):
            theta[p_idx][i] += lr * A * grad[i]
    # KL penalty: pull theta toward reference
    for i in range(len(probs)):
        theta[p_idx][i] -= beta * (theta[p_idx][i] - reference[p_idx][i])

A vantagem relativa ao grupo é o truque da DeepSeek de 2024. Nenhum crítico é necessário. A "linha de base" (baseline) é a média do grupo, e a normalização usa o desvio padrão do grupo.

Passo 4: comparar com a linha de base do REINFORCE (livre de valor)

Mesma configuração, mesma computação, REINFORCE simples. O GRPO converge mais rápido e de forma mais estável.

Passo 5: observar entropia e KL

Mesmos diagnósticos do RLHF: KL médio em relação à referência, entropia da política, recompensa ao longo do tempo. Quando estes se estabilizam, o treinamento está concluído.

Armadilhas (Pitfalls)

• Trapaça de recompensa (Reward hacking) por meio de manipulação do verificador. O GRPO herda o risco do RLHF: se o verificador estiver errado ou for explorável, a LLM encontrará a brecha. Verificadores robustos (múltiplos casos de teste, provas formais) são importantes.
• Tamanho de grupo muito pequeno. A variância da linha de base do grupo varia como 1/√G. Abaixo de G = 4, o sinal de vantagem é ruidoso; a escolha padrão é de G = 8 a 64.
• Viés de comprimento. Conclusões de LLMs com comprimentos diferentes têm log-probabilidades diferentes. Normalize pela contagem de tokens, use log-prob no nível de sequência ou trunque para o comprimento máximo.
• Ciclos puros de auto-jogo. O treinamento no estilo AlphaZero pode ficar preso em loops de dominância em jogos de soma geral. Mitigado por pools de oponentes diversos (jogo de liga/league play, Lição 10).
• Incompatibilidade de política de busca. O AlphaZero treina a política para imitar a saída da busca. Se a rede de política for pequena demais para representar a distribuição da busca, o treinamento estagna.
• Piso computacional mínimo. O MuZero / AlphaZero precisam de computação massiva. Uma única ablação geralmente consome centenas de horas de GPU. Existem demonstrações em miniatura (por exemplo, AlphaZero no Connect Four) para fins de aprendizado.
• Cobertura do verificador. Testes unitários que passam para uma solução com bugs reforçam o bug. Projete verificadores que capturem casos extremos.

Use

O panorama de RL para jogos em 2026, por domínio:

A receita — auto-jogo, melhoria aumentada por busca, destilação de política — abrange texto, pixels e controle físico. O GRPO é o exemplo mais recente; outros estão por vir.

Envie

Salve como outputs/skill-game-rl-designer.md:

---
name: game-rl-designer
description: Design a game-RL or reasoning-RL training pipeline (AlphaZero / MuZero / GRPO) for a given domain.
version: 1.0.0
phase: 9
lesson: 12
tags: [rl, alphazero, muzero, grpo, self-play]
---

Given a target (perfect-info game / imperfect-info / Atari / LLM reasoning / combinatorial), output:

1. Environment fit. Known rules? Markov? Stochastic? Multi-agent? Informs AlphaZero vs MuZero vs GRPO.
2. Search strategy. MCTS (PUCT with learned prior), Gumbel-sampled, best-of-N, or none.
3. Self-play plan. Symmetric self-play / league / offline data / verifier-generated.
4. Target signal. Game outcome / verifier reward / preference / learned model. Include robustness plan.
5. Diagnostics. Win rate vs baseline, ELO curve, verifier pass rate, KL to reference.

Refuse AlphaZero on imperfect-info games (route to CFR). Refuse GRPO without a trusted verifier. Refuse any game-RL pipeline without a fixed baseline opponent set (self-play ELO is uncalibrated otherwise).

Exercícios

1. Fácil. Implemente o bandit de GRPO em code/main.py. Treine em 2 prompts × 4 tokens de resposta cada. Converja em < 1.000 atualizações com G=8.
2. Médio. Conecte o PPO (cortado/clipped) e o REINFORCE clássico. Compare a eficiência de amostragem e a variância da recompensa com o GRPO no mesmo bandit.
3. Difícil. Estenda para uma "cadeia de raciocínio" de comprimento 2: o agente emite dois tokens e o verificador recompensa o par. Meça como o GRPO lida com a atribuição de crédito ao longo de sequências de duas etapas. (Dica: calcule a vantagem do grupo por sequência completa, propague para ambas as posições de token.)

Termos-Chave

Leituras Adicionais

• Silver et al. (2017). Mastering the game of Go without human knowledge (AlphaGo Zero).
• Silver et al. (2018). A general reinforcement learning algorithm that masters chess, shogi, and Go through self-play (AlphaZero).
• Schrittwieser et al. (2020). Mastering Atari, Go, chess and shogi by planning with a learned model (MuZero).
• Vinyals et al. (2019). Grandmaster level in StarCraft II (AlphaStar).
• DeepSeek-AI (2024). DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models (GRPO) — o artigo que introduziu o GRPO e a linha de base relativa ao grupo.
• DeepSeek-AI (2025). DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning — a receita do R1 completa de quatro estágios mais a ablação do R1-Zero.
• Brown et al. (2019). Superhuman AI for multiplayer poker (Pluribus) — CFR + aprendizado profundo em escala.
• Tesauro (1995). Temporal Difference Learning and TD-Gammon — o artigo que deu início a tudo.
• Hugging Face TRL — GRPOTrainer — a referência de produção para aplicar GRPO com funções de recompensa personalizadas.
• Qwen Team (2024). Qwen2.5-Math — GRPO replication — replicação aberta da receita do R1 em múltiplas escalas.
• Sutton & Barto (2018). Ch. 17 — Frontiers of Reinforcement Learning — o enquadramento didático para auto-jogo, busca e "recompensa projetada" que o R1 instancia na escala de LLMs.