Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Points de terminaison d'inférence génératifs basés sur l'IA

Le service d'analyse comparative de l' SageMaker IA mesure les performances des grands modèles linguistiques (LLM) hébergés sur des terminaux d' SageMaker IA. Il exécute des tests à l'aide de NVIDIA AiPerf, produisant des métriques telles que la latence des demandes, le débit, le délai jusqu'au premier jeton et la latence entre les jetons.

Conditions préalables

Avant de créer une tâche de référence, vous devez disposer des éléments suivants :

Étape 1 : Création d'une tâche de référence

Une tâche de référence cible un point de terminaison d' SageMaker IA spécifique et fait référence à une configuration de charge de travail.

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 INTERFACE DE LIGNE DE COMMANDE (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
        

Si votre point de terminaison héberge plusieurs modèles via des composants d'inférence, vous pouvez les spécifier dans le InferenceComponents paramètre duBenchmarkTarget.

Si votre point de terminaison se trouve dans un VPC, transmettez le NetworkConfig paramètre avec vos VpcConfig paramètres, y compris les ID de groupes de sécurité et les sous-réseaux.

Pour suivre les résultats du benchmark avec MLflow entièrement géré sur SageMaker AI, ajoutez un MlflowConfig objet àOutputConfig. Pour de plus amples informations, veuillez consulter Suivez les recommandations d'inférence et les résultats de référence avec MLflow.

Composants d'inférence de référence

Si votre point de terminaison utilise des composants d'inférence au lieu de déployer directement un modèle, vous devez spécifier les composants d'inférence à comparer dans le. BenchmarkTarget Lorsque des composants d'inférence sont spécifiés, le service d'analyse comparative achemine les demandes vers ces composants spécifiques plutôt que vers le modèle par défaut du point de terminaison.

Transmettez un ou plusieurs noms de composants d'inférence ou ARN dans la InferenceComponents liste :

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 INTERFACE DE LIGNE DE COMMANDE (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
        

Points de terminaison multi-LoRA de référence

Pour comparer un point de terminaison qui dessert plusieurs adaptateurs LoRa, spécifiez chaque adaptateur en tant que composant d'inférence dans le. BenchmarkTarget Vous pouvez éventuellement utiliser le paramètre de model_selection_strategy charge de travail pour contrôler la manière dont le benchmark répartit les demandes entre les adaptateurs. Si vous ne spécifiez aucune stratégie, la valeur par défaut estround_robin.

Créez d'abord une configuration de charge de travail. L'exemple suivant inclut le model_selection_strategy paramètre facultatif :

# 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)}
)
        

Créez ensuite une tâche de référence qui cible tous les composants d'inférence de l'adaptateur 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",
)
        

Le model_selection_strategy paramètre est facultatif et détermine la manière dont l'outil de référence distribue les demandes entre les composants d'inférence spécifiés. Les valeurs valides sont :

Si vous ne le spécifiez pasmodel_selection_strategy, le benchmark utilise round_robin par défaut.

Comparez les points de terminaison multimodaux avec des images synthétiques

Vous pouvez comparer les modèles de langage visuel en générant des images synthétiques dans le cadre de la configuration de la charge de travail. Le service d'analyse comparative utilise AiPerf pour créer des images aux dimensions et au format configurables, puis les envoie sous forme de charges utiles codées en base64 à votre terminal.

L'exemple suivant crée une configuration de charge de travail pour l'analyse comparative d'un modèle de langage de vision avec des images synthétiques :

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

Les paramètres suivants contrôlent la génération d'images synthétiques :

Variable-size images

Utilisez les paramètres d'écart type pour générer des images de différentes dimensions, en simulant des charges de travail réelles où les tailles d'image diffèrent :

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

Comparez les points de terminaison multimodaux avec une vidéo synthétique

Vous pouvez comparer les modèles multimodaux qui traitent les entrées vidéo en générant des vidéos synthétiques dans le cadre de la configuration de la charge de travail. Le service d'analyse comparative utilise la génération de vidéos synthétiques d'AiPerf pour créer des vidéos avec une résolution, une fréquence d'images, une durée et un encodage configurables, puis les envoie sous forme de charges utiles codées en base64 à votre terminal.

L'exemple suivant crée une configuration de charge de travail pour l'analyse comparative d'un modèle multimodal avec une vidéo synthétique à une résolution 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)}
)

Paramètres vidéo

Les paramètres suivants contrôlent la génération de vidéos synthétiques :

Pistes audio intégrées

