Guia Prático para Fine-Tuning por Reforço no Amazon Bedrock com APIs Compatíveis OpenAI

Em dezembro de 2025, a Amazon anunciou a disponibilidade do Reinforcement Fine-Tuning (RFT) no Amazon Bedrock, inicialmente para modelos Nova, ampliando em fevereiro de 2026 para modelos Open weight como OpenAI GPT OSS 20B e Qwen 3 32B. Essa técnica representa uma evolução na personalização de grandes modelos de linguagem (LLMs), permitindo que eles aprendam a partir de um ciclo iterativo de feedback, em vez de depender exclusivamente de grandes datasets rotulados.

Como Funciona o Fine-Tuning por Reforço (RFT)

O RFT difere do fine-tuning supervisionado tradicional ao permitir que o modelo aprenda com múltiplas respostas geradas, avaliadas por uma função de recompensa que atribui notas conforme a qualidade das respostas. Esse processo se assemelha ao treinamento de um jogador de xadrez que aprende com suas jogadas, recebendo feedback sobre quais estratégias levam à vitória.

Os componentes-chave do RFT incluem:

Modelo ator (policy): o modelo base que será ajustado (ex: Amazon Nova, Llama, Qwen).
Estado (state): o contexto da interação, incluindo prompt, histórico de conversa e metadados.
Ação (action): a resposta gerada pelo modelo ao prompt.
Função de recompensa: avalia a qualidade da resposta com base em critérios específicos, fornecendo um escore numérico que guia o aprendizado.

Uma vantagem significativa do RFT é o aprendizado online, onde o modelo explora e melhora continuamente a partir das respostas geradas durante o treinamento, sem necessidade de pré-coleta e rotulagem massiva de dados.

Fluxo de Trabalho Completo no Amazon Bedrock

O RFT no Amazon Bedrock automatiza todo o pipeline de personalização, permitindo que equipes foquem na solução do problema e não na infraestrutura. O processo inclui:

Configurar a autenticação usando a API key do Bedrock.
Fazer upload dos dados de treinamento no formato JSONL via Files API.
Implementar a função de recompensa como uma função AWS Lambda para avaliação das respostas.
Iniciar o job de fine-tuning utilizando o motor GRPO, que gerencia geração, avaliação e atualização do modelo.
Monitorar o progresso do treinamento via API e dashboards do Amazon Bedrock.
Executar inferência sob demanda no modelo ajustado, sem necessidade de provisionamento de endpoint.

Durante todo o processo, os dados permanecem seguros dentro do ambiente AWS e não são usados para treinar modelos padrão do Bedrock.

Pré-requisitos para Começar

Conta AWS com acesso ao Amazon Bedrock em região suportada.
Chave API do Bedrock (preferencialmente de curta duração para segurança).
Permissões IAM adequadas para execução de Lambda e fine-tuning no Bedrock.
Ambiente Python com as bibliotecas openai, boto3 e aws-bedrock-token-generator instaladas.

Passo a Passo Técnico

1. Configurar o Cliente OpenAI

Use o SDK OpenAI padrão apontando para o endpoint Mantle do Bedrock, autenticando com a API key gerada pela 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),
)

2. Preparar e Enviar Dados de Treinamento

Os dados devem estar no formato JSONL, com cada linha contendo um campo messages (lista de mensagens com papéis e conteúdos) e opcionalmente reference_answer para a função de recompensa. Exemplo para dataset GSM8K:

{
  "messages": [
    {"role": "user", "content": "Problema matemático formatado com instruções para raciocínio e resposta final."}
  ],
  "reference_answer": "72"
}

Use a função helper disponível no repositório GitHub para converter dados GSM8K para esse formato.

Faça upload 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}")

3. Implementar a Função Lambda de Recompensa

A função Lambda recebe as respostas geradas e retorna uma pontuação (0 ou 1) comparando a resposta com o gabarito. Exemplo simplificado:

def lambda_handler(event, context):
    trajectories = event if isinstance(event, list) else event.get("trajectories", [])
    scores = []
    for trajectory in trajectories:
        response = next((msg.get("content", "") for msg in reversed(trajectory.get("messages", [])) if msg.get("role") == "assistant"), "")
        ground_truth = extract_ground_truth(trajectory.get("reference_answer", {}))
        score = 1.0 if response_matches_ground_truth(response, ground_truth) else 0.0
        scores.append({"aggregate_reward_score": score})
    return scores

Configure a função com timeout de 5 minutos e memória de 512 MB. Para tarefas subjetivas, o Bedrock também suporta uso de modelos como juízes.

4. Criar o Job de Fine-Tuning

Com uma única chamada API, inicie o treinamento:

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}
                },
                "hyperparameters": {
                    "n_epochs": 1,
                    "batch_size": 4,
                    "learning_rate_multiplier": 1.0
                }
            }
        }
    }
)
job_id = job_response.id

Parâmetros importantes:

n_epochs: número de passagens completas sobre os dados (recomenda-se começar com 1).
batch_size: quantidade de prompts por passo (maior traz maior estabilidade).
learning_rate_multiplier: multiplicador da taxa de aprendizado (valor menor que 1.0 para estabilidade).

5. Monitorar o Treinamento

Use a API para listar eventos do job e acompanhar métricas como média de recompensas, perda, entropia e tamanho das respostas. Alguns indicadores importantes:

critic_rewards_mean: média da pontuação, deve subir ao longo do treinamento.
actor_entropy: indica diversidade das respostas, não deve colapsar para zero.
actor_grad_norm: magnitude das atualizações, picos podem indicar instabilidade.
response_length_mean: tamanho médio das respostas, monitorar para evitar que o modelo "trapaceie" aumentando a resposta para obter mais recompensa.

Links Úteis para Implementação

Este guia oferece um roteiro prático para quem deseja explorar o fine-tuning por reforço em modelos de linguagem com o Amazon Bedrock, utilizando APIs compatíveis com OpenAI e aproveitando a infraestrutura escalável e segura da AWS.