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 AI 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:

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 l'endpoint si trova in un VPC, passa NetworkConfig il parametro con le VpcConfig impostazioni, inclusi gli ID dei gruppi di sicurezza e le sottoreti.

Per tenere traccia dei risultati del benchmark con MLFlow on SageMaker AI completamente gestito, aggiungi un oggetto a. MlflowConfig OutputConfig Per ulteriori informazioni, consulta Tieni traccia dei consigli di inferenza e confronta i risultati con MLFlow.

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
        

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:

Se non lo specifichimodel_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:

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

Puoi confrontare i 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.

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:

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_channelsImpostare su 1 (mono) o 2 (stereo) per abilitarlo.

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

Fase 2: Monitora lo stato del lavoro

Controlla 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:

Ogni metrica include riepiloghi statistici: media, minima, massima, P50, P90, P99 e deviazione standard.

Endpoint in formato personalizzato di benchmark

Se il tuo endpoint utilizza un formato di richiesta o risposta personalizzato (ad esempio, gestori personalizzati DJL, formato TensorRT-LLM nativo o altri framework di server che non supportano l'API di completamento delle chat OpenAI), puoi eseguirne il benchmark utilizzando un modello Jinja2 per definire la forma del payload del tuo endpoint.

Il servizio di benchmarking esegue il rendering del modello per richiesta con prompt sintetici o personalizzati, quindi inoltra il payload all'endpoint SageMaker AI. È inoltre necessario specificare una query JMESpath per estrarre il testo generato dalla risposta dell'endpoint.

Crea il modello di payload

Definisci il formato di richiesta del tuo endpoint come file modello Jinja2. Nel modello sono disponibili le seguenti variabili:

Usa il |tojson filtro per un corretto escape JSON dei valori delle stringhe. L'esempio seguente mostra un modello per un endpoint DJL con formato di chiamata agli strumenti:

{
  "messages": [{"role": "user", "content": {{ text|tojson }}}],
  "tools": [
    {"function": {"name": "Chit_Chat", "description": "casual conversation",
      "parameters": {"type": "object", "properties": {}}}}
  ],
  "max_tokens": {{ max_tokens }}
}

Carica il file modello su Amazon S3 (ad esempio,s3://DOC-EXAMPLE-BUCKET/templates/my_endpoint_template.jinja).

Crea la configurazione del carico di lavoro

Crea una configurazione del carico di lavoro che faccia riferimento al file modello. Utilizzate il extra_inputs parametro per specificare il percorso del modello e la query di estrazione della risposta. Distribuisci il file modello al contenitore di benchmark tramite un DatasetConfig canale.

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",
                    }
                },
            }
        ]
    },
)

ChannelNameDetermina dove il file viene visualizzato all'interno del contenitore di benchmark. Un canale denominato template rende il file disponibile su/opt/ml/input/data/template/<filename>.

Il response_field valore è una query JMESPath che estrae il testo generato dalla risposta dell'endpoint. I modelli più comuni includono:

Se si ometteresponse_field, lo strumento di benchmarking rileva automaticamente il formato di risposta.

Esegui il benchmark

Crea un lavoro di riferimento mirato al tuo endpoint. Il servizio rileva automaticamente la modalità modello dalla payload_template chiave in extra_inputs e indirizza le richieste attraverso il percorso proxy appropriato.

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

Considerazioni

Correla le richieste e le risposte dei benchmark

Una volta completato un processo di benchmark, gli artefatti di output includono dati di input e output per richiesta che è possibile unire per la post-elaborazione. Ciò consente casi d'uso come la valutazione della qualità, il controllo della sicurezza, il confronto delle risposte tra le configurazioni e il debug del comportamento imprevisto del modello.

Effettua il benchmark degli artefatti di output

L'output.tar.gzarchivio nella posizione di output di Amazon S3 contiene i seguenti file relativi alla correlazione tra pronta risposta:

Unisci gli input agli output

Correla i prompt con le relative risposte utilizzando il conversation_id campo in outputs.json e il campo in: session_id 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}...")

Note importanti

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