Realizar evaluaciones e interpretar los resultados - Amazon SageMaker AI
Ejecutar el trabajo de evaluaciónComprender los resultados de la evaluaciónResolución de problemasPrácticas recomendadasSiguientes pasosFunciones de recompensa preestablecidas

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Realizar evaluaciones e interpretar los resultados

Ejecutar el trabajo de evaluación

Paso 1: Prepare sus datos

  • Formatee los datos de evaluación de acuerdo con los requisitos de formato de datos

  • Suba su archivo JSONL a S3: s3://your-bucket/eval-data/eval_data.jsonl

Paso 2: Configura tu receta

Actualice la receta de muestra con su configuración:

  • model_name_or_pathConfigúrelo a la ubicación de su modelo

  • Configura lambda_arn tu función de recompensa ARN

  • output_s3_pathAjústelo a la ubicación de salida que desee

  • Ajuste inference los parámetros según sea necesario

Guarde la receta como rft_eval_recipe.yaml

Paso 3: Ejecute la evaluación

Ejecute el trabajo de evaluación utilizando el cuaderno suministrado: Cuadernos de evaluación

Contenedor de evaluación

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

Paso 4: Supervisar el progreso

Supervise su trabajo de evaluación mediante:

  • SageMaker Consola: compruebe el estado y los registros del trabajo

  • CloudWatch Registros: vea los registros de ejecución detallados

  • Registros Lambda: Depurar problemas con la función de recompensa

Comprender los resultados de la evaluación

Formato de salida

El trabajo de evaluación envía los resultados a la ubicación S3 especificada en formato JSONL. Cada línea contiene los resultados de la evaluación de una muestra:

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

El resultado del trabajo de evaluación de RFT es idéntico al formato de respuesta Lambda. El servicio de evaluación analiza la respuesta de la función Lambda sin modificaciones, lo que garantiza la coherencia entre los cálculos de recompensas y los resultados finales.

Interpretación de los resultados

Puntuación de recompensa agregada

  • Rango: normalmente de 0.0 (peor) a 1.0 (mejor), pero depende de la implementación

  • Propósito: Un solo número que resume el rendimiento general

  • Uso: comparar modelos, realizar un seguimiento de las mejoras con respecto a la formación

Métricas individuales

  • Tipo de métrica: métricas informativas para el análisis

  • Tipo de recompensa: métricas utilizadas durante el entrenamiento de RFT

  • Interpretación: Los valores más altos generalmente indican un mejor rendimiento (a menos que diseñe métricas inversas)

Puntos de referencia de rendimiento

Lo que constituye un rendimiento «bueno» depende del caso de uso:

Rango de puntuación Interpretación Action
0.8 - 1.0 Excelente Modelo listo para su despliegue
0,6 - 0,8 Buena Las mejoras menores pueden ser beneficiosas
0,4 - 0,6 Regular Se necesita una mejora significativa
0,0 - 0,4 Pobre Revise los datos de entrenamiento y la función de recompensa
importante

Estas son pautas generales. Defina sus propios umbrales en función de:

  • Requisitos empresariales

  • Rendimiento del modelo de referencia

  • Restricciones específicas del dominio

  • Análisis coste-beneficio de la formación continua

Análisis de resultados

Calcule las estadí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 los casos de fallo: revise las muestras con puntuaciones bajas para comprender las debilidades

  • Compare las métricas: analice la correlación entre las diferentes métricas para identificar las compensaciones

  • Realice un seguimiento a lo largo del tiempo: compare los resultados de las evaluaciones en las distintas iteraciones de entrenamiento

Resolución de problemas

Problemas comunes

Problema Causa Solución
Tiempo de espera de Lambda Cálculo complejo de recompensas Aumente el tiempo de espera de Lambda u optimice la función
Permiso denegado Faltan permisos de IAM: Verificar que SageMaker el rol pueda invocar Lambda
Puntuaciones inconsistentes Función de recompensa no determinista Utilice semillas fijas o lógica determinista
Faltan resultados Errores Lambda no detectados Añada una gestión integral de errores en Lambda

Lista de verificación de depuración

  • Compruebe que los datos de entrada sigan el formato correcto con matrices de contenido anidadas

  • Confirme que el ARN de Lambda sea correcto y que la función esté implementada

  • Compruebe los permisos de IAM para SageMaker → Invocación a Lambda

  • Revise CloudWatch los registros para detectar errores de Lambda

  • Valide que la respuesta de Lambda coincida con el formato esperado

