Executando avaliações e interpretando resultados - SageMaker IA da Amazon
Executando o trabalho de avaliaçãoEntendendo os resultados da avaliaçãoSolução de problemasPráticas recomendadasPróximas etapasFunções de recompensa predefinidas

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Executando avaliações e interpretando resultados

Executando o trabalho de avaliação

Etapa 1: Preparar seus dados

  • Formate seus dados de avaliação de acordo com os requisitos de formato de dados

  • Faça upload do seu arquivo JSONL para o S3: s3://your-bucket/eval-data/eval_data.jsonl

Etapa 2: configure sua receita

Atualize a receita de amostra com sua configuração:

  • model_name_or_pathDefina a localização do seu modelo

  • lambda_arnDefina para sua função de recompensa ARN

  • output_s3_pathDefina o local de saída desejado

  • Ajuste inference os parâmetros conforme necessário

Salve a receita como rft_eval_recipe.yaml

Etapa 3: Executar a avaliação

Execute o trabalho de avaliação usando o notebook fornecido: cadernos de avaliação

Contêiner de avaliação

708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest

Etapa 4: monitorar o progresso

Monitore seu trabalho de avaliação por meio de:

  • SageMaker Console: verifique o status e os registros do trabalho

  • CloudWatch Registros: veja registros de execução detalhados

  • Lambda Logs: Depurar problemas na função de recompensa

Entendendo os resultados da avaliação

Formato de saída

O trabalho de avaliação gera resultados para a localização especificada do S3 no formato JSONL. Cada linha contém os resultados da avaliação de uma amostra:

{  
  "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

O RFT Evaluation Job Output é idêntico ao formato Lambda Response. O serviço de avaliação passa pela resposta da função 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 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 - 1,0 Excelente Modelo pronto para implantação
0,6 - 0,8 Boa Pequenas melhorias podem ser benéficas
0,4 - 0,6 Razoável É necessária uma melhoria significativa
0,0 - 0,4 Pobre Revise os dados de treinamento e a função de recompensa
Importante

Essas são diretrizes gerais. Defina seus próprios limites com base em:

  • Requisitos de negócios

  • Desempenho do modelo básico

  • Restrições específicas do domínio

  • Análise de custo-benefício do treinamento adicional

Analisar resultados

Calcular estatísticas resumidas

import json  
import numpy as np  
scores = []  
with open('evaluation_results.jsonl', 'r') as f:  
    for line in f:  
        result = json.loads(line)  
        scores.append(result['aggregate_reward_score'])  
  
print(f"Mean: {np.mean(scores):.3f}")  
print(f"Median: {np.median(scores):.3f}")  
print(f"Std Dev: {np.std(scores):.3f}")  
print(f"Min: {np.min(scores):.3f}")  
print(f"Max: {np.max(scores):.3f}")

  • Identifique casos de falha: analise amostras com pontuações baixas para entender os pontos fracos

  • Compare métricas: analise a correlação entre diferentes métricas para identificar compensações

  • Monitore ao longo do tempo: compare os resultados da avaliação em todas as iterações de treinamento

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 a SageMaker função 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 está implantada

  • Verifique as permissões do IAM para SageMaker → Invocação do Lambda

  • Revise CloudWatch os registros de erros do Lambda

  • Valide que a resposta do Lambda corresponde ao formato esperado

Práticas recomendadas

  • Comece de forma simples: comece com as funções básicas de recompensa e repita

  • Teste 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 de versão: acompanhe as versões da função de recompensa junto com as versões do modelo

  • Monitore os custos: as invocações do Lambda e o tempo de computação afetam os custos

  • Registre extensivamente: use instruções de impressão no Lambda para depuração

  • Defina os tempos limite de forma adequada: equilíbrio entre paciência e custo

  • Métricas do documento: defina claramente o que cada métrica mede

Próximas etapas

Depois de concluir a avaliação do 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

Funções de recompensa predefinidas

Duas funções de recompensa predefinidas (prime_code, prime_math) da biblioteca verl de código aberto estão disponíveis em uma camada Lambda que você pode agrupar com seu RFT Lambda.

Visão geral do

Essas funções predefinidas fornecem recursos out-of-the-box de avaliação 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. Baixe a camada Lambda dos lançamentos nova-custom-eval-sdk

  2. Publique a camada Lambda usando: 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

  3. Adicione a camada à sua função Lambda em AWS Management Console ( preset-function-layerselecione a camada personalizada e também adicione AWSSDKPandas-Python 312 para dependências numéricas)

  4. Importe e use em seu código Lambda:

    from prime_code import compute_score  # For code evaluation  
from prime_math import compute_score  # For math evaluation

função prime_code

Objetivo: avalia as tarefas de geração de código em Python executando o código em casos de teste e medindo a exatidão.

Exemplo de formato de conjunto de dados de entrada a partir da avaliação

{"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

  • 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 validação e compilação de sintaxe

  • Relatórios detalhados de erros com rastreamentos

função prime_math

Objetivo: 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

  • 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

  • Normalização e simplificaçã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, cadeias de caracteres, 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 LaTe X, texto simples ou notação simbólica

  • Equivalência — Verificada simbolicamente, não apenas correspondência de strings

Práticas recomendadas

  • Use tipos de dados adequados em casos de teste (inteiros versus strings, booleanos versus “True”)

  • Forneça assinaturas de funções claras em problemas de código

  • Inclua casos extremos 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 amostra 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 tempo de execução durante a execução

  • Dados de entrada malformados

  • Cenários de tempo limite para loops infinitos

  • Expressões matemáticas inválidas