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:

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.

Para acompanhar os resultados do benchmark com MLflow totalmente gerenciado em SageMaker IA, adicione um MlflowConfig objeto a. OutputConfig Para obter mais informações, consulte Acompanhe as recomendações de inferência e os resultados de benchmark com o MLflow.

Componentes de inferência de benchmark

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
        

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:

Se você não especificarmodel_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:

Variable-size imagens

Use parâmetros de desvio padrão para gerar imagens com dimensões variadas, simulando cargas de trabalho do mundo real 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.

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:

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_channelsDefina como 1 (mono) ou 2 (estéreo) para ativá-lo.

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

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

Cada métrica inclui resumos estatísticos: média, mínimo, máximo, P50, P90, P99 e desvio padrão.

Compare endpoints com formato personalizado

Se o seu endpoint usa um formato personalizado de solicitação ou resposta (por exemplo, manipuladores personalizados DJL, formato TensorRT-LLM nativo ou outras estruturas de atendimento que não suportam a API de conclusão de chat do OpenAI), você pode compará-lo usando um modelo Jinja2 para definir a forma da carga útil do seu endpoint.

O serviço de benchmarking renderiza o modelo por solicitação com solicitações sintéticas ou personalizadas e, em seguida, encaminha a carga para seu endpoint de IA. SageMaker Você também especifica uma consulta JMESPath para extrair o texto gerado da resposta do seu endpoint.

Crie o modelo de carga

Defina o formato de solicitação do seu endpoint como um arquivo de modelo Jinja2. As seguintes variáveis estão disponíveis no modelo:

Use o |tojson filtro para o escape JSON adequado dos valores da string. O exemplo a seguir mostra um modelo para um endpoint DJL com formato de chamada de ferramenta:

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

Faça o upload do arquivo de modelo para o Amazon S3 (por exemplo,s3://DOC-EXAMPLE-BUCKET/templates/my_endpoint_template.jinja).

Crie a configuração da carga de trabalho

Crie uma configuração de carga de trabalho que faça referência ao arquivo de modelo. Use o extra_inputs parâmetro para especificar o caminho do modelo e a consulta de extração da resposta. Entregue o arquivo de modelo ao contêiner de benchmark por meio de um DatasetConfig canal.

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 onde o arquivo aparece dentro do contêiner de benchmark. Um canal chamado template disponibiliza o arquivo em/opt/ml/input/data/template/<filename>.

O response_field valor é uma consulta JMESPath que extrai o texto gerado da resposta do seu endpoint. Os padrões comuns incluem:

Se você omitirresponse_field, a ferramenta de benchmarking detectará automaticamente o formato da resposta.

Execute o benchmark

Crie um trabalho de referência direcionado ao seu endpoint. O serviço detecta automaticamente o modo de modelo a partir da payload_template chave extra_inputs e encaminha as solicitações pelo caminho de proxy apropriado.

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

Considerações

Correlacione solicitações e respostas de benchmark

Após a conclusão de um trabalho de benchmark, os artefatos de saída incluem dados de entrada e saída por solicitação que você pode unir para pós-processamento. Isso permite casos de uso como avaliação de qualidade, auditoria de segurança, comparação de respostas entre configurações e depuração de comportamento inesperado do modelo.

Artefatos de saída de referência

O output.tar.gz arquivamento em seu local de saída do Amazon S3 contém os seguintes arquivos relevantes para a correlação de resposta rápida:

Unir entradas às saídas

Correlacione as solicitações com suas respostas usando o conversation_id campo em outputs.json e o session_id campo em: 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}...")

Observações importantes

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