Prácticas recomendadas

  • Comience de forma sencilla: comience con las funciones de recompensa básicas e itere

  • Pruebe Lambda por separado: utilice los eventos de prueba Lambda antes de la evaluación completa

  • Validar en un conjunto de datos pequeño: ejecute la evaluación en el subconjunto antes que en el conjunto de datos completo

  • Control de versiones: haga un seguimiento de las versiones de las funciones de recompensa junto con las versiones del modelo

  • Supervise los costos: las invocaciones a Lambda y el tiempo de cómputo afectan los costos

  • Registre exhaustivamente: utilice sentencias impresas en Lambda para la depuración

  • Establezca los tiempos de espera de forma adecuada: equilibre la paciencia y el costo

  • Documente las métricas: defina claramente lo que mide cada métrica

Siguientes pasos

Tras completar la evaluación de la RFT:

  • Si los resultados son satisfactorios: implemente el modelo en producción

  • Si es necesaria una mejora:

    • Ajusta la función de recompensa

    • Recopila más datos de entrenamiento

    • Modifique los hiperparámetros de entrenamiento

    • Ejecute iteraciones de entrenamiento de RFT adicionales

  • Supervisión continua: reevalúe periódicamente con nuevos datos

Funciones de recompensa preestablecidas

Dos funciones de recompensa predefinidas (prime_code, prime_math) de la biblioteca verl de código abierto están disponibles en una capa Lambda que puede agrupar con su RFT Lambda.

Descripción general de

Estas funciones out-of-the-box preestablecidas proporcionan capacidades de evaluación para:

  • prime_code: generación de código y evaluación de su corrección

  • prime_math — Evaluación del razonamiento matemático y la resolución de problemas

Configuración rápida

  1. Descargue la capa Lambda de las versiones nova-custom-eval-sdk

  2. Publique la capa Lambda mediante: 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. Agregue la capa a su función Lambda en AWS Management Console (seleccione la preset-function-layer capa personalizada y también agregue AWSSDKPandas-Python 312 para numerosas dependencias)

  4. Importe y use en su código Lambda:

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

función prime_code

Objetivo: Evalúa las tareas de generación de código de Python mediante la ejecución del código en casos de prueba y la medición de la corrección.

Ejemplo de formato de conjunto de datos de entrada obtenido de una evaluación

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

Características principales

  • Extracción automática de código a partir de bloques de códigos rebajados

  • Detección de funciones y pruebas basadas en llamadas

  • Pruebe la ejecución de casos con protección de tiempo de espera

  • Comprobaciones de validación y compilación de la sintaxis

  • Informes detallados de errores con rastreos

función prime_math

Propósito: Evalúa el razonamiento matemático y las capacidades de resolución de problemas con apoyo matemático simbólico.

Formato de entrada

{"messages":[{"role":"user","content":"What is the derivative of x^2 + 3x?."}],"reference_answer":"2*x + 3"}

Características principales

  • Evaluación matemática simbólica mediante SymPy

  • Múltiples formatos de respuesta (LaTeX, texto plano, simbólico)

  • Comprobación de equivalencias matemáticas

  • Normalización y simplificación de expresiones

Requisitos del formato de los datos

Para la evaluación del código

  • Entradas: matriz de argumentos de funciones (tipos adecuados: enteros, cadenas, etc.)

  • Salidas: matriz de valores de retorno esperados (tipos adecuados: booleanos, números, etc.)

  • Código: debe estar en Python con definiciones de funciones claras

Para la evaluación matemática

  • Respuesta de referencia: expresión matemática o valor numérico

  • Respuesta: puede ser una LaTe X, texto sin formato o notación simbólica

  • Equivalencia: se comprueba simbólicamente, no solo la coincidencia de cadenas

Prácticas recomendadas

  • Utilice los tipos de datos adecuados en los casos de prueba (números enteros frente a cadenas, valores booleanos frente a «verdaderos»)

  • Proporcione firmas de funciones claras en los problemas de código

  • Incluya casos extremos en las entradas de prueba (cero, números negativos, entradas vacías)

  • Formatee las expresiones matemáticas de forma coherente en las respuestas de referencia

  • Pruebe su función de recompensa con datos de muestra antes de implementarla

Gestión de errores

Ambas funciones incluyen una sólida gestión de errores para:

  • Errores de compilación en el código generado

  • Excepciones de tiempo de ejecución durante la ejecución

  • Datos de entrada mal formados

  • Escenarios de tiempo de espera para bucles infinitos

  • Expresiones matemáticas no válidas