Do iniciante ao mestre: análise aprofundada do aprendizado por reforço e do treinamento do modelo GRPO

Saiba tudo sobre o aprendizado por reforço (RL) e como usar o Sem pano responder cantando GRPO Treine-se. DeepSeek-R1 Modelos de raciocínio. Um guia completo do iniciante ao mestre.

O que você aprenderá

1. O que é RL?RLVR?PPO?GRPO?RLHF?RFT?O aprendizado por reforço é realmente **"Sorte é tudo o que você precisa? **
2. O que é um ambiente? Inteligência? Ações? Funções de recompensa? Prêmios?

Este artigo aborda tudo o que você precisa saber sobre GRPO, aprendizado por reforço (RL) e funções de recompensa (do introdutório ao avançado), bem como algumas dicas e truques e os fundamentos do GRPO usando o Unsloth. Se estiver procurando um tutorial passo a passo sobre o uso do GRPO, consulte nosso guia aqui.

O que é aprendizado por reforço (RL)?

O objetivo da RL é:

1. Aumentar as chances de obter "bons" resultados.
2. Reduzir as chances de ver resultados "ruins".

**É isso aí! **Existem complexidades sobre o que significa "bom" e "ruim", ou como podemos "adicionar" ou "subtrair" disso. Ou mesmo o que significa "resultado", há algumas complexidades.

Por exemploJogos do Pacman (jogo Pacman):

1. matriz (ambiente) é o mundo do jogo.
2. Você pode usar omovimento (ações) são para cima, para a esquerda, para a direita e para baixo.
3. Se você comer um feijão.incentivos (recompensas) é bom; se você atingir os inimigos que se contorcem, as recompensas são ruins.
4. Na RL, não é possível saber qual é a "melhor jogada" a ser feita, mas é possível observar as etapas intermediárias ou o estado final do jogo (vitória ou derrota).

Como outro exemplo, imagine que lhe seja feita uma pergunta como esta:"Quanto é igual a 2 + 2?" (4) Um modelo de linguagem não alinhado produzirá 3, 4, C, D, -10, qualquer coisa.

1. É melhor um número do que um C ou um D, certo?
2. É melhor receber três do que oito, certo?
3. O resultado 4 está absolutamente correto.

Acabamos de projetar umfunção de recompensa (função de recompensa)!

De RLHF, PPO para GRPO e RLVR

A OpenAI promove o conceito de RLHF (Reinforcement Learning from Human Feedback), em que treinamos um **"agente "** (inteligência) para responder a uma pergunta (ou sejaestado das coisas (estado)) gera resultados que são avaliados como mais úteis por humanos.

Por exemplo, as curtidas e os toques no ChatGPT podem ser usados para o processo RLHF.

Fórmula PPO

clip(..., 1-e, 1+e) é usado para forçar o PPO a não mudar muito. Há também um termo KL com beta definido como > 0 para forçar o modelo a não se desviar muito.

Para implementar o RLHF, oPPO (otimização da política proximal) foi desenvolvido. Nesse caso, ocorpo inteligenteé o modelo de linguagem. Na verdade, ele consiste em 3 sistemas:

1. Estratégia de geração (modelo atualmente treinado)
2. Estratégia de referência (modelo original)
3. Modelagem de valor (Estimador de recompensa média)

Usamosmodelagem de incentivospara computar as recompensas do ambiente atual, nosso objetivo éMaximize esse prêmio!

A fórmula do PPO parece ser bastante complexa, pois foi projetada para ser estável. Visite nosso AI Engineer Talk sobre RL em 2025 para saber mais sobre a derivação matemática detalhada do PPO.

DeepSeek desenvolvido GRPO (otimização de política relativa de grupo) para treinar seu modelo de inferência R1. A principal diferença em relação à PPO é:

1. **O modelo de valor foi removido e substituído por estatísticas derivadas de várias chamadas para o modelo de recompensa.
2. Modelo de recompensa removidoe substituí-lo por algo que possa ser usado RLVR da função de recompensa personalizada.

Isso significa que o GRPO é muito eficiente. Anteriormente, o PPO exigia o treinamento de vários modelos - agora que os modelos de recompensa e valor foram removidos, podemos economizar memória e acelerar tudo.

