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.

Compare los puntos finales de inferencia de IA generativa

El servicio de evaluación comparativa de la SageMaker IA mide el rendimiento de los modelos de lenguaje de gran tamaño (LLM) alojados en puntos finales de IA. SageMaker Realiza pruebas comparativas con NVIDIA AiPerf y produce métricas como la latencia de las solicitudes, el rendimiento, el tiempo transcurrido hasta el primer token y la latencia entre los mismos.

Requisitos previos

Antes de crear un trabajo de referencia, necesitas lo siguiente:

Paso 1: Cree un trabajo de referencia

Un trabajo de referencia se dirige a un punto final de SageMaker IA específico y hace referencia a una configuración de carga de trabajo.

Python (boto3)

response = client.create_ai_benchmark_job(
    AIBenchmarkJobName="my-benchmark-job",
    BenchmarkTarget={
        "Endpoint": {
            "Identifier": "my-sagemaker-endpoint"
        }
    },
    OutputConfig={
        "S3OutputLocation": "s3://DOC-EXAMPLE-BUCKET/benchmark-results/"
    },
    AIWorkloadConfigIdentifier="my-benchmark-config",
    RoleArn="arn:aws:iam::111122223333:role/ExampleRole",
)
print(response["AIBenchmarkJobArn"])
        

AWS CLI

aws sagemaker create-ai-benchmark-job \
  --ai-benchmark-job-name "my-benchmark-job" \
  --benchmark-target '{"Endpoint": {"Identifier": "my-sagemaker-endpoint"}}' \
  --output-config '{"S3OutputLocation": "s3://DOC-EXAMPLE-BUCKET/benchmark-results/"}' \
  --ai-workload-config-identifier "my-benchmark-config" \
  --role-arn "arn:aws:iam::111122223333:role/ExampleRole" \
  --region us-west-2
        

Si su punto final aloja varios modelos a través de componentes de inferencia, puede especificarlos en el InferenceComponents parámetro de. BenchmarkTarget

Si su dispositivo de punto final está en una VPC, transfiera el NetworkConfig parámetro con su VpcConfig configuración, incluidos los ID de los grupos de seguridad y las subredes.

Para realizar un seguimiento de los resultados de referencia con un MLflow totalmente gestionado en SageMaker IA, añada un MlflowConfig objeto a. OutputConfig Para obtener más información, consulte Realice un seguimiento de las recomendaciones de inferencias y los resultados comparativos con MLflow.

Compare los componentes de inferencia

Si su terminal utiliza componentes de inferencia en lugar de implementar un modelo directamente, debe especificar los componentes de inferencia que desea comparar en el. BenchmarkTarget Cuando se especifican los componentes de inferencia, el servicio de evaluación comparativa dirige las solicitudes a esos componentes específicos en lugar de al modelo predeterminado del punto final.

Pase uno o más nombres de componentes de inferencia o ARN de la lista: InferenceComponents

Python (boto3)

response = client.create_ai_benchmark_job(
    AIBenchmarkJobName="my-ic-benchmark",
    BenchmarkTarget={
        "Endpoint": {
            "Identifier": "my-multi-model-endpoint",
            "InferenceComponents": [
                {"Identifier": "my-inference-component-llama"}
            ]
        }
    },
    OutputConfig={
        "S3OutputLocation": "s3://DOC-EXAMPLE-BUCKET/benchmark-results/"
    },
    AIWorkloadConfigIdentifier="my-benchmark-config",
    RoleArn="arn:aws:iam::111122223333:role/ExampleRole",
)
        

AWS CLI

aws sagemaker create-ai-benchmark-job \
  --ai-benchmark-job-name "my-ic-benchmark" \
  --benchmark-target '{
    "Endpoint": {
      "Identifier": "my-multi-model-endpoint",
      "InferenceComponents": [
        {"Identifier": "my-inference-component-llama"}
      ]
    }
  }' \
  --output-config '{"S3OutputLocation": "s3://DOC-EXAMPLE-BUCKET/benchmark-results/"}' \
  --ai-workload-config-identifier "my-benchmark-config" \
  --role-arn "arn:aws:iam::111122223333:role/ExampleRole" \
  --region us-west-2
        

Compare los puntos finales de varios LORA

Para comparar un punto final que sirve a varios adaptadores LoRa, especifique cada adaptador como componente de inferencia en el. BenchmarkTarget Si lo desea, puede utilizar el parámetro de model_selection_strategy carga de trabajo para controlar la forma en que el punto de referencia distribuye las solicitudes entre los adaptadores. Si no especifica una estrategia, la opción predeterminada esround_robin.

En primer lugar, cree una configuración de carga de trabajo. El siguiente ejemplo incluye el model_selection_strategy parámetro opcional:

