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:
+ Un terminal de SageMaker IA en `InService` estado que aloja un LLM compatible con la API de finalización de OpenAI-compatible chats
+ Un bucket de Amazon S3 para una producción de referencia
+ Una función de ejecución de IAM que otorga a la SageMaker IA acceso a su punto final y al depósito de salida
## 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](generative-ai-inference-recommendations-mlflow.md).
## 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
```
**nota**
Si el punto final está configurado para los componentes de inferencia, pero no se especifica `InferenceComponents` en el objetivo de referencia, el trabajo no se realizará correctamente y aparecerá un error que indica que no se ha implementado ningún modelo directamente en el punto final. Incluya siempre el `InferenceComponents` parámetro cuando realice una evaluación comparativa de los puntos finales basados en componentes de inferencia.
## 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 es`round_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:
+ `round_robin`(predeterminado): cada adaptador recibe las solicitudes en orden. La enésima solicitud se envía al adaptador (sin número de modelos).
+ `random`— cada solicitud se asigna a un adaptador de manera uniforme y aleatoria.
Si no lo especifica`model_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:
| Parámetro | Tipo | Predeterminado | Description (Descripción) |
| --- | --- | --- | --- |
| image\_width\_mean | float | Ninguno | Ancho medio de la imagen en píxeles. |
| image\_width\_stddev | float | Ninguno | Desviación estándar del ancho de la imagen. Se configura para variar las dimensiones de la imagen en función de las solicitudes. |
| image\_height\_mean | float | Ninguno | Altura media de la imagen en píxeles. |
| image\_height\_stddev | float | Ninguno | Desviación estándar de la altura de la imagen. |
| image\_batch\_size | int | 1 | Número de imágenes por solicitud. |
| image\_format | cadena | png | Formato de imagen. Valores válidos: png (sin pérdidas), jpeg (archivos más pequeños y con pérdidas), random (selecciona al azar PNG o JPEG por imagen). |
**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.
**nota**
La generación de vídeo está desactivada de forma predeterminada. Debe especificar ambas opciones `video_height` en `video_width` la configuración de la carga de trabajo para habilitarla.
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:
| Parámetro | Tipo | Predeterminado | Description (Descripción) |
| --- | --- | --- | --- |
| video\_width | int | Ninguno | Ancho del fotograma en píxeles. Debe configurarse con video\_height para permitir la generación de vídeo. |
| video\_height | int | Ninguno | Altura del fotograma en píxeles. Debe configurarse con video\_width para permitir la generación de vídeo. |
| video\_fps | int | 4 | Fotogramas por segundo. |
| video\_duration | float | 5.0 | Duración del clip en segundos. |
| video\_batch\_size | int | 1 | Número de vídeos por solicitud. |
| video\_synth\_type | cadena | moving\_shapes | Patrón de síntesis. Valores válidos: moving\_shapes (formas geométricas animadas), grid\_clock (cuadrícula con animación de reloj), noise (ruido de píxeles aleatorio). |
| video\_format | cadena | webm | Formato contenedor. Valor válido: webm. |
| video\_codec | cadena | libvpx-vp9 | Códec de vídeo. Valor admitido: libvpx-vp9 (VP9, WebM). |
**nota**
El servicio de evaluación comparativa solo admite la codificación VP9 con formato WebM.
### 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_channels`Ajústelo en `1` (mono) o `2` (estéreo) para activarlo.
| Parámetro | Tipo | Predeterminado | Description (Descripción) |
| --- | --- | --- | --- |
| video\_audio\_num\_channels | int | 0 | 0 = desactivado, 1 = mono, 2 = estéreo. |
| video\_audio\_sample\_rate | int | 44100 | Frecuencia de muestreo en Hz (8000—96000). |
| video\_audio\_codec | cadena | auto | Códec de audio. Auto-selects libvorbispara WebM y MP4aac. Puede anular conaac,libvorbis, o. libopus |
| video\_audio\_depth | int | 16 | Profundidad de bits por muestra (8, 16, 24 o 32). |
### 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
+ Una resolución y una velocidad de fotogramas más altas aumentan el tiempo de codificación del vídeo y el tamaño de la carga útil. Para realizar pruebas de alto rendimiento, utilice resoluciones más bajas (320 × 240 o 640 × 480).
+ El VP9 (`libvpx-vp9`) con formato WebM es el único códec compatible y proporciona una buena compresión para la evaluación comparativa de las cargas útiles.
+ El audio añade una sobrecarga mínima en comparación con la transmisión de vídeo. Utilice mono (`1`) a 16 kHz para cargas de trabajo centradas en la voz.
## 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:
`request_throughput`
Solicitudes por segundo.
`request_latency`
End-to-end latencia de solicitudes con desgloses de percentiles (P50, P90, P99).
`time_to_first_token`
Tiempo transcurrido desde el envío de la solicitud hasta el primer token recibido.
`inter_token_latency`
Tiempo transcurrido entre los tokens de salida consecutivos.
`output_token_throughput`
Tokens de salida generados por segundo.
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:
| Variable | Description (Descripción) |
| --- | --- |
| text | Primer contenido de texto (sintético o de un conjunto de datos). |
| texts | Lista de todo el contenido del texto. |
| model | Nombre del modelo. |
| max\_tokens | Límite de token de salida. |
| stream | Si la transmisión está habilitada. |
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",
}
},
}
]
},
)
```
`ChannelName`Determina 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/`.
El `response_field` valor es una consulta de [JMEspath](https://jmespath.org/) que extrae el texto generado de la respuesta del punto final. Los patrones comunes incluyen lo siguiente:
+ `choices[0].message.content`— Formato OpenAI
+ `generation_details.generations[0].content`— Formato DJL
+ `output.text`— respuesta de texto simple
Si lo omite`response_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
+ Las plantillas se deben entregar como archivos a través de Amazon S3. No se admiten las plantillas JSON integradas en la `extra_inputs` cadena porque las comas de JSON entran en conflicto con el analizador de parámetros.
+ Se admiten puntos finales con un único componente de inferencia. Los puntos finales con varios componentes de inferencia no se admiten en el modo de plantilla porque el servicio no puede determinar a qué componente enrutar cada solicitud desde un formato de carga útil arbitrario.
+ Se admiten puntos de conexión tanto de transmisión como de no transmisión. Establezca `"streaming": true` o incluya los parámetros `"streaming": false` de la carga de trabajo.
## 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:
`inputs.json`
El conjunto de datos sintético completo de las conversaciones generadas. Cada registro tiene una `session_id` carga útil de solicitud completa (mensajes, max\_tokens, modelo).
`outputs.json`
Per-request metadatos de respuesta para las solicitudes que se enviaron al punto final. Cada registro incluye el texto de respuesta del modelo, la latencia por solicitud, el recuento de tokens de salida y un registro `conversation_id` que se corresponde con la entrada.
### 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
+ **Clave de unión.** `conversation_id``outputs.json`Utilízala para igualar contra `session_id` ella`inputs.json`. No lo utilice `session_num` como índice posicional: representa el orden de ejecución, que difiere del orden de creación de la entrada cuando la simultaneidad es superior a 1.
+ **No todas las entradas tienen salidas.** El `inputs.json` archivo contiene el conjunto completo de conjuntos de datos generados. Cuando `request_count` es inferior al tamaño del grupo, solo se envía un subconjunto de conversaciones al punto final. Las entradas no coincidentes son conversaciones que se generaron pero no se utilizaron.
+ **Esquema de salida.** Cada registro `outputs.json` incluye `conversation_id``response_text`, `metrics` (con `request_latency` y`output_sequence_length`) y campos de temporización (`request_start_ns`,`request_end_ns`).
## 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"
)
```