Entendendo o Aprendizado por Reforço em Modelos de Linguagem
Em dezembro de 2025, a AWS anunciou a disponibilidade do aprendizado por reforço para fine-tuning (RFT) no Amazon Bedrock, inicialmente com suporte aos modelos Nova. Alguns meses depois, em fevereiro de 2026, expandiu o suporte para modelos de código aberto como OpenAI GPT OSS 20B e Qwen 3 32B. O RFT no Amazon Bedrock automatiza todo o fluxo de customização de modelos, permitindo que eles aprendam com feedback sobre múltiplas respostas possíveis usando um conjunto pequeno de prompts, em vez de grandes datasets tradicionais.
O Conceito Fundamental: Aprender com Feedback
O aprendizado por reforço funciona como ensinar um agente — neste caso, um modelo de linguagem — a tomar melhores decisões fornecendo feedback sobre suas ações. Pense na analogia de treinar um jogador de xadrez: em vez de mostrar cada movimento possível em cada situação imaginável, você deixa o jogador jogar e indica quais movimentos levaram a posições vencedoras. Com o tempo, o jogador aprende a reconhecer padrões e tomar decisões estratégicas que levam ao sucesso.
Para modelos de linguagem, o processo é similar. O modelo gera múltiplas respostas possíveis para um prompt, recebe pontuações (recompensas) para cada resposta baseadas em quão bem elas atendem seus critérios, e aprende a favorecer os padrões e estratégias que produzem saídas com pontuação mais alta.
Componentes Principais do RFT
O RFT envolve quatro componentes essenciais: o modelo ator/agente (política), os estados de entrada, as ações de saída e a função de recompensa.
O modelo ator é o modelo de fundação que você está customizando. No Amazon Bedrock RFT, pode ser Amazon Nova, Llama, Qwen ou outros modelos suportados. O estado é o contexto atual, incluindo o prompt, histórico de conversa (para interações multi-turno) e metadados relevantes. A ação é a resposta do modelo ao prompt. A função de recompensa atribui uma pontuação numérica ao par (estado, ação), avaliando a qualidade da resposta do modelo para um determinado estado.
A função de recompensa pode usar informações adicionais como respostas de referência ou testes unitários para geração de código. É esse o sinal crítico de feedback que impulsiona o aprendizado — pontuações mais altas indicam respostas melhores. Uma vantagem chave do RFT é que o modelo aprende com as respostas que gera durante o treinamento, não apenas com exemplos pré-coletados. Essa abordagem desbloqueia vários benefícios cumulativos: como o modelo explora ativamente novas abordagens e aprende com os resultados, pode se adaptar em tempo real, encontrando naturalmente novos cenários que o impulsionam para frente. Isso também torna o processo muito mais eficiente, eliminando a necessidade de pré-gerar e rotular milhares de exemplos antecipadamente.
Como o Amazon Bedrock RFT Funciona
O Amazon Bedrock RFT foi construído para tornar o aprendizado por reforço viável no nível empresarial. Ele gerencia a infraestrutura pesada, permitindo que as equipes se concentrem no problema que estão resolvendo, não na complexidade técnica subjacente.
Todo o pipeline de RFT é executado automaticamente. Para cada prompt no seu dataset de treinamento, o Amazon Bedrock gera múltiplas respostas candidatas do seu modelo ator, gerenciando batching, paralelização e alocação de recursos nos bastidores. O cálculo de recompensas escala perfeitamente. Seja usando recompensas verificáveis ou uma configuração com modelo-como-juiz, o Amazon Bedrock orquestra a avaliação em milhares de pares prompt-resposta enquanto gerencia concorrência e recuperação de erros automaticamente.
A otimização de política executa o GRPO (um algoritmo de aprendizado por reforço de última geração), com detecção de convergência integrada para que o treinamento pare quando apropriado. Durante todo o processo, métricas do Amazon CloudWatch e o console do Amazon Bedrock oferecem visibilidade em tempo real sobre tendências de recompensa, atualizações de política e desempenho geral do modelo.
O fluxo de trabalho começa do seu ambiente de desenvolvimento (VS Code, Terminal, Jupyter ou notebook SageMaker AI) usando o SDK padrão do OpenAI apontado para o endpoint Mantle do Bedrock. A partir daí:
- Upload de dados de treinamento via Files API (formato .jsonl com mensagens e respostas de referência)
- Deploy de uma função de recompensa como AWS Lambda que pontua respostas geradas pelo modelo
- Criação do job de fine-tuning — o engine GRPO do Bedrock gera respostas, envia para seu Lambda grader e atualiza pesos com base nas pontuações
- Monitoramento de treinamento via eventos e checkpoints
- Invocação de seu modelo fine-tuned sob demanda — sem provisionamento de endpoint, sem hosting
Seus dados não deixam o ambiente seguro da AWS durante o processo e não são utilizados para treinar modelos fornecidos pelo Amazon Bedrock.
Guia Prático: Configuração e Treinamento
Pré-requisitos
Antes de começar, você precisa de:
- Uma conta AWS com acesso ao Amazon Bedrock em uma região suportada
- Uma chave de API do Bedrock (de curto ou longo prazo). Você também pode autenticar usando credenciais AWS Sigv4, mas neste guia usamos uma chave de API do Amazon Bedrock
- Funções IAM para execução de Lambda e fine-tuning do Amazon Bedrock
- Python com openai, boto3 e aws-bedrock-token-generator instalados. Se estiver trabalhando em um shell dentro de um venv ou com Jupyter notebook, execute:
pip install openai boto3 aws-bedrock-token-generator
Etapa 1: Configurar o Cliente OpenAI
Aponte o SDK padrão do OpenAI para seu endpoint Amazon Bedrock Mantle. A autenticação usa uma chave de API do Bedrock gerada através da biblioteca aws-bedrock-token-generator:
from openai import OpenAI
from aws_bedrock_token_generator import provide_token
AWS_REGION = "us-west-2"
MANTLE_ENDPOINT = f"https://bedrock-mantle.{AWS_REGION}.api.aws"
client = OpenAI(
base_url=f"{MANTLE_ENDPOINT}/v1",
api_key=provide_token(region=AWS_REGION),
)É isso. Cada chamada subsequente usa a interface padrão do SDK do OpenAI! Recomenda-se usar e renovar chaves do Bedrock de curto prazo conforme necessário, em vez de definir e usar chaves de longo prazo que não expiram.
Etapa 2: Preparar e Fazer Upload de Dados de Treinamento
Cada registro no dataset requer um campo messages e pode incluir opcionalmente um campo reference_answer. O campo messages contém o prompt apresentado ao modelo, formatado usando o padrão de mensagem do OpenAI onde cada mensagem especifica um role (como “user”) e conteúdo correspondente. O campo reference_answer opcional fornece contexto complementar para cálculo de recompensa, como uma resposta de verdade fundamental, regra de avaliação ou dimensões de pontuação usadas pela função de recompensa.
Para exemplos do dataset matemático GSM8K, cada amostra de treinamento contém um problema matemático em linguagem natural na mensagem do usuário e uma resposta de referência contendo a solução numérica correta. O prompt instrui o modelo a fornecer seu raciocínio dentro de tags estruturadas e apresentar a resposta final em formato \boxed{} que a função de recompensa possa extrair confiavelmente:
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "A chat between a curious User and an artificial intelligence Bot. The Bot gives helpful, detailed, and polite answers to the User's questions. The Bot first thinks about the reasoning process and then provides the User with the answer. The reasoning process and answer are enclosed within <|begin_internal_thought|> <|end_internal_thought|> and <|begin_of_solution|> <|end_of_solution|> respectively. The final answer must be enclosed in \\boxed{} within the solution block.\n\nNatalia sold clips to 48 of her friends in April, and then she sold half as many clips in May. How many clips did Natalia sell altogether in April and May?"
}
]
}
],
"reference_answer": {
"answer": "72"
},
"data_source": "gsm8k_nova"Um repositório do GitHub fornece uma função auxiliar para converter os registros brutos do GSM8K para formato JSONL compatível com Amazon Bedrock RFT. Note que o campo data_source garante que a função de recompensa apropriada seja aplicada durante o treinamento, enquanto os formatos de prompt estruturados alinham as saídas com a lógica de extração da função de recompensa.
Os dados de treinamento são um arquivo JSONL onde cada linha contém uma conversa com mensagens e uma resposta de referência:
{
"messages": [
{"role": "user", "content": "Janet's ducks lay 16 eggs per day. She eats three for breakfast and bakes muffins with four. She sells the rest at $2 each. How much does she make daily? Let's think step by step and output the final answer after '####'."}
],
"reference_answer": "#### 18"
}Você pode usar campos adicionais aqui que sejam úteis para sua função Lambda grader na próxima etapa, mas note que a estrutura messages e reference_answer são obrigatórias. Você pode fazer upload do seu dataset preparado via Files API:
with open("rft_train_data.jsonl", "rb") as f:
file_response = client.files.create(file=f, purpose="fine-tune")
training_file_id = file_response.id
print(f"Training file uploaded: {training_file_id}")Etapa 3: Deploy de uma Função Lambda de Recompensa
A função de recompensa é o núcleo do RFT. Ela recebe respostas geradas pelo modelo e retorna uma pontuação. Para problemas matemáticos, é direto: extrair a resposta e compará-la com a verdade fundamental. Aqui está um exemplo da função de recompensa usada em um caso prático (do repositório de exemplos):
def lambda_handler(event, context):
trajectories = event if isinstance(event, list) else event.get("trajectories", [])
scores = []
for trajectory in trajectories:
trajectory_id = trajectory.get("id", "no-id")
# Get the model's response from the last assistant message
response = ""
for msg in reversed(trajectory.get("messages", [])):
if msg.get("role") == "assistant":
response = msg.get("content", "")
break
# Extract ground truth from reference answer
reference_answer = trajectory.get("reference_answer", {})
reference_text = reference_answer.get("text", "")
gt_match = re.findall(r"#### (\-?[0-9\.\,]+)", reference_text)
ground_truth = gt_match[-1].replace(",", "") if gt_match else ""
# Score: 1.0 if correct, 0.0 otherwise
result = compute_score(
trajectory_id=trajectory_id,
solution_str=response,
ground_truth=ground_truth,
)
scores.append(asdict(result))
return scoresA função retorna uma lista de objetos RewardOutput, cada um contendo um aggregate_reward_score entre 0 e 1. Deploy isso como uma função AWS Lambda com timeout de 5 minutos e 512 MB de memória. Note que você pode customizar completamente o que acontece dentro dessa função Lambda de recompensa para adequar-se ao seu caso de uso. O Amazon Bedrock também suporta graders modelo-como-juiz para tarefas subjetivas onde verificação automatizada não é possível. Para mais informações sobre configuração de funções de recompensa, consulte a documentação sobre configuração de funções de recompensa para modelos de código aberto.
Etapa 4: Criar o Job de Fine-tuning
Use a seguinte chamada de API única para iniciar o job:
job_response = client.fine_tuning.jobs.create(
model="openai.gpt-oss-20b",
training_file=training_file_id,
extra_body={
"method": {
"type": "reinforcement",
"reinforcement": {
"grader": {
"type": "lambda",
"lambda": {
"function": lambda_arn # Replace with reward function Arn
}
},
"hyperparameters": {
"n_epochs": 1,
"batch_size": 4,
"learning_rate_multiplier": 1.0
}
}
}
}
)
job_id = job_response.idA chamada create do job de fine-tuning anterior usa os seguintes hiperparâmetros:
- n_epochs: Número de passadas completas pelos dados de treinamento. Comece com 1.
- batch_size: Prompts por etapa de treinamento. Maior = atualizações mais estáveis.
- learning_rate_multiplier: Recomenda-se usar um valor menor que 1.0 para estabilidade.
Etapa 5: Monitorar o Treinamento
Para rastrear o progresso do job, use a API de listagem de eventos:
events = client.fine_tuning.jobs.list_events(
fine_tuning_job_id=job_id,
limit=100)Para um job de exemplo com GPT-OSS que usa o subset de dados GSM8K, o treinamento executa um total de 67 etapas com vários eventos emitidos conforme o job progride.
Um evento típico durante o progresso de treinamento contém várias métricas importantes. O critic_rewards_mean (pontuação média de recompensa no lote) é a métrica principal a observar — você quer que suba. O actor_pg_loss (perda de gradiente de política) é o objetivo sendo otimizado. O actor_entropy (quanto dispersa está a distribuição de probabilidade de tokens) indica exploração; se cair para 0, há colapso de modo. O actor_grad_norm (magnitude da atualização de gradiente) ajuda a identificar instabilidade. O response_length_mean (comprimento médio de tokens das respostas) deve ser monitorado — se crescer descontroladamente, o modelo pode estar “hackeando” o sistema para ganhar recompensa baseada em tamanho.
O código de exemplo também fornece exemplos de como plotar essas métricas. A curva de recompensa mostra o modelo melhorando de aproximadamente 0.56 para consistentemente 0.85–0.97 no meio do treinamento. Os comprimentos de resposta também tendem a ficar mais curtos ao longo do tempo, sugerindo que o modelo aprendeu a ser mais conciso enquanto resolve problemas do GSM8K corretamente.
Você também pode listar checkpoints conforme são salvos:
checkpoints = client.fine_tuning.jobs.checkpoints.list(
fine_tuning_job_id=job_id)Etapa 6: Executar Inferência Sob Demanda
Após o job ter sucesso, invoque seu modelo fine-tuned diretamente. Sem provisionamento de endpoint, sem hosting:
job_details = client.fine_tuning.jobs.retrieve(job_id)
fine_tuned_model = job_details.fine_tuned_model
response = client.chat.completions.create(
model=fine_tuned_model,
messages=[
{"role": "user", "content": "If a train travels 120 miles in 2 hours, what is its speed in miles per hour?"}
],
)
print(response.choices[0].message.content)Você também pode usar a API de respostas para transmitir respostas do modelo fine-tuned:
stream = client.responses.create(
model=fine_tuned_model,
input=[{"role": "user", "content": "Your prompt here"}],
stream=True,
reasoning={"effort": "low"}
)
for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="", flush=True)Recursos Adicionais
O notebook completo com código de ponta a ponta tanto para GPT-OSS 20B quanto para Qwen3 32B está disponível no github.com/aws-samples/amazon-bedrock-samples/tree/main/custom-models/bedrock-reinforcement-fine-tuning.
Para mais detalhes, consulte a documentação de aprendizado por reforço do Amazon Bedrock. Você também pode encontrar informações sobre acesso e segurança para modelos de código aberto no guia de usuário do Amazon Bedrock.
Conclusão
O aprendizado por reforço para fine-tuning no Amazon Bedrock reúne três elementos que tornam o fluxo de trabalho de ponta a ponta prático: compatibilidade com SDK OpenAI (não há novo SDK para aprender — aponte OPENAI_BASE_URL e OPENAI_API_KEY para Bedrock e use as mesmas chamadas client.fine_tuning.jobs.create()), funções de recompensa baseadas em Lambda (escreva sua lógica de pontuação em Python, deploy como Lambda, e o Amazon Bedrock gerencia o loop de treinamento com GRPO para você) e inferência sob demanda (sem gerenciamento de endpoint — chame client.chat.completions.create() com seu ID de modelo fine-tuned e pague por token).
Para organizações brasileiras e globais que trabalham com inteligência artificial, essa abordagem simplifica significativamente a customização de modelos de linguagem em escala, eliminando a complexidade técnica e acelerando o tempo para resultados.
Fonte
Reinforcement fine-tuning on Amazon Bedrock with OpenAI-Compatible APIs: a technical walkthrough (https://aws.amazon.com/blogs/machine-learning/reinforcement-fine-tuning-on-amazon-bedrock-with-openai-compatible-apis-a-technical-walkthrough/)
Leave a Reply