Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Endpoint di inferenza AI generativa di benchmark
Il servizio di benchmarking SageMaker basato sull'intelligenza artificiale misura le prestazioni dei modelli linguistici di grandi dimensioni (LLM) ospitati su endpoint di intelligenza artificiale. SageMaker Esegue benchmark utilizzando NVIDIA AiPerf, producendo metriche come latenza delle richieste, throughput, time to first token e latenza tra token.
## Prerequisiti
Prima di creare un job di benchmark, è necessario quanto segue:
+ Un endpoint SageMaker AI in `InService` status che ospita un LLM che supporta l'API di completamento della chat OpenAI-compatible
+ Un bucket Amazon S3 per risultati di benchmark
+ Un ruolo di esecuzione IAM che garantisce all' SageMaker IA l'accesso all'endpoint e al bucket di output
## Fase 1: Creare un lavoro di riferimento
Un lavoro di benchmark si rivolge a un endpoint di SageMaker intelligenza artificiale specifico e fa riferimento a una configurazione del carico di lavoro.
**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
```
Se il tuo endpoint ospita più modelli tramite componenti di inferenza, puoi specificarli nel parametro di. `InferenceComponents` `BenchmarkTarget`
Se il tuo endpoint si trova in un VPC, passa `NetworkConfig` il parametro con le `VpcConfig` tue impostazioni, inclusi gli ID dei gruppi di sicurezza e le sottoreti.
## Componenti di inferenza di benchmark
Se l'endpoint utilizza *componenti di inferenza* anziché distribuire direttamente un modello, è necessario specificare i componenti di inferenza da confrontare in. `BenchmarkTarget` Quando vengono specificati i componenti di inferenza, il servizio di benchmarking indirizza le richieste a tali componenti specifici anziché al modello predefinito dell'endpoint.
Passa uno o più nomi di componenti di inferenza o ARN nell'elenco: `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**
Se l'endpoint è configurato per i componenti di inferenza ma non lo specifichi `InferenceComponents` nel benchmark target, il processo ha esito negativo e viene visualizzato un errore che indica che nessun modello è distribuito direttamente sull'endpoint. Includi sempre il `InferenceComponents` parametro quando esegui il benchmarking degli endpoint basati su componenti di inferenza.
## Esegui il benchmark degli endpoint multi-LORA
Per eseguire il benchmark di un endpoint che serve più adattatori LoRa, specifica ogni adattatore come componente di inferenza in. `BenchmarkTarget` Facoltativamente, puoi utilizzare il parametro `model_selection_strategy` workload per controllare il modo in cui il benchmark distribuisce le richieste tra gli adattatori. Se non specifichi una strategia, l'impostazione predefinita è. `round_robin`
Innanzitutto, crea una configurazione del carico di lavoro. L'esempio seguente include il `model_selection_strategy` parametro opzionale:
```
# 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)}
)
```
Quindi, crea un processo di benchmark destinato a tutti i componenti di inferenza dell'adattatore 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",
)
```
Il `model_selection_strategy` parametro è facoltativo e determina in che modo lo strumento di benchmark distribuisce le richieste tra i componenti di inferenza specificati. I valori validi sono:
+ `round_robin`(impostazione predefinita): ogni adattatore riceve le richieste in ordine. L'ennesima richiesta viene inviata all'adattatore (in modalità numero di modelli).
+ `random`— ogni richiesta viene assegnata a un adattatore in modo uniforme e casuale.
Se non lo specifichi`model_selection_strategy`, il benchmark utilizza come impostazione `round_robin` predefinita.
## Effettua il benchmark degli endpoint multimodali con immagini sintetiche
Puoi confrontare i modelli del linguaggio di visione generando immagini sintetiche come parte della configurazione del carico di lavoro. Il servizio di benchmarking utilizza AiPerf per creare immagini con dimensioni e formati configurabili, quindi le invia come payload con codifica base64 all'endpoint.
L'esempio seguente crea una configurazione del carico di lavoro per il benchmarking di un modello di linguaggio di visione con immagini sintetiche:
```
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)}
)
```
I seguenti parametri controllano la generazione di immagini sintetiche:
| Parametro | Tipo | Predefinita | Description |
| --- | --- | --- | --- |
| image\_width\_mean | virgola mobile | Nessuno | Larghezza media dell'immagine in pixel. |
| image\_width\_stddev | virgola mobile | Nessuno | Deviazione standard della larghezza dell'immagine. Impostato per variare le dimensioni dell'immagine tra le richieste. |
| image\_height\_mean | virgola mobile | Nessuno | Altezza media dell'immagine in pixel. |
| image\_height\_stddev | virgola mobile | Nessuno | Deviazione standard dell'altezza dell'immagine. |
| image\_batch\_size | int | 1 | Numero di immagini per richiesta. |
| image\_format | stringa | png | Formato di immagine Valori validi: png (senza perdita di dati), jpeg (file più piccoli e con perdita di dati), random (seleziona in modo casuale PNG o JPEG per immagine). |
**Variable-size images**
Utilizza i parametri di deviazione standard per generare immagini con dimensioni variabili, simulando carichi di lavoro reali in cui le dimensioni delle immagini differiscono:
```
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"
}
}
```
## Effettua il benchmark degli endpoint multimodali con video sintetici
È possibile effettuare benchmark di modelli multimodali che elaborano gli input video generando video sintetici come parte della configurazione del carico di lavoro. Il servizio di benchmarking utilizza la generazione di video sintetici di AiPerf per creare video con risoluzione, frame rate, durata e codifica configurabili, quindi li invia come payload con codifica base64 all'endpoint.
**Nota**
La generazione di video è disattivata per impostazione predefinita. È necessario specificarli entrambi `video_width` e attivarli `video_height` nella configurazione del carico di lavoro.
L'esempio seguente crea una configurazione del carico di lavoro per il benchmarking di un modello multimodale con video sintetico a risoluzione 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)}
)
```
### Parametri video
I seguenti parametri controllano la generazione di video sintetici:
| Parametro | Tipo | Predefinita | Description |
| --- | --- | --- | --- |
| video\_width | int | Nessuno | Larghezza del fotogramma in pixel. Deve essere impostato con video\_height per abilitare la generazione di video. |
| video\_height | int | Nessuno | Altezza della cornice in pixel. Deve essere impostato con video\_width per abilitare la generazione di video. |
| video\_fps | int | 4 | Fotogrammi al secondo. |
| video\_duration | virgola mobile | 5.0 | Durata della clip in secondi. |
| video\_batch\_size | int | 1 | Numero di video per richiesta. |
| video\_synth\_type | stringa | moving\_shapes | Schema di sintesi. Valori validi: moving\_shapes (forme geometriche animate), grid\_clock (griglia con animazione dell'orologio), noise (rumore casuale dei pixel). |
| video\_format | stringa | webm | Formato del contenitore. Valore valido: webm. |
| video\_codec | stringa | libvpx-vp9 | Codec video. Valore supportato: libvpx-vp9 (VP9, WebM). |
**Nota**
Il servizio di benchmarking supporta la codifica VP9 solo con il formato WebM.
### Tracce audio integrate
Per i modelli che elaborano video e audio insieme, potete incorporare una traccia audio sintetica nei video generati. L'audio è disabilitato per impostazione predefinita. `video_audio_num_channels`Impostare su `1` (mono) o `2` (stereo) per abilitarlo.
| Parametro | Tipo | Predefinita | Description |
| --- | --- | --- | --- |
| video\_audio\_num\_channels | int | 0 | 0 = disabilitato, 1 = mono, 2 = stereo. |
| video\_audio\_sample\_rate | int | 44100 | Frequenza di campionamento in Hz (8000—96000). |
| video\_audio\_codec | stringa | auto | Codec audio. Auto-selects libvorbisper WebM e aac per MP4. È possibile eseguire l'override conaac, olibvorbis. libopus |
| video\_audio\_depth | int | 16 | Profondità di bit per campione (8, 16, 24 o 32). |
### Esempi di benchmarking video
**Low-resolution comprensione dei video**
```
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"
}
}
```
**analisi comparativa di video 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"
}
}
```
**Video con audio per modelli multimodali**
```
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"
}
}
```
**Testo e video misti**
Combina video con istruzioni di testo per carichi di lavoro relativi alla risposta a domande video o all'inserimento di sottotitoli:
```
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"
}
}
```
### Considerazioni sulle prestazioni
+ Una risoluzione e un frame rate più elevati aumentano il tempo di codifica video e le dimensioni del payload. Per test ad alta produttività, utilizzate risoluzioni inferiori (320×240 o 640×480).
+ VP9 (`libvpx-vp9`) con formato WebM è l'unico codec supportato e offre una buona compressione per il benchmarking dei payload.
+ L'audio aggiunge un sovraccarico minimo rispetto allo streaming video. Usa mono (`1`) a 16 kHz per carichi di lavoro incentrati sulla voce.
## Fase 2: Monitora lo stato del lavoro
Esamina lo stato del lavoro fino a quando non raggiunge lo stato terminale.
**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
```
## Fase 3: Rivedi i risultati del benchmark
I risultati del benchmark vengono scritti nella posizione di output di Amazon S3 specificata. I risultati includono le seguenti metriche chiave:
`request_throughput`
Richieste al secondo.
`request_latency`
End-to-end latenza delle richieste con suddivisioni percentili (P50, P90, P99).
`time_to_first_token`
Tempo compreso tra l'invio della richiesta e il primo token ricevuto.
`inter_token_latency`
Tempo tra token di output consecutivi.
`output_token_throughput`
Token di output generati al secondo.
Ogni metrica include riepiloghi statistici: media, minima, massima, P50, P90, P99 e deviazione standard.
## Gestisci le risorse di benchmark
Utilizza le seguenti operazioni per gestire i job di benchmark e le configurazioni dei carichi di lavoro.
```
# 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"
)
```