As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Endpoints de inferência de IA generativa de referência
O serviço de benchmarking de SageMaker IA mede o desempenho de modelos de linguagem grande (LLMs) hospedados em endpoints de SageMaker IA. Ele executa benchmarks usando o NVIDIA AiPerf, produzindo métricas como latência da solicitação, taxa de transferência, tempo até o primeiro token e latência entre tokens.
## Pré-requisitos
Antes de criar um trabalho de referência, você precisa do seguinte:
+ Um endpoint de SageMaker IA em `InService` status hospedando um LLM que suporta a API de conclusão de OpenAI-compatible bate-papo
+ Um bucket Amazon S3 para resultados de benchmark
+ Uma função de execução do IAM que concede acesso à SageMaker IA ao seu endpoint e bucket de saída
## Etapa 1: criar um trabalho de referência
Um trabalho de benchmark tem como alvo um endpoint de SageMaker IA específico e faz referência a uma configuração de carga de trabalho.
**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 seu endpoint hospeda vários modelos por meio de componentes de inferência, você pode especificá-los no `InferenceComponents` parâmetro do. `BenchmarkTarget`
Se seu endpoint estiver em uma VPC, passe `NetworkConfig` o parâmetro com `VpcConfig` suas configurações, incluindo IDs de grupos de segurança e sub-redes.
## Componentes de inferência de referência
Se seu endpoint usa *componentes de inferência* em vez de implantar um modelo diretamente, você deve especificar os componentes de inferência a serem comparados no. `BenchmarkTarget` Quando os componentes de inferência são especificados, o serviço de benchmarking encaminha as solicitações para esses componentes específicos, em vez do modelo padrão do endpoint.
Passe um ou mais nomes de componentes de inferência ou ARNs na `InferenceComponents` lista:
**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 seu endpoint estiver configurado para componentes de inferência, mas você não especificar `InferenceComponents` no destino do benchmark, o trabalho falhará com um erro indicando que nenhum modelo foi implantado diretamente no endpoint. Sempre inclua o `InferenceComponents` parâmetro ao comparar endpoints baseados em componentes de inferência.
## Compare endpoints multi-LoRa
Para comparar um endpoint que atende a vários adaptadores LoRa, especifique cada adaptador como um componente de inferência no. `BenchmarkTarget` Opcionalmente, você pode usar o parâmetro `model_selection_strategy` de carga de trabalho para controlar como o benchmark distribui as solicitações entre os adaptadores. Se você não especificar uma estratégia, o padrão será`round_robin`.
Primeiro, crie uma configuração de carga de trabalho. O exemplo a seguir inclui o `model_selection_strategy` parâmetro opcional:
```
# 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)}
)
```
Em seguida, crie um trabalho de benchmark que tenha como alvo todos os componentes de inferência do adaptador 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",
)
```
O `model_selection_strategy` parâmetro é opcional e determina como a ferramenta de benchmark distribui as solicitações nos componentes de inferência especificados. Os valores válidos são:
+ `round_robin`(padrão) — cada adaptador recebe solicitações em ordem. A enésima solicitação é enviada para o adaptador (no modo número de modelos).
+ `random`— cada solicitação é atribuída a um adaptador de maneira uniforme e aleatória.
Se você não especificar`model_selection_strategy`, o benchmark usará `round_robin` por padrão.
## Compare endpoints multimodais com imagens sintéticas
Você pode comparar modelos de linguagem de visão gerando imagens sintéticas como parte da configuração da carga de trabalho. O serviço de benchmarking usa o AiPerf para criar imagens com dimensões e formato configuráveis e, em seguida, as envia como cargas codificadas em base64 para seu endpoint.
O exemplo a seguir cria uma configuração de carga de trabalho para comparar um modelo de linguagem de visão com imagens sintéticas:
```
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)}
)
```
Os seguintes parâmetros controlam a geração de imagens sintéticas:
| Parâmetro | Tipo | Padrão | Description |
| --- | --- | --- | --- |
| image\_width\_mean | flutuação | Nenhum | Largura média da imagem em pixels. |
| image\_width\_stddev | flutuação | Nenhum | Desvio padrão da largura da imagem. Defina para variar as dimensões da imagem entre as solicitações. |
| image\_height\_mean | flutuação | Nenhum | Altura média da imagem em pixels. |
| image\_height\_stddev | flutuação | Nenhum | Desvio padrão da altura da imagem. |
| image\_batch\_size | int | 1 | Número de imagens por solicitação. |
| image\_format | string | png | Formato da imagem. Valores válidos: png (sem perdas), jpeg (com perdas, arquivos menores), (seleciona aleatoriamente PNG ou random JPEG por imagem). |
**Variable-size imagens**
Use parâmetros de desvio padrão para gerar imagens com dimensões variadas, simulando cargas de trabalho reais em que os tamanhos das imagens são diferentes:
```
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"
}
}
```
## Compare endpoints multimodais com vídeo sintético
Você pode comparar modelos multimodais que processam entradas de vídeo gerando vídeos sintéticos como parte da configuração da carga de trabalho. O serviço de benchmarking usa a geração de vídeo sintético do AiPerf para criar vídeos com resolução, taxa de quadros, duração e codificação configuráveis e, em seguida, os envia como cargas codificadas em base64 para seu endpoint.
**nota**
A geração de vídeo está desativada por padrão. Você deve especificar ambos `video_width` e `video_height` em sua configuração de carga de trabalho para habilitá-lo.
O exemplo a seguir cria uma configuração de carga de trabalho para comparar um modelo multimodal com vídeo sintético com resolução de 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)}
)
```
### Parâmetros de vídeo
Os seguintes parâmetros controlam a geração de vídeo sintético:
| Parâmetro | Tipo | Padrão | Description |
| --- | --- | --- | --- |
| video\_width | int | Nenhum | Largura do quadro em pixels. Deve ser definido com video\_height para permitir a geração de vídeo. |
| video\_height | int | Nenhum | Altura do quadro em pixels. Deve ser definido com video\_width para permitir a geração de vídeo. |
| video\_fps | int | 4 | Quadros por segundo. |
| video\_duration | flutuação | 5,0 | Duração do clipe em segundos. |
| video\_batch\_size | int | 1 | Número de vídeos por solicitação. |
| video\_synth\_type | string | formas\_móveis | Padrão de síntese. Valores válidos: moving\_shapes (formas geométricas animadas), grid\_clock (grade com animação de relógio), noise (ruído aleatório de pixels). |
| video\_format | string | webm | Formato de contêiner. Valor válido: webm. |
| video\_codec | string | libvpx-vp9 | Codec de vídeo. Valor suportado: libvpx-vp9 (VP9, WebM). |
**nota**
O serviço de benchmarking suporta a codificação VP9 somente com o formato WebM.
### Faixas de áudio incorporadas
Para modelos que processam vídeo e áudio juntos, você pode incorporar uma faixa de áudio sintética nos vídeos gerados. O áudio está desativado por padrão. `video_audio_num_channels`Defina como `1` (mono) ou `2` (estéreo) para ativá-lo.
| Parâmetro | Tipo | Padrão | Description |
| --- | --- | --- | --- |
| video\_audio\_num\_channels | int | 0 | 0 = desativado, 1 = mono, 2 = estéreo. |
| video\_audio\_sample\_rate | int | 44100 | Taxa de amostragem em Hz (8000—96000). |
| video\_audio\_codec | string | auto | Codec de áudio. Auto-selects libvorbispara WebM e MP4aac. Você pode substituir por aaclibvorbis, oulibopus. |
| video\_audio\_depth | int | 16 | Profundidade de bits por amostra (8, 16, 24 ou 32). |
### Exemplos de benchmarking de vídeo
**Low-resolution compreensão de vídeo**
```
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"
}
}
```
**Análise comparativa de vídeo em 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"
}
}
```
**Vídeo com áudio para modelos multimodais**
```
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"
}
}
```
**Texto e vídeo mistos**
Combine vídeo com instruções de texto para cargas de trabalho de resposta a perguntas ou legendas em vídeo:
```
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"
}
}
```
### Considerações sobre a performance
+ Resoluções e taxas de quadros mais altas aumentam o tempo de codificação do vídeo e o tamanho da carga útil. Para testes de alto rendimento, use resoluções mais baixas (320 × 240 ou 640 × 480).
+ O VP9 (`libvpx-vp9`) com formato WebM é o único codec compatível e fornece boa compactação para benchmarking de cargas úteis.
+ O áudio adiciona uma sobrecarga mínima em comparação com o fluxo de vídeo. Use mono (`1`) a 16 kHz para cargas de trabalho focadas na fala.
## Etapa 2: monitorar o status do trabalho
Pesquise o status do trabalho até que ele atinja um estado terminal.
**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
```
## Etapa 3: analisar os resultados do benchmark
Os resultados do benchmark são gravados no local de saída do Amazon S3 que você especificou. Os resultados incluem as seguintes métricas principais:
`request_throughput`
Solicitações por segundo.
`request_latency`
End-to-end latência de solicitação com detalhamentos de percentis (P50, P90, P99).
`time_to_first_token`
Tempo desde o envio da solicitação até o primeiro token recebido.
`inter_token_latency`
Tempo entre tokens de saída consecutivos.
`output_token_throughput`
Tokens de saída gerados por segundo.
Cada métrica inclui resumos estatísticos: média, mínimo, máximo, P50, P90, P99 e desvio padrão.
## Gerencie recursos de benchmark
Use as operações a seguir para gerenciar seus trabalhos de referência e configurações de carga de trabalho.
```
# 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"
)
```