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:

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.

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
        

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:

Wenn Sie nichts angebenmodel_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:

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.

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:

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.

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

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:

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:

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/<filename>.

Der response_field Wert ist eine JMESPath-Abfrage, die den generierten Text aus der Antwort Ihres Endpunkts extrahiert. Zu den gängigen Mustern gehören:

Wenn Sie es weglassenresponse_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

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:

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

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"
)