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.

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
        

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

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

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