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.
# SageMaker Inférence
Les modèles Amazon Nova personnalisés sont désormais disponibles par SageMaker inférence. Avec Amazon Nova activé SageMaker, vous pouvez commencer à obtenir des prédictions, ou des inférences, à partir de vos modèles Amazon Nova personnalisés et entraînés. SageMaker propose une large sélection d'options de déploiement d'infrastructures et de modèles de machine learning pour répondre à tous vos besoins en matière d'inférence de machine learning. Grâce à SageMaker l'inférence, vous pouvez adapter le déploiement de vos modèles, gérer les modèles plus efficacement en production et réduire la charge opérationnelle.
SageMaker vous propose diverses options d'inférence, telles que des points de terminaison en temps réel pour obtenir une inférence à faible latence et des points de terminaison asynchrones pour des lots de demandes. En tirant parti de l’option d’inférence adaptée à votre cas d’utilisation, vous pouvez garantir des déploiements et des inférences de modèles efficaces. Pour plus d'informations sur l' SageMaker inférence, voir [Déployer des modèles pour l'inférence](https://docs.aws.amazon.com//sagemaker/latest/dg/deploy-model.html).
**Important**
Seuls les modèles personnalisés de rang complet et les modèles fusionnés par LoRA sont pris en charge par inférence. SageMaker Pour les modèles LoRa et les modèles de base non fusionnés, utilisez Amazon Bedrock.
## Caractéristiques
Les fonctionnalités suivantes sont disponibles pour les modèles Amazon Nova par SageMaker inférence :
**Capacités du modèle**
+ Génération de texte
**Déploiement et évolutivité**
+ Points de terminaison en temps réel avec sélection d'instance personnalisée
+ Auto Scaling — Ajustez automatiquement la capacité en fonction des modèles de trafic afin d'optimiser les coûts et l'utilisation du GPU. Pour plus d'informations, consultez [Automatically Scale Amazon SageMaker Models](https://docs.aws.amazon.com//sagemaker/latest/dg/endpoint-auto-scaling.html).
+ Support de l'API de streaming pour la génération de jetons en temps réel
**Surveillance et optimisation**
+ CloudWatch Intégration avec Amazon pour la surveillance et les alertes
+ Optimisation de la latence en fonction de la zone de disponibilité grâce à la configuration VPC
**Outils de développement**
+ AWS CLI support — Pour plus d'informations, consultez le manuel de [référence des commandes AWS CLI pour SageMaker](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/).
+ Intégration à un ordinateur portable via le support du SDK
## Modèles et instances pris en charge
Lorsque vous créez vos points de terminaison d' SageMaker inférence, vous pouvez définir deux variables d'environnement pour configurer votre déploiement : `CONTEXT_LENGTH` et. `MAX_CONCURRENCY`
+ `CONTEXT_LENGTH`— Longueur totale maximale du jeton (entrée\$1sortie) par demande
+ `MAX_CONCURRENCY`— Nombre maximum de demandes simultanées traitées par le point de terminaison
Le tableau suivant répertorie les modèles, les types d'instances et les configurations Amazon Nova pris en charge. Les valeurs MAX\$1CONCURRENCY représentent la simultanéité maximale prise en charge pour chaque paramètre CONTEXT\$1LENGTH :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/nova/latest/nova2-userguide/nova-model-sagemaker-inference.html)
**Note**
Les valeurs MAX\$1CONCURRENCY affichées sont les limites supérieures de chaque paramètre CONTEXT\$1LENGTH. Vous pouvez utiliser des longueurs de contexte plus faibles avec la même simultanéité, mais le dépassement de ces valeurs entraînera l'échec de la création du point de SageMaker terminaison.
Par exemple, sur Amazon Nova Micro avec un ml.g5.12xlarge :
`CONTEXT_LENGTH=2000`, `MAX_CONCURRENCY=32` → Valide
`CONTEXT_LENGTH=8000`, `MAX_CONCURRENCY=32` → Rejeté (la limite de simultanéité est de 16 à une longueur de contexte de 8 000)
`CONTEXT_LENGTH=8000`, `MAX_CONCURRENCY=4` → Valide
`CONTEXT_LENGTH=8000`, `MAX_CONCURRENCY=16` → Valide
`CONTEXT_LENGTH=10000`→ Rejeté (la longueur maximale du contexte est de 8 000 sur cette instance)
## AWS Régions prises en charge
Le tableau suivant répertorie les AWS régions dans lesquelles les modèles Amazon Nova sont disponibles par SageMaker inférence :
****
| Nom de la région | Code région | Disponibilité |
| --- | --- | --- |
| USA Est (Virginie du Nord) | us-east-1 | Available |
| USA Ouest (Oregon) | us-west-2 | Available |
## Images de conteneurs prises en charge
Le tableau suivant répertorie l'image du conteneur URIs pour les modèles Amazon Nova par SageMaker inférence par région. Deux balises d'image sont disponibles pour chaque région : une balise versionnée (`v1.0.0`) et une balise la plus récente (`SM-Inference-latest`). Pour les déploiements de production, nous recommandons d'utiliser la balise versionnée.
****
| Région | Image du conteneur URIs |
| --- | --- |
| us-east-1 | 708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-inference-repo:SM-Inference-latest |
| us-west-2 | 176779409107.dkr.ecr.us-west-2.amazonaws.com/nova-inference-repo:SM-Inference-latest |
## Bonnes pratiques
Pour connaître les meilleures pratiques relatives au déploiement et à la gestion des modèles sur SageMaker, consultez la section [Meilleures pratiques pour SageMaker](https://docs.aws.amazon.com//sagemaker/latest/dg/best-practices.html).
## Support
En cas de problème ou d'assistance concernant les modèles Amazon Nova par SageMaker inférence, contactez le AWS Support via la console ou votre responsable de AWS compte.
**Topics**
+ [Caractéristiques](#nova-sagemaker-inference-features)
+ [Modèles et instances pris en charge](#nova-sagemaker-inference-supported)
+ [AWS Régions prises en charge](#nova-sagemaker-inference-regions)
+ [Images de conteneurs prises en charge](#nova-sagemaker-inference-container-images)
+ [Bonnes pratiques](#nova-sagemaker-inference-best-practices)
+ [Support](#nova-sagemaker-inference-support)
+ [Démarrage](nova-sagemaker-inference-getting-started.md)
+ [Référence d’API](nova-sagemaker-inference-api-reference.md)
+ [Évaluer les modèles hébergés sur SageMaker Inference](nova-eval-on-sagemaker-inference.md)
+ [Déploiement des modèles Amazon Nova Forge dans le cadre de la détection des abus SageMaker par Amazon Inference](nova-sagemaker-inference-abuse-detection.md)
# Démarrage
Ce guide explique comment déployer des modèles Amazon Nova personnalisés sur des points de terminaison SageMaker en temps réel, configurer les paramètres d'inférence et invoquer vos modèles à des fins de test.
## Conditions préalables
Les conditions requises pour déployer des modèles Amazon Nova par SageMaker inférence sont les suivantes :
+ Créer un Compte AWS - Si vous n'en avez pas déjà un, consultez la section [Création d'un AWS compte](https://docs.aws.amazon.com//sagemaker/latest/dg/gs-set-up.html#sign-up-for-aws).
+ Autorisations IAM requises : assurez-vous que les politiques gérées suivantes sont associées à votre utilisateur ou à votre rôle IAM :
+ `AmazonSageMakerFullAccess`
+ `AmazonS3FullAccess`
+ SDKs/CLI Versions requises : les versions du SDK suivantes ont été testées et validées par inférence avec les modèles Amazon SageMaker Nova :
+ SageMaker SDK Python v3.0.0\$1 (`sagemaker>=3.0.0`) pour une approche d'API basée sur les ressources
+ Boto3 version 1.35.0\$1 (`boto3>=1.35.0`) pour les appels d'API directs. Les exemples présentés dans ce guide utilisent cette approche.
+ Augmentation du quota de service : demandez une augmentation du quota de SageMaker service Amazon pour le type d'instance ML que vous prévoyez d'utiliser pour votre point de terminaison d' SageMaker inférence (par exemple,`ml.p5.48xlarge for endpoint usage`). Pour obtenir la liste des types d’instances, consultez [Modèles et instances pris en charge](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported). Pour demander une augmentation, consultez la section [Demande d'augmentation de quota](https://docs.aws.amazon.com//servicequotas/latest/userguide/request-quota-increase.html). Pour plus d'informations sur les quotas d' SageMaker instance, consultez la section [SageMaker Points de terminaison et quotas](https://docs.aws.amazon.com//general/latest/gr/sagemaker.html).
## Étape 1 : Configuration des AWS informations d'identification
Configurez vos AWS informations d'identification à l'aide de l'une des méthodes suivantes :
**Option 1 : AWS CLI (recommandée)**
```
aws configure
```
Entrez votre clé AWS d'accès, votre clé secrète et votre région par défaut lorsque vous y êtes invité.
**Option 2 : fichier AWS d'informations d'identification**
Créez ou modifiez `~/.aws/credentials` :
```
[default]
aws_access_key_id = YOUR_ACCESS_KEY
aws_secret_access_key = YOUR_SECRET_KEY
```
**Option 3 : variables d'environnement**
```
export AWS_ACCESS_KEY_ID=your_access_key
export AWS_SECRET_ACCESS_KEY=your_secret_key
```
**Note**
Pour plus d'informations sur les informations AWS d'identification, consultez [Configuration et paramètres du fichier d'informations d'identification](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-files.html).
**Initialiser les clients AWS **
Créez un script ou un bloc-notes Python avec le code suivant pour initialiser le AWS SDK et vérifier vos informations d'identification :
```
import boto3
# AWS Configuration - Update these for your environment
REGION = "us-east-1" # Supported regions: us-east-1, us-west-2
AWS_ACCOUNT_ID = "YOUR_ACCOUNT_ID" # Replace with your AWS account ID
# Initialize AWS clients using default credential chain
sagemaker = boto3.client('sagemaker', region_name=REGION)
sts = boto3.client('sts')
# Verify credentials
try:
identity = sts.get_caller_identity()
print(f"Successfully authenticated to AWS Account: {identity['Account']}")
if identity['Account'] != AWS_ACCOUNT_ID:
print(f"Warning: Connected to account {identity['Account']}, expected {AWS_ACCOUNT_ID}")
except Exception as e:
print(f"Failed to authenticate: {e}")
print("Please verify your credentials are configured correctly.")
```
Si l'authentification est réussie, vous devriez voir un message confirmant l'identifiant de votre AWS compte.
## Étape 2 : Création d'un rôle SageMaker d'exécution
Un rôle SageMaker d'exécution est un rôle IAM qui accorde des SageMaker autorisations pour accéder aux AWS ressources en votre nom, telles que les compartiments Amazon S3 pour les artefacts du modèle et CloudWatch pour la journalisation.
**Création du rôle d'exécution**
**Note**
La création de rôles IAM nécessite `iam:CreateRole` et `iam:AttachRolePolicy` autorisations. Assurez-vous que votre utilisateur ou rôle IAM dispose de ces autorisations avant de continuer.
Le code suivant crée un rôle IAM doté des autorisations nécessaires pour déployer des modèles personnalisés Amazon Nova :
```
import json
# Create SageMaker Execution Role
role_name = f"SageMakerInference-ExecutionRole-{AWS_ACCOUNT_ID}"
trust_policy = {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "sagemaker.amazonaws.com"},
"Action": "sts:AssumeRole"
}
]
}
iam = boto3.client('iam', region_name=REGION)
# Create the role
role_response = iam.create_role(
RoleName=role_name,
AssumeRolePolicyDocument=json.dumps(trust_policy),
Description='SageMaker execution role with S3 and SageMaker access'
)
# Attach required policies
iam.attach_role_policy(
RoleName=role_name,
PolicyArn='arn:aws:iam::aws:policy/AmazonSageMakerFullAccess'
)
iam.attach_role_policy(
RoleName=role_name,
PolicyArn='arn:aws:iam::aws:policy/AmazonS3FullAccess'
)
SAGEMAKER_EXECUTION_ROLE_ARN = role_response['Role']['Arn']
print(f"Created SageMaker execution role: {SAGEMAKER_EXECUTION_ROLE_ARN}")
```
**Utilisation d'un rôle d'exécution existant (facultatif)**
Si vous avez déjà un rôle SageMaker d'exécution, vous pouvez l'utiliser à la place :
```
# Replace with your existing role ARN
SAGEMAKER_EXECUTION_ROLE_ARN = "arn:aws:iam::YOUR_ACCOUNT_ID:role/YOUR_EXISTING_ROLE_NAME"
```
Pour rechercher des SageMaker rôles existants dans votre compte, procédez comme suit :
```
iam = boto3.client('iam', region_name=REGION)
response = iam.list_roles()
sagemaker_roles = [role for role in response['Roles'] if 'SageMaker' in role['RoleName']]
for role in sagemaker_roles:
print(f"{role['RoleName']}: {role['Arn']}")
```
**Important**
Le rôle d'exécution doit avoir une relation de confiance `sagemaker.amazonaws.com` et être autorisé à accéder à Amazon S3 et à SageMaker ses ressources.
Pour plus d'informations sur les rôles SageMaker d'exécution, consultez la section [SageMaker Rôles](https://docs.aws.amazon.com//sagemaker/latest/dg/sagemaker-roles.html).
## Étape 3 : Configuration des paramètres du modèle
Configurez les paramètres de déploiement pour votre modèle Amazon Nova. Ces paramètres contrôlent le comportement du modèle, l'allocation des ressources et les caractéristiques d'inférence. Pour obtenir une liste des types d'instances pris en charge et des valeurs CONTEXT\$1LENGTH et MAX\$1CONCURRENCY prises en charge pour chacun, consultez. [Modèles et instances pris en charge](nova-model-sagemaker-inference.md#nova-sagemaker-inference-supported)
**Paramètres requis**
+ `IMAGE`: URI de l'image du conteneur Docker pour le conteneur d'inférence Amazon Nova. Cela sera fourni par AWS.
+ `CONTEXT_LENGTH`: longueur du contexte du modèle.
+ `MAX_CONCURRENCY`: nombre maximum de séquences par itération ; définit la limite du nombre de demandes utilisateur individuelles (invites) pouvant être traitées simultanément au sein d'un même lot sur le GPU. Plage : entier supérieur à 0.
**Paramètres de génération facultatifs**
+ `DEFAULT_TEMPERATURE`: Contrôle le caractère aléatoire de la génération. Plage : 0,0 à 2,0 (0,0 = déterministe, plus élevé = plus aléatoire).
+ `DEFAULT_TOP_P`: seuil d'échantillonnage du noyau pour la sélection des jetons. Plage : 1e-10 à 1,0.
+ `DEFAULT_TOP_K`: Limite la sélection de jetons aux K jetons les plus probables. Plage : entier égal ou supérieur à -1 (-1 = aucune limite).
+ `DEFAULT_MAX_NEW_TOKENS`: Nombre maximum de jetons à générer en réponse (c'est-à-dire nombre maximum de jetons de sortie). Plage : entier égal ou supérieur à 1.
+ `DEFAULT_LOGPROBS`: nombre de probabilités de log à renvoyer par jeton. Plage : nombre entier de 1 à 20.
**Configurez votre déploiement**
```
# AWS Configuration
REGION = "us-east-1" # Must match region from Step 1
# ECR Account mapping by region
ECR_ACCOUNT_MAP = {
"us-east-1": "708977205387",
"us-west-2": "176779409107"
}
# Container Image
IMAGE = f"{ECR_ACCOUNT_MAP[REGION]}.dkr.ecr.{REGION}.amazonaws.com/nova-inference-repo:SM-Inference-latest"
print(f"IMAGE = {IMAGE}")
# Model Parameters
CONTEXT_LENGTH = "16000" # Maximum total context length
MAX_CONCURRENCY = "2" # Maximum concurrent sequences
# Optional: Default generation parameters (uncomment to use)
DEFAULT_TEMPERATURE = "0.0" # Deterministic output
DEFAULT_TOP_P = "1.0" # Consider all tokens
# DEFAULT_TOP_K = "50" # Uncomment to limit to top 50 tokens
# DEFAULT_MAX_NEW_TOKENS = "2048" # Uncomment to set max output tokens
# DEFAULT_LOGPROBS = "1" # Uncomment to enable log probabilities
# Build environment variables for the container
environment = {
'CONTEXT_LENGTH': CONTEXT_LENGTH,
'MAX_CONCURRENCY': MAX_CONCURRENCY,
}
# Add optional parameters if defined
if 'DEFAULT_TEMPERATURE' in globals():
environment['DEFAULT_TEMPERATURE'] = DEFAULT_TEMPERATURE
if 'DEFAULT_TOP_P' in globals():
environment['DEFAULT_TOP_P'] = DEFAULT_TOP_P
if 'DEFAULT_TOP_K' in globals():
environment['DEFAULT_TOP_K'] = DEFAULT_TOP_K
if 'DEFAULT_MAX_NEW_TOKENS' in globals():
environment['DEFAULT_MAX_NEW_TOKENS'] = DEFAULT_MAX_NEW_TOKENS
if 'DEFAULT_LOGPROBS' in globals():
environment['DEFAULT_LOGPROBS'] = DEFAULT_LOGPROBS
print("Environment configuration:")
for key, value in environment.items():
print(f" {key}: {value}")
```
**Configuration des paramètres spécifiques au déploiement**
Configurez maintenant les paramètres spécifiques pour le déploiement de votre modèle Amazon Nova, notamment l'emplacement des artefacts du modèle et la sélection du type d'instance.
**Définir l'identifiant de déploiement**
```
# Deployment identifier - use a descriptive name for your use case
JOB_NAME = "my-nova-deployment"
```
**Spécifier l'emplacement des artefacts du modèle**
Indiquez l'URI Amazon S3 où sont stockés vos artefacts de modèle Amazon Nova entraînés. Il doit s'agir de l'emplacement de sortie de votre tâche d'entraînement ou de mise au point de votre modèle.
```
# S3 location of your trained Nova model artifacts
# Replace with your model's S3 URI - must end with /
MODEL_S3_LOCATION = "s3://your-bucket-name/path/to/model/artifacts/"
```
**Sélectionnez la variante du modèle et le type d'instance**
```
# Configure model variant and instance type
TESTCASE = {
"model": "lite2", # Options: micro, lite, lite2
"instance": "ml.p5.48xlarge" # Refer to "Supported models and instances" section
}
# Generate resource names
INSTANCE_TYPE = TESTCASE["instance"]
MODEL_NAME = JOB_NAME + "-" + TESTCASE["model"] + "-" + INSTANCE_TYPE.replace(".", "-")
ENDPOINT_CONFIG_NAME = MODEL_NAME + "-Config"
ENDPOINT_NAME = MODEL_NAME + "-Endpoint"
print(f"Model Name: {MODEL_NAME}")
print(f"Endpoint Config: {ENDPOINT_CONFIG_NAME}")
print(f"Endpoint Name: {ENDPOINT_NAME}")
```
**Conventions de dénomination**
Le code génère automatiquement des noms cohérents pour les AWS ressources :
+ Nom du modèle : `{JOB_NAME}-{model}-{instance-type}`
+ Config du point de terminaison : `{MODEL_NAME}-Config`
+ Nom du point de terminaison : `{MODEL_NAME}-Endpoint`
## Étape 4 : Création de la configuration SageMaker du modèle et du point de terminaison
Au cours de cette étape, vous allez créer deux ressources essentielles : un objet de SageMaker modèle qui référence les artefacts de votre modèle Amazon Nova et une configuration de point de terminaison qui définit la manière dont le modèle sera déployé.
**SageMaker Modèle** : objet modèle qui regroupe l'image du conteneur d'inférence, l'emplacement des artefacts du modèle et la configuration de l'environnement. Il s'agit d'une ressource réutilisable qui peut être déployée sur plusieurs terminaux.
**Configuration du point de terminaison** : définit les paramètres d'infrastructure pour le déploiement, notamment le type d'instance, le nombre d'instances et les variantes de modèle. Cela vous permet de gérer les paramètres de déploiement séparément du modèle lui-même.
**Création du SageMaker modèle**
Le code suivant crée un SageMaker modèle qui fait référence aux artefacts de votre modèle Amazon Nova :
```
try:
model_response = sagemaker.create_model(
ModelName=MODEL_NAME,
PrimaryContainer={
'Image': IMAGE,
'ModelDataSource': {
'S3DataSource': {
'S3Uri': MODEL_S3_LOCATION,
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': environment
},
ExecutionRoleArn=SAGEMAKER_EXECUTION_ROLE_ARN,
EnableNetworkIsolation=True
)
print("Model created successfully!")
print(f"Model ARN: {model_response['ModelArn']}")
except sagemaker.exceptions.ClientError as e:
print(f"Error creating model: {e}")
```
Paramètres clés :
+ `ModelName`: identifiant unique pour votre modèle
+ `Image`: URI de l'image du conteneur Docker pour l'inférence Amazon Nova
+ `ModelDataSource`: emplacement des artefacts de votre modèle sur Amazon S3
+ `Environment`: variables d'environnement configurées à l'étape 3
+ `ExecutionRoleArn`: rôle IAM à partir de l'étape 2
+ `EnableNetworkIsolation`: défini sur True pour une sécurité renforcée (empêche le conteneur de passer des appels réseau sortants)
**Création de la configuration du point de terminaison**
Créez ensuite une configuration de point de terminaison qui définit votre infrastructure de déploiement :
```
# Create Endpoint Configuration
try:
production_variant = {
'VariantName': 'primary',
'ModelName': MODEL_NAME,
'InitialInstanceCount': 1,
'InstanceType': INSTANCE_TYPE,
}
config_response = sagemaker.create_endpoint_config(
EndpointConfigName=ENDPOINT_CONFIG_NAME,
ProductionVariants=[production_variant]
)
print("Endpoint configuration created successfully!")
print(f"Config ARN: {config_response['EndpointConfigArn']}")
except sagemaker.exceptions.ClientError as e:
print(f"Error creating endpoint configuration: {e}")
```
Paramètres clés :
+ `VariantName`: identifiant pour cette variante de modèle (utilisez « principal » pour les déploiements à modèle unique)
+ `ModelName`: fait référence au modèle créé ci-dessus
+ `InitialInstanceCount`: nombre d'instances à déployer (commencez par 1, puis augmentez ultérieurement si nécessaire)
+ `InstanceType`: type d'instance ML sélectionné à l'étape 3
**Vérifier la création de ressources**
Vous pouvez vérifier que vos ressources ont été créées avec succès :
```
# Describe the model
model_info = sagemaker.describe_model(ModelName=MODEL_NAME)
print(f"Model Status: {model_info['ModelName']} created")
# Describe the endpoint configuration
config_info = sagemaker.describe_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
print(f"Endpoint Config Status: {config_info['EndpointConfigName']} created")
```
## Étape 5 : Déployer le point de terminaison
L'étape suivante consiste à déployer votre modèle Amazon Nova en créant un point de terminaison SageMaker en temps réel. Ce point de terminaison hébergera votre modèle et fournira un point de terminaison HTTPS sécurisé pour effectuer des demandes d'inférence.
La création d'un point de terminaison prend généralement 15 à 30 minutes pour AWS provisionner l'infrastructure, télécharger les artefacts de votre modèle et initialiser le conteneur d'inférence.
**Créer le point de terminaison**
```
import time
try:
endpoint_response = sagemaker.create_endpoint(
EndpointName=ENDPOINT_NAME,
EndpointConfigName=ENDPOINT_CONFIG_NAME
)
print("Endpoint creation initiated successfully!")
print(f"Endpoint ARN: {endpoint_response['EndpointArn']}")
except Exception as e:
print(f"Error creating endpoint: {e}")
```
**Surveillez la création de terminaux**
Le code suivant interroge l'état du terminal jusqu'à ce que le déploiement soit terminé :
```
# Monitor endpoint creation progress
print("Waiting for endpoint creation to complete...")
print("This typically takes 15-30 minutes...\n")
while True:
try:
response = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
status = response['EndpointStatus']
if status == 'Creating':
print(f"⏳ Status: {status} - Provisioning infrastructure and loading model...")
elif status == 'InService':
print(f"✅ Status: {status}")
print("\nEndpoint creation completed successfully!")
print(f"Endpoint Name: {ENDPOINT_NAME}")
print(f"Endpoint ARN: {response['EndpointArn']}")
break
elif status == 'Failed':
print(f"❌ Status: {status}")
print(f"Failure Reason: {response.get('FailureReason', 'Unknown')}")
print("\nFull response:")
print(response)
break
else:
print(f"Status: {status}")
except Exception as e:
print(f"Error checking endpoint status: {e}")
break
time.sleep(30) # Check every 30 seconds
```
**Vérifiez que le terminal est prêt**
Une fois que le point de terminaison est en place InService, vous pouvez vérifier sa configuration :
```
# Get detailed endpoint information
endpoint_info = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
print("\n=== Endpoint Details ===")
print(f"Endpoint Name: {endpoint_info['EndpointName']}")
print(f"Endpoint ARN: {endpoint_info['EndpointArn']}")
print(f"Status: {endpoint_info['EndpointStatus']}")
print(f"Creation Time: {endpoint_info['CreationTime']}")
print(f"Last Modified: {endpoint_info['LastModifiedTime']}")
# Get endpoint config for instance type details
endpoint_config_name = endpoint_info['EndpointConfigName']
endpoint_config = sagemaker.describe_endpoint_config(EndpointConfigName=endpoint_config_name)
# Display production variant details
for variant in endpoint_info['ProductionVariants']:
print(f"\nProduction Variant: {variant['VariantName']}")
print(f" Current Instance Count: {variant['CurrentInstanceCount']}")
print(f" Desired Instance Count: {variant['DesiredInstanceCount']}")
# Get instance type from endpoint config
for config_variant in endpoint_config['ProductionVariants']:
if config_variant['VariantName'] == variant['VariantName']:
print(f" Instance Type: {config_variant['InstanceType']}")
break
```
**Résolution des problèmes liés à la création de terminaux**
Raisons de défaillance courantes :
+ **Capacité insuffisante** : le type d'instance demandé n'est pas disponible dans votre région
+ Solution : essayez un autre type d'instance ou demandez une augmentation de quota
+ **Autorisations IAM** : le rôle d'exécution ne dispose pas des autorisations nécessaires
+ Solution : vérifier que le rôle a accès aux artefacts du modèle Amazon S3 et aux SageMaker autorisations nécessaires
+ **Artefacts du modèle introuvables** : l'URI Amazon S3 est incorrecte ou inaccessible
+ Solution : vérifiez l'URI Amazon S3 et les autorisations du bucket, assurez-vous que vous vous trouvez dans la bonne région
+ Limites de **ressources : limites** de compte dépassées pour les points de terminaison ou les instances
+ Solution : demander une augmentation du quota de service via Service Quotas ou AWS Support
**Note**
Si vous devez supprimer un point de terminaison défaillant et recommencer à zéro :
```
sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME)
```
## Étape 6 : Invoquer le point de terminaison
Une fois que votre point de terminaison est en place InService, vous pouvez envoyer des demandes d'inférence pour générer des prédictions à partir de votre modèle Amazon Nova. SageMaker prend en charge les points de terminaison synchrones (en temps réel avec modes de streaming/non streaming) et les points de terminaison asynchrones (basés sur Amazon S3 pour le traitement par lots).
**Configuration du client d'exécution**
Créez un client SageMaker Runtime avec les paramètres de délai d'expiration appropriés :
```
import json
import boto3
import botocore
from botocore.exceptions import ClientError
# Configure client with appropriate timeouts
config = botocore.config.Config(
read_timeout=120, # Maximum time to wait for response
connect_timeout=10, # Maximum time to establish connection
retries={'max_attempts': 3} # Number of retry attempts
)
# Create SageMaker Runtime client
runtime_client = boto3.client('sagemaker-runtime', config=config, region_name=REGION)
```
**Création d'une fonction d'inférence universelle**
La fonction suivante gère à la fois les demandes de diffusion en continu et les demandes non liées au streaming :
```
def invoke_nova_endpoint(request_body):
"""
Invoke Nova endpoint with automatic streaming detection.
Args:
request_body (dict): Request payload containing prompt and parameters
Returns:
dict: Response from the model (for non-streaming requests)
None: For streaming requests (prints output directly)
"""
body = json.dumps(request_body)
is_streaming = request_body.get("stream", False)
try:
print(f"Invoking endpoint ({'streaming' if is_streaming else 'non-streaming'})...")
if is_streaming:
response = runtime_client.invoke_endpoint_with_response_stream(
EndpointName=ENDPOINT_NAME,
ContentType='application/json',
Body=body
)
event_stream = response['Body']
for event in event_stream:
if 'PayloadPart' in event:
chunk = event['PayloadPart']
if 'Bytes' in chunk:
data = chunk['Bytes'].decode()
print("Chunk:", data)
else:
# Non-streaming inference
response = runtime_client.invoke_endpoint(
EndpointName=ENDPOINT_NAME,
ContentType='application/json',
Accept='application/json',
Body=body
)
response_body = response['Body'].read().decode('utf-8')
result = json.loads(response_body)
print("✅ Response received successfully")
return result
except ClientError as e:
error_code = e.response['Error']['Code']
error_message = e.response['Error']['Message']
print(f"❌ AWS Error: {error_code} - {error_message}")
except Exception as e:
print(f"❌ Unexpected error: {str(e)}")
```
**Exemple 1 : fin d'un chat sans diffusion en continu**
Utilisez le format de chat pour les interactions conversationnelles :
```
# Non-streaming chat request
chat_request = {
"messages": [
{"role": "user", "content": "Hello! How are you?"}
],
"max_tokens": 100,
"max_completion_tokens": 100, # Alternative to max_tokens
"stream": False,
"temperature": 0.7,
"top_p": 0.9,
"top_k": 50,
"logprobs": True,
"top_logprobs": 3,
"reasoning_effort": "low", # Options: "low", "high"
"allowed_token_ids": None, # List of allowed token IDs
"truncate_prompt_tokens": None, # Truncate prompt to this many tokens
"stream_options": None
}
response = invoke_nova_endpoint(chat_request)
```
**Exemple de réponse**:
```
{
"id": "chatcmpl-123456",
"object": "chat.completion",
"created": 1234567890,
"model": "default",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "Hello! I'm doing well, thank you for asking. I'm here and ready to help you with any questions or tasks you might have. How can I assist you today?"
},
"logprobs": {
"content": [
{
"token": "Hello",
"logprob": -0.123,
"top_logprobs": [
{"token": "Hello", "logprob": -0.123},
{"token": "Hi", "logprob": -2.456},
{"token": "Hey", "logprob": -3.789}
]
}
# Additional tokens...
]
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 12,
"completion_tokens": 28,
"total_tokens": 40
}
}
```
**Exemple 2 : complétion de texte simple**
Utilisez le format de complétion pour une génération de texte simple :
```
# Simple completion request
completion_request = {
"prompt": "The capital of France is",
"max_tokens": 50,
"stream": False,
"temperature": 0.0,
"top_p": 1.0,
"top_k": -1, # -1 means no limit
"logprobs": 3, # Number of log probabilities to return
"allowed_token_ids": None, # List of allowed token IDs
"truncate_prompt_tokens": None, # Truncate prompt to this many tokens
"stream_options": None
}
response = invoke_nova_endpoint(completion_request)
```
**Exemple de réponse**:
```
{
"id": "cmpl-789012",
"object": "text_completion",
"created": 1234567890,
"model": "default",
"choices": [
{
"text": " Paris.",
"index": 0,
"logprobs": {
"tokens": [" Paris", "."],
"token_logprobs": [-0.001, -0.002],
"top_logprobs": [
{" Paris": -0.001, " London": -5.234, " Rome": -6.789},
{".": -0.002, ",": -4.567, "!": -7.890}
]
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 6,
"completion_tokens": 2,
"total_tokens": 8
}
}
```
**Exemple 3 : fin du chat en streaming**
```
# Streaming chat request
streaming_request = {
"messages": [
{"role": "user", "content": "Tell me a short story about a robot"}
],
"max_tokens": 200,
"stream": True,
"temperature": 0.7,
"top_p": 0.95,
"top_k": 40,
"logprobs": True,
"top_logprobs": 2,
"reasoning_effort": "high", # For more detailed reasoning
"stream_options": {"include_usage": True}
}
invoke_nova_endpoint(streaming_request)
```
**Exemple de sortie de streaming :**
```
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"role":"assistant","content":"","reasoning_content":null},"logprobs":null,"finish_reason":null}],"prompt_token_ids":null}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" Once","reasoning_content":null},"logprobs":{"content":[{"token":"\u2581Once","logprob":-0.6078429222106934,"bytes":[226,150,129,79,110,99,101],"top_logprobs":[{"token":"\u2581Once","logprob":-0.6078429222106934,"bytes":[226,150,129,79,110,99,101]},{"token":"\u2581In","logprob":-0.7864127159118652,"bytes":[226,150,129,73,110]}]}]},"finish_reason":null,"token_ids":null}]}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" upon","reasoning_content":null},"logprobs":{"content":[{"token":"\u2581upon","logprob":-0.0012345,"bytes":[226,150,129,117,112,111,110],"top_logprobs":[{"token":"\u2581upon","logprob":-0.0012345,"bytes":[226,150,129,117,112,111,110]},{"token":"\u2581a","logprob":-6.789,"bytes":[226,150,129,97]}]}]},"finish_reason":null,"token_ids":null}]}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" a","reasoning_content":null},"logprobs":{"content":[{"token":"\u2581a","logprob":-0.0001234,"bytes":[226,150,129,97],"top_logprobs":[{"token":"\u2581a","logprob":-0.0001234,"bytes":[226,150,129,97]},{"token":"\u2581time","logprob":-9.123,"bytes":[226,150,129,116,105,109,101]}]}]},"finish_reason":null,"token_ids":null}]}
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{"content":" time","reasoning_content":null},"logprobs":{"content":[{"token":"\u2581time","logprob":-0.0023456,"bytes":[226,150,129,116,105,109,101],"top_logprobs":[{"token":"\u2581time","logprob":-0.0023456,"bytes":[226,150,129,116,105,109,101]},{"token":",","logprob":-6.012,"bytes":[44]}]}]},"finish_reason":null,"token_ids":null}]}
# Additional chunks...
Chunk: data: {"id":"chatcmpl-029ca032-fa01-4868-80b7-c4cb1af90fb9","object":"chat.completion.chunk","created":1772060532,"model":"default","choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}],"usage":{"prompt_tokens":15,"completion_tokens":87,"total_tokens":102}}
Chunk: data: [DONE]
```
**Exemple 4 : achèvement d'une conversation multimodale**
Utilisez le format multimodal pour les entrées d'image et de texte :
```
# Multimodal chat request (if supported by your model)
multimodal_request = {
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": "What's in this image?"},
{"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}}
]
}
],
"max_tokens": 150,
"temperature": 0.3,
"top_p": 0.8,
"stream": False
}
response = invoke_nova_endpoint(multimodal_request)
```
**Exemple de réponse**:
```
{
"id": "chatcmpl-345678",
"object": "chat.completion",
"created": 1234567890,
"model": "default",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "The image shows..."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 1250,
"completion_tokens": 45,
"total_tokens": 1295
}
}
```
## Étape 7 : Nettoyer les ressources (facultatif)
Pour éviter d'encourir des frais inutiles, supprimez les AWS ressources que vous avez créées au cours de ce didacticiel. SageMaker les terminaux sont soumis à des frais pendant leur fonctionnement, même si vous ne faites pas activement de demandes d'inférence.
**Important**
La suppression de ressources est permanente et ne peut pas être annulée. Assurez-vous de ne plus avoir besoin de ces ressources avant de continuer.
**Supprimer le point de terminaison**
```
import boto3
# Initialize SageMaker client
sagemaker = boto3.client('sagemaker', region_name=REGION)
try:
print("Deleting endpoint...")
sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME)
print(f"✅ Endpoint '{ENDPOINT_NAME}' deletion initiated")
print("Charges will stop once deletion completes (typically 2-5 minutes)")
except Exception as e:
print(f"❌ Error deleting endpoint: {e}")
```
**Note**
La suppression du point de terminaison est asynchrone. Vous pouvez contrôler l'état de suppression :
```
import time
print("Monitoring endpoint deletion...")
while True:
try:
response = sagemaker.describe_endpoint(EndpointName=ENDPOINT_NAME)
status = response['EndpointStatus']
print(f"Status: {status}")
time.sleep(10)
except sagemaker.exceptions.ClientError as e:
if e.response['Error']['Code'] == 'ValidationException':
print("✅ Endpoint successfully deleted")
break
else:
print(f"Error: {e}")
break
```
**Supprimer la configuration du point de terminaison**
Une fois le point de terminaison supprimé, supprimez la configuration du point de terminaison :
```
try:
print("Deleting endpoint configuration...")
sagemaker.delete_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
print(f"✅ Endpoint configuration '{ENDPOINT_CONFIG_NAME}' deleted")
except Exception as e:
print(f"❌ Error deleting endpoint configuration: {e}")
```
**Supprimer le modèle**
Supprimez l'objet SageMaker modèle :
```
try:
print("Deleting model...")
sagemaker.delete_model(ModelName=MODEL_NAME)
print(f"✅ Model '{MODEL_NAME}' deleted")
except Exception as e:
print(f"❌ Error deleting model: {e}")
```
# Référence d’API
Les modèles Amazon Nova SageMaker utilisent l'API SageMaker Runtime standard à des fins d'inférence. Pour consulter la documentation complète de l'API, voir [Tester un modèle déployé](https://docs.aws.amazon.com//sagemaker/latest/dg/realtime-endpoints-test-endpoints.html).
## Invocation du terminal
Les modèles Amazon Nova SageMaker prennent en charge deux méthodes d'invocation :
+ **Invocation synchrone** : utilisez l'[InvokeEndpoint](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)API pour les demandes d'inférence en temps réel, sans diffusion en continu.
+ **Invocation en streaming** : utilisez l'[InvokeEndpointWithResponseStream](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithResponseStream.html)API pour les demandes d'inférence en streaming en temps réel.
## Format des demandes
Les modèles Amazon Nova prennent en charge deux formats de demande :
**Format d'achèvement du chat**
Utilisez ce format pour les interactions conversationnelles :
```
{
"messages": [
{"role": "user", "content": "string"}
],
"max_tokens": integer,
"max_completion_tokens": integer,
"stream": boolean,
"temperature": float,
"top_p": float,
"top_k": integer,
"logprobs": boolean,
"top_logprobs": integer,
"reasoning_effort": "low" | "high",
"allowed_token_ids": [integer],
"truncate_prompt_tokens": integer,
"stream_options": {
"include_usage": boolean
}
}
```
**Format de complétion du texte**
Utilisez ce format pour générer du texte en toute simplicité :
```
{
"prompt": "string",
"max_tokens": integer,
"stream": boolean,
"temperature": float,
"top_p": float,
"top_k": integer,
"logprobs": integer,
"allowed_token_ids": [integer],
"truncate_prompt_tokens": integer,
"stream_options": {
"include_usage": boolean
}
}
```
**Format de complétion de chat multimodal**
Utilisez ce format pour les saisies d'images et de texte :
```
{
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": "What's in this image?"},
{"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}}
]
}
],
"max_tokens": integer,
"temperature": float,
"top_p": float,
"stream": boolean
}
```
**Paramètres de requête**
+ `messages`(array) : Pour le format de fin du chat. Tableau d'objets de message avec `role` et `content` champs. Le contenu peut être une chaîne pour le texte uniquement ou un tableau pour les entrées multimodales.
+ `prompt`(chaîne) : Pour le format de complétion du texte. Le texte d'entrée à partir duquel générer.
+ `max_tokens`(entier) : nombre maximum de jetons à générer dans la réponse. Plage : 1 ou plus.
+ `max_completion_tokens`(entier) : alternative à max\$1tokens pour terminer le chat. Nombre maximum de jetons de complétion à générer.
+ `temperature`(float) : contrôle le caractère aléatoire de la génération. Plage : 0,0 à 2,0 (0,0 = déterministe, 2,0 = caractère aléatoire maximal).
+ `top_p`(float) : seuil d'échantillonnage du noyau. Plage : 1e-10 à 1,0.
+ `top_k`(entier) : limite la sélection des jetons aux K jetons les plus probables. Plage : -1 ou plus (-1 = aucune limite).
+ `stream`(booléen) : s'il faut diffuser la réponse. Réglez sur `true` pour le streaming, `false` pour le non-streaming.
+ `logprobs`(booléen/entier) : pour terminer le chat, utilisez le booléen. Pour les complétions de texte, utilisez un entier pour le nombre de probabilités logarithmiques à renvoyer. Gamme : 1 à 20.
+ `top_logprobs`(entier) : nombre de jetons les plus susceptibles de renvoyer des probabilités de journalisation (discussions terminées uniquement).
+ `reasoning_effort`(string) : niveau d'effort de raisonnement. Options : « faible », « élevé » (achèvement du chat pour les modèles personnalisés de Nova 2 Lite uniquement).
+ `allowed_token_ids`(array) : liste des jetons IDs dont la génération est autorisée. Limite la sortie aux jetons spécifiés.
+ `truncate_prompt_tokens`(entier) : tronquez l'invite à ce nombre de jetons s'il dépasse la limite.
+ `stream_options`(objet) : options pour le streaming des réponses. Contient un `include_usage` booléen pour inclure l'utilisation des jetons dans les réponses de streaming.
## Format de la réponse
Le format de réponse dépend de la méthode d'appel et du type de demande :
**Réponse à la fin du chat (hors diffusion)**
Pour les demandes de fin de chat synchrone :
```
{
"id": "chatcmpl-123e4567-e89b-12d3-a456-426614174000",
"object": "chat.completion",
"created": 1677652288,
"model": "nova-micro-custom",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "Hello! I'm doing well, thank you for asking. How can I help you today?",
"refusal": null,
"reasoning": null,
"reasoning_content": null
},
"logprobs": {
"content": [
{
"token": "Hello",
"logprob": -0.31725305,
"bytes": [72, 101, 108, 108, 111],
"top_logprobs": [
{
"token": "Hello",
"logprob": -0.31725305,
"bytes": [72, 101, 108, 108, 111]
},
{
"token": "Hi",
"logprob": -1.3190403,
"bytes": [72, 105]
}
]
}
]
},
"finish_reason": "stop",
"stop_reason": null,
"token_ids": [9906, 0, 358, 2157, 1049, 11, 1309, 345, 369, 6464, 13]
}
],
"usage": {
"prompt_tokens": 9,
"completion_tokens": 12,
"total_tokens": 21,
"prompt_tokens_details": {
"cached_tokens": 0
}
},
"prompt_token_ids": [9906, 0, 358]
}
```
**Réponse de fin de texte (hors diffusion en continu)**
Pour les demandes de saisie synchrone de texte :
```
{
"id": "cmpl-123e4567-e89b-12d3-a456-426614174000",
"object": "text_completion",
"created": 1677652288,
"model": "nova-micro-custom",
"choices": [
{
"index": 0,
"text": "Paris, the capital and most populous city of France.",
"logprobs": {
"tokens": ["Paris", ",", " the", " capital"],
"token_logprobs": [-0.31725305, -0.07918124, -0.12345678, -0.23456789],
"top_logprobs": [
{
"Paris": -0.31725305,
"London": -1.3190403,
"Rome": -2.1234567
},
{
",": -0.07918124,
" is": -1.2345678
}
]
},
"finish_reason": "stop",
"stop_reason": null,
"prompt_token_ids": [464, 6864, 315, 4881, 374],
"token_ids": [3915, 11, 279, 6864, 323, 1455, 95551, 3363, 315, 4881, 13]
}
],
"usage": {
"prompt_tokens": 5,
"completion_tokens": 11,
"total_tokens": 16,
"prompt_tokens_details": {
"cached_tokens": 0
}
}
}
```
**Réponse en streaming à la fin du chat**
Pour les demandes de fin de chat en streaming, les réponses sont envoyées sous forme d'événements envoyés par le serveur (SSE) :
```
data: {
"id": "chatcmpl-123e4567-e89b-12d3-a456-426614174000",
"object": "chat.completion.chunk",
"created": 1677652288,
"model": "nova-micro-custom",
"choices": [
{
"index": 0,
"delta": {
"role": "assistant",
"content": "Hello",
"refusal": null,
"reasoning": null,
"reasoning_content": null
},
"logprobs": {
"content": [
{
"token": "Hello",
"logprob": -0.31725305,
"bytes": [72, 101, 108, 108, 111],
"top_logprobs": [
{
"token": "Hello",
"logprob": -0.31725305,
"bytes": [72, 101, 108, 108, 111]
}
]
}
]
},
"finish_reason": null,
"stop_reason": null
}
],
"usage": null,
"prompt_token_ids": null
}
data: {
"id": "chatcmpl-123e4567-e89b-12d3-a456-426614174000",
"object": "chat.completion.chunk",
"created": 1677652288,
"model": "nova-micro-custom",
"choices": [
{
"index": 0,
"delta": {
"content": "! I'm"
},
"logprobs": null,
"finish_reason": null,
"stop_reason": null
}
],
"usage": null
}
data: {
"id": "chatcmpl-123e4567-e89b-12d3-a456-426614174000",
"object": "chat.completion.chunk",
"created": 1677652288,
"model": "nova-micro-custom",
"choices": [
{
"index": 0,
"delta": {},
"finish_reason": "stop",
"stop_reason": null
}
],
"usage": {
"prompt_tokens": 9,
"completion_tokens": 12,
"total_tokens": 21,
"prompt_tokens_details": {
"cached_tokens": 0
}
}
}
data: [DONE]
```
**Réponse en streaming à la fin du texte**
Pour les demandes de complétion de texte en streaming :
```
data: {
"id": "cmpl-123e4567-e89b-12d3-a456-426614174000",
"object": "text_completion",
"created": 1677652288,
"model": "nova-micro-custom",
"choices": [
{
"index": 0,
"text": "Paris",
"logprobs": {
"tokens": ["Paris"],
"token_logprobs": [-0.31725305],
"top_logprobs": [
{
"Paris": -0.31725305,
"London": -1.3190403
}
]
},
"finish_reason": null,
"stop_reason": null
}
],
"usage": null
}
data: {
"id": "cmpl-123e4567-e89b-12d3-a456-426614174000",
"object": "text_completion",
"created": 1677652288,
"model": "nova-micro-custom",
"choices": [
{
"index": 0,
"text": ", the capital",
"logprobs": null,
"finish_reason": null,
"stop_reason": null
}
],
"usage": null
}
data: {
"id": "cmpl-123e4567-e89b-12d3-a456-426614174000",
"object": "text_completion",
"created": 1677652288,
"model": "nova-micro-custom",
"choices": [
{
"index": 0,
"text": "",
"finish_reason": "stop",
"stop_reason": null
}
],
"usage": {
"prompt_tokens": 5,
"completion_tokens": 11,
"total_tokens": 16
}
}
data: [DONE]
```
**Explication des champs de réponse**
+ `id`: identifiant unique pour la réalisation
+ `object`: Type d'objet renvoyé (« chat.completion », « text\$1completion », « chat.completion.chunk »)
+ `created`: horodatage Unix indiquant le moment où la complétion a été créée
+ `model`: Modèle utilisé pour la réalisation
+ `choices`: éventail de choix de complétion
+ `usage`: informations sur l'utilisation des jetons, y compris l'invite, l'achèvement et le nombre total de jetons
+ `logprobs`: enregistrez les informations de probabilité pour les jetons (sur demande)
+ `finish_reason`: Raison pour laquelle le modèle a cessé de générer (« stop », « length », « content\$1filter »)
+ `delta`: contenu incrémental dans les réponses au streaming
+ `reasoning`: contenu de raisonnement lorsque reasoning\$1effort est utilisé
+ `token_ids`: tableau de jetons IDs pour le texte généré
Pour une documentation complète sur les API, consultez les [InvokeEndpoint sections Référence](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) d'[InvokeEndpointWithResponseStream API et Référence d'API](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithResponseStream.html).
# Évaluer les modèles hébergés sur SageMaker Inference
Ce guide explique comment évaluer vos modèles Amazon Nova personnalisés déployés sur des points de terminaison d' SageMaker inférence à l'aide d'[Inspect AI](https://github.com/UKGovernmentBEIS/inspect_ai), un framework d'évaluation open source.
**Note**
Pour une présentation pratique, consultez le bloc-notes de [démarrage rapide SageMaker Inspect AI](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/sagemaker-inference/sagemaker_inspect_quickstart.ipynb).
## Présentation de
Vous pouvez évaluer vos modèles Amazon Nova personnalisés déployés sur des SageMaker terminaux à l'aide de benchmarks standardisés élaborés par la communauté des chercheurs en intelligence artificielle. Cette approche vous permet de :
+ Évaluez des modèles Amazon Nova personnalisés (affinés, distillés ou autrement adaptés) à grande échelle
+ Exécutez des évaluations par inférence parallèle sur plusieurs instances de point de terminaison
+ Comparez les performances des modèles à l'aide de benchmarks tels que MMLU, TruthfulQA et HumanEval
+ Intégrez à votre SageMaker infrastructure existante
## Modèles pris en charge
Le fournisseur SageMaker d'inférence travaille avec :
+ Modèles Amazon Nova (Nova Micro, Nova Lite, Nova Lite 2)
+ Modèles déployés via des serveurs d'inférence compatibles vLLM ou OpenAI
+ Tout point de terminaison compatible avec le format d'API OpenAI Chat Completions
## Conditions préalables
Avant de commencer, assurez-vous de disposer des éléments suivants :
+ Et Compte AWS avec les autorisations nécessaires pour créer et invoquer des points de SageMaker terminaison
+ AWS informations d'identification AWS CLI configurées via des variables d'environnement ou un rôle IAM
+ Python 3.9 ou supérieur
**Autorisations IAM requises**
Votre utilisateur ou rôle IAM a besoin des autorisations suivantes :
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:InvokeEndpoint",
"sagemaker:DescribeEndpoint"
],
"Resource": "arn:aws:sagemaker:*:*:endpoint/*"
}
]
}
```
## Étape 1 : Déployer un SageMaker point de terminaison
Avant d'exécuter des évaluations, vous avez besoin d'un point de terminaison d' SageMaker inférence exécutant votre modèle.
Pour obtenir des instructions sur la création d'un point de terminaison d' SageMaker inférence avec les modèles Amazon Nova, consultez[Démarrage](nova-sagemaker-inference-getting-started.md).
Une fois que votre terminal est en `InService` état, notez le nom du point de terminaison à utiliser dans les commandes d'évaluation.
## Étape 2 : Installation des dépendances d'évaluation
Créez un environnement virtuel Python et installez les packages requis.
```
# Create virtual environment
python3.12 -m venv venv
source venv/bin/activate
# Install uv for faster package installation
pip install uv
# Install Inspect AI and evaluation benchmarks
uv pip install inspect-ai inspect-evals
# Install AWS dependencies
uv pip install aioboto3 boto3 botocore openai
```
## Étape 3 : Configuration des AWS informations d'identification
Choisissez l'une des méthodes d'authentification suivantes :
**Option 1 : AWS CLI (recommandée)**
```
aws configure
```
Entrez votre ID de clé AWS d'accès, votre clé d'accès secrète et votre région par défaut lorsque vous y êtes invité.
**Option 2 : variables d'environnement**
```
export AWS_ACCESS_KEY_ID=your_access_key
export AWS_SECRET_ACCESS_KEY=your_secret_key
export AWS_DEFAULT_REGION=us-west-2
```
**Option 3 : rôle IAM**
Si l'instance est exécutée sur Amazon EC2 ou sur SageMaker des ordinateurs portables, le rôle IAM de l'instance est automatiquement utilisé.
**Vérifier les informations d'identification**
```
import boto3
sts = boto3.client('sts')
identity = sts.get_caller_identity()
print(f"Account: {identity['Account']}")
print(f"User/Role: {identity['Arn']}")
```
## Étape 4 : Installation du SageMaker fournisseur
Le SageMaker fournisseur permet à Inspect AI de communiquer avec vos SageMaker terminaux. Le processus d'installation du fournisseur est rationalisé dans le [bloc-notes de démarrage rapide](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/sagemaker-inference/sagemaker_inspect_quickstart.ipynb).
## Étape 5 : Téléchargez les benchmarks d'évaluation
Clonez le référentiel Inspect Evals pour accéder aux benchmarks standard :
```
git clone https://github.com/UKGovernmentBEIS/inspect_evals.git
```
Ce référentiel inclut des benchmarks tels que :
+ MMLU et MMLU-Pro (connaissances et raisonnement)
+ TruthfulQA (véracité)
+ HumanEval (génération de code)
+ GSM8K (raisonnement mathématique)
## Étape 6 : Exécuter les évaluations
Exécutez une évaluation à l'aide de votre SageMaker point de terminaison :
```
cd inspect_evals/src/inspect_evals/
inspect eval mmlu_pro/mmlu_pro.py \
--model sagemaker/my-nova-endpoint \
-M region_name=us-west-2 \
--max-connections 256 \
--max-retries 100 \
--display plain
```
**Principaux paramètres**
| Paramètre | Par défaut | Description |
| --- | --- | --- |
| --max-connections | 10 | Nombre de requêtes parallèles adressées au point de terminaison. Echelle en fonction du nombre d'instances (par exemple, 10 instances × 25 = 250). |
| --max-retries | 3 | Réessayez en cas d'échec des demandes. Utilisez 50-100 pour les évaluations de grande envergure. |
| -M region\$1name | us-east-1 | AWS région dans laquelle votre terminal est déployé. |
| -M read\$1timeout | 600 | Délai d'expiration de la demande en secondes. |
| -M connect\$1timeout | 60 | Délai d'expiration de la connexion en secondes. |
**Recommandations de réglage**
Pour un point de terminaison multi-instance :
```
# 10-instance endpoint example
--max-connections 250 # ~25 connections per instance
--max-retries 100 # Handle transient errors
```
Un réglage `--max-connections` trop élevé risque de submerger le terminal et de provoquer un ralentissement. Si elle est trop basse, la capacité est sous-utilisée.
## Étape 7 : Afficher les résultats
Lancez le visualiseur Inspect AI pour analyser les résultats de l'évaluation :
```
inspect view
```
Le visualiseur affiche :
+ Scores et indicateurs globaux
+ Résultats par échantillon avec réponses du modèle
+ Analyse des erreurs et modèles de défaillance
## Gestion des points de terminaison
**Mettre à jour un terminal**
Pour mettre à jour un point de terminaison existant avec un nouveau modèle ou une nouvelle configuration :
```
import boto3
sagemaker = boto3.client('sagemaker', region_name=REGION)
# Create new model and endpoint configuration
# Then update the endpoint
sagemaker.update_endpoint(
EndpointName=EXISTING_ENDPOINT_NAME,
EndpointConfigName=NEW_ENDPOINT_CONFIG_NAME
)
```
**Supprimer un point de terminaison**
```
sagemaker.delete_endpoint(EndpointName=ENDPOINT_NAME)
```
## Intégration de benchmarks personnalisés
Vous pouvez ajouter de nouveaux points de référence à Inspect AI à l'aide du flux de travail suivant :
1. Étudier le format de l'ensemble de données de référence et les mesures d'évaluation
1. Passez en revue les implémentations similaires dans `inspect_evals/`
1. Créez un fichier de tâches qui convertit les enregistrements de jeux de données en échantillons Inspect AI
1. Implémenter des solveurs et des évaluateurs appropriés
1. Validez avec un petit essai
Exemple de structure de tâches :
```
from inspect_ai import Task, task
from inspect_ai.dataset import hf_dataset
from inspect_ai.scorer import choice
from inspect_ai.solver import multiple_choice
@task
def my_benchmark():
return Task(
dataset=hf_dataset("dataset_name", split="test"),
solver=multiple_choice(),
scorer=choice()
)
```
## Résolution des problèmes
**Problèmes courants**
**Limitation ou temporisation des terminaux**
+ Réduire `--max-connections`
+ Augmenter `--max-retries`
+ Vérifiez les CloudWatch indicateurs des terminaux pour détecter les problèmes de capacité
**Erreurs d'authentification**
+ Vérifiez que les AWS informations d'identification sont correctement configurées
+ Vérifiez que les autorisations IAM incluent `sagemaker:InvokeEndpoint`
**Erreurs de modèle**
+ Vérifiez que le terminal est en `InService` état
+ Vérifiez que le modèle supporte le format d'API OpenAI Chat Completions
## Ressources connexes
+ [Inspectez la documentation de l'IA](https://inspect.ai-safety-institute.org.uk/)
+ [Inspecter le référentiel Evals](https://github.com/UKGovernmentBEIS/inspect_evals)
+ [SageMaker Manuel du développeur](https://docs.aws.amazon.com//sagemaker/latest/dg/whatis.html)
+ [Déployer des modèles à des fins d'inférence](https://docs.aws.amazon.com//sagemaker/latest/dg/deploy-model.html)
+ [Configuration du AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-configure.html)
# Déploiement des modèles Amazon Nova Forge dans le cadre de la détection des abus SageMaker par Amazon Inference
AWS s'engage à utiliser l'IA de manière responsable. Pour éviter toute utilisation abusive potentielle, lorsque vous déployez des modèles Amazon Nova Forge dans Amazon SageMaker Inference, SageMaker Inference met en œuvre des mécanismes automatisés de détection des abus afin d'identifier les violations potentielles de la [politique d' AWS utilisation acceptable](https://aws.amazon.com/aup/) (AUP) et des conditions de service de l'entreprise, y compris la politique d'intelligence artificielle [responsable](https://aws.amazon.com/ai/responsible-ai/policy/).
Nos mécanismes de détection des abus sont entièrement automatisés. Personne ne vérifie ni ne consulte les entrées utilisateur ni les sorties des modèles.
La détection automatique des abus inclut ce qui suit :
+ **Catégoriser le contenu** — Nous utilisons des classificateurs pour détecter les contenus préjudiciables (tels que les contenus incitant à la violence) dans les entrées des utilisateurs et dans les sorties des modèles. Un classificateur est un algorithme qui traite les entrées et les sorties des modèles, et attribue le type de préjudice et le niveau de confiance. Nous pouvons exécuter ces classificateurs en fonction de l'utilisation du modèle Amazon Nova Forge. Le processus de classification est automatisé et n’implique aucune vérification humaine des entrées utilisateur ni des sorties des modèles.
+ **Identifier les modèles** — Nous utilisons les métriques du classificateur pour identifier les violations potentielles et les comportements récurrents. Nous pouvons compiler et partager des statistiques de classification anonymisées. Amazon SageMaker Inference ne stocke pas les entrées de l'utilisateur ni les sorties du modèle.
+ **Détection et blocage du matériel pédopornographique (CSAM)** : vous êtes responsable du contenu que vous (et vos utilisateurs finaux) téléchargez sur Amazon SageMaker Inference et devez vous assurer que ce contenu ne contient pas d'images illégales. Pour aider à stopper la diffusion du CSAM, lors du déploiement d'un modèle Amazon Nova Forge dans Amazon SageMaker Inference, SageMaker Inference peut utiliser des mécanismes automatisés de détection des abus (tels que la technologie de hachage ou les classificateurs) pour détecter les CSAM apparents. Si Amazon SageMaker Inference détecte un CSAM apparent dans vos images saisies, Amazon SageMaker Inference bloquera la demande et vous recevrez un message d'erreur automatique. Amazon SageMaker Inference peut également déposer un rapport auprès du National Center for Missing and Exploited Children (NCMEC) ou d'une autorité compétente. Nous prenons le CSAM très au sérieux et nous continuerons à mettre à jour nos mécanismes de détection, de blocage et de signalement. Les lois applicables peuvent vous obliger à prendre des mesures supplémentaires, et vous êtes responsable de ces actions.
Une fois que nos mécanismes automatisés de détection des abus ont identifié des violations potentielles, nous pouvons vous demander des informations sur votre utilisation d'Amazon SageMaker Inference et sur le respect de nos conditions d'utilisation. Si vous ne répondez pas, si vous ne voulez pas ou si vous êtes incapable de vous conformer à ces conditions ou politiques, vous AWS pouvez suspendre votre accès à Amazon SageMaker Inference. L'échec de la tâche d'inférence peut également vous être facturé si nos tests automatisés détectent que les réponses du modèle ne sont pas conformes à nos conditions générales.
Contactez AWS le Support si vous avez d'autres questions. Pour plus d'informations, consultez le site [Amazon SageMaker FAQs](https://aws.amazon.com/sagemaker/ai/faqs/).