Evaluación de su modelo entrenado por SageMaker AI - Amazon Nova
Requisitos previosTareas de referencia disponiblesConfiguraciones específicas de la evaluaciónTrabajos de entrenamiento de evaluaciónEvaluación de los resultados de la evaluaciónPrácticas recomendadas y solución de problemasSubtareas disponibles

Evaluación de su modelo entrenado por SageMaker AI

El objetivo del proceso de evaluación es evaluar el rendimiento del modelo entrenado comparándolo con referencias o un conjunto de datos personalizado. El proceso de evaluación suele incluir pasos para crear una fórmula de evaluación basada en el modelo entrenado, especificar los conjuntos de datos y las métricas de la evaluación, enviar un trabajo independiente para la evaluación y evaluar en función de referencias estándar o datos personalizados. El proceso de evaluación devolverá métricas de rendimiento almacenadas en su bucket de Amazon S3.

nota

El proceso de evaluación que se describe en este tema es un proceso sin conexión. El modelo se prueba con referencias fijas con respuestas predefinidas, en lugar de evaluarse en tiempo real o mediante interacciones con los usuarios en directo. Para evaluaciones en tiempo real, puede probar el modelo después de implementarlo en Amazon Bedrock llamando a las API de tiempo de ejecución de Amazon Bedrock.

Temas

Requisitos previos

Antes de empezar un trabajo de entrenamiento de evaluación, tenga en cuenta lo siguiente.

  • Un modelo de Amazon Nova entrenado por SageMaker AI del que desee evaluar su rendimiento.

  • Fórmula básica de Amazon Nova para evaluación. Para obtener más información, consulte Obtención de fórmulas de Amazon Nova.

Tareas de referencia disponibles

Hay un paquete de códigos de ejemplo que muestra cómo calcular métricas de referencia mediante la característica de evaluación de modelos de SageMaker AI para Amazon Nova. Para acceder a los paquetes de códigos, consulte sample-Nova-lighteval-custom-task.

A continuación se muestra una lista de las referencias estándar del sector disponibles y compatibles. Puede especificar las siguientes referencias para el parámetro eval_task.

Referencia disponibles para la evaluación del modelo

Referencia Modalidad Descripción Métricas Strategy (Estrategia) Subtarea disponible
mmlu

Texto

Comprensión del lenguaje multitarea: evalúa los conocimientos sobre 57 materias.

precisión

 zs_cot Sí
mmlu_pro Texto

MMLU (subconjunto profesional): se centra en dominios profesionales como derecho, medicina, contabilidad e ingeniería.

 precisión zs_cot No
bbh Texto

Tareas de razonamiento avanzado: conjunto de problemas complejos que ponen a prueba las habilidades cognitivas y de resolución de problemas de nivel superior.

 precisión fs_cot Sí
gpqa Texto

Respuesta a preguntas de física general: evalúa la comprensión de conceptos de física y habilidades relacionadas con la resolución de problemas.

 precisión zs_cot No
math Texto

Resolución de problemas matemáticos: mide el razonamiento matemático en temas como álgebra, cálculo y problemas verbales.

 exact_match zs_cot Sí
strong_reject Texto

Tarea de control de calidad: prueba la capacidad del modelo para detectar y rechazar contenido inapropiado, dañino o incorrecto.

 desviación zs Sí
ifeval Texto

Evaluación de seguimiento de instrucciones: mide la precisión con la que un modelo sigue las instrucciones dadas y completa las tareas según las especificaciones.

 precisión zs No
gen_qa Multimodal (imagen)

Evaluación personalizada de conjuntos de datos: permite usar un conjunto de datos propio para realizar pruebas comparativas y así comparar resultados del modelo con respuestas de referencia con métricas como ROUGE y BLEU. gen_qa admite la inferencia de imágenes para los modelos basados en Amazon Nova Lite o Amazon Nova Pro. También es compatible con funciones de Lambda que usen sus propias métricas. (En el caso de la evaluación de RFT, utilice la fórmula de evaluación de RFT)

 all gen_qa No
mmmu Multimodal

Comprensión multidisciplinaria masiva y multimodal (MMMU): prueba comparativa de nivel universitario que consta de preguntas de opción múltiple y preguntas abiertas de 30 disciplinas.

 precisión zs_cot Sí
llm_judge Texto

Comparación de preferencias de LLM como juez: utiliza un modelo Nova Judge para determinar la preferencia entre las respuestas emparejadas (B en comparación con A) para las peticiones, calculando la probabilidad de que se prefiera B a A.

 all judge No

mm_llm_judge

 Multimodal (imagen)

Esta nueva prueba comparativa se comporta igual que la indicada anteriormente, llm_judge, la cual está basada en texto. La única diferencia es que admite la inferencia de imágenes.

 all judge No

rubric_llm_judge

Texto

Rubric Judge es un modelo de evaluación mejorado de LLM como juez basado en Nova 2.0 Lite. A diferencia del modelo juez original, que solo proporciona veredictos preferenciales, Rubric Judge genera de forma dinámica criterios de evaluación personalizados adaptados a cada petición y puntúa de forma detallada varias dimensiones.

all

judge

No

aime_2024

Texto

AIME 2024: problemas del American Invitational Mathematics Examination (AIME) que ponen a prueba el razonamiento matemático avanzado y la resolución de problemas

exact_match

zs_cot

No

calendar_scheduling

 Texto

