O problema dos sinais de recompensa no treinamento de LLMs
Treinar grandes modelos de linguagem (LLMs) exige sinais de feedback precisos. No aprendizado por reforço (RL) tradicional, esses sinais costumam ser pouco confiáveis: funções de recompensa imprecisas, vieses ocultos e critérios de sucesso ambíguos podem fazer o modelo aprender comportamentos indesejados — fenômeno conhecido como reward hacking, em que o modelo encontra atalhos para maximizar a pontuação sem realmente alcançar o objetivo desejado.
Para endereçar esse problema, a AWS publicou um tutorial completo sobre como implementar o Aprendizado por Reforço com Recompensas Verificáveis (RLVR — Reinforcement Learning with Verifiable Rewards) combinado com o algoritmo Otimização de Política Relativa por Grupos (GRPO — Group Relative Policy Optimization) no Amazon SageMaker AI. A abordagem é especialmente eficaz em tarefas com saídas objetivamente verificáveis, como raciocínio matemático, geração de código e manipulação simbólica.
Conceitos fundamentais: RLVR e GRPO
O que é RLVR?
O RLVR combate o reward hacking por meio de funções de recompensa baseadas em regras definidas pelo próprio tutor do modelo. Em vez de depender de avaliações humanas subjetivas, o sistema utiliza funções programáticas que pontuam as saídas automaticamente com base em critérios objetivos e reproduzíveis. Isso permite iterações rápidas e adaptação a novos cenários sem o gargalo da coleta de anotações humanas.
O que é GRPO?
O GRPO é um algoritmo de aprendizado por reforço que melhora o aprendizado de modelos de IA comparando o desempenho dentro de grupos, em vez de avaliar todos os dados de uma vez. Ele organiza os dados de treinamento em grupos significativos e otimiza o desempenho relativo à linha de base de cada grupo. Essa otimização orientada por grupos reduz a variância do treinamento, acelera a convergência e produz modelos com desempenho mais consistente entre diferentes categorias.
A combinação das duas técnicas
Combinar RLVR com GRPO cria uma estrutura em que as recompensas automatizadas guiam o aprendizado enquanto a otimização relativa por grupos impulsiona um desempenho equilibrado. As funções de recompensa são definidas para diferentes aspectos da tarefa, e o GRPO as trata como grupos distintos durante o treinamento, facilitando a melhoria simultânea em múltiplas dimensões.
Adicionar aprendizado few-shot (com poucos exemplos) potencializa ainda mais esse framework: os exemplos fornecem modelos do que são boas respostas, reduzindo o espaço de busca para exploração; o GRPO aproveita esses exemplos gerando múltiplas respostas candidatas por prompt e aprendendo com o desempenho relativo delas dentro de cada grupo; e as recompensas verificáveis confirmam imediatamente quais abordagens funcionam.
Visão geral da solução no SageMaker AI
O tutorial demonstra como fazer o fine-tuning do modelo Qwen2.5-0.5B no SageMaker AI usando Amazon SageMaker Training Jobs. Os Training Jobs suportam configurações distribuídas com múltiplas GPUs e múltiplos nós, permitindo criar clusters de alto desempenho sob demanda, treinar modelos com bilhões de parâmetros mais rapidamente e desligar os recursos automaticamente ao final do job.
Vale notar: o Qwen2.5-0.5B foi escolhido para este caso de uso específico, mas tarefas como geração de código exigirão modelos maiores (como o Qwen2.5-Coder-7B) e instâncias de treinamento mais robustas.
Pré-requisitos
Para executar o exemplo, são necessários: uma conta AWS, uma role de AWS Identity and Access Management (IAM — Gerenciamento de Identidade e Acesso) com acesso ao SageMaker AI, e acesso a uma instância de treinamento ml.p4d.24xlarge. O ambiente de desenvolvimento pode ser qualquer IDE de preferência (VS Code, PyCharm) com credenciais AWS configuradas, ou o próprio Amazon SageMaker Studio. O código-fonte está disponível no repositório GitHub de exemplos.
Preparação do dataset e sistema de recompensas duplas
O dataset GSM8K
O tutorial usa o dataset GSM8K (Matemática do Ensino Fundamental — 8 mil problemas), uma coleção de problemas matemáticos de nível escolar que exigem raciocínio aritmético em múltiplas etapas. O dataset é preparado extraindo a resposta final de cada questão — informação essencial para calcular as recompensas durante o treinamento. O exemplo utiliza 8 exemplos few-shot por entrada para melhorar o desempenho do treinamento, com base em pesquisas sobre o uso de exemplos em aprendizado por reforço para raciocínio em LLMs (veja o paper “Reinforcement Learning for Reasoning in Large Language Models with One Training Example”).
Sistema de recompensas duplas
A implementação do GRPO para raciocínio matemático emprega um sistema de recompensa dupla que fornece feedback objetivo e verificável durante o treinamento, sem necessidade de anotação humana:
Função de recompensa de formato: verifica se o modelo estrutura corretamente suas respostas. Ela busca o padrão #### The final answer is [número] e concede 0,5 ponto para formatação correta e 0,0 para formatação incorreta.
#Format reward function
def format_reward_func_qa(completions, **kwargs):
pattern = r"\n#### The final answer is \d+"
completion_contents = [completion for completion in completions]
matches = [re.search(pattern, content) for content in completion_contents]
return [0.5 if match else 0.0 for match in matches]Função de recompensa de correção: realiza a verificação matemática central. Ela extrai respostas numéricas via regex, normaliza caracteres de formatação (vírgulas, símbolos de moeda) e usa uma tolerância de 1e-3 para lidar com precisão de ponto flutuante. Concede 1,0 para respostas corretas e 0,0 para incorretas.
#Correctness reward function
def correctness_reward_func_qa(completions, final_answer, **kwargs):
rewards = []
for completion, ground_truth in zip(completions, final_answer):
try:
match = re.search(r'####.*?([\d,]+(?:\.\d+)?)', completion)
if match:
answer = match.group(1)
for remove_char in [',', '$', '%', 'g']:
answer = answer.replace(remove_char, '')
if abs(float(answer)-float(ground_truth)) < 1e-3:
rewards.append(1.0)
else:
rewards.append(0.0)
else:
rewards.append(0.0)
except ValueError:
rewards.append(0.0)
return rewardsAs duas funções são integradas ao pipeline de treinamento do GRPO via GRPOTrainer. A recompensa máxima combinada por completion é 1,5 (0,5 de formato + 1,0 de correção). O GRPO compara as completions dentro dos grupos para identificar as melhores respostas e atualiza os parâmetros do modelo de forma que completions com maior recompensa aumentem sua probabilidade, enquanto as de menor recompensa a diminuem.
rewards_funcs = [format_reward_func_qa, correctness_reward_func_qa]
trainer = GRPOTrainer(
model=model,
args=training_args,
train_dataset=train_dataset,
eval_dataset=test_dataset,
processing_class=tokenizer,
peft_config=peft_config,
reward_funcs=rewards_funcs,
)Configuração do treinamento com QLoRA e DeepSpeed
O fine-tuning utiliza QLoRA (Adaptação de Baixo Rank Quantizada — Quantized Low-Rank Adaptation) para reduzir os requisitos de recursos de treinamento com uma pequena troca de acurácia. A receita completa de treinamento inclui os principais hiperparâmetros:
# Model arguments
model_name_or_path: Qwen/Qwen2.5-0.5B
tokenizer_name_or_path: Qwen/Qwen2.5-0.5B
model_revision: main
torch_dtype: bfloat16
attn_implementation: flash_attention_2
bf16: true
tf32: true
output_dir: /opt/ml/model/Qwen2.5-0.5B-RL-VR-GRPO
# Dataset arguments
train_dataset_id_or_path: /opt/ml/input/data/train/dataset.json
test_dataset_id_or_path: /opt/ml/input/data/val/dataset.json
dataset_splits: 'train'
max_seq_length: 2048
packing: true
# LoRA arguments
use_peft: true
load_in_4bit: true
lora_target_modules: ["q_proj", "k_proj", "v_proj", "o_proj", "up_proj", "down_proj", "gate_proj"]
lora_modules_to_save: ["lm_head", "embed_tokens"]
lora_r: 16
lora_alpha: 16
# Training arguments
num_train_epochs: 2
per_device_train_batch_size: 16
gradient_accumulation_steps: 2
gradient_checkpointing: true
gradient_checkpointing_kwargs:
use_reentrant: True
learning_rate: 1.84e-4
lr_scheduler_type: cosine
warmup_ratio: 0.1
# Logging arguments
logging_strategy: steps
logging_steps: 5
report_to:
- mlflow
save_strategy: "no"
seed: 42Para o treinamento distribuído em múltiplas GPUs, o script utiliza o Hugging Face Accelerate combinado com DeepSpeed ZeRO-3. O Accelerate simplifica o lançamento do treinamento distribuído, enquanto o ZeRO-3 reduz o uso de memória particionando estados do otimizador, gradientes e parâmetros entre as GPUs — permitindo que modelos com bilhões de parâmetros caibam e treinem mais rapidamente.
NUM_GPUS=$(nvidia-smi --list-gpus | wc -l)
echo "Detected ${NUM_GPUS} GPUs on the machine"
# Launch fine-tuning with Accelerate + DeepSpeed (Zero3)
accelerate launch \
--config_file accelerate_configs/deepspeed_zero3.yaml \
--num_processes ${NUM_GPUS} \
run_grpo.py \
--config $CONFIG_PATHResultados: melhoria de 3,7x no raciocínio matemático
Após avaliar os modelos em 100 amostras de teste, o modelo GRPO treinado com 8 exemplos few-shot alcançou 41% de acurácia, contra 11% do modelo base — uma melhoria de 3,7 vezes no raciocínio matemático em cadeia de pensamento.
Os resultados revelam um comportamento de limiar interessante: configurações com 0-shot (6%) e 2-shot (3%) tiveram desempenho até pior que o modelo base, enquanto o desempenho melhorou drasticamente a partir de 4-shot (33%), atingindo o pico com 8-shot (41%). Esse padrão de escalonamento não-linear sugere que o treinamento com GRPO cria padrões de raciocínio que precisam de um número mínimo de exemplos para serem ativados efetivamente — consistente com a abordagem de otimização baseada em grupos do algoritmo.
Generalizando o RLVR para outros domínios
Embora o tutorial foque em raciocínio matemático com o GSM8K, a abordagem RLVR se generaliza para qualquer domínio com saídas objetivamente verificáveis:
- Geração de código com recompensas baseadas em execução: recompensas parciais quando o código compila e executa sem erros, recompensas completas quando as saídas passam em testes unitários abrangentes.
- Geração de texto especializado com validação semântica: para domínios como escrita médica ou técnica, recompensas baseadas em palavras-chave guiam os modelos em direção à terminologia apropriada — por exemplo, recompensar textos que combinam palavras-chave diagnósticas com palavras-chave de tratamento em padrões clinicamente válidos.
Limpeza de recursos
Para evitar cobranças desnecessárias após os experimentos, a AWS recomenda: excluir recursos não utilizados do SageMaker Studio, opcionalmente excluir o domínio do SageMaker Studio, excluir os buckets S3 criados e verificar se os training jobs não estão mais em execução. Para mais detalhes, consulte a documentação de limpeza de recursos.
Conclusão
O tutorial da AWS demonstra como o RLVR combinado com GRPO representa uma alternativa robusta aos métodos de treinamento baseados em preferências humanas. O modelo Qwen2.5-0.5B treinado com essa abordagem alcançou uma melhoria de 3,7x sobre o modelo base no GSM8K, validando o RLVR como uma abordagem promissora para domínios com resultados objetivamente verificáveis. O comportamento de limiar observado sugere que o GRPO aprende a aproveitar comparações de grupo a partir de múltiplos exemplos, consistente com sua abordagem de otimização baseada em grupos.
Para mais informações sobre treinamento gerenciado no Amazon SageMaker AI, consulte a seção de treinamento da documentação do SageMaker AI. O código de suporte está disponível no GitHub.
Fonte
Overcoming reward signal challenges: Verifiable rewards-based reinforcement learning with GRPO on SageMaker AI (https://aws.amazon.com/blogs/machine-learning/overcoming-reward-signal-challenges-verifiable-rewards-based-reinforcement-learning-with-grpo-on-sagemaker-ai/)
Leave a Reply