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.
Um die Benchmark-Ergebnisse mit vollständig verwaltetem MLflow auf SageMaker KI zu verfolgen, fügen Sie ein `MlflowConfig` Objekt hinzu. `OutputConfig` Weitere Informationen finden Sie unter [Verfolgen Sie Inferenzempfehlungen und Benchmark-Ergebnisse mit MLflow](generative-ai-inference-recommendations-mlflow.md).
## 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 | Dauer des Clips 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: Auftragsstatus überwachen
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-Endpunkte im benutzerdefinierten Format
Wenn Ihr Endpunkt ein benutzerdefiniertes Anfrage- oder Antwortformat verwendet (z. B. benutzerdefinierte DJL-Handler, TensorRT-LLM natives Format oder andere Serving-Frameworks, die die OpenAI-API für Chat-Vervollständigungen nicht unterstützen), können Sie ihn mithilfe einer Jinja2-Vorlage vergleichen, um die Payload-Shape Ihres Endpunkts zu definieren.
Der Benchmarking-Service rendert die Vorlage pro Anfrage mit synthetischen oder benutzerdefinierten Eingabeaufforderungen und leitet die Payload dann an Ihren KI-Endpunkt weiter. SageMaker Sie geben auch eine JMESPath-Abfrage an, um den generierten Text aus der Antwort Ihres Endpunkts zu extrahieren.
### Erstellen Sie die Payload-Vorlage
Definieren Sie das Anforderungsformat Ihres Endpunkts als Jinja2-Vorlagendatei. Die folgenden Variablen sind in der Vorlage verfügbar:
| Variable | Description |
| --- | --- |
| text | Erster Textinhalt (synthetisch oder aus einem Datensatz). |
| texts | Liste aller Textinhalte. |
| model | Name des Modells. |
| max\_tokens | Limit für Ausgabetokens. |
| stream | Ob Streaming aktiviert ist. |
Verwenden Sie den `|tojson` Filter für das korrekte JSON-Escaping von Zeichenkettenwerten. Das folgende Beispiel zeigt eine Vorlage für einen DJL-Endpunkt im Tool-Aufruf-Format:
```
{
"messages": [{"role": "user", "content": {{ text|tojson }}}],
"tools": [
{"function": {"name": "Chit_Chat", "description": "casual conversation",
"parameters": {"type": "object", "properties": {}}}}
],
"max_tokens": {{ max_tokens }}
}
```
Laden Sie die Vorlagendatei auf Amazon S3 hoch (z. B.`s3://DOC-EXAMPLE-BUCKET/templates/my_endpoint_template.jinja`).
### Erstellen Sie die Workload-Konfiguration
Erstellen Sie eine Workload-Konfiguration, die auf die Vorlagendatei verweist. Verwenden Sie den `extra_inputs` Parameter, um den Vorlagenpfad und die Antwortextraktionsabfrage anzugeben. Übermitteln Sie die Vorlagendatei über einen `DatasetConfig` Kanal an den Benchmark-Container.
```
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",
}
},
}
]
},
)
```
Das `ChannelName` bestimmt, wo die Datei im Benchmark-Container erscheint. Ein Kanal mit dem Namen `template` macht die Datei verfügbar unter`/opt/ml/input/data/template/`.
Der `response_field` Wert ist eine [JMESPath-Abfrage](https://jmespath.org/), die den generierten Text aus der Antwort Ihres Endpunkts extrahiert. Zu den gängigen Mustern gehören:
+ `choices[0].message.content`— OpenAI-Format
+ `generation_details.generations[0].content`— DJL-Format
+ `output.text`— einfache Textantwort
Wenn Sie es weglassen`response_field`, erkennt das Benchmarking-Tool das Antwortformat automatisch.
### Führen Sie den Benchmark aus
Erstellen Sie einen Benchmark-Job, der auf Ihren Endpunkt abzielt. Der Dienst erkennt anhand der Eingabe automatisch den `payload_template` Vorlagenmodus `extra_inputs` und leitet Anfragen über den entsprechenden Proxypfad weiter.
```
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",
)
```
### Überlegungen
+ Vorlagen müssen als Dateien über Amazon S3 geliefert werden. Inline-JSON-Vorlagen in der `extra_inputs` Zeichenfolge werden nicht unterstützt, da Kommas in JSON mit dem Parameter-Parser in Konflikt stehen.
+ Endpunkte mit einer einzigen Inferenzkomponente werden unterstützt. Endpunkte mit mehreren Inferenzkomponenten werden im Vorlagenmodus nicht unterstützt, da der Dienst nicht bestimmen kann, an welche Komponente jede Anforderung aus einem beliebigen Nutzdatenformat weitergeleitet werden soll.
+ Sowohl Streaming-Endpunkte als auch Nicht-Streaming-Endpunkte werden unterstützt. Stellen Sie `"streaming": true` oder `"streaming": false` in den Workload-Parametern ein.
## Korrelieren Sie Benchmark-Eingabeaufforderungen und Antworten
Nach Abschluss eines Benchmark-Jobs enthalten die Ausgabeartefakte Eingabe- und Ausgabedaten pro Anforderung, die Sie für die Nachbearbeitung zusammenfügen können. Dies ermöglicht Anwendungsfälle wie Qualitätsbewertung, Sicherheitsaudits, den Vergleich von Antworten zwischen Konfigurationen und das Debuggen von unerwartetem Modellverhalten.
### Benchmark-Ausgabeartefakte
Das `output.tar.gz` Archiv in Ihrem Amazon S3-Ausgabespeicherort enthält die folgenden Dateien, die für die Prompt-Response-Korrelation relevant sind:
`inputs.json`
Der vollständige synthetische Datensatz der generierten Konversationen. Jeder Datensatz hat eine `session_id` und die vollständige Nutzlast der Anfrage (messages, max\_tokens, model).
`outputs.json`
Per-request Antwortmetadaten für Anfragen, die an den Endpunkt gesendet wurden. Jeder Datensatz enthält den Antworttext des Modells, die Latenz pro Anfrage, die Anzahl der Ausgabetokens und eine`conversation_id`, die der Eingabe zugeordnet ist.
### Verbindet Eingaben mit Ausgaben
Korrelieren Sie die Eingabeaufforderungen mit ihren Antworten, indem Sie das `conversation_id` Feld in `outputs.json` und das `session_id` Feld in verwenden: `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}...")
```
### Wichtige Hinweise
+ **Schlüssel verbinden.** Benutze `conversation_id` in`outputs.json`, um gegen `session_id` in zu spielen`inputs.json`. Nicht `session_num` als Positionsindex verwenden — er steht für die Ausführungsreihenfolge, die sich von der Reihenfolge der Eingabeerstellung unterscheidet, wenn die Parallelität größer als 1 ist.
+ **Nicht alle Eingaben haben Ausgaben.** Die `inputs.json` Datei enthält den gesamten generierten Datensatzpool. Wenn der `request_count` Wert kleiner als die Poolgröße ist, wird nur eine Teilmenge der Konversationen an den Endpunkt gesendet. Bei den nicht übereinstimmenden Eingaben handelt es sich um Konversationen, die generiert, aber nicht verwendet wurden.
+ **Ausgabeschema.** Jeder Datensatz in `outputs.json` enthält`conversation_id`,`response_text`, `metrics` (mit `request_latency` und`output_sequence_length`) und Timing-Felder (`request_start_ns`,`request_end_ns`).
## 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"
)
```