Natural Plan: tarea de planificación de calendario que ponen a prueba las capacidades de planificación para programar reuniones a lo largo de varios días y con múltiples personas

exact_match

fs

 No

humaneval

 Texto

HumanEval: conjunto de datos de referencia diseñado para evaluar las capacidades de generación de código de modelos de lenguaje de gran tamaño

pass@1

 zs No

Configuraciones específicas de la evaluación

A continuación, encontrará un desglose de los componentes clave de la fórmula y una guía sobre cómo modificarlos para sus casos de uso.

Comprensión y modificación de sus fórmulas

Configuración general de ejecución

run:
  name: eval_job_name
  model_type: amazon.nova-lite-v1:0:300k
  model_name_or_path: nova-lite/prod # or s3://escrow_bucket/model_location
  replicas: 1
  data_s3_path: ""
  mlflow_tracking_uri: ""
  mlflow_experiment_name : ""
  mlflow_run_name : ""

  • name: nombre descriptivo del trabajo de evaluación.

  • model_type: especifica la variante del modelo Nova que desea utilizar. No modifique manualmente este campo. Las opciones son:

    • amazon.nova-micro-v1:0:128k

    • amazon.nova-lite-v1:0:300k

    • amazon.nova-pro-v1:0:300k

    • amazon.nova-2-lite-v1:0:256k (modelo de Nova 2.0: consulte Nova 2.0 customization guide)

  • model_name_or_path: ruta al modelo base o ruta de s3 para el punto de comprobación entrenado posteriormente. Las opciones son:

    • nova-micro/prod

    • nova-lite/prod

    • nova-pro/prod

    • nova-lite-2/prod (modelo de Nova 2.0)

    • Ruta de S3 para la ruta de punto de comprobación entrenado posteriormente (s3:customer-escrow-111122223333-smtj-<unique_id>/<training_run_name>)

      nota

      Evaluación de modelos de entrenados posteriormente

      Para evaluar un modelo entrenado posteriormente después de un trabajo de entrenamiento de Nova SFT, siga estos pasos después de ejecutar un trabajo de entrenamiento correcto. Al final de los registros de entrenamiento, verá el mensaje de registro "Training is complete". También encontrará un archivo manifest.json en su bucket de salida que contiene la ubicación de su punto de comprobación. Este archivo se ubicará dentro de un archivo output.tar.gz en la ubicación S3 de salida. Para continuar con la evaluación, utilice este punto de comprobación configurándolo como el valor para run.model_name_or_path en la configuración de la fórmula.

  • replica: el número de instancias de computación que se van a utilizar para la inferencia distribuida (inferencia en varios nodos). Establezca replica > 1 para habilitar la inferencia en varios nodos, lo que acelera la evaluación. Si se especifican tanto instance_count como replica, instance_count tiene prioridad. Tenga en cuenta que las réplicas múltiples solo se aplican a los trabajos de entrenamiento de SageMaker AI.

  • data_s3_path: ruta de Amazon S3 del conjunto de datos de entrada. Este campo es obligatorio, pero siempre debe dejarse vacío.

  • mlflow_tracking_uri: (opcional) La ubicación del servidor de seguimiento de MLflow (solo se necesita en SMHP)

  • mlflow_experiment_name: (opcional) Nombre del experimento para agrupar los procesamientos de ML relacionados

  • mlflow_run_name: (opcional) nombre personalizado para un entrenamiento específico realizado dentro de un experimento

Configuración de evaluación

