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.
## 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 4e 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.
## 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"
)
```