# Avaliação de RFT
## O que é avaliação de RFT?
A avaliação de RFT permite que você avalie o desempenho do seu modelo usando funções de recompensa personalizadas antes, durante ou após o treinamento de aprendizado por reforço. Ao contrário das avaliações padrão que usam métricas predefinidas, a avaliação de RFT permite que você defina seus próprios critérios de sucesso por meio de uma função do Lambda que pontua os resultados do modelo com base em seus requisitos específicos.
## Por que avaliar com o RFT?
A avaliação é crucial para determinar se o processo de ajuste fino do RL:
+ Aprimorou o alinhamento de modelos com seu caso de uso específico e valores humanos
+ Manteve ou aprimorou os recursos dos modelos nas principais tarefas
+ Evitou efeitos colaterais indesejados, como redução da factualidade, aumento da verbosidade ou degradação do desempenho em outras tarefas
+ Atendeu aos seus critérios de sucesso personalizados, conforme definido por sua função de recompensa
## Quando usar a avaliação de RFT
Use a avaliação de RFT nestes cenários:
+ Antes do treinamento de RFT: estabeleça métricas de linha de base em seu conjunto de dados de avaliação
+ Durante o treinamento de RFT: monitore o progresso do treinamento com pontos de verificação intermediários
+ Após o treinamento de RFT: valide se o modelo final atende aos seus requisitos
+ Comparando modelos: avalie várias versões do modelo usando critérios de recompensa consistentes
**nota**
Use a avaliação de RFT quando precisar de métricas personalizadas e específicas do domínio. Para avaliação de propósito geral (precisão, perplexidade, BLEU), use métodos de avaliação padrão.
## Requisitos de formato de dados
### Estrutura de dados de entrada
Os dados de entrada da avaliação de RFT devem seguir o formato de ajuste fino por reforço da OpenAI. Cada exemplo é um objeto JSON que contém:
+ `messages`: matriz de turnos de conversação com os perfis `system` e `user`
+ `reference_answer`: saída esperada ou dados de verdade fundamental usados por sua função de recompensa para pontuação
### Exemplo de formato de dados
```
{
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Solve for x. Return only JSON like {\"x\": }. Equation: 2x + 5 = 13"
}
]
}
],
"reference_answer": {
"x": 4
}
}
```
### Limitações atuais
+ Somente texto: não há compatibilidade com entradas multimodais (imagens, áudio, vídeo)
+ Conversas em um único turno: compatível apenas com mensagens de um único usuário (sem diálogos com vários turnos)
+ Formato JSON: os dados de entrada devem estar no formato JSONL (um objeto JSON por linha)
+ Saídas do modelo: a avaliação é realizada nas conclusões geradas do modelo específico
## Preparação da sua fórmula de avaliação
### Exemplo de bloco de notas
Para obter um exemplo completo, consulte [Cadernos de avaliação](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook).
### Configuração do exemplo de fórmula
```
run:
name: nova-lite-rft-eval-job
model_type: amazon.nova-lite-v1:0:300k
model_name_or_path: s3://escrow_bucket/model_location # [MODIFIABLE] S3 path to your model or model identifier
replicas: 1 # [MODIFIABLE] For SageMaker Training jobs only; fixed for HyperPod jobs
data_s3_path: "" # [REQUIRED FOR HYPERPOD] Leave empty for SageMaker Training jobs and use TrainingInput in sagemaker python SDK
output_s3_path: "" # [REQUIRED] Output artifact S3 path for evaluation results
evaluation:
task: rft_eval # [FIXED] Do not modify
strategy: rft_eval # [FIXED] Do not modify
metric: all # [FIXED] Do not modify
# Inference Configuration
inference:
max_new_tokens: 8192 # [MODIFIABLE] Maximum tokens to generate
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
top_logprobs: 0 # [MODIFIABLE] Set between 1-20 to enable logprobs output
# =============================================================================
# Bring Your Own Reinforcement Learning Environment
# =============================================================================
rl_env:
reward_lambda_arn: arn:aws:lambda:::function:
```
## Funções de recompensa predefinidas
Duas funções de recompensa predefinidas (`prime_code` e `prime_math`) estão disponíveis como uma camada do Lambda para facilitar a integração com suas funções de RFT do Lambda.
### Visão geral
Essas funções predefinidas fornecem recursos de avaliação prontos para uso para:
+ `prime_code`: geração de código e avaliação de exatidão
+ `prime_math`: raciocínio matemático e avaliação da resolução de problemas
### Configuração rápida
1. Faça download da camada do Lambda das [versões nova-custom-eval-sdk](https://github.com/aws/nova-custom-eval-sdk/releases).
1. Publique a camada do Lambda usando a interface de linha de comandos da AWS (AWS CLI):
```
aws lambda publish-layer-version \
--layer-name preset-function-layer \
--description "Preset reward function layer with dependencies" \
--zip-file fileb://universal_reward_layer.zip \
--compatible-runtimes python3.9 python3.10 python3.11 python3.12 \
--compatible-architectures x86_64 arm64
```
1. Adicione a camada à sua função do Lambda no Console de Gerenciamento da AWS (selecione preset-function-layer da camada personalizada e também adicione AWSSDKPandas-Python312 para dependências numpy).
1. Importe e use no seu código do Lambda:
```
from prime_code import compute_score # For code evaluation
from prime_math import compute_score # For math evaluation
```
### função prime\$1code
Avalia as tarefas de geração de código Python executando o código em casos de teste e avaliando a exatidão.
**Exemplo de formato de conjunto de dados de entrada**
```
{"messages":[{"role":"user","content":"Write a function that returns the sum of two numbers."}],"reference_answer":{"inputs":["3\n5","10\n-2","0\n0"],"outputs":["8","8","0"]}}
{"messages":[{"role":"user","content":"Write a function to check if a number is even."}],"reference_answer":{"inputs":["4","7","0","-2"],"outputs":["True","False","True","True"]}}
```
**Recursos principais do**
+ Extração automática de código de blocos de código markdown
+ Detecção de funções e testes baseados em chamadas
+ Execução de casos de teste com proteção de tempo limite
+ Verificações de compilação e validação de sintaxe
+ Relatórios detalhados de erros com rastreamentos
### prime\$1math function
Avalia o raciocínio matemático e as capacidades de resolução de problemas com suporte matemático simbólico.
**Formato de entrada**
```
{"messages":[{"role":"user","content":"What is the derivative of x^2 + 3x?."}],"reference_answer":"2*x + 3"}
```
**Recursos principais do**
+ Avaliação matemática simbólica usando SymPy
+ Vários formatos de resposta (LaTeX, texto simples, simbólico)
+ Verificação de equivalência matemática
+ Simplificação e normalização da expressão
### Requisitos de formato de dados
**Para avaliação de código**
+ Entradas: matriz de argumentos de funções (tipos próprios: números inteiros, strings etc.)
+ Saídas: matriz de valores de retorno esperados (tipos próprios: booleanos, números etc.)
+ Código: deve estar em Python com definições de função claras
**Para avaliação matemática**
+ Resposta de referência: expressão matemática ou valor numérico
+ Resposta: pode ser LaTeX, texto simples ou notação simbólica
+ Equivalência: verificada simbolicamente, não apenas a correspondência de strings
### Práticas recomendadas
+ Use tipos de dados adequados em casos de teste (inteiros vs. strings, booleanos vs. “True”)
+ Forneça assinaturas de funções claras em problemas de código
+ Inclua casos de borda nas entradas de teste (zero, números negativos, entradas vazias)
+ Formate expressões matemáticas de forma consistente nas respostas de referência
+ Teste sua função de recompensa com dados de exemplo antes da implantação
### Tratamento de erros
Ambas as funções incluem tratamento robusto de erros para:
+ Erros de compilação no código gerado
+ Exceções de runtime durante a execução
+ Dados de entrada malformados
+ Cenários de tempo limite para loops infinitos
+ Expressões matemáticas inválidas
## Criação da função de recompensa
### Requisitos do ARN do Lambda
O ARN do Lambda precisa seguir este formato:
```
"arn:aws:lambda:*:*:function:*SageMaker*"
```
Se o Lambda não tiver esse esquema de nomenclatura, a tarefa falhará com este erro:
```
[ERROR] Unexpected error: lambda_arn must contain one of: ['SageMaker', 'sagemaker', 'Sagemaker'] when running on SMHP platform (Key: lambda_arn)
```
### Formato de solicitação do Lambda
Sua função do Lambda recebe dados neste formato:
```
[
{
"id": "sample-001",
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Do you have a dedicated security team?"
}
]
},
{
"role": "nova_assistant",
"content": [
{
"type": "text",
"text": "As an AI developed by Company, I don't have a dedicated security team..."
}
]
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
]
```
**nota**
A estrutura da mensagem inclui a matriz `content` aninhada, correspondente ao formato dos dados de entrada. A última mensagem com o perfil `nova_assistant` contém a resposta gerada pelo modelo.
### Formato de resposta do Lambda
Sua função do Lambda deve retornar dados neste formato:
```
[
{
"id": "sample-001",
"aggregate_reward_score": 0.75,
"metrics_list": [
{
"name": "accuracy",
"value": 0.85,
"type": "Metric"
},
{
"name": "fluency",
"value": 0.90,
"type": "Reward"
}
]
}
]
```
**Campos de resposta**
+ `id`: deve corresponder ao ID do exemplo de entrada
+ `aggregate_reward_score`: pontuação geral (normalmente de 0,0 a 1,0)
+ `metrics_list`: matriz de métricas individuais com:
+ `name`: identificador de métricas (por exemplo, “precisão”, “fluência”)
+ `value`: pontuação de métricas (normalmente de 0,0 a 1,0)
+ `type`: “métrica” (para relatórios) ou “recompensa” (usada no treinamento)
## permissões do IAM
### Permissões obrigatórias
O seu perfil de execução do SageMaker precisa ter as permissões para invocar sua função do Lambda. Adicione esta política ao seu perfil de execução do SageMaker:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
### Função de execução do Lambda
O perfil de execução de uma função do Lambda precisa de permissões básicas de execução do Lambda:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
Se sua função do Lambda acessar outros serviços da AWS (por exemplo, S3 para dados de referência, DynamoDB para registro em log), adicione essas permissões ao perfil de execução do Lambda.
## Execução da tarefa de avaliação
1. **Preparar seus dados**: formate seus dados de avaliação de acordo com os requisitos de formato de dados e carregue seu arquivo JSONL no S3: `s3://your-bucket/eval-data/eval_data.jsonl`
1. **Configurar sua fórmula**: atualize a fórmula de amostra com sua configuração:
+ Defina `model_name_or_path` para a localização do seu modelo
+ Defina `lambda_arn` para o ARN da função de recompensa
+ Defina `output_s3_path` para o local de saída desejado
+ Ajuste os parâmetros `inference` conforme necessário
Salve a fórmula como `rft_eval_recipe.yaml`
1. **Executar a avaliação**: execute a tarefa de avaliação usando o caderno fornecido: [Cadernos de avaliação](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook)
1. **Monitorar o progresso**: monitore sua tarefa de avaliação por meio do:
+ Console do SageMaker: verifique o status e os logs da tarefa
+ CloudWatch Logs: visualize logs de execução detalhados
+ Lambda Logs: depure problemas na função de recompensa
## Conceitos básicos dos resultados da avaliação
### Formato de saída
A tarefa de avaliação gera resultados para a localização específica do S3 no formato JSONL. Cada linha contém os resultados da avaliação de um exemplo:
```
{
"id": "sample-001",
"aggregate_reward_score": 0.75,
"metrics_list": [
{
"name": "accuracy",
"value": 0.85,
"type": "Metric"
},
{
"name": "fluency",
"value": 0.90,
"type": "Reward"
}
]
}
```
**nota**
A saída da tarefa de avaliação de RFT é idêntica ao formato da resposta do Lambda. O serviço de avaliação passa pela resposta da função do Lambda sem modificação, garantindo a consistência entre seus cálculos de recompensa e os resultados finais.
### Como interpretar os resultados do
**Pontuação de recompensa agregada**
+ Intervalo: normalmente de 0,0 (pior) a 1,0 (melhor), mas depende da sua implementação
+ Objetivo: número único resumindo o desempenho geral
+ Uso: compare modelos, acompanhe a melhoria em relação ao treinamento
**Métricas individuais**
+ Tipo de métrica: métricas informativas para análise
+ Tipo de recompensa: métricas usadas durante o treinamento de RFT
+ Interpretação: valores mais altos geralmente indicam melhor desempenho (a menos que você crie métricas inversas)
### Benchmarks de desempenho
O que constitui um desempenho “bom” depende do seu caso de uso:
| Intervalo de pontuação | Interpretação | Ação |
| --- | --- | --- |
| 0,8 a 1,0 | Excelente | Modelo pronto para implantação |
| 0,6 a 0,8 | Boa | Pequenas melhorias podem ser benéficas |
| 0,4 a 0,6 | Razoável | Melhoria significativa necessária |
| 0,0 a 0,4 | Ruim | Revise os dados de treinamento e a função de recompensa |
**Importante**
Essas são as diretrizes gerais. Defina seus próprios limites com base nos requisitos de negócios, no desempenho do modelo de base, nas restrições específicas do domínio e na análise de custo-benefício do treinamento adicional.
## Solução de problemas
### Problemas comuns
| Problema | Causa | Solução |
| --- | --- | --- |
| tempo limite do Lambda | Cálculo complexo de recompensas | Aumente o tempo limite do Lambda ou otimize a função |
| Permissão negada | Ausência de permissões do IAM | Verifique se o perfil do SageMaker pode invocar o Lambda |
| Pontuações inconsistentes | Função de recompensa não determinística | Use sementes fixas ou lógica determinística |
| Resultados ausentes | Erros do Lambda não detectados | Adicione tratamento abrangente de erros no Lambda |
### Lista de verificação de depuração
+ Verifique se os dados de entrada seguem o formato correto com matrizes de conteúdo aninhadas
+ Confirme se o ARN do Lambda está correto e se a função foi implantada
+ Verifique as permissões do IAM para o SageMaker → invocação do Lambda
+ Analise os logs do CloudWatch para erros do Lambda
+ Valide que a resposta do Lambda corresponde ao formato esperado
## Práticas recomendadas
+ Começar de forma simples: comece com as funções básicas de recompensa e itere
+ Testar o Lambda separadamente: use os eventos de teste do Lambda antes da avaliação completa
+ Validar em um conjunto de dados pequeno: execute a avaliação no subconjunto antes do conjunto de dados completo
+ Controle da versão: acompanhe as versões da função de recompensa junto com as versões do modelo
+ Monitorar os custos: as invocações do Lambda e o tempo de computação afetam os custos
+ Registrar em log de forma extensiva: use instruções de impressão no Lambda para depuração
+ Definir os tempos limite de forma adequada: concilie tempo de espera e custo
+ Métricas do documento: defina claramente o que cada métrica avalia
## Próximas etapas
Depois de concluir a avaliação de RFT:
+ Se os resultados forem satisfatórios: implante o modelo na produção
+ Se for necessário melhorar:
+ Ajuste a função de recompensa
+ Colete mais dados de treinamento
+ Modifique os hiperparâmetros de treinamento
+ Execute iterações adicionais de treinamento de RFT
+ Monitoramento contínuo: reavalie periodicamente com novos dados