evaluation:
  task: mmlu
  strategy: zs_cot
  subtask: abstract_algebra
  metric: accuracy

  • task: especifica la referencia o la tarea de evaluación que se va a utilizar. Entre las tareas admitidas se incluyen:

    • mmlu

    • mmlu_pro

    • bbh

    • gpqa

    • math

    • strong_reject

    • gen_qa

    • ifeval

    • mmmu

    • llm_judge

    • mm_llm_judge

    • rubric_llm_judge

    • aime_2024

    • calendar_scheduling

    • humaneval

  • strategy: define el enfoque de evaluación:

    • zs_cot: cadena de pensamientos de cero intentos: enfoque para realizar peticiones a modelos de lenguaje de gran tamaño que fomenta el razonamiento paso a paso sin necesidad de ejemplos explícitos.

    • fs_cot: cadena de pensamiento de pocos pasos: enfoque que proporciona algunos ejemplos de razonamiento paso a paso antes de pedirle al modelo que resuelva un problema nuevo.

    • zs: cero intentos: enfoque para resolver un problema sin ejemplos de entrenamiento anteriores.

    • gen_qa: estrategia específica para utilizar su propio conjunto de datos.

    • judge: estrategia específica para mm_llm_judge y un LLM como juez de Nova.

  • subtask: opcional. Componentes específicos de la tarea de evaluación. Para obtener una lista completa de las subtareas disponibles, consulte Subtareas disponibles.

    • Compruebe las subtareas compatibles en las tareas de referencia disponibles.

    • Debe eliminar este campo si no hay referencias de subtareas.

  • metric: métrica de evaluación que se va a utilizar.

    • accuracy: porcentaje de respuestas correctas.

    • exact_match: para referencia matemática, devuelve la velocidad a la que las cadenas de entrada previstas coinciden exactamente con sus referencias.

    • deflection: para referencia de rechazo fuerte, devuelve la deflexión relativa al modelo base y la diferencia en las métricas de importancia.

    • all:

      Para gen_qa, utilice su propio conjunto de datos como punto de referencia y se devuelven las siguientes métricas:

      • rouge1: mide la superposición de unigramas (palabras individuales) entre el texto generado y el de referencia.

      • rouge2: mide la superposición de bigramas (dos palabras consecutivas) entre texto generado y de referencia.

      • rougeL: mide la subsecuencia común más larga entre textos, por lo que puede haber lagunas en la coincidencia.

      • exact_match: puntuación binaria (0 o 1) que indica si el texto generado coincide exactamente con el texto de referencia, carácter por carácter.

      • quasi_exact_match: similar a la coincidencia exacta, pero más flexible, pues suele ignorar el uso de mayúsculas y minúsculas, los signos de puntuación y los espacios en blanco.

      • f1_score: media armónica de precisión y recuperación que mide la superposición de palabras entre respuestas previstas y de referencia.

      • f1_score_quasi: similar a f1_score, pero con una coincidencia más flexible, utiliza una comparación de texto normalizada que no tiene en cuenta pequeñas diferencias.

      • bleu: mide la precisión de las coincidencias de n-gramas entre texto generado y de referencia, suele utilizarse en la evaluación de traducciones.

      En el caso de llm_judge y mm_llm_judge con su propio conjunto de datos comparativo, devuelve las siguientes métricas:

      • a_scores: número de aciertos para response_A en pasadas de evaluación hacia delante y hacia atrás.

      • a_scores_stderr: error estándar de response_A_scores en juicios por pares.

      • b_scores: mide el número de aciertos para response_B en pasadas de evaluación hacia delante y hacia atrás.

      • a_scores_stderr: error estándar de response_B_scores en juicios por pares.

      • ties: número de juicios en los que se evalúa response_A y response_B como iguales.

      • ties_stderr: error estándar de ties en juicios por pares.

      • inference_error: número de juicios que no se han podido evaluar adecuadamente.

      • score: puntuación global basada en aciertos de pasadas hacia adelante y hacia atrás para response_B.

      • score_stderr: puntuación global basada en aciertos de pasadas hacia adelante y hacia atrás para response_B.

      • inference_error_stderr: error estándar de puntuación global en juicios por pares.

      • winrate: probabilidad de que se prefiera response_B a response_A calculada utilizando probabilidad de Bradley-Terry.

      • lower_rate: límite inferior (percentil 2,5) de la tasa de aciertos estimada a partir del muestreo de inicio.

      • upper_rate: límite superior (percentil 97,5) de la tasa de aciertos estimada a partir del muestreo de inicio.

Configuración de inferencia (opcional)

inference:
  max_new_tokens: 2048
  top_k: -1
  top_p: 1.0
  temperature: 0
  top_logprobs: 10
  reasoning_effort: null  # options: low/high to enable reasoning or null to disable reasoning

  • max_new_tokens: número máximo de tokens que se generarán. Debe ser un número entero. (No disponible para LLM Judge)

  • top_k: número de tokens de mayor probabilidad que se deben tener en cuenta. Debe ser un número entero.

  • top_p: umbral de probabilidad acumulada para el muestreo de tokens. Debe ser un valor flotante entre 1,0 y 0,0.

  • temperature: asignación al azar en selección de tokens (mayor = más aleatorio), mantenga 0 para que el resultado sea determinista. De tipo flotante, el valor mínimo es 0.

  • top_logprobs: el número de probabilidades logarítmicas principales que se devolverán en la respuesta de inferencia. El valor debe ser un número entero entre 0 y 20. Las probabilidades logarítmicas contienen los tokens resultantes considerados y las probabilidades de registro de cada token resultante devuelto en el contenido del mensaje.

  • reasoning_effort: controla el comportamiento de razonamiento de los modelos capaces de razonar. Establezca reasoning_effort solo cuando model_type especifique un modelo con capacidad de razonamiento (actualmente, amazon.nova-2-lite-v1:0:256k). Las opciones disponibles son null (valor predeterminado si no se establece ninguno; desactiva el razonamiento), low o high.

Formato de salida de la probabilidad logarítmica

Cuando top_logprobs se configura en los ajustes de inferencia, el resultado de la evaluación incluye las probabilidades logarítmicas del token en los archivos de parquet. Cada posición de un token contiene un diccionario de los principales tokens candidatos con sus probabilidades logarítmicas siguiendo esta estructura:

{
"Ġint": {"logprob_value": -17.8125, "decoded_value": " int"},
"Ġthe": {"logprob_value": -2.345, "decoded_value": " the"}
}

Cada entrada de token contiene lo siguiente:

  • logprob_value: el valor de probabilidad logarítmica del token

  • decoded_value: la representación en cadena decodificada legible por humanos del token

El token tokenizador sin procesar se utiliza como clave del diccionario para garantizar la exclusividad, mientras que decoded_value proporciona una interpretación legible.

Ejemplos de fórmula de evaluación

Amazon Nova ofrece cuatro tipos diferentes de fórmulas de evaluación. Todas las fórmulas están disponibles en el repositorio de fórmulas de Amazon SageMaker HyperPod de GitHub.