# Create a workload config for multi-LoRA benchmarking
workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "prompt_input_tokens_mean": 550,
        "output_tokens_mean": 150,
        "concurrency": 10,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B",
        "model_selection_strategy": "round_robin"
    },
    "secrets": {
        "hf_token": "arn:aws:secretsmanager:us-west-2:111122223333:secret:my-hf-token-AbCdEf"
    },
    "tooling": {"api_standard": "openai"}
}

import json
client.create_ai_workload_config(
    AIWorkloadConfigName="multi-lora-config",
    WorkloadSpec={"Inline": json.dumps(workload_spec)}
)
        

A continuación, cree un trabajo de referencia que se dirija a todos los componentes de inferencia del adaptador LoRa:

response = client.create_ai_benchmark_job(
    AIBenchmarkJobName="multi-lora-benchmark",
    BenchmarkTarget={
        "Endpoint": {
            "Identifier": "my-lora-endpoint",
            "InferenceComponents": [
                {"Identifier": "lora-adapter-customer-support"},
                {"Identifier": "lora-adapter-code-generation"},
                {"Identifier": "lora-adapter-summarization"}
            ]
        }
    },
    OutputConfig={
        "S3OutputLocation": "s3://DOC-EXAMPLE-BUCKET/multi-lora-results/"
    },
    AIWorkloadConfigIdentifier="multi-lora-config",
    RoleArn="arn:aws:iam::111122223333:role/ExampleRole",
)
        

El model_selection_strategy parámetro es opcional y determina cómo la herramienta de referencia distribuye las solicitudes entre los componentes de inferencia especificados. Los valores válidos son los siguientes:

Si no lo especificamodel_selection_strategy, el punto de referencia lo utiliza de forma round_robin predeterminada.

Compare puntos finales multimodales con imágenes sintéticas

Puede comparar modelos de lenguaje visual mediante la generación de imágenes sintéticas como parte de la configuración de la carga de trabajo. El servicio de evaluación comparativa utiliza AIPerf para crear imágenes con dimensiones y formatos configurables y, a continuación, las envía como cargas útiles codificadas en base64 a su terminal.

El siguiente ejemplo crea una configuración de carga de trabajo para realizar una evaluación comparativa de un modelo de lenguaje visual con imágenes sintéticas:

import json

workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "image_width_mean": 640,
        "image_height_mean": 480,
        "prompt_input_tokens_mean": 100,
        "output_tokens_mean": 150,
        "concurrency": 8,
        "request_count": 100,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    },
    "secrets": {
        "hf_token": "arn:aws:secretsmanager:us-west-2:111122223333:secret:my-hf-token-AbCdEf"
    }
}

client.create_ai_workload_config(
    AIWorkloadConfigName="image-benchmark-config",
    WorkloadSpec={"Inline": json.dumps(workload_spec)}
)

Los siguientes parámetros controlan la generación de imágenes sintéticas:

Variable-size imágenes

Utilice parámetros de desviación estándar para generar imágenes con dimensiones variables, simulando cargas de trabajo del mundo real en las que los tamaños de las imágenes varían:

workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "image_width_mean": 800,
        "image_width_stddev": 200,
        "image_height_mean": 600,
        "image_height_stddev": 150,
        "image_batch_size": 2,
        "concurrency": 4,
        "request_count": 50,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    }
}

Compare puntos finales multimodales con vídeo sintético

Puede comparar modelos multimodales que procesan entradas de vídeo mediante la generación de vídeos sintéticos como parte de la configuración de la carga de trabajo. El servicio de evaluación comparativa utiliza la generación de vídeo sintético de AIPerf para crear vídeos con una resolución, velocidad de fotogramas, duración y codificación configurables, y luego los envía como cargas útiles codificadas en base64 a su terminal.

El siguiente ejemplo crea una configuración de carga de trabajo para realizar una evaluación comparativa de un modelo multimodal con vídeo sintético con una resolución de 640 x 480:

import json

workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "video_width": 640,
        "video_height": 480,
        "video_fps": 4,
        "video_duration": 5.0,
        "output_tokens_mean": 150,
        "concurrency": 4,
        "request_count": 50,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    },
    "secrets": {
        "hf_token": "arn:aws:secretsmanager:us-west-2:111122223333:secret:my-hf-token-AbCdEf"
    }
}

client.create_ai_workload_config(
    AIWorkloadConfigName="video-benchmark-config",
    WorkloadSpec={"Inline": json.dumps(workload_spec)}
)

Parámetros de vídeo

Los siguientes parámetros controlan la generación de vídeo sintético:

Pistas de audio integradas