Pour les modèles qui traitent simultanément la vidéo et le son, vous pouvez intégrer une piste audio synthétique dans les vidéos générées. Le son est désactivé par défaut. Réglez video_audio_num_channels sur 1 (mono) ou 2 (stéréo) pour l'activer.

Exemples de benchmarking vidéo

Low-resolution compréhension vidéo

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

Analyse comparative des vidéos 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"
    }
}

Vidéo avec audio pour les modèles multimodaux

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

Texte et vidéo mixtes

Combinez des vidéos avec des instructions textuelles pour répondre à des questions ou sous-titrer des vidéos :

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

Considérations sur les performances

Étape 2 : Surveiller l'état du travail

Interrogez le statut de la tâche jusqu'à ce qu'elle atteigne un état 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 INTERFACE DE LIGNE DE COMMANDE (CLI)

aws sagemaker describe-ai-benchmark-job \
  --ai-benchmark-job-name "my-benchmark-job" \
  --region us-west-2
        

Étape 3 : Examiner les résultats de référence

Les résultats du benchmark sont écrits sur l'emplacement de sortie Amazon S3 que vous avez spécifié. Les résultats incluent les indicateurs clés suivants :

Chaque métrique inclut des résumés statistiques : moyenne, minimale, maximale, P50, P90, P99 et écart type.

Analysez les points de terminaison au format personnalisé

Si votre terminal utilise un format de demande ou de réponse personnalisé (par exemple, des gestionnaires personnalisés DJL, un format TensorRT-LLM natif ou d'autres frameworks de service qui ne prennent pas en charge l'API de complétion de chat OpenAI), vous pouvez le comparer à l'aide d'un modèle Jinja2 pour définir la forme de la charge utile de votre point de terminaison.

Le service d'analyse comparative affiche le modèle par demande avec des instructions synthétiques ou personnalisées, puis transmet la charge utile à votre point de terminaison d'IA. SageMaker Vous spécifiez également une requête JMESpath pour extraire le texte généré de la réponse de votre point de terminaison.

Création du modèle de charge utile

Définissez le format de demande de votre point de terminaison sous la forme d'un fichier modèle Jinja2. Les variables suivantes sont disponibles dans le modèle :

Utilisez le |tojson filtre pour échapper correctement aux valeurs de chaîne au format JSON. L'exemple suivant montre un modèle pour un point de terminaison DJL au format d'appel d'outils :

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

Téléchargez le fichier modèle sur Amazon S3 (par exemple,s3://DOC-EXAMPLE-BUCKET/templates/my_endpoint_template.jinja).

Création de la configuration de charge de travail

Créez une configuration de charge de travail qui fait référence au fichier modèle. Utilisez le extra_inputs paramètre pour spécifier le chemin du modèle et la requête d'extraction des réponses. Envoyez le fichier modèle au conteneur de référence via un 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",
                    }
                },
            }
        ]
    },
)

ChannelNameDétermine l'endroit où le fichier apparaît dans le conteneur de référence. Un canal nommé template rend le fichier disponible à l'adresse/opt/ml/input/data/template/<filename>.

La response_field valeur est une requête JMESpath qui extrait le texte généré de la réponse de votre point de terminaison. Les modèles courants incluent :

Si vous omettezresponse_field, l'outil d'analyse comparative détecte automatiquement le format de réponse.

Exécutez le benchmark

Créez une offre d'emploi de référence ciblant votre point de terminaison. Le service détecte automatiquement le mode modèle à partir de payload_template la saisie extra_inputs et achemine les demandes via le chemin de proxy approprié.

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

Considérations

Corréler les demandes et les réponses aux critères de référence

Une fois qu'une tâche de référence est terminée, les artefacts de sortie incluent des données d'entrée et de sortie par demande que vous pouvez associer pour le post-traitement. Cela permet des cas d'utilisation tels que l'évaluation de la qualité, l'audit de sécurité, la comparaison des réponses entre les configurations et le débogage de comportements inattendus du modèle.

Objets de sortie de référence

L'output.tar.gzarchive de votre emplacement de sortie Amazon S3 contient les fichiers suivants relatifs à la corrélation entre invite et réponse :

Joindre les entrées aux sorties

Corrélez les demandes avec leurs réponses en utilisant le conversation_id champ dans outputs.json et le session_id champ dans : 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}...")

Remarques importantes

Gérez les ressources de référence

Utilisez les opérations suivantes pour gérer vos tâches de référence et vos configurations de charge de travail.

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