GRPO: como o aprendizado por reforço treina modelos de linguagem pequenos com recompensas verificáveis

A ideia central

Um modelo de linguagem pode escrever “deixa eu verificar isso” e mesmo assim errar a multiplicação. Pode até escrever “espera, deixa eu reconsiderar” e chegar a uma resposta errada diferente. Nenhuma dessas frases é evidência de raciocínio. Se o objetivo é resolver o problema, só o número final importa.

É dessa premissa que parte o GRPO (Group Relative Policy Optimization), técnica de aprendizado por reforço que ganhou destaque com o DeepSeek-R1-Zero. Ela permite treinar um modelo de linguagem com recompensas verificáveis — sem precisar de um modelo “crítico” separado e sem precisar escrever a solução que o modelo deve imitar.

Como o GRPO funciona

O GRPO foi introduzido no trabalho do DeepSeekMath como alternativa ao PPO convencional, que treina um estimador de valor (o critic) junto da política. Esse estimador consome memória e fornece a linha de base para julgar o resultado de uma ação.

O GRPO dispensa o critic: a linha de base vem de um grupo de respostas geradas para a mesma pergunta. Em vez de perguntar “quão bem o modelo deveria ir?”, ele compara “quão bem várias tentativas realmente foram”.

Imagine quatro respostas a uma mesma questão de aritmética, com recompensa binária (certa = 1, errada = 0): duas acertam e duas erram. A média do grupo é 0,5. As que acertaram ficam acima da média; as que erraram, abaixo. A “vantagem” de cada tentativa é calculada pela fórmula:

advantage = (recompensa - média_do_grupo) / desvio_padrão_do_grupo

Em Python, para recompensas binárias, o cálculo fica assim:

from statistics import mean, pstdev

rewards = [1.0, 0.0, 1.0, 0.0]
group_mean = mean(rewards)
group_std = pstdev(rewards)

# Recompensas iguais não geram ranking dentro do grupo
if group_std == 0:
    advantages = [0.0] * len(rewards)
else:
    advantages = [(r - group_mean) / group_std for r in rewards]

print(advantages)  # [1.0, -1.0, 1.0, -1.0]

O otimizador usa essas vantagens para ajustar as probabilidades das respostas geradas, favorecendo as de maior recompensa. É um sinal que se aplica à resposta inteira — sem apontar exatamente qual passo aritmético causou o acerto.

O ponto que muitos ignoram: a função de recompensa

O GRPO em si é só o algoritmo. O que define o sucesso é o que você escolhe recompensar. Se a regra for “recompense sempre que a string 42 aparecer na resposta”, um texto como “eu considerei 42, mas minha resposta final é 40” seria aceito — e o verificador estaria errado antes mesmo do treinamento começar.

Um verificador mínimo precisa exigir um bloco de resposta único e extrair o inteiro final:

import re

FINAL = re.compile(r"<answer>\s*([+-]?[0-9]{1,12})\s*</answer>\s*\Z")

def extract_final_count(response: str):
    if response.count("<answer>") != 1 or response.count("</answer>") != 1:
        return None
    m = FINAL.search(response)
    return int(m.group(1)) if m else None

def correctness_reward(response: str, expected: int) -> float:
    c = extract_final_count(response)
    return 0.0 if c is None else float(c == expected)

A decisão do verificador define quais respostas o treinamento vai favorecer. Recompensar frases como “espera” ou “deixa eu reconsiderar” incentivaria o modelo a usá-las sem provar que elas melhoram a resolução.

Por que o treinamento local ficou viável

Sem o critic, o consumo de memória cai. Somando LoRA (que representa as atualizações de pesos em matrizes de baixo rank), QLoRA (quantização em 4 bits) e ferramentas como o Unsloth, experimentos menores cabem em máquinas locais.

Um modelo como o Qwen2.5-1.5B-Instruct, com cerca de 1,54 bilhão de parâmetros, ilustra a escala. Em 4 bits, os pesos ocupam aproximadamente 0,75 GB — mas isso é só uma conta idealizada: a GPU ainda precisa de espaço para metadados de quantização, adaptadores, ativações, caches de geração e buffers. Dois experimentos com o mesmo modelo podem ter requisitos de memória muito diferentes, dependendo das configurações de rollout.

Respostas mais longas não são (necessariamente) raciocínio

Um cuidado importante: quando as respostas ficam mais longas e com autocorreções, a interpretação tentadora é “raciocínio”. Mas pesquisas sobre o treinamento estilo R1-Zero mostraram que comportamentos associados ao “momento aha” já existiam nos modelos iniciais, e identificaram vieses na formulação original do GRPO — incluindo efeitos no comprimento das respostas —, o que motivou o Dr. GRPO.

Por isso, a avaliação deve ser feita em perguntas inéditas, com as mesmas instruções e o mesmo orçamento de tokens. A conclusão honesta de um run que melhora a recompensa é específica: naquela tarefa, o modelo ficou mais propenso a produzir respostas que o verificador aceita. Se isso generaliza para novas perguntas, é outra história.

O GRPO simplifica uma parte do aprendizado por reforço de LLMs e, com adaptadores e quantização, aproxima esses experimentos de máquinas locais. O julgamento difícil continua sendo humano: decidir o que recompensar — e checar depois se o modelo aprendeu a resolver ou apenas a agradar o verificador.