Fórmulas de evaluación

    Estas fórmulas le permiten evaluar las capacidades fundamentales de los modelos de Amazon Nova a través de un amplio conjunto de referencias solo de texto.

    Formato de fórmula: xxx_general_text_benchmark_eval.yaml.

    Estas fórmulas le permiten utilizar su propio conjunto de datos como referencia y comparar las salidas del modelo con las respuestas de referencia utilizando diferentes tipos de métricas.

    Formato de fórmula: xxx_ bring_your_own_dataset_eval.yaml.

    Requisitos del conjunto de datos de uso propio

    Formato de archivo:

    • Archivo gen_qa.jsonl único que contiene ejemplos de evaluación. El nombre del archivo debe llamarse exactamente gen_qa.jsonl.

    • Debe cargar el conjunto de datos en una ubicación de S3 a la que puedan acceder los trabajos de entrenamiento de SageMaker AI.

    • El archivo debe seguir el formato de esquema requerido para un conjunto de datos general de preguntas y respuestas.

    Requisitos del formato de esquema: cada línea del archivo .jsonl debe ser un objeto JSON con los siguientes campos:

    • Campos obligatorios.

      query: cadena que contiene la pregunta o la instrucción que necesita una respuesta.

      response: cadena que contiene la salida esperada del modelo.

    • Campos opcionales.

      system: cadena que contiene la petición del sistema que establece el comportamiento, el rol o la personalidad del modelo de IA antes de que procese la consulta.

      images: matriz que contiene una lista de objetos con atributos de datos (cadenas de imágenes codificadas en Base64).

      metadata: cadena que contiene los metadatos asociados a la entrada con fines de etiquetado.

    Ejemplo de entrada

    {
"system":"You are an English major with top marks in class who likes to give minimal word responses: ",
   "query":"What is the symbol that ends the sentence as a question",
   "response":"?"
}{
"system":"You are a pattern analysis specialist who provides succinct answers: ",
   "query":"What is the next number in this series? 1, 2, 4, 8, 16, ?",
   "response":"32"
}{
"system":"You have great attention to detail and follow instructions accurately: ",
   "query":"Repeat only the last two words of the following: I ate a hamburger today and it was kind of dry",
   "response":"of dry"
}{
"system": "Image inference: ",
  "query": "What is the number in the image? Please just use one English word to answer.",
  "response": "two",
  "images": [
    {
      "data": "data:image/png;Base64,iVBORw0KGgoA ..."
    }
  ]
}

    Para usar un conjunto de datos personalizado, modifique la fórmula de evaluación agregando los siguientes campos obligatorios, sin cambiar la configuración existente:

    evaluation:
  task: gen_qa
  strategy: gen_qa
  metric: all

    Limitaciones

    • Solo se permite un archivo .jsonl por evaluación.

    • El archivo debe seguir estrictamente el esquema definido.

    Uso de sus propias métricas

    Puede usar sus propias métricas para personalizar completamente el flujo de trabajo de evaluación del modelo con funciones personalizadas de preprocesamiento, posprocesamiento y métricas. El preprocesamiento le permite procesar los datos de entrada antes de enviarlos al servidor de inferencia, y el posprocesamiento le permite personalizar el cálculo de las métricas y devolver métricas personalizadas en función de sus necesidades.

    Siga estos pasos para crear sus propias métricas con el SDK de evaluación personalizada:

    1. Si no lo ha hecho, cree primero una función AWS Lambda en su Cuenta de AWS.

    2. Descargue el archivo nova-custom-eval-layer.zip ya creado del repositorio de GitHub. Puede usar este SDK de evaluación personalizada de Nova de código abierto para validar las cargas útiles de entrada y salida de tu función personalizada y proporcionar una interfaz unificada para integrarla con la evaluación de métricas propia de Nova durante el entrenamiento.

    3. Use el siguiente comando para cargar la capa de Lambda personalizada:

      aws lambda publish-layer-version \
    --layer-name nova-custom-eval-layer \
    --zip-file fileb://nova-custom-eval-layer.zip \
    --compatible-runtimes python3.12 python3.11 python3.10 python3.9

    4. Agregue esta capa como capa personalizada a la función de Lambda, junto con la capa de AWS necesaria: AWSLambdaPowertoolsPythonV3-python312-arm64 (necesaria para la dependencia pydantic).

    5. Actualice el código de Lambda usando el ejemplo proporcionado y modifique el código según sea necesario. Este código de ejemplo crea una función de Lambda para la evaluación personalizada de Nova con pasos de preprocesamiento y posprocesamiento destinados a la evaluación del modelo:

      from nova_custom_evaluation_sdk.processors.decorators import preprocess, postprocess
from nova_custom_evaluation_sdk.lambda_handler import build_lambda_handler

@preprocess
def preprocessor(event: dict, context) -> dict:
    data = event.get('data', {})
    return {
        "statusCode": 200,
        "body": {
            "system": data.get("system"),
            "prompt": data.get("prompt", ""),
            "gold": data.get("gold", "")
        }
    }

@postprocess
def postprocessor(event: dict, context) -> dict:
    # data is already validated and extracted from event
    data = event.get('data', [])
    inference_output = data.get('inference_output', '')
    gold = data.get('gold', '')

    metrics = []
    inverted_accuracy = 0 if inference_output.lower() == gold.lower() else 1.0
    metrics.append({
        "metric": "inverted_accuracy_custom",
        "value": accuracy
    })

    # Add more metrics here

    return {
        "statusCode": 200,
        "body": metrics
    }

