Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Benchmark-Endpunkte generativer KI-Inferenz
Der SageMaker KI-Benchmarking-Service misst die Leistung von großen Sprachmodellen (LLMs), die auf KI-Endpunkten gehostet werden. SageMaker Er führt Benchmarks mithilfe von NVIDIA AIPerf durch und erstellt Metriken wie Anforderungslatenz, Durchsatz, Zeit bis zum ersten Token und Latenz zwischen Tokens.
## Voraussetzungen
Bevor Sie einen Benchmark-Job erstellen, benötigen Sie Folgendes:
+ Ein SageMaker KI-Endpunkt im `InService` Status, der ein LLM hostet, das die OpenAI-compatible Chat-Completion-API unterstützt
+ Ein Amazon S3 S3-Bucket für die Benchmark-Ausgabe
+ Eine IAM-Ausführungsrolle, die SageMaker KI Zugriff auf Ihren Endpunkt und Ihren Ausgabe-Bucket gewährt
## Schritt 1: Erstellen Sie einen Benchmark-Job
Ein Benchmark-Job zielt auf einen bestimmten SageMaker KI-Endpunkt ab und verweist auf eine Workload-Konfiguration.
**Python (Teil 3)**
```
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
```
Wenn Ihr Endpunkt mehrere Modelle mithilfe von Inferenzkomponenten hostet, können Sie diese im `InferenceComponents` Parameter von angeben. `BenchmarkTarget`
Wenn sich Ihr Endpunkt in einer VPC befindet, übergeben Sie den `NetworkConfig` Parameter mit Ihren `VpcConfig` Einstellungen, einschließlich Sicherheitsgruppen-IDs und Subnetzen.
## Benchmark-Inferenzkomponenten
Wenn Ihr Endpunkt *Inferenzkomponenten* verwendet, anstatt ein Modell direkt bereitzustellen, müssen Sie die zu vergleichenden Inferenzkomponenten in der angeben. `BenchmarkTarget` Wenn Inferenzkomponenten angegeben sind, leitet der Benchmarking-Service Anfragen an diese spezifischen Komponenten weiter und nicht an das Standardmodell des Endpunkts.
Übergeben Sie einen oder mehrere Namen oder ARNs der Inferenzkomponenten in der Liste: `InferenceComponents`
**Python (Teil 3)**
```
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
```
**Anmerkung**
Wenn Ihr Endpunkt für Inferenzkomponenten konfiguriert ist, Sie dies jedoch nicht `InferenceComponents` im Benchmark-Ziel angeben, schlägt der Job fehl und es wird ein Fehler angezeigt, der darauf hinweist, dass kein Modell direkt auf dem Endpunkt bereitgestellt wird. Beziehen Sie den `InferenceComponents` Parameter immer mit ein, wenn Sie Endpunkte vergleichen, die auf Inferenzkomponenten basieren.
## Vergleichen Sie mehrere LORA-Endpunkte
Um einen Endpunkt zu vergleichen, der mehrere LoRa-Adapter bedient, geben Sie jeden Adapter als Inferenzkomponente in der an. `BenchmarkTarget` Sie können optional den `model_selection_strategy` Workload-Parameter verwenden, um zu steuern, wie der Benchmark Anfragen auf die Adapter verteilt. Wenn Sie keine Strategie angeben, ist `round_robin` die Standardeinstellung.
Erstellen Sie zunächst eine Workload-Konfiguration. Das folgende Beispiel enthält den optionalen `model_selection_strategy` Parameter:
```
# 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)}
)
```
Erstellen Sie dann einen Benchmark-Job, der auf alle LoRa-Adapter-Inferenzkomponenten abzielt:
```
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",
)
```
Der `model_selection_strategy` Parameter ist optional und bestimmt, wie das Benchmark-Tool Anfragen auf die angegebenen Inferenzkomponenten verteilt. Folgende sind gültige Werte:
+ `round_robin`(Standard) — jeder Adapter empfängt Anfragen der Reihe nach. Die n-te Anfrage wird an den Adapter (im Modus Anzahl der Modelle) gesendet.
+ `random`— Jede Anfrage wird einem Adapter einheitlich nach dem Zufallsprinzip zugewiesen.
Wenn Sie nichts angeben`model_selection_strategy`, verwendet der Benchmark `round_robin` standardmäßig.
## Vergleichen Sie multimodale Endpunkte mit synthetischen Bildern
Sie können Modelle mit Bildverarbeitungssprache vergleichen, indem Sie im Rahmen der Workload-Konfiguration synthetische Bilder generieren. Der Benchmarking-Dienst verwendet AiPerf, um Bilder mit konfigurierbaren Abmessungen und Formaten zu erstellen, und sendet sie dann als Base64-kodierte Payloads an Ihren Endpunkt.
Im folgenden Beispiel wird eine Workload-Konfiguration für das Benchmarking eines Vision-Language-Modells mit synthetischen Bildern erstellt:
```
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)}
)
```
Die folgenden Parameter steuern die Erzeugung synthetischer Bilder:
| Parameter | Typ | Standard | Description |
| --- | --- | --- | --- |
| image\_width\_mean | float | Keine | Mittlere Bildbreite in Pixeln. |
| image\_width\_stddev | float | Keine | Standardabweichung der Bildbreite. Legt fest, dass die Bildabmessungen je nach Anfrage variieren. |
| image\_height\_mean | float | Keine | Durchschnittliche Bildhöhe in Pixeln. |
| image\_height\_stddev | float | Keine | Standardabweichung der Bildhöhe. |
| image\_batch\_size | int | 1 | Anzahl der Bilder pro Anfrage. |
| image\_format | Zeichenfolge | PNG | Image-Format. Gültige Werte: png (verlustfrei), jpeg (verlustbehaftete, kleinere Dateien), random (wählt zufällig PNG oder JPEG pro Bild aus). |
**Variable-size Bilder**
Verwenden Sie Parameter für Standardabweichungen, um Bilder mit unterschiedlichen Abmessungen zu erzeugen und reale Workloads zu simulieren, bei denen sich die Bildgrößen unterscheiden:
```
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"
}
}
```
## Vergleichen Sie multimodale Endpunkte mit synthetischem Video
Sie können multimodale Modelle vergleichen, die Videoeingaben verarbeiten, indem Sie im Rahmen der Workload-Konfiguration synthetische Videos generieren. Der Benchmarking-Dienst verwendet die synthetische Videogenerierung von AiPerf, um Videos mit konfigurierbarer Auflösung, Bildrate, Dauer und Kodierung zu erstellen und sendet sie dann als Base64-kodierte Payloads an Ihren Endpunkt.
**Anmerkung**
Die Videogenerierung ist standardmäßig deaktiviert. Sie müssen `video_width` sowohl als auch `video_height` in Ihrer Workload-Konfiguration angeben, um sie zu aktivieren.
Im folgenden Beispiel wird eine Workload-Konfiguration für das Benchmarking eines multimodalen Modells mit synthetischem Video bei einer Auflösung von 640×480 erstellt:
```
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)}
)
```
### Videoparameter
Die folgenden Parameter steuern die synthetische Videogenerierung:
| Parameter | Typ | Standard | Description |
| --- | --- | --- | --- |
| video\_width | int | Keine | Rahmenbreite in Pixeln. Muss auf eingestellt seinvideo\_height, um die Videogenerierung zu aktivieren. |
| video\_height | int | Keine | Rahmenhöhe in Pixeln. Muss auf eingestellt seinvideo\_width, um die Videogenerierung zu aktivieren. |
| video\_fps | int | 4 | Bilder pro Sekunde. |
| video\_duration | float | 5.0 | Clip-Dauer in Sekunden. |
| video\_batch\_size | int | 1 | Anzahl der Videos pro Anfrage. |
| video\_synth\_type | Zeichenfolge | moving\_shapes | Synthesemuster. Gültige Werte: moving\_shapes (animierte geometrische Formen), grid\_clock (Raster mit Uhranimation), noise (zufälliges Pixelrauschen). |
| video\_format | Zeichenfolge | webm | Containerformat. Zulässiger Wert: webm. |
| video\_codec | Zeichenfolge | libvpx-vp9 | Videocodec. Unterstützter Wert: libvpx-vp9 (VP9, WebM). |
**Anmerkung**
Der Benchmarking-Dienst unterstützt die VP9-Codierung nur im WebM-Format.
### Eingebettete Audiotracks
Bei Modellen, die Video und Audio zusammen verarbeiten, können Sie eine synthetische Audiospur in die generierten Videos einbetten. Audio ist standardmäßig deaktiviert. Stellen Sie `video_audio_num_channels` es auf `1` (mono) oder `2` (Stereo) ein, um es zu aktivieren.
| Parameter | Typ | Standard | Description |
| --- | --- | --- | --- |
| video\_audio\_num\_channels | int | 0 | 0 = deaktiviert, 1 = mono, 2 = Stereo. |
| video\_audio\_sample\_rate | int | 44100 | Abtastrate in Hz (8000—96000). |
| video\_audio\_codec | Zeichenfolge | auto | Audiocodec. Auto-selects libvorbisfür WebM und aac für MP4. Sie können es mit aaclibvorbis, oder libopus überschreiben. |
| video\_audio\_depth | int | 16 | Bittiefe pro Sample (8, 16, 24 oder 32). |
### Beispiele für Video-Benchmarking
**Low-resolution Verständnis von Videos**
```
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"
}
}
```
**Benchmarking von HD-Videos**
```
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 mit Audio für multimodale Modelle**
```
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"
}
}
```
**Gemischter Text und Video**
Kombinieren Sie Video mit Textansagen für Workloads zur Beantwortung von Videofragen oder zur Untertitelung:
```
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"
}
}
```
### Leistungsaspekte
+ Höhere Auflösungen und Bildraten erhöhen die Zeit für die Videokodierung und erhöhen die Größe der Nutzlast. Verwenden Sie für Tests mit hohem Durchsatz niedrigere Auflösungen (320×240 oder 640×480).
+ VP9 (`libvpx-vp9`) mit WebM-Format ist der einzige unterstützte Codec und bietet eine gute Komprimierung für Benchmark-Payloads.
+ Audio verursacht im Vergleich zum Videostream nur minimalen Overhead. Verwenden Sie mono (`1`) bei 16 kHz für sprachorientierte Workloads.
## Schritt 2: Überwachen Sie den Auftragsstatus
Fragen Sie den Auftragsstatus ab, bis er einen Terminalstatus erreicht.
**Python (Teil 3)**
```
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
```
## Schritt 3: Überprüfen Sie die Benchmark-Ergebnisse
Benchmark-Ergebnisse werden an den von Ihnen angegebenen Amazon S3 S3-Ausgabespeicherort geschrieben. Die Ergebnisse beinhalten die folgenden wichtigen Kennzahlen:
`request_throughput`
Anfragen pro Sekunde.
`request_latency`
End-to-end Anforderungslatenz mit Perzentilunterbrechungen (P50, P90, P99).
`time_to_first_token`
Zeit von der Einreichung der Anfrage bis zum ersten empfangenen Token.
`inter_token_latency`
Zeit zwischen aufeinanderfolgenden Ausgabetokens.
`output_token_throughput`
Pro Sekunde generierte Ausgabetokens.
Jede Metrik enthält statistische Zusammenfassungen: Durchschnitt, Minimum, Maximum, P50, P90, P99 und Standardabweichung.
## Benchmark-Ressourcen verwalten
Verwenden Sie die folgenden Operationen, um Ihre Benchmark-Jobs und Workload-Konfigurationen zu verwalten.
```
# 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"
)
```