Para los modelos que procesan vídeo y audio juntos, puede incrustar una pista de audio sintética en los vídeos generados. El audio está desactivado de forma predeterminada. video_audio_num_channelsAjústelo en 1 (mono) o 2 (estéreo) para activarlo.

Ejemplos de análisis comparativos de vídeo

Low-resolution comprensión del vídeo

workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "video_width": 320,
        "video_height": 240,
        "video_fps": 2,
        "video_duration": 3.0,
        "video_synth_type": "moving_shapes",
        "concurrency": 4,
        "request_count": 50,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    }
}

Análisis comparativo de vídeo HD

workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "video_width": 1920,
        "video_height": 1080,
        "video_fps": 8,
        "video_duration": 10.0,
        "concurrency": 2,
        "request_count": 20,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    }
}

Vídeo con audio para modelos multimodales

workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "video_width": 640,
        "video_height": 480,
        "video_fps": 4,
        "video_duration": 5.0,
        "video_audio_num_channels": 1,
        "video_audio_sample_rate": 16000,
        "concurrency": 4,
        "request_count": 50,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    }
}

Texto y vídeo mixtos

Combine el vídeo con instrucciones de texto para cargas de trabajo de vídeo con preguntas, respuestas o subtítulos:

workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "video_width": 640,
        "video_height": 480,
        "video_fps": 4,
        "video_duration": 5.0,
        "prompt_input_tokens_mean": 100,
        "output_tokens_mean": 50,
        "concurrency": 8,
        "request_count": 100,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    }
}

Consideraciones sobre el rendimiento

Paso 2: Supervise el estado del trabajo

Sondea el estado del trabajo hasta que alcance un estado terminal.

Python (boto3)

import time

while True:
    response = client.describe_ai_benchmark_job(
        AIBenchmarkJobName="my-benchmark-job"
    )
    status = response["AIBenchmarkJobStatus"]
    print(f"Status: {status}")
    if status in ("Completed", "Failed", "Stopped"):
        break
    time.sleep(30)

if status == "Completed":
    print(f"Results at: {response['OutputConfig']['S3OutputLocation']}")
elif status == "Failed":
    print(f"Job failed: {response.get('FailureReason', 'unknown')}")
        

AWS CLI

aws sagemaker describe-ai-benchmark-job \
  --ai-benchmark-job-name "my-benchmark-job" \
  --region us-west-2
        

Paso 3: Revise los resultados del punto de referencia

Los resultados de las pruebas comparativas se escriben en la ubicación de salida de Amazon S3 que especificó. Los resultados incluyen las siguientes métricas clave:

Cada métrica incluye resúmenes estadísticos: promedio, mínimo, máximo, P50, P90, P99 y desviación estándar.

Compare puntos finales con formato personalizado

Si tu terminal usa un formato de solicitud o respuesta personalizado (por ejemplo, controladores personalizados de DJL, formato TensorRT-LLM nativo u otros marcos de servicio que no admiten la API de finalización de chats de OpenAI), puedes compararlo con una plantilla Jinja2 para definir la forma de la carga útil de tu punto final.

El servicio de evaluación comparativa procesa la plantilla por solicitud con indicaciones sintéticas o personalizadas y, a continuación, reenvía la carga útil al punto final de IA. SageMaker También especificas una consulta de JMESPath para extraer el texto generado a partir de la respuesta de tu terminal.

Cree la plantilla de carga útil

Defina el formato de solicitud de su punto final como un archivo de plantilla de Jinja2. Las siguientes variables están disponibles en la plantilla:

Utilice el |tojson filtro para obtener el escape correcto de los valores de cadena en JSON. En el siguiente ejemplo, se muestra una plantilla para un terminal de DJL con un formato de llamada a herramientas:

{
  "messages": [{"role": "user", "content": {{ text|tojson }}}],
  "tools": [
    {"function": {"name": "Chit_Chat", "description": "casual conversation",
      "parameters": {"type": "object", "properties": {}}}}
  ],
  "max_tokens": {{ max_tokens }}
}

Cargue el archivo de plantilla en Amazon S3 (por ejemplo,s3://DOC-EXAMPLE-BUCKET/templates/my_endpoint_template.jinja).

Cree la configuración de la carga de trabajo

Cree una configuración de carga de trabajo que haga referencia al archivo de plantilla. Utilice el extra_inputs parámetro para especificar la ruta de la plantilla y la consulta de extracción de respuestas. Entregue el archivo de plantilla al contenedor de referencia a través de un DatasetConfig canal.

import json

TEMPLATE_LOCAL_PATH = "/opt/ml/input/data/template/my_endpoint_template.jinja"
RESPONSE_FIELD = "generation_details.generations[0].content"

workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "extra_inputs": f"payload_template:{TEMPLATE_LOCAL_PATH} response_field:{RESPONSE_FIELD}",
        "tokenizer": "meta-llama/Llama-3.2-1B",
        # ... other benchmark parameters (concurrency, request_count, etc.)
    },
}