# Build Lambda handler
lambda_handler = build_lambda_handler(
    preprocessor=preprocessor,
    postprocessor=postprocessor
)

    6. Otorgue a Lambda acceso al trabajo de evaluación. Asegúrese de que el rol de puesta en marcha especificado para el trabajo de evaluación incluya una política para invocar la función de Lambda. A continuación, se muestra un ejemplo de política.

      JSON
      {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "LambdaAccess",
            "Effect": "Allow",
            "Action": [
                "lambda:InvokeFunction"
            ],
            "Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction",
            "Condition": {
                "StringLike": {
                    "aws:PrincipalArn": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-ARN"
                }
            }
        },
        {
            "Sid": "DenyNonAWSEventSourcesForLambda",
            "Effect": "Deny",
            "Action": [
                "lambda:InvokeFunction"
            ],
            "Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction",
            "Condition": {
                "Null": {
                    "lambda:EventSourceToken": false
                }
            }
        }
    ]
}

    7. Revise el esquema de la carga útil de Lambda. La tabla siguiente muestra el esquema de solicitud y respuesta de Lambda. Puede validar el esquema con el SDK de evaluación personalizada de Nova.

      Carga útil de la solicitud de Lambda Carga útil de la respuesta de Lambda
      Preprocesador 
      {
    "process_type": "preprocess",
    "data": {
        "system": "You are a helpful assistant",
        "prompt": "What is 2+2?",
        "gold": "4"
    }
}                                             
      {
    "statusCode": 200,
    "body": {
        "system": "You are a helpful assistant that can substitute * for addition",
        "prompt": "What is 2*2?",
        "gold": "4"
    }
}
      Posprocesador 
      {
    "process_type": "postprocess",
    "data":  {
    "prompt": "What is 2+2?",
    "inference_output": "2+2=4",
    "gold": "4"
    }
}
      		 
      {
    "statusCode": 200,
    "body": [
        {"metric": "accuracy", "value": 1.0},
        {"metric": "f1_score", "value": 1.0},
        {"metric": "exact_match", "value": 1},
        {"metric": "length_ratio", "value": 0.8}
    ]
}

    8. Modifique el archivo de la fórmula. A continuación se muestra un ejemplo. 

      processor:
  lambda_arn: arn:aws:lambda:us-east-1:111122223333:function:name
  lambda_type: "custom_metrics"
  preprocessing:
    enabled: true
  postprocessing:
    enabled: true
  aggregation: average

      • lambda-arn: el nombre de recurso de Amazon (ARN) de la función de Lambda que gestiona el preprocesamiento y el posprocesamiento.

      • lambda_type: “custom_metrics” o “rft”.

      • preprocessing: si se deben habilitar las operaciones de preprocesamiento personalizadas.

      • postprocessing: si se deben habilitar las operaciones de posprocesamiento personalizadas.

      • aggregation: función de agregación integrada (opciones válidas: mínimo, máximo, promedio, suma).

    Limitaciones

    • El uso de sus propias métricas solo se aplica a los conjuntos de datos de entrada de texto.

    • No se admiten los conjuntos de datos de entrada multimodales.

    • El paso de preprocesamiento no procesa el campo de metadatos.

    Nova LLM Judge es una característica de evaluación de modelos que le permite comparar la calidad de las respuestas de un modelo con las respuestas de un modelo de referencia mediante un conjunto de datos personalizado. Acepta un conjunto de datos que contiene peticiones, respuestas de referencia y respuestas de desafío, y utiliza un modelo de Nova Judge para proporcionar una métrica de tasa de aciertos basada en probabilidad de Bradley-Terry con comparaciones por pares. Formato de fórmula: xxx_llm_judge_eval.yaml.

    Requisitos del conjunto de datos de Nova LLM

    Formato de archivo:

    • Archivo llm_judge.jsonl único que contiene ejemplos de evaluación. El nombre del archivo debe llamarse exactamente llm_judge.jsonl.

    • Debe cargar el conjunto de datos en una ubicación de S3 a la que puedan acceder los trabajos de entrenamiento de SageMaker AI.

    • El archivo debe seguir el formato de esquema requerido para el conjunto de datos llm_judge.

    • El conjunto de datos de entrada debe garantizar que todos los registros tengan una longitud de contexto inferior a 12 000.

    Formato de esquema: cada línea del archivo .jsonl debe ser un objeto JSON con los siguientes campos.

    • Campos obligatorios.

      prompt: cadena que contiene la petición de la respuesta generada.

      response_A: cadena que contiene la respuesta de referencia.

      response_B: cadena que contiene la respuesta alternativa que se comparará con la respuesta de referencia.

    Ejemplo de entrada

    {
"prompt": "What is the most effective way to combat climate change?",
"response_A": "The most effective way to combat climate change is through a combination of transitioning to renewable energy sources and implementing strict carbon pricing policies. This creates economic incentives for businesses to reduce emissions while promoting clean energy adoption.",
"response_B": "We should focus on renewable energy. Solar and wind power are good. People should drive electric cars. Companies need to pollute less."
}
{
"prompt": "Explain how a computer's CPU works",
"response_A": "CPU is like brain of computer. It does math and makes computer work fast. Has lots of tiny parts inside.",
"response_B": "A CPU (Central Processing Unit) functions through a fetch-execute cycle, where instructions are retrieved from memory, decoded, and executed through its arithmetic logic unit (ALU). It coordinates with cache memory and registers to process data efficiently using binary operations."
}
{
"prompt": "How does photosynthesis work?",
"response_A": "Plants do photosynthesis to make food. They use sunlight and water. It happens in leaves.",
"response_B": "Photosynthesis is a complex biochemical process where plants convert light energy into chemical energy. They utilize chlorophyll to absorb sunlight, combining CO2 and water to produce glucose and oxygen through a series of chemical reactions in chloroplasts."
}

    Para usar un conjunto de datos personalizado, modifique la fórmula de evaluación con los siguientes campos obligatorios, sin cambiar ningún contenido:

    evaluation:
  task: llm_judge
  strategy: judge
  metric: all

    Limitaciones

    • Solo se permite un archivo .jsonl por evaluación.

    • El archivo debe seguir estrictamente el esquema definido.

    • Los modelos de Nova Judge son los mismos en todas las especificaciones micro, lite y pro.

    • Actualmente no se admiten modelos de juez personalizados.

    LLM como juez de Nova de fórmulas de referencia multimodales (imágenes)

    LLM como juez de Nova para entradas multimodales (imágenes) es una característica de evaluación de modelos que le permite comparar la calidad de las respuestas de un modelo con las respuestas de un modelo de referencia mediante un conjunto de datos personalizado. Acepta un conjunto de datos que contiene peticiones, respuestas de referencia y respuestas de desafío, así como imágenes en forma de cadena codificada en Base64. Utiliza un modelo juez de Nova para proporcionar una métrica de tasa de aciertos basada en probabilidad de Bradley-Terry con comparaciones por pares. Formato de fórmula: xxx_mm_llm_judge_eval.yaml.

    Requisitos del conjunto de datos de Nova LLM

    Formato de archivo:

    • Archivo mm_llm_judge.jsonl único que contiene ejemplos de evaluación. El nombre de archivo debe ser llm_judge.jsonl.

    • Debe cargar el conjunto de datos en una ubicación de S3 a la que puedan acceder los trabajos de entrenamiento de SageMaker AI.

    • El archivo debe seguir el formato de esquema requerido para el conjunto de datos mm_llm_judge.

    • El conjunto de datos de entrada debe garantizar que todos los registros tengan una longitud de contexto inferior a 12 000, sin incluir el atributo de la imagen.

    Formato de esquema: cada línea del archivo .jsonl debe ser un objeto JSON con los siguientes campos.

    • Campos obligatorios.

      prompt: cadena que contiene la petición de la respuesta generada.

      images: matriz que contiene una lista de objetos con atributos de datos (los valores son cadenas de imágenes codificadas en Base64).

      response_A: cadena que contiene la respuesta de referencia.

      response_B: cadena que contiene la respuesta alternativa que se comparará con la respuesta de referencia.

    Ejemplo de entrada

    Para facilitar la lectura, el siguiente ejemplo incluye nuevas líneas e indentaciones, pero en el conjunto de datos real, cada registro debe estar en una sola línea.

    {
  "prompt": "What is in the image?",
  "images": [
    {
      "data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
    }
  ],
  "response_A": "a dog.",
  "response_B": "a cat.",
}
{
  "prompt": "How many animals are in each of the images?",
  "images": [
    {
      "data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
    },
    {
      "data": "data:image/jpeg;Base64,/DKEafe3gihn..."
    }
  ],
  "response_A": "The first image contains one cat and the second image contains one dog",
  "response_B": "The first image has one aminal and the second has one animal"
}

    Para usar un conjunto de datos personalizado, modifique la fórmula de evaluación con los siguientes campos obligatorios, sin cambiar ningún contenido:

    evaluation:
  task: mm_llm_judge
  strategy: judge
  metric: all

    Limitaciones

    • Solo se permite un archivo .jsonl por evaluación.

    • El archivo debe seguir estrictamente el esquema definido.

    • Los modelos MM como juez de Nova solo admiten referencias de imagen.

    • Los modelos MM como juez de Nova son los mismos en todas las especificaciones de Amazon Nova Micro, Amazon Nova Lite y Amazon Nova Pro.

    • Actualmente no se admiten modelos de juez personalizados.

    • No se admite el URI de imagen de Amazon S3.

    • El conjunto de datos de entrada debe garantizar que todos los registros tengan una longitud de contexto inferior a 12 000, sin incluir los atributos de imagen.

    Ejecución de trabajos de entrenamiento de evaluación

    Comience un trabajo de entrenamiento con el siguiente ejemplo de cuaderno. Use el siguiente cuaderno como ejemplo para llevar a cabo el trabajo de entrenamiento de evaluación. Para obtener más información, consulte Uso de un estimador de SageMaker AI para ejecutar un trabajo de entrenamiento.

    Tablas de referencia

    Antes de ejecutar el cuaderno, consulte las siguientes tablas de referencia para seleccionar la URI de la imagen y las configuraciones de instancias.

    Selección de la URI de la imagen

    Fórmula URI de imagen

    URI de imagen de evaluación

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

    Selección del tipo y el recuento de instancias

    Modelo Tipo de trabajo Tipo de instancia Recuento de instancia recomendado Recuento de instancias permitido
    Amazon Nova Micro Evaluación (SFT/DPO)

    g5.12xlarge

    		 1 1-16
    Amazon Nova Lite Evaluación (SFT/DPO)

    g5.12xlarge

    		 1 1-16
    Amazon Nova Pro Evaluación (SFT/DPO)

    p5.48xlarge

    		 1 1-16

    Cuaderno de ejemplo

    En el siguiente cuaderno de ejemplo se muestra cómo ejecutar un trabajo de entrenamiento de evaluación.

    # install python SDK