RLVR (Aprendizado por reforço com recompensas verificáveis) Permite recompensar modelos com base em tarefas com soluções facilmente verificáveis. Exemplo:

1. As equações matemáticas podem ser facilmente verificadas. Por exemplo, 2+2 = 4.
2. A saída do código pode ser verificada quanto à execução correta.
3. Projetar funções de recompensa verificáveis pode ser difícil, portanto, a maioria dos exemplos é matemática ou baseada em código.
4. Os casos de uso do GRPO não se limitam a código ou matemática - seu processo de raciocínio pode aumentar tarefas como automação de e-mail, recuperação de banco de dados, direito e medicina, melhorando drasticamente a precisão com base em seu conjunto de dados e função de recompensa - o truque é definir umesquema de marcação (rubrica) - ou seja, uma série de recompensas menores verificáveis, em vez de uma única recompensa final e abrangente. A OpenAI, por exemplo, promove isso em seu serviço de ajuste fino do aprendizado por reforço (RFT).

Por que Group Relative?

O GRPO remove completamente o modelo de valor, mas ainda precisamos estimar a **"recompensa média "** considerando o estado atual.

O truque é fazer uma amostragem de modelos de linguagem grandes! Em seguida, calculamos a recompensa média contando o processo de amostragem para várias perguntas diferentes.

Por exemplo, para a pergunta "What does 2+2 equal?" (Quanto é igual a 2+2?) Por exemplo, para a pergunta "Quantas vezes 2+2 é igual a?", testamos a pergunta 4 vezes. Podemos obter 4, 3, D, C. Em seguida, calculamos a recompensa para cada uma dessas respostas e, depois, calculamos a recompensa paraIncentivo médioresponder cantando(estatística) desvio padrãoe, em seguida, prossiga para Padronização de escore Z!

Isso cria oVantagem A (vantagem A), que usaremos em vez do modelo de valor. Isso economiza muita memória!

Cálculo dos pontos fortes da GRPO

Sorte (ou paciência) é tudo o que você precisa!

O truque da RL é que você só precisa de duas coisas:

1. Uma pergunta ou instrução, por exemplo, "What is 2+2 equal to?" (O que é 2+2 igual a?) "Criar um jogo Flappy Bird em Python".
2. Uma função de recompensa e um validador para verificar se o resultado é bom ou ruim.

Apenas com esses dois, podemos basicamenteChamadas ilimitadas para um modelo de idiomaAté obtermos uma boa resposta. Por exemplo, para a pergunta "What does 2+2 equal?" um modelo de linguagem pobre não treinado produziria:

0, cat, -10, 1928, 3, A, B, 122, 17, 182, 172, A, C, BAHS, %$, #, 9, -192, 12,31 e, de repente, 4.

O sinal de recompensa é 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 e, de repente, 1.

Assim, por meio da sorte e do acaso, a RL conseguiu encontrar a resposta certa em muitos **"rollouts "** (lançamentos). Nosso objetivo é ver mais respostas boas e muito menos o resto (respostas ruins).

Portanto, o objetivo da RL é ser paciente - no limite, se a probabilidade da resposta correta for pelo menos um número pequeno (não zero), é apenas um jogo de espera - você 100% certamente encontrará a resposta correta no limite.

É por isso que gosto de chamar o aprendizado por reforço de "sorte é tudo de que você precisa".

Bem, uma maneira melhor de dizer isso seria "paciência é tudo o que você precisa" para o aprendizado por reforço.

Essencialmente, a RL nos oferece um truque: em vez de simplesmente esperar até o infinito, recebemos "sinais ruins", ou seja, respostas ruins, e podemos efetivamente "inicializar" o modelo para que ele tente não gerar soluções ruins. Podemos efetivamente "orientar" o modelo para que ele tente não gerar soluções ruins. Isso significa que, mesmo que você tenha esperado muito tempo para que uma "boa" resposta apareça, o modelo já mudou e fará o possível para não gerar uma resposta ruim.

No exemplo "What does 2+2 equal?" (O que equivale a 2+2?) exemplo:

0, cat, -10, 1928, 3, A, B, 122, 17, 182, 172, A, C, BAHS, %$, #, 9, -192, 12,31 e, de repente, 4.

À medida que obtemos respostas ruins, a RL influencia o modelo a tentar não produzir respostas ruins. Isso significa que, com o passar do tempo, estamos cuidadosamente "podando" ou afastando a distribuição de saída do modelo das respostas ruins. Isso significa que a RL não é ineficiente porque não estamos apenas esperando o infinito, mas estamos ativamente tentando "empurrar" o modelo o máximo possível para o "espaço de respostas corretas".

Se a probabilidade for sempre 0, então a RL nunca funcionará!. É por isso que se prefere iniciar a RL com um modelo que tenha sido ajustado pelas instruções, que possa seguir as instruções de forma parcial e razoável - isso provavelmente aumentará a probabilidade acima de 0.

O que o Unsloth oferece à RL

• Com apenas 15 GB de VRAM, o Unsloth permite transformar qualquer modelo com até 17 bilhões de parâmetros, como Llama 3.1 (8 bilhões), Phi-4 (14 bilhões), Mistral (7 bilhões) ou Qwen2.5 (7 bilhões), em um modelo de inferência.
• **Requisitos mínimos:** Apenas 5 GB de VRAM são suficientes para treinar seu próprio modelo de inferência localmente (para qualquer modelo com parâmetros de 1,5 B ou menos).

⚡ Tutorial: treinando seus próprios modelos de inferência com o GRPO

Caderno do GRPO

• Qwen3 (4B) - alto nível
• DeepSeek-R1-0528-Qwen3-8B - recentemente
• Llama 3.2 (3B) - Premium
• Gemma 3 (1B)
• Phi-4 (14B)
• Qwen2.5 (3B)
• Mistral v0.3 (7B)
• Llama 3.1 (8B)

**Novo recurso! **Agora oferecemos suporte ao Dr. GRPO e à maioria das outras novas tecnologias GRPO. Você pode encontrar isso na seção GRPOConfig Use os seguintes parâmetros para ativá-los:

fazer uma cópia de

epsilon=0.2,
epsilon_high=0.28, # one sided
delta=1.5, # two sided
loss_type='bnpo',
# or:
loss_type='grpo',
# or:
loss_type='dr_grpo',
mask_truncated_completions=True,

• Se não obtiver nenhum resultado de inferência, verifique se há etapas de treinamento suficientes e se a função de recompensa/validador está funcionando corretamente. Fornecemos exemplos de funções de recompensa aqui.
• Demonstrações anteriores mostraram que você pode obter seus próprios momentos de epifania com o Qwen 2.5 (3B), mas isso requer uma GPU 2xA100 (160 GB de VRAM). Agora, com o Unsloth, você pode obter o mesmo momento de epifania com apenas uma GPU de 5 GB de VRAM.
• Anteriormente, o GRPO suportava apenas o ajuste fino completo, mas tornamos possível usá-lo com o QLoRA e o LoRA.
• Por exemploComprimento do contexto de 20KCom 8 respostas geradas por prompt, o Unsloth usa apenas 54,3 GB de VRAM para o Llama 3.1 (8B), enquanto a implementação padrão (+ Flash Attention 2) requer 510.8GB (Unsloth reduzido por 90%).
• Observe que isso não é um ajuste fino do modelo de destilação R1 do DeepSeek ou um ajuste usando os dados de destilação do R1, que já são suportados pelo Unsloth. Trata-se de converter um modelo padrão usando GRPO em um modelo de inferência completo.

Em um exemplo de teste, embora só tenhamos treinado o Phi-4 para 100 etapas com GRPO, os resultados já são óbvios. O modelo que não usou o GRPO não pensou no Token, enquanto o modelo treinado com o GRPO pensou, e a resposta estava correta.

Treinamento com o GRPO

Para obter um tutorial sobre como converter qualquer modelo de linguagem grande e aberto em um modelo de inferência usando Unsloth e GRPO, consulte aqui.

Como a GRPO treina modelos

1. Para cada par de testes, o modelo gera várias respostas possíveis (por exemplo, 8 variantes).
2. Cada resposta é avaliada usando uma função de recompensa.
3. Etapas do treinamento:
   • Se você tiver 300 linhas de dados, serão 300 etapas de treinamento (900 etapas se você treinar 3 épocas).
   • Você pode aumentar o número de respostas geradas por pergunta (por exemplo, de 8 para 16).
4. O modelo aprende atualizando seus pesos a cada etapa.

Se estiver tendo problemas para aprender seu modelo de GRPO, recomendamos usar nosso Advanced GRPO Notebook, pois ele tem uma função de recompensa melhor e você deverá ver os resultados com mais rapidez e frequência.

Noções básicas/dicas

• Pelo menos, espere. 300 passosSe você não treinar, as recompensas podem realmente aumentar. Para obter resultados decentes, você provavelmente precisará treinar por pelo menos 12 horas (é assim que o GRPO funciona), mas lembre-se de que isso não é obrigatório e você pode parar a qualquer momento.
• Para obter melhores resultados, pelo menos 500 linhas de dadosVocê pode até tentar com 10 linhas de dados, mas mais seria melhor. Você pode até tentar com 10 linhas de dados, mas mais dados seriam melhores.
• Cada execução de treinamento varia de acordo com seu modelo, dados, função de recompensa/validador, etc. Portanto, embora tenhamos escrito um mínimo de 300 etapas, às vezes podem ser necessárias 1.000 ou mais. Portanto, isso depende de vários fatores.
• Se estiver usando o Unsloth localmente para o GRPO, se encontrar um erro, também pip install diffusers. Além disso, use a versão mais recente do vLLM.
• Recomenda-se que o GRPO seja aplicado a pelo menos 1.5B Parâmetrospara gerar o Think Token corretamente, pois modelos menores podem não conseguir fazer isso.
• GRPO'sRequisitos de VRAM da GPU (QLoRA de 4 bits)A regra geral é que os parâmetros do modelo = a quantidade de VRAM necessária (você pode usar menos VRAM, mas isso é apenas por segurança). Quanto mais longo for o comprimento do contexto, mais VRAM será necessária. loRA de 16 bits usará pelo menos 4 vezes mais VRAM.
• O ajuste fino contínuo éPossivelmente, você pode manter o GRPO em execução em segundo plano o tempo todo.
• No notebook de exemplo, usamos oConjunto de dados GSM8KEssa é, de longe, a opção mais popular para o treinamento no estilo R1.
• Se você estiver usando o modelo básico, certifique-se de ter um modelo de bate-papo.
• Quanto mais você treinar com o GRPO, melhor. A vantagem do GRPO é que você nem precisa de muitos dados. Tudo o que você precisa é de uma função/validador de recompensa excelente e, quanto mais você treinar, melhor será o seu modelo. Espere que sua recompensa aumente com o tempo em relação ao número de etapas, conforme mostrado abaixo:

• O rastreamento de perda de treinamento do GRPO agora está incorporado diretamente no Unsloth, eliminando a necessidade de ferramentas externas, como o wandb. Ele contém detalhes completos de registro de todas as funções de recompensa, incluindo a própria função de recompensa agregada.

Funções de bônus / validadores

Em Intensive Learning (Aprendizagem Intensiva).função de recompensa (Função de recompensa) evalidador (Verificador) desempenha uma função diferente na avaliação da saída do modelo. Em geral, você pode entendê-los como a mesma coisa, mas, tecnicamente, não são a mesma coisa, mas isso não importa, pois geralmente são usados em combinação.

validador (Verificador):

• Determina se a resposta gerada está correta ou incorreta.
• Ele não atribui pontuações numéricas, apenas verifica a correção.
• Exemplo: Se um modelo gerar "5" para "2+2", o validador verifica e marca essa resposta como "errada" (porque a resposta correta é 4).
• O validador também pode executar o código (por exemplo, em Python) para verificar a lógica, a sintaxe e a correção sem avaliação manual.

função de recompensa (Função de recompensa):

• Converter resultados de validação (ou outros critérios) em pontuações numéricas.
• Exemplo: Se a resposta estiver errada, pode ser atribuída uma penalidade (-1, -2, etc.), enquanto uma resposta correta pode receber uma pontuação positiva (+1, +2).
• Ele também pode penalizar com base em critérios que não sejam a correção, como comprimento excessivo ou legibilidade ruim.

A principal diferença::

• validadorVerifique se está correto, mas não pontue.
• função de recompensaAtribuição de pontuações, mas não necessariamente verificação da correção em si.
• função de recompensapossívelSão usados validadores, mas eles não são tecnicamente iguais.

Entendendo a função de recompensa

O principal objetivo do GRPO é maximizar as recompensas e aprender como as respostas são obtidas, em vez de apenas memorizar e reproduzir as respostas dos dados de treinamento.

• Em cada etapa de treinamento, o GRPO Ajuste dos pesos do modelopara maximizar os prêmios. Esse processo ajusta progressivamente o modelo.
• Ajuste fino de rotina (sem GRPO) apenasMaximizar a probabilidade prevista da próxima palavramas não será otimizado para recompensas.GRPO Otimização para uma função de recompensae não apenas prever a próxima palavra.
• Você pode fazer isso em várias épocasReutilização de dados.
• Função de recompensa padrãopodem ser predefinidos para vários casos de uso, ou você pode fazer com que o ChatGPT/modelos nativos os gerem para você.
• Não existe uma única maneira correta de projetar uma função de recompensa ou validador - as possibilidades são infinitas. Entretanto, eles devem ser bem projetados e significativos, pois recompensas mal projetadas podem inadvertidamente degradar o desempenho do modelo.

Exemplo de uma função de recompensa

Você pode consultar o exemplo a seguir. Você pode inserir os resultados gerados em um arquivo como o ChatGPT 4o ou em um modelo de linguagem grande, como o Llama 3.1 (8B), e crie uma função de recompensa e um validador para avaliá-lo. Por exemplo, alimente os resultados gerados no modelo de linguagem grande de sua escolha e defina uma regra: "Se a resposta parecer muito com um robô, deduza 3 pontos". Isso ajuda a otimizar o resultado com base em critérios de qualidade.

Exemplo #1: Tarefas aritméticas simples

• Pergunta: "2 + 2"
• Respostas: "4"
• Função de recompensa 1:
  • Se for detectado um número → +1
  • Se nenhum número for detectado → -1
• Função de recompensa 2:
  • Se o número corresponder à resposta correta → +3
  • Se estiver incorreto → -3
• Total Rewards: Soma de todas as funções de recompensa

Exemplo #2: Tarefas de automação de e-mail

• Pergunta: e-mail de entrada
• Respostas: e-mail de saída
• Função de recompensa:
  • Se a resposta contiver as palavras-chave necessárias → +1
  • Se a resposta corresponder exatamente à resposta desejada → +1
  • Se a resposta for muito longa → -1
  • Se o nome do destinatário estiver incluído → +1
  • Se houver um bloco de assinatura (telefone, e-mail, endereço) → +1

Unsloth Função de recompensa baseada em vizinhança

Se você já viu nossoCaderno de anotações Premium GRPO ColabVocê notará que criamos uma solução totalmente construída do zeroFunção de recompensa personalizada baseada na vizinhançaque foi projetado para recompensar as respostas mais próximas da resposta correta. Essa função flexível pode ser aplicada a uma ampla gama de tarefas.

• Em nosso exemplo, temos o Qwen3 (Basic Edition) tem o raciocínio ativado e o direciona para concluir tarefas específicas.
• Aplique uma política de pré-ajuste para evitar a preferência padrão do GRPO por formatos somente de aprendizado.
• Use a correspondência baseada em expressões regulares para melhorar a precisão da avaliação.
• Criar além de prompts genéricos (por exemplo think) de um modelo GRPO personalizado, como <start_working_out></end_working_out>.
• Aplicar pontuação baseada em proximidade - os modelos são mais recompensados por terem respostas mais próximas (por exemplo, prever 9 em vez de 10 é melhor do que prever 3), enquanto os outliers são penalizados.

Função de recompensa do GSM8K

Em nossos outros exemplos, usamos as funções de recompensa GSM8K existentes fornecidas por @willccbb, que são populares e se mostraram bastante eficazes:

• correctness_reward_func - Recompense as respostas que correspondam exatamente às tags.
• int_reward_func - Incentive as respostas somente para números inteiros.
• soft_format_reward_func - Verifique a estrutura, mas permita pequenas incompatibilidades de quebra de linha.
• strict_format_reward_func - Certifique-se de que a estrutura da resposta corresponda ao prompt, inclusive as quebras de linha.
• xmlcount_reward_func - Certifique-se de que cada tag XML apareça apenas uma vez na resposta.

Usando o vLLM

Agora você pode usar o vLLM diretamente em sua pilha de ajuste fino, o que leva a uma maior taxa de transferência e permite que você faça o ajuste fino e raciocine sobre o modelo ao mesmo tempo! Espera-se que a quantificação dinâmica de 4 bits da estrutura Llama 3.2 3B usando Unsloth em um A100 40GB 1x seja de aproximadamente 4000 tokens /seg. Em uma Tesla T4 de 16 GB (GPU Colab gratuita), você pode chegar a 300 tokens/seg.

Também eliminamos magicamente a necessidade de carregamento simultâneo de vLLM O uso duplo de memória ao carregar o Unsloth e o Unsloth economiza cerca de 5 GB para o Llama 3.1 8B e 3 GB para o Llama 3.2 3B. O Unsloth poderia ter ajustado a estrutura do Llama 3.3 70B em GPUs de 1x 48 GB, em que os pesos do Llama 3.3 70B ocupam 40 GB de VRAM. eliminarmos o uso de memória dupla, carregar o Unsloth e o vLLM ao mesmo tempo exigiria >= 80 GB de VRAM.

Mas com o Unsloth, você ainda pode fazer o ajuste fino e aproveitar os benefícios da inferência rápida simultaneamente em um pacote com menos de 48 GB de VRAM! Para usar a inferência rápida, primeiro instale o vllm e use o comando fast_inference Instanciar o Unsloth:

fazer uma cópia de

pip install unsloth vllm
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "unsloth/Llama-3.2-3B-Instruct",
fast_inference = True,
)
model.fast_generate(["Hello!"])

Guia de requisitos do GRPO

Quando você usa o Unsloth para GRPO, reduzimos de forma inteligente o uso de VRAM em mais de 90% com uma variedade de truques em comparação com a implementação padrão usando o Flash Attention 2! Por exemplo, com um comprimento de contexto de 20K e gerando 8 respostas por sinal, o Unsloth for Llama 3.1 8B usa apenas 54,3 GB de VRAMe a implementação padrão requer 510.8GB (Unsloth reduzido por 90%).

1. GRPO's Requisitos de VRAM da GPU de 4 bits do QLoRAA regra geral é que os parâmetros do modelo = a quantidade de VRAM necessária (você pode usar menos VRAM, mas isso é apenas por segurança). Quanto mais longo for o comprimento do contexto, mais VRAM será necessária. loRA de 16 bits usará pelo menos 4 vezes mais VRAM.
2. Nossos novos núcleos lineares com eficiência de memória para GRPO reduzem o uso de memória em um fator de 8 ou mais. Isso economiza 68,5 GB de memória, enquanto o torch.compile de ajuda realmente mais rápido!
3. Aproveitamos nosso algoritmo inteligente de ponto de verificação de gradiente Unsloth, lançado recentemente. Ele descarrega de forma inteligente as ativações intermediárias para a RAM do sistema de forma assíncrona, sendo apenas 1% mais lento. Isso economiza 52 GB de memória.
4. O Unsloth também usa o mesmo espaço de memória da GPU/CUDA que o mecanismo de inferência subjacente (vLLM), ao contrário das implementações em outros pacotes. Isso economiza 16 GB de memória.

Em uma implementação padrão típica do GRPO, é necessário criar 2 logits de tamanho (8, 20K) para calcular a perda do GRPO. Isso ocupa 2 * 2 字节 * 8 (生成数量) * 20K (上下文长度) * 128256 (词汇表大小) = 78.3GB.

O Unsloth economiza 8 vezes o uso da memória para GRPOs de contexto longo, portanto, para um comprimento de contexto de 20K, precisamos apenas de 9,8 GB adicionais de VRAM!

Também precisamos processar o cache KV no formato de 16 bits. O Llama 3.1 8B tem 32 camadas e o tamanho de K e V é 1024. Portanto, o uso de memória para um comprimento de contexto de 20K = 2 * 2 字节 * 32 层 * 20K 上下文长度 * 1024 = 每个批次 2.5GB. Definiríamos o tamanho do lote do vLLM como 8, mas, para economizar VRAM, o deixamos em 1 em nossos cálculos.