response = client.create_ai_workload_config(
    AIWorkloadConfigName="custom-format-config",
    AIWorkloadConfigs={"WorkloadSpec": {"Inline": json.dumps(workload_spec)}},
    DatasetConfig={
        "InputDataConfig": [
            {
                "ChannelName": "template",
                "DataSource": {
                    "S3DataSource": {
                        "S3Uri": "s3://DOC-EXAMPLE-BUCKET/templates/my_endpoint_template.jinja",
                    }
                },
            }
        ]
    },
)

ChannelNameDetermina dónde aparece el archivo dentro del contenedor de referencia. Un canal llamado template hace que el archivo esté disponible en/opt/ml/input/data/template/<filename>.

El response_field valor es una consulta de JMEspath que extrae el texto generado de la respuesta del punto final. Los patrones comunes incluyen lo siguiente:

Si lo omiteresponse_field, la herramienta de evaluación comparativa detecta automáticamente el formato de respuesta.

Ejecute el punto de referencia

Cree un trabajo de referencia orientado a su punto final. El servicio detecta automáticamente el modo plantilla a partir de la payload_template clave extra_inputs y enruta las solicitudes a través de la ruta proxy adecuada.

response = client.create_ai_benchmark_job(
    AIBenchmarkJobName="custom-format-benchmark",
    BenchmarkTarget={"Endpoint": {"Identifier": "my-custom-endpoint"}},
    OutputConfig={"S3OutputLocation": "s3://DOC-EXAMPLE-BUCKET/results/"},
    AIWorkloadConfigIdentifier="custom-format-config",
    RoleArn="arn:aws:iam::111122223333:role/ExampleRole",
)

Consideraciones

Correlaciona las indicaciones y respuestas de los puntos de referencia

Una vez finalizado un trabajo de referencia, los artefactos de salida incluyen datos de entrada y salida por solicitud que se pueden unir para su posterior procesamiento. Esto permite casos de uso como la evaluación de la calidad, la auditoría de seguridad, la comparación de respuestas entre configuraciones y la depuración de comportamientos inesperados del modelo.

Compare los artefactos de salida

El output.tar.gz archivo de la ubicación de salida de Amazon S3 contiene los siguientes archivos relevantes para la correlación entre solicitudes y respuestas:

Une las entradas con las salidas

Correlaciona las solicitudes con sus respuestas utilizando el conversation_id campo en outputs.json y el session_id campo en: inputs.json

import json

# Load the artifacts extracted from output.tar.gz in your S3 output location
with open("inputs.json") as f:
    inputs = json.load(f)
with open("outputs.json") as f:
    outputs = json.load(f)

# Build lookup tables and join
inputs_by_id = {rec["session_id"]: rec for rec in inputs["data"]}
outputs_by_id = {rec["conversation_id"]: rec for rec in outputs["data"]}

matched_ids = set(inputs_by_id.keys()) & set(outputs_by_id.keys())
print(f"Matched: {len(matched_ids)} prompt-response pairs")

# Display a correlated sample
for sid in sorted(matched_ids)[:3]:
    in_rec = inputs_by_id[sid]
    out_rec = outputs_by_id[sid]
    prompt = in_rec["payloads"][0]["messages"][0]["content"][:100]
    response = out_rec.get("response_text", "")[:100]
    latency = out_rec["metrics"]["request_latency"]
    print(f"\n[{sid}] Latency: {latency:.0f}ms")
    print(f"  Prompt:   {prompt}...")
    print(f"  Response: {response}...")

Notas importantes

Gestione los recursos de referencia

Utilice las siguientes operaciones para gestionar sus trabajos de referencia y las configuraciones de carga de trabajo.

# List benchmark jobs
response = client.list_ai_benchmark_jobs(MaxResults=10)
for job in response["AIBenchmarkJobs"]:
    print(f"{job['AIBenchmarkJobName']} - {job['AIBenchmarkJobStatus']}")

# Stop a running job
client.stop_ai_benchmark_job(
    AIBenchmarkJobName="my-benchmark-job"
)

# Delete a job (must be in a terminal state)
client.delete_ai_benchmark_job(
    AIBenchmarkJobName="my-benchmark-job"
)

# List workload configurations
response = client.list_ai_workload_configs(MaxResults=10)
for config in response["AIWorkloadConfigs"]:
    print(f"{config['AIWorkloadConfigName']} - {config['AIWorkloadConfigArn']}")

# Delete a workload configuration
client.delete_ai_workload_config(
    AIWorkloadConfigName="my-benchmark-config"
)