# Do not use sagemaker v3, as sagemaker v3 introduced breaking changes

!pip install sagemaker==2.254.1

import os
import sagemaker,boto3
from sagemaker.inputs import TrainingInput
from sagemaker.pytorch import PyTorch

sagemaker_session = sagemaker.Session()
role = sagemaker.get_execution_role()

# Download recipe from https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/evaluation/nova to local
# Assume the file name be `recipe.yaml`

# Populate parameters
# input_s3_uri = "s3://<path>/input/" # (Optional) Only used for multi-modal dataset or bring your own dataset s3 location
output_s3_uri= "s3://<path>/output/" # Output data s3 location, a zip containing metrics json and tensorboard metrics files will be stored to this location
instance_type = "instance_type"  # ml.g5.16xlarge as example
instance_count = 1 # The number of instances for inference (set instance_count > 1 for multi-node inference to accelerate evaluation)
job_name = "your job name"
recipe_path = "recipe path" # ./recipe.yaml as example
image_uri = "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest" # Do not change
output_kms_key = "<KMS key arn to encrypt trained model in Amazon-owned S3 bucket>" # optional, leave blank for Amazon managed encryption

# (Optional) To bring your own dataset and LLM judge for evaluation
# evalInput = TrainingInput(
# s3_data=input_s3_uri,
# distribution='FullyReplicated',
# s3_data_type='S3Prefix'
#)

estimator = PyTorch(
    output_path=output_s3_uri,
    base_job_name=job_name,
    role=role,
    instance_type=instance_type,
    instance_count=instance_count,
    training_recipe=recipe_path,
    sagemaker_session=sagemaker_session,
    image_uri=image_uri,
    output_kms_key=output_kms_key
)
estimator.fit()

# If input dataset exist, pass in inputs
# estimator.fit(inputs={"train": evalInput})

    Evaluación y análisis de los resultados de la evaluación

    Una vez que el trabajo de evaluación haya finalizado satisfactoriamente, podrá evaluar los resultados y analizarlos mediante los pasos siguientes.

    Para evaluar y analizar los resultados, siga estos pasos.

    1. Comprenda la estructura de la ubicación de salida. Los resultados se almacenan en la ubicación de salida de Amazon S3 especificada como un archivo comprimido:

      s3://your-bucket/output/benchmark-name/
└── job_name/
    └── output/
        └── output.tar.gz

    2. Descargue el archivo output.tar.gz de su bucket. Extraiga el contenido para revelarlo.

      run_name/
├── eval_results/
|   └── results_[timestamp].json
│   └── inference_output.jsonl (only present for gen_qa)
|   └── details/
|         └── model/
|              └── <execution-date-time>/
|                    └──details_<task_name>_#_<datetime>.parquet
└── tensorboard_results/
    └── eval/
        └── events.out.tfevents.[timestamp]

      • results_[timestamp].json: archivo JSON de métricas de salida

      • details_<task_name>_#_<datetime>.parquet: archivo de resultados de inferencias (excepto strong_reject)

      • events.out.tfevents.[timestamp]: archivo de salida de TensorBoard

      • inference_output.jsonl: archivo de salida de inferencias limpio (solo para tareas gen_qa)

    3. Vea los resultados en TensorBoard. Para visualizar sus métricas de evaluación:

      1. Cargue la carpeta extraída en un bucket de S3

      2. Navegue hasta SageMaker AI TensorBoard.

      3. Seleccione sus "carpetas de S3"

      4. Añada la ruta de la carpeta de S3

      5. Espere a que se complete la sincronización

    4. Analice los resultados de las inferencias. Todas las tareas de evaluación, excepto llm_judge y strong_reject, tendrán los siguientes campos de análisis en el resultado de la inferencia.

      • full_prompt: la petición completa del usuario enviada al modelo utilizado para la tarea de evaluación.

      • gold: el campo que contiene las respuestas correctas especificadas en el conjunto de datos.

      • metrics: el campo que contiene las métricas evaluadas en la inferencia individual. Los valores que requieren agregación no tendrían ningún valor en los resultados de la inferencia individuales.

      • predictions: el campo que contiene una lista de los resultados del modelo para la petición dada.

      • pred_logits: el campo que contiene los tokens resultantes considerados y las probabilidades de registro de cada token resultante devuelto en el contenido del mensaje.

      Al observar estos campos, puede determinar la causa de las diferencias métricas y comprender el comportamiento de los modelos personalizados.

      Para llm_judge, el archivo de salida de inferencias contiene los siguientes campos en el campo de métricas por par de evaluaciones.

      • forward_output: las preferencias brutas de Judge al evaluar en orden (response_A, response_B).

      • backward_output: las preferencias brutas de Judge al evaluar en orden inverso (response_B, response_A).

      • Pairwise metrics: métricas que se calculan por pares de evaluaciones hacia adelante y hacia atrás, incluidas a_scores, b_scores, ties, inference-score y score.

        nota

        Las métricas agrupadas como winrate solo están disponibles en los archivos de resultados de resumen, no por valoración individual.

      Para gen_qa, el archivo inference_output.jsonl contiene los siguientes campos para cada objeto JSON:

      • petición: última petición enviada al modelo

      • inferencia: salida de inferencia sin procesar del modelo

      • gold: la respuesta objetivo del conjunto de datos de entrada

      • metadata: la cadena de metadatos del conjunto de datos de entrada, si se proporciona

    Prácticas recomendadas y solución de problemas de evaluación

    Prácticas recomendadas

    A continuación se enumeran algunas de las prácticas recomendadas para el proceso de evaluación.

    • Mantenga las rutas de salida organizadas por modelo y tipo de referencia.

    • Mantenga convenciones de nomenclatura coherentes para facilitar el seguimiento.

    • Guarde los resultados extraídos en un lugar seguro.

    • Supervise el estado de sincronización de TensorBoard para que los datos se carguen correctamente.

    Solución de problemas

    Puede utilizar el grupo de registros de CloudWatch /aws/sagemaker/TrainingJobs para los registros de errores de los trabajos de entrenamiento.

    Fallo del núcleo del motor

    Problema:

    Si ve lo siguiente: 

    RuntimeError: Engine core initialization failed.

    Causa:

    Aunque se trata de un error general que puede tener varias causas, suele producirse cuando no coinciden el punto de control del modelo que se intenta cargar y el tipo de modelo especificado. Por ejemplo, quiere evaluar un punto de control de un modelo de Nova 2.0 Lite refinado, pero el tipo de modelo que proporciona es de la versión 1.0, p. ej. amazon.nova-micro-v1:0:128k

    La asignación correcta debería ser la siguiente: 

    model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod # or s3://escrow_bucket/model_location

    Prevención:

    Compruebe que model_name_or_path se haya asignado al model_type correcto antes de enviar el trabajo de evaluación.

    Subtareas disponibles

    A continuación, se indican las subtareas disponibles para la evaluación de modelos en varios dominios, como MMLU (Massive Multitask Language Understanding), BBH (Big Bench Hard), MATH y MMMU (Massive Multi-discipline Multimodal Understanding). Estas subtareas le permiten evaluar el rendimiento del modelo en función de capacidades y áreas de conocimiento específicas.

    MMLU

    MMLU_SUBTASKS = [
    "abstract_algebra",
    "anatomy",
    "astronomy",
    "business_ethics",
    "clinical_knowledge",
    "college_biology",
    "college_chemistry",
    "college_computer_science",
    "college_mathematics",
    "college_medicine",
    "college_physics",
    "computer_security",
    "conceptual_physics",
    "econometrics",
    "electrical_engineering",
    "elementary_mathematics",
    "formal_logic",
    "global_facts",
    "high_school_biology",
    "high_school_chemistry",
    "high_school_computer_science",
    "high_school_european_history",
    "high_school_geography",
    "high_school_government_and_politics",
    "high_school_macroeconomics",
    "high_school_mathematics",
    "high_school_microeconomics",
    "high_school_physics",
    "high_school_psychology",
    "high_school_statistics",
    "high_school_us_history",
    "high_school_world_history",
    "human_aging",
    "human_sexuality",
    "international_law",
    "jurisprudence",
    "logical_fallacies",
    "machine_learning",
    "management",
    "marketing",
    "medical_genetics",
    "miscellaneous",
    "moral_disputes",
    "moral_scenarios",
    "nutrition",
    "philosophy",
    "prehistory",
    "professional_accounting",
    "professional_law",
    "professional_medicine",
    "professional_psychology",
    "public_relations",
    "security_studies",
    "sociology",
    "us_foreign_policy",
    "virology",
    "world_religions"
]

    BBH

    BBH_SUBTASKS = [
    "boolean_expressions",
    "causal_judgement",
    "date_understanding",
    "disambiguation_qa",
    "dyck_languages",
    "formal_fallacies",
    "geometric_shapes",
    "hyperbaton",
    "logical_deduction_five_objects",
    "logical_deduction_seven_objects",
    "logical_deduction_three_objects",
    "movie_recommendation",
    "multistep_arithmetic_two",
    "navigate",
    "object_counting",
    "penguins_in_a_table",
    "reasoning_about_colored_objects",
    "ruin_names",
    "salient_translation_error_detection",
    "snarks",
    "sports_understanding",
    "temporal_sequences",
    "tracking_shuffled_objects_five_objects",
    "tracking_shuffled_objects_seven_objects",
    "tracking_shuffled_objects_three_objects",
    "web_of_lies",
    "word_sorting"
]

    Matemático

    MATH_SUBTASKS = [
    "algebra",
    "counting_and_probability",
    "geometry",
    "intermediate_algebra",
    "number_theory",
    "prealgebra",
    "precalculus",

    MMMU

    
            MATH_SUBTASKS = [
    "Accounting",
    "Agriculture",
    "Architecture_and_Engineering",
    "Art",
    "Art_Theory",
    "Basic_Medical_Science",
    "Biology",
    "Chemistry",
    "Clinical_Medicine",
    "Computer_Science",
    "Design",
    "Diagnostics_and_Laboratory_Medicine",
    "Economics",
    "Electronics",
    "Energy_and_Power",
    "Finance",
    "Geography",
    "History",
    "Literature",
    "Manage",
    "Marketing",
    "Materials",
    "Math",
    "Mechanical_Engineering",
    "Music",
    "Pharmacy",
    "Physics",
    "Psychology",
    "Public_Health",
    "Sociology",

    Evalúe sus modelos de Nova personalizados utilizando varios métodos y métricas de evaluación.

    En esta sección: