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.
# 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}")
```