Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Points de terminaison d'inférence génératifs basés sur l'IA
Le service d'analyse comparative de l' SageMaker IA mesure les performances des grands modèles linguistiques (LLM) hébergés sur des terminaux d' SageMaker IA. Il exécute des tests à l'aide de NVIDIA AiPerf, produisant des métriques telles que la latence des demandes, le débit, le délai jusqu'au premier jeton et la latence entre les jetons.
## Conditions préalables
Avant de créer une tâche de référence, vous devez disposer des éléments suivants :
+ Un point de terminaison d' SageMaker IA en `InService` statut hébergeant un LLM qui prend en charge l'API de fin de OpenAI-compatible chat
+ Un compartiment Amazon S3 pour les résultats de référence
+ Un rôle d'exécution IAM qui accorde à l' SageMaker IA un accès à votre point de terminaison et à votre bucket de sortie
## Étape 1 : Création d'une tâche de référence
Une tâche de référence cible un point de terminaison d' SageMaker IA spécifique et fait référence à une configuration de charge de travail.
**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 INTERFACE DE LIGNE DE COMMANDE (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 votre point de terminaison héberge plusieurs modèles via des composants d'inférence, vous pouvez les spécifier dans le `InferenceComponents` paramètre du`BenchmarkTarget`.
Si votre point de terminaison se trouve dans un VPC, transmettez le `NetworkConfig` paramètre avec vos `VpcConfig` paramètres, y compris les ID de groupes de sécurité et les sous-réseaux.
Pour suivre les résultats du benchmark avec MLflow entièrement géré sur SageMaker AI, ajoutez un `MlflowConfig` objet à`OutputConfig`. Pour de plus amples informations, veuillez consulter [Suivez les recommandations d'inférence et les résultats de référence avec MLflow](generative-ai-inference-recommendations-mlflow.md).
## Composants d'inférence de référence
Si votre point de terminaison utilise des *composants d'inférence* au lieu de déployer directement un modèle, vous devez spécifier les composants d'inférence à comparer dans le. `BenchmarkTarget` Lorsque des composants d'inférence sont spécifiés, le service d'analyse comparative achemine les demandes vers ces composants spécifiques plutôt que vers le modèle par défaut du point de terminaison.
Transmettez un ou plusieurs noms de composants d'inférence ou ARN dans la `InferenceComponents` liste :
**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 INTERFACE DE LIGNE DE COMMANDE (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
```
**Note**
Si votre point de terminaison est configuré pour les composants d'inférence mais que vous ne le spécifiez pas `InferenceComponents` dans la cible de référence, la tâche échoue avec une erreur indiquant qu'aucun modèle n'est déployé directement sur le point de terminaison. Incluez toujours le `InferenceComponents` paramètre lors de l'analyse comparative des points de terminaison basés sur des composants d'inférence.
## Points de terminaison multi-LoRA de référence
Pour comparer un point de terminaison qui dessert plusieurs adaptateurs LoRa, spécifiez chaque adaptateur en tant que composant d'inférence dans le. `BenchmarkTarget` Vous pouvez éventuellement utiliser le paramètre de `model_selection_strategy` charge de travail pour contrôler la manière dont le benchmark répartit les demandes entre les adaptateurs. Si vous ne spécifiez aucune stratégie, la valeur par défaut est`round_robin`.
Créez d'abord une configuration de charge de travail. L'exemple suivant inclut le `model_selection_strategy` paramètre facultatif :
```
# 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)}
)
```
Créez ensuite une tâche de référence qui cible tous les composants d'inférence de l'adaptateur 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",
)
```
Le `model_selection_strategy` paramètre est facultatif et détermine la manière dont l'outil de référence distribue les demandes entre les composants d'inférence spécifiés. Les valeurs valides sont :
+ `round_robin`(par défaut) : chaque adaptateur reçoit les demandes dans l'ordre. La nième demande est envoyée au 5e adaptateur (en mode, nombre de modèles).
+ `random`— chaque demande est assignée à un adaptateur de manière uniforme et aléatoire.
Si vous ne le spécifiez pas`model_selection_strategy`, le benchmark utilise `round_robin` par défaut.
## Comparez les points de terminaison multimodaux avec des images synthétiques
Vous pouvez comparer les modèles de langage visuel en générant des images synthétiques dans le cadre de la configuration de la charge de travail. Le service d'analyse comparative utilise AiPerf pour créer des images aux dimensions et au format configurables, puis les envoie sous forme de charges utiles codées en base64 à votre terminal.
L'exemple suivant crée une configuration de charge de travail pour l'analyse comparative d'un modèle de langage de vision avec des images synthétiques :
```
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)}
)
```
Les paramètres suivants contrôlent la génération d'images synthétiques :
| Paramètre | Type | Par défaut | Description |
| --- | --- | --- | --- |
| image\_width\_mean | float | Aucune | Largeur moyenne de l'image en pixels. |
| image\_width\_stddev | float | Aucune | Écart type de la largeur de l'image. Paramétrez pour faire varier les dimensions de l'image en fonction des demandes. |
| image\_height\_mean | float | Aucune | Hauteur moyenne de l'image en pixels. |
| image\_height\_stddev | float | Aucune | Écart type de la hauteur de l'image. |
| image\_batch\_size | int | 1 | Nombre d'images par demande. |
| image\_format | chaîne | png | Format d'image. Valeurs valides : png (sans perte), jpeg (fichiers plus petits avec perte), random (sélectionne au hasard un PNG ou un JPEG par image). |
**Variable-size images**
Utilisez les paramètres d'écart type pour générer des images de différentes dimensions, en simulant des charges de travail réelles où les tailles d'image diffèrent :
```
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"
}
}
```
## Comparez les points de terminaison multimodaux avec une vidéo synthétique
Vous pouvez comparer les modèles multimodaux qui traitent les entrées vidéo en générant des vidéos synthétiques dans le cadre de la configuration de la charge de travail. Le service d'analyse comparative utilise la génération de vidéos synthétiques d'AiPerf pour créer des vidéos avec une résolution, une fréquence d'images, une durée et un encodage configurables, puis les envoie sous forme de charges utiles codées en base64 à votre terminal.
**Note**
La génération de vidéos est désactivée par défaut. Vous devez spécifier les deux `video_width` et `video_height` dans la configuration de votre charge de travail pour l'activer.
L'exemple suivant crée une configuration de charge de travail pour l'analyse comparative d'un modèle multimodal avec une vidéo synthétique à une résolution de 640 × 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)}
)
```
### Paramètres vidéo
Les paramètres suivants contrôlent la génération de vidéos synthétiques :
| Paramètre | Type | Par défaut | Description |
| --- | --- | --- | --- |
| video\_width | int | Aucune | Largeur du cadre en pixels. Doit être défini avec video\_height pour activer la génération vidéo. |
| video\_height | int | Aucune | Hauteur du cadre en pixels. Doit être défini avec video\_width pour activer la génération vidéo. |
| video\_fps | int | 4 | Images par seconde. |
| video\_duration | float | 5.0 | Durée du clip en secondes. |
| video\_batch\_size | int | 1 | Nombre de vidéos par demande. |
| video\_synth\_type | chaîne | formes\_mobiles | Schéma de synthèse. Valeurs valides : moving\_shapes (formes géométriques animées), grid\_clock (grille avec animation d'horloge), noise (bruit de pixels aléatoire). |
| video\_format | chaîne | webm | Format du conteneur. Valeur valide : webm. |
| video\_codec | chaîne | libvpx-vp9 | Codec vidéo Valeur prise en charge : libvpx-vp9 (VP9, WebM). |
**Note**
Le service d'analyse comparative prend en charge le codage VP9 au format WebM uniquement.
### Pistes audio intégrées
Pour les modèles qui traitent simultanément la vidéo et le son, vous pouvez intégrer une piste audio synthétique dans les vidéos générées. Le son est désactivé par défaut. Réglez `video_audio_num_channels` sur `1` (mono) ou `2` (stéréo) pour l'activer.
| Paramètre | Type | Par défaut | Description |
| --- | --- | --- | --- |
| video\_audio\_num\_channels | int | 0 | 0 = désactivé, 1 = mono, 2 = stéréo. |
| video\_audio\_sample\_rate | int | 44100 | Fréquence d'échantillonnage en Hz (8000—96000). |
| video\_audio\_codec | chaîne | auto | Codec audio. Auto-selects libvorbispour WebM et aac pour MP4. Vous pouvez remplacer par aaclibvorbis, oulibopus. |
| video\_audio\_depth | int | 16 | Profondeur de bits par échantillon (8, 16, 24 ou 32). |
### Exemples de benchmarking vidéo
**Low-resolution compréhension vidéo**
```
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"
}
}
```
**Analyse comparative des vidéos 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"
}
}
```
**Vidéo avec audio pour les modèles multimodaux**
```
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"
}
}
```
**Texte et vidéo mixtes**
Combinez des vidéos avec des instructions textuelles pour répondre à des questions ou sous-titrer des vidéos :
```
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"
}
}
```
### Considérations sur les performances
+ Une résolution et une fréquence d'images plus élevées augmentent le temps d'encodage vidéo et la taille de la charge utile. Pour les tests à haut débit, utilisez des résolutions inférieures (320 × 240 ou 640 × 480).
+ Le VP9 (`libvpx-vp9`) au format WebM est le seul codec pris en charge et fournit une bonne compression pour l'analyse comparative des charges utiles.
+ L'audio ajoute un surcoût minimal par rapport au flux vidéo. Utilisez mono (`1`) à 16 kHz pour les charges de travail axées sur la parole.
## Étape 2 : Surveiller l'état du travail
Interrogez le statut de la tâche jusqu'à ce qu'elle atteigne un état 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 INTERFACE DE LIGNE DE COMMANDE (CLI)**
```
aws sagemaker describe-ai-benchmark-job \
--ai-benchmark-job-name "my-benchmark-job" \
--region us-west-2
```
## Étape 3 : Examiner les résultats de référence
Les résultats du benchmark sont écrits sur l'emplacement de sortie Amazon S3 que vous avez spécifié. Les résultats incluent les indicateurs clés suivants :
`request_throughput`
Demandes par seconde.
`request_latency`
End-to-end latence des demandes avec répartition par centiles (P50, P90, P99).
`time_to_first_token`
Temps écoulé entre la soumission de la demande et la réception du premier jeton.
`inter_token_latency`
Durée entre deux jetons de sortie consécutifs.
`output_token_throughput`
Jetons de sortie générés par seconde.
Chaque métrique inclut des résumés statistiques : moyenne, minimale, maximale, P50, P90, P99 et écart type.
## Analysez les points de terminaison au format personnalisé
Si votre terminal utilise un format de demande ou de réponse personnalisé (par exemple, des gestionnaires personnalisés DJL, un format TensorRT-LLM natif ou d'autres frameworks de service qui ne prennent pas en charge l'API de complétion de chat OpenAI), vous pouvez le comparer à l'aide d'un modèle Jinja2 pour définir la forme de la charge utile de votre point de terminaison.
Le service d'analyse comparative affiche le modèle par demande avec des instructions synthétiques ou personnalisées, puis transmet la charge utile à votre point de terminaison d'IA. SageMaker Vous spécifiez également une requête JMESpath pour extraire le texte généré de la réponse de votre point de terminaison.
### Création du modèle de charge utile
Définissez le format de demande de votre point de terminaison sous la forme d'un fichier modèle Jinja2. Les variables suivantes sont disponibles dans le modèle :
| Variable | Description |
| --- | --- |
| text | Premier contenu textuel (synthétique ou issu d'un ensemble de données). |
| texts | Liste de tous les contenus du texte. |
| model | Nom du modèle |
| max\_tokens | Limite de jetons de sortie. |
| stream | Si le streaming est activé. |
Utilisez le `|tojson` filtre pour échapper correctement aux valeurs de chaîne au format JSON. L'exemple suivant montre un modèle pour un point de terminaison DJL au format d'appel d'outils :
```
{
"messages": [{"role": "user", "content": {{ text|tojson }}}],
"tools": [
{"function": {"name": "Chit_Chat", "description": "casual conversation",
"parameters": {"type": "object", "properties": {}}}}
],
"max_tokens": {{ max_tokens }}
}
```
Téléchargez le fichier modèle sur Amazon S3 (par exemple,`s3://DOC-EXAMPLE-BUCKET/templates/my_endpoint_template.jinja`).
### Création de la configuration de charge de travail
Créez une configuration de charge de travail qui fait référence au fichier modèle. Utilisez le `extra_inputs` paramètre pour spécifier le chemin du modèle et la requête d'extraction des réponses. Envoyez le fichier modèle au conteneur de référence via 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`Détermine l'endroit où le fichier apparaît dans le conteneur de référence. Un canal nommé `template` rend le fichier disponible à l'adresse`/opt/ml/input/data/template/`.
La `response_field` valeur est une requête [JMESpath](https://jmespath.org/) qui extrait le texte généré de la réponse de votre point de terminaison. Les modèles courants incluent :
+ `choices[0].message.content`— Format OpenAI
+ `generation_details.generations[0].content`— Format DJL
+ `output.text`— réponse textuelle simple
Si vous omettez`response_field`, l'outil d'analyse comparative détecte automatiquement le format de réponse.
### Exécutez le benchmark
Créez une offre d'emploi de référence ciblant votre point de terminaison. Le service détecte automatiquement le mode modèle à partir de `payload_template` la saisie `extra_inputs` et achemine les demandes via le chemin de proxy approprié.
```
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",
)
```
### Considérations
+ Les modèles doivent être fournis sous forme de fichiers via Amazon S3. Les modèles JSON intégrés dans la `extra_inputs` chaîne ne sont pas pris en charge car les virgules du JSON entrent en conflit avec l'analyseur de paramètres.
+ Les points de terminaison dotés d'un seul composant d'inférence sont pris en charge. Les points de terminaison dotés de plusieurs composants d'inférence ne sont pas pris en charge en mode modèle car le service ne peut pas déterminer à quel composant acheminer chaque demande à partir d'un format de charge utile arbitraire.
+ Les terminaux de streaming et non de streaming sont pris en charge. Définissez `"streaming": true` ou `"streaming": false` dans les paramètres de charge de travail.
## Corréler les demandes et les réponses aux critères de référence
Une fois qu'une tâche de référence est terminée, les artefacts de sortie incluent des données d'entrée et de sortie par demande que vous pouvez associer pour le post-traitement. Cela permet des cas d'utilisation tels que l'évaluation de la qualité, l'audit de sécurité, la comparaison des réponses entre les configurations et le débogage de comportements inattendus du modèle.
### Objets de sortie de référence
L'`output.tar.gz`archive de votre emplacement de sortie Amazon S3 contient les fichiers suivants relatifs à la corrélation entre invite et réponse :
`inputs.json`
L'ensemble de données synthétique complet des conversations générées. Chaque enregistrement possède une `session_id` charge utile complète de la demande (messages, max\_tokens, modèle).
`outputs.json`
Per-request métadonnées de réponse pour les demandes envoyées au point de terminaison. Chaque enregistrement inclut le texte de réponse du modèle, le temps de latence par demande, le nombre de jetons de sortie et un `conversation_id` identifiant qui correspond à l'entrée.
### Joindre les entrées aux sorties
Corrélez les demandes avec leurs réponses en utilisant le `conversation_id` champ dans `outputs.json` et le `session_id` champ dans : `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}...")
```
### Remarques importantes
+ **Clé de connexion.** Utilisez `conversation_id` in `outputs.json` pour affronter `session_id` in`inputs.json`. Ne l'utilisez pas `session_num` comme indice positionnel : il représente l'ordre d'exécution, qui diffère de l'ordre de création des entrées lorsque la simultanéité est supérieure à 1.
+ **Toutes les entrées n'ont pas de sorties.** Le `inputs.json` fichier contient le pool de jeux de données généré dans son intégralité. Lorsqu'il `request_count` est inférieur à la taille du pool, seul un sous-ensemble de conversations est envoyé au point de terminaison. Les entrées non concordantes sont des conversations qui ont été générées mais qui n'ont pas été utilisées.
+ **Schéma de sortie.** Chaque enregistrement `outputs.json` inclut des champs`conversation_id`,`response_text`, `metrics` (avec `request_latency` et`output_sequence_length`) et de chronométrage (`request_start_ns`,`request_end_ns`).
## Gérez les ressources de référence
Utilisez les opérations suivantes pour gérer vos tâches de référence et vos configurations de charge de travail.
```
# 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"
)
```