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.
# Optimisation des inférences pour les modèles Amazon SageMaker AI
Avec Amazon SageMaker AI, vous pouvez améliorer les performances de vos modèles d’IA générative en appliquant des techniques d’optimisation des inférences. En optimisant vos modèles, vous pouvez obtenir un meilleur rapport coût-performance pour votre cas d’utilisation. Lorsque vous optimisez un modèle, vous choisissez quelles techniques d’optimisation appliquer parmi celles prises en charge, telles que la quantification, le décodage spéculatif et la compilation. Une fois votre modèle optimisé, vous pouvez exécuter une évaluation pour consulter les métriques de performance en termes de latence, de débit et de prix.
Pour de nombreux modèles, SageMaker AI propose également plusieurs versions préoptimisées, chacune répondant aux différents besoins des applications en termes de latence et de débit. Pour de tels modèles, vous pouvez déployer l’une des versions optimisées sans avoir préalablement optimisé le modèle vous-même.
## Techniques d’optimisation
Amazon SageMaker AI prend en charge les techniques d’optimisation suivantes.
### Compilation
La *compilation* optimise le modèle pour obtenir les meilleures performances disponibles sur le type de matériel choisi sans perte de précision. Vous pouvez appliquer la compilation de modèle afin d’optimiser les LLM pour le matériel accéléré, tel que les instances GPU, les instances AWS Trainium ou les instances AWS Inferentia.
Lorsque vous optimisez un modèle via la compilation, vous bénéficiez d’une compilation anticipée. Vous réduisez le temps de déploiement du modèle et la latence d’autoscaling, car les poids du modèle ne nécessitent pas de compilation en flux tendu quand le modèle est déployé sur une nouvelle instance.
Si vous choisissez de compiler votre modèle pour une instance GPU, SageMaker AI utilise la bibliothèque TensorRT-LLM pour exécuter la compilation. Si vous choisissez de compiler votre modèle pour une instance AWS Trainium ou AWS Inferentia, SageMaker AI utilise le kit AWS Neuron SDK pour exécuter la compilation.
### Quantification
La *quantification* est une technique qui permet de réduire les exigences matérielles d’un modèle en utilisant un type de données moins précis pour les poids et les activations. Après avoir optimisé un modèle avec la quantification, vous pouvez l’héberger sur des GPU moins coûteux et plus disponibles. Cependant, le modèle quantifié peut être moins précis que le modèle source que vous avez optimisé.
Les formats de données pris en charge par SageMaker AI pour la quantification varient d’un modèle à l’autre. Les formats pris en charge comprennent :
+ INT4-AWQ : format de données 4 bits. La quantification du poids sensible à l’activation (AWQ) est une technique de quantification des LLM efficace, précise, faible en bits et uniquement axée sur le poids.
+ FP8 : format à virgule flottante 8 bits (FP8) de faible précision pour les nombres à virgule flottante. Il équilibre efficacité de la mémoire et précision du modèle en représentant des valeurs avec moins de bits que le format à virgule flottante FP16 standard.
+ INT8-SmoothQuant : format de données 8 bits. SmoothQuant est une méthode de quantification à précision mixte qui permet de mettre à l’échelle les activations et les poids conjointement en équilibrant leurs plages dynamiques.
### Décodage spéculatif
Le *décodage spéculatif* est une technique permettant d’accélérer le processus de décodage des grands modèles de langage (LLM). Il optimise les modèles pour réduire la latence sans compromettre la qualité du texte généré.
Cette technique utilise un modèle plus petit, mais plus rapide, appelé *brouillon* de modèle. Le brouillon de modèle génère des jetons candidats, qui sont ensuite validés par le modèle *cible* plus grand, mais plus lent. À chaque itération, le brouillon de modèle génère plusieurs jetons candidats. Le modèle cible vérifie les jetons, et s’il trouve qu’un jeton en particulier n’est pas acceptable, il le rejette et le génère à nouveau. Ainsi, le modèle cible vérifie les jetons et en génère une petite quantité.
Le brouillon de modèle est nettement plus rapide que le modèle cible. Il génère rapidement tous les jetons, puis en envoie des lots au modèle cible pour vérification. Le modèle cible les évalue tous en parallèle, ce qui accélère la réponse finale.
SageMaker AI propose un brouillon de modèle prédéfini que vous pouvez utiliser pour ne pas avoir à concevoir le vôtre. Si vous préférez utiliser votre propre brouillon de modèle personnalisé, SageMaker AI prend également en charge cette option.
### Chargement rapide des modèles
La technique du *chargement rapide des modèles* prépare un LLM afin que SageMaker AI puisse le charger plus rapidement sur une instance de ML.
Pour préparer le modèle, SageMaker AI le partitionne à l’avance en le divisant en portions pouvant chacune résider sur un GPU distinct pour une inférence distribuée. SageMaker AI stocke également les poids du modèle sous forme de segments de taille égale pour pouvoir les charger simultanément sur l’instance.
Lorsque SageMaker AI charge le modèle optimisé sur l’instance, les poids du modèle sont directement diffusés depuis Amazon S3 vers les GPU de l’instance. En diffusant les poids, SageMaker AI omet plusieurs étapes chronophages qui sont normalement nécessaires. Ces étapes incluent le téléchargement des artefacts du modèle depuis Amazon S3 sur le disque, le chargement des artefacts du modèle sur la mémoire de l’hôte et le partitionnement du modèle sur l’hôte avant de finalement charger les partitions sur les GPU.
Après avoir optimisé votre modèle pour accélérer le chargement, vous pouvez le déployer plus rapidement sur un point de terminaison SageMaker AI. De plus, si vous configurez le point de terminaison pour utiliser l’autoscaling, il augmente horizontalement plus rapidement pour s’adapter à la hausse du trafic.
# Déploiement d’un modèle préoptimisé
Certains modèles JumpStart sont préoptimisés par SageMaker AI, ce qui signifie que vous pouvez déployer des versions optimisées de ces modèles sans créer au préalable une tâche d’optimisation d’inférence.
Pour obtenir la liste des modèles avec options préoptimisées, consultez [Modèles JumpStart préoptimisés](#pre-optimized-js).
## Amazon SageMaker Studio
Utilisez la procédure suivante pour déployer un modèle JumpStart préoptimisé à l’aide d’Amazon SageMaker Studio.
**Pour déployer un modèle préoptimisé**
1. Dans le menu de navigation de gauche de Studio, choisissez **JumpStart**.
1. Sur la page **Tous les modèles publics**, choisissez l’un des modèles préoptimisés.
1. Sur la page des détails du modèle, choisissez **Déployer**.
1. Sur la page de déploiement, certains modèles JumpStart nécessitent que vous signiez un contrat de licence d’utilisateur final (CLUF) avant de pouvoir continuer. Si nécessaire, consultez les termes du contrat de licence dans la section **Contrat de licence**. Si les conditions sont acceptables pour votre cas d’utilisation, cochez la case **J’accepte le CLUF et j’en ai lu les conditions générales**.
Pour plus d’informations, consultez [Contrats de licence de l'utilisateur final](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula).
1. Pour **Nom du point de terminaison** et **Nombre d’instances initiales**, acceptez les valeurs par défaut ou définissez les valeurs personnalisées.
1. For **Type d’instance**, conservez la valeur par défaut. Sinon, vous ne pouvez pas déployer de configuration préoptimisée.
1. Sous **Modèles**, développez la configuration du modèle. Studio affiche un tableau qui répertorie les configurations préoptimisées que vous pouvez choisir. Chaque option comporte des métriques de latence et de débit. Choisissez l’option qui correspond le mieux aux besoins de votre application.
1. Choisissez **Déployer**.
## SageMaker AI Python SDK
Vous pouvez déployer un modèle préoptimisé en utilisant le kit SageMaker AI Python SDK dans votre projet. Commencez par définir une instance `Model` à l’aide de la classe `ModelBuilder`. Vous utilisez ensuite la méthode `set_deployment_config()` pour définir la configuration préoptimisée que vous souhaitez déployer. Puis vous utilisez la méthode `build()` pour créer le modèle. Enfin, vous utilisez la méthode `deploy()` pour le déployer sur un point de terminaison d’inférence.
Pour plus d’informations sur les classes et les méthodes utilisées dans les exemples suivants, consultez [API](https://sagemaker.readthedocs.io/en/stable/api/index.html) dans la documentation du kit SageMaker AI Python SDK.
**Pour configurer votre projet**
1. Dans votre code d’application, importez les bibliothèques nécessaires. Les exemples suivants importent le kit SDK pour Python (Boto3). Il importe également les modules du kit SageMaker AI Python SDK que vous utilisez pour définir des modèles et travailler avec :
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
```
1. Initialisez une session SageMaker AI. L’exemple suivant utilise la classe `Session()` :
```
sagemaker_session = Session()
```
**Pour définir votre modèle**
1. Créez une instance `SchemaBuilder` et fournissez des exemples d’entrée et de sortie. Vous fournissez cette instance à la classe `ModelBuilder` lorsque vous définissez un modèle. Avec celle-ci, SageMaker AI génère automatiquement les fonctions de transformation pour sérialiser et désérialiser l’entrée et la sortie.
Pour plus d’informations sur les classes `SchemaBuilder` et `ModelBuilder`, consultez [Créez un modèle dans Amazon SageMaker AI avec ModelBuilder](how-it-works-modelbuilder-creation.md).
L’exemple suivant fournit des exemples de chaînes d’entrée et de sortie à la classe `SchemaBuilder` :
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. Définissez votre modèle pour SageMaker AI. L’exemple suivant définit les paramètres pour initialiser une instance `ModelBuilder` :
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
Cet exemple utilise un modèle JumpStart. Remplacez `jumpstart-model-id` par l’ID d’un modèle JumpStart, tel que `meta-textgeneration-llama-3-70b`.
**Pour extraire des métriques de référence**
1. Pour déterminer quelle configuration préoptimisée vous souhaitez déployer, examinez les options proposées par SageMaker AI. L’exemple suivant les affiche :
```
model_builder.display_benchmark_metrics()
```
Cette méthode `display_benchmark_metrics()` imprime un tableau comme celui-ci :
```
| Instance Type | Config Name | Concurrent Users | Latency, TTFT (P50 in sec) | Throughput (P50 in tokens/sec/user) |
|:----------------|:--------------|-------------------:|-----------------------------:|--------------------------------------:|
| ml.g5.48xlarge | lmi-optimized | 1 | 2.25 | 49.70 |
| ml.g5.48xlarge | lmi-optimized | 2 | 2.28 | 21.10 |
| ml.g5.48xlarge | lmi-optimized | 4 | 2.37 | 14.10 |
. . .
| ml.p4d.24xlarge | lmi-optimized | 1 | 0.10 | 137.40 |
| ml.p4d.24xlarge | lmi-optimized | 2 | 0.11 | 109.20 |
| ml.p4d.24xlarge | lmi-optimized | 4 | 0.13 | 85.00 |
. . .
```
La première colonne répertorie les types d’instances potentiels que vous pouvez utiliser pour héberger le modèle JumpStart que vous avez choisi. Pour chaque type d’instance, la colonne `Config Name` répertorie les noms des configurations préoptimisées. Les configurations fournies par SageMaker AI sont nommées `lmi-optimized`. Pour chaque type d’instance et chaque configuration, le tableau fournit des métriques de référence. Ces métriques indiquent le débit et la latence que votre modèle prendra en charge pour différents nombres d’utilisateurs simultanés.
1. Sur la base des indicateurs de référence, choisissez le type d’instance et le nom de configuration qui répondent le mieux à vos besoins en matière de performances. Vous utiliserez ces valeurs lorsque vous créerez une configuration de déploiement.
**Pour déployer un modèle préoptimisé**
1. Créez une configuration de déploiement. L’exemple suivant utilise une instance `ModelBuilder`. Il transmet un type d’instance et un nom de configuration à la méthode `set_deployment_config()` :
```
model_builder.set_deployment_config(
config_name="config-name",
instance_type="instance-type",
)
```
Remplacez *`config-name`* par un nom de configuration figurant dans le tableau, tel que `lmi-optimized`. Remplacez `instance-type` par un type d’instance figurant dans le tableau, tel que `ml.p4d.24xlarge`.
1. Créez votre modèle. L’exemple suivant utilise la méthode `.build()` de l’instance `ModelBuilder` :
```
optimized_model = model_builder.build()
```
La méthode `.build()` renvoie une instance `Model` déployable.
1. Déployez votre modèle sur un point de terminaison d’inférence. L’exemple suivant utilise la méthode `.deploy()` de l’instance `Model` :
```
predictor = optimized_model.deploy(accept_eula=True)
```
La méthode `deploy()` renvoie une instance `Predictor` que vous pouvez utiliser pour envoyer des demandes d’inférence au modèle.
**Pour tester votre modèle à l’aide d’une demande d’inférence**
+ Après avoir déployé votre modèle sur un point de terminaison d’inférence, testez les prédictions du modèle. L’exemple suivant envoie une demande d’inférence à l’aide de l’instance `Predictor` :
```
predictor.predict(sample_input)
```
Le modèle renvoie le texte qu’il génère avec une réponse comme suit :
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## Modèles JumpStart préoptimisés
Les modèles JumpStart dont les configurations sont préoptimisées sont les suivants.
**Meta**
+ Llama 3.1 70B Instruct
+ Llama 3.1 70B
+ Llama 3.1 405B Instruct FP8
+ Llama 3.1 405B FP8
+ Llama 3 8B Instruct
+ Llama 3 8B
+ Llama 3 70B Instruct
+ Llama 3 70B
+ Llama 2 70B Chat
+ Llama 2 7B Chat
+ Llama 2 13B Chat
**HuggingFace**
+ Mixtral 8x7B Instruct
+ Mixtral 8x7B
+ Mistral 7B Instruct
+ Mistral 7B
### Modèles JumpStart précompilés
Pour certains modèles et configurations, SageMaker AI fournit des modèles précompilés pour des instances AWS Inferentia et AWS Trainium spécifiques. Dans ce cas, si vous créez une tâche d’optimisation de compilation et que vous choisissez ml.inf2.48xlarge ou ml.trn1.32xlarge comme type d’instance de déploiement, SageMaker AI récupère les artefacts compilés. Comme la tâche utilise un modèle déjà compilé, elle s’exécute rapidement sans que la compilation parte de zéro.
Voici les modèles JumpStart pour lesquels SageMaker AI propose des modèles précompilés :
**Meta**
+ Llama3 8B
+ Llama3 70B
+ Llama2 7B
+ Llama2 70B
+ Llama2 13B
+ Code Llama 7B
+ Code Llama 70B
**HuggingFace**
+ Mistral 7B
# Création d’une tâche d’optimisation d’inférence
Vous pouvez créer une tâche d'optimisation des inférences à l'aide de Studio ou du SDK SageMaker AI Python. La tâche optimise votre modèle en appliquant les techniques que vous choisissez. Pour de plus amples informations, veuillez consulter [Techniques d’optimisation](model-optimize.md#optimization-techniques).
**Tarification des instances pour les tâches d’optimisation d’inférences**
Lorsque vous créez une tâche d'optimisation des inférences qui applique la quantification ou la compilation, SageMaker AI choisit le type d'instance à utiliser pour exécuter la tâche. Vous êtes facturé en fonction de l’instance utilisée.
Pour connaître les types d'instances possibles et les détails de leur tarification, consultez les informations tarifaires relatives à l'optimisation des inférences sur la page de [ SageMaker tarification d'Amazon](https://aws.amazon.com/sagemaker/pricing/).
Vous n’encourez aucun coût supplémentaire pour les tâches qui appliquent un décodage spéculatif.
Pour connaître les modèles pris en charge que vous pouvez optimiser, consultez [Référence des modèles pris en charge](optimization-supported-models.md).
## Amazon SageMaker Studio
Procédez comme suit pour créer une tâche d’optimisation d’inférence dans Studio.
**Pour commencer la création d’une tâche d’optimisation**
1. Dans SageMaker AI Studio, créez une tâche d'optimisation en utilisant l'un des chemins suivants :
+ Pour créer une tâche pour un JumpStart modèle, procédez comme suit :
1. Dans le menu de navigation, choisissez **JumpStart**.
1. Sur la page **Tous les modèles publics**, choisissez un fournisseur de modèles, puis l’un des modèles compatibles avec l’optimisation.
1. Sur la page des détails du modèle, choisissez **Optimiser**. Ce bouton est activé uniquement pour les modèles qui prennent en charge l’optimisation.
1. Sur la page **Créer une tâche d'optimisation des inférences**, certains JumpStart modèles nécessitent que vous signiez un contrat de licence utilisateur final (EULA) avant de pouvoir continuer. Si nécessaire, consultez les termes du contrat de licence dans la section **Contrat de licence**. Si les conditions sont acceptables pour votre cas d’utilisation, cochez la case **J’accepte le CLUF et j’en ai lu les conditions générales**.
+ Pour créer une tâche pour un JumpStart modèle affiné, procédez comme suit :
1. Dans le panneau de navigation, sous **Tâches**, choisissez **Entraînement**.
1. Sur la page **Tâches de formation**, choisissez le nom d'une tâche que vous avez utilisée pour peaufiner un JumpStart modèle. Le type **JumpStartTraining** de ces tâches est indiqué dans la colonne **Type de tâche**.
1. Sur la page de détails de la tâche d’entraînement, choisissez **Optimiser**.
+ Pour créer une tâche pour un modèle personnalisé, procédez comme suit :
1. Dans le menu de navigation, sous **Tâches**, choisissez **Optimisation de l’inférence**.
1. Choisissez **Create new job** (Créer une nouvelle tâche).
1. Sur la page **Créer une tâche d’optimisation d’inférence**, sélectionnez **Ajouter un modèle**.
1. Dans la fenêtre **Ajouter un modèle**, sélectionnez **Modèle personnalisé**.
1. Choisissez l’une des options suivantes :
**Utiliser votre modèle existant** : sélectionnez cette option pour optimiser un modèle que vous avez déjà créé dans SageMaker AI.
**Nom du modèle existant** : entrez le nom de votre modèle d' SageMaker IA.
**Depuis S3** : sélectionnez cette option pour fournir des artefacts de modèle provenant d'Amazon S3. Pour l’**URI S3**, entrez l’URI de l’emplacement Amazon S3 où vous avez stocké les artefacts de votre modèle.
1. (Facultatif) Pour le ****nom du modèle de sortie****, vous pouvez entrer un nom personnalisé pour le modèle optimisé créé par la tâche. Si vous ne fournissez pas de nom, Studio en génère un automatiquement en fonction de votre sélection.
1. Sur la page **Créer une tâche d'optimisation des inférences**, pour **Nom de la tâche**, vous pouvez accepter le nom par défaut attribué par SageMaker AI. Ou, pour saisir un nom de tâche personnalisé, choisissez le champ **Nom de la tâche**, puis choisissez **Saisir le nom de la tâche**.
**Pour définir les configurations d’optimisation**
1. Pour **Type d’instance de déploiement**, choisissez le type d’instance pour lequel vous souhaitez optimiser le modèle.
Le type d’instance influe sur les techniques d’optimisation que vous pouvez choisir. Pour la plupart des types utilisant du matériel GPU, les techniques prises en charge sont la **quantification** et le **décodage spéculatif**. Si vous choisissez une instance qui utilise du silicium personnalisé, comme l'instance AWS Inferentia ml.inf2.8xlarge, la technique prise en charge est la **compilation**, que vous pouvez utiliser pour compiler le modèle pour ce type de matériel spécifique.
1. Sélectionnez une ou plusieurs des techniques d’optimisation proposées par Studio :
+ Si vous sélectionnez **Quantification**, choisissez un type de données pour le **type de données Précision**.
+ Si vous sélectionnez le **décodage spéculatif**, choisissez l’une des options suivantes :
+ **Utiliser le modèle de brouillon d' SageMaker IA** — Choisissez d'utiliser le modèle de brouillon fourni par l' SageMaker IA.
**Note**
Si vous choisissez d'utiliser le modèle de brouillon SageMaker AI, vous devez également activer l'isolation du réseau. Studio propose cette option sous **Sécurité**.
+ **Choisir un modèle JumpStart de brouillon** : choisissez de sélectionner un modèle dans le JumpStart catalogue à utiliser comme modèle de brouillon.
+ **Choisir mon propre brouillon de modèle** : choisissez d’utiliser votre propre brouillon de modèle et fournissez l’URI S3 qui le localise.
+ Si vous choisissez **Chargement rapide du modèle**, Studio affiche la variable d’environnement `OPTION_TENSOR_PARALLEL_DEGREE`. Utilisez le champ **Valeur** pour définir le degré de parallélisme de tenseur. La valeur doit diviser de manière égale le nombre de GPUs dans l'instance que vous avez choisie pour le **type d'instance de déploiement**. Par exemple, pour fragmenter votre modèle lors de l'utilisation d'une instance avec 8 GPUs, utilisez les valeurs 2, 4 ou 8.
+ Si vous définissez **le type d'instance de déploiement** sur une instance AWS Inferentia ou AWS Trainium, Studio peut indiquer que la **compilation** est la seule option prise en charge. Dans ce cas, Studio sélectionne cette option pour vous.
1. Pour **Sortie**, entrez l’URI d’un emplacement Amazon S3. L' SageMaker IA y stocke les artefacts du modèle optimisé créé par votre travail.
1. (Facultatif) Développez les **options avancées** pour un contrôle plus précis des paramètres tels que le rôle IAM, le VPC et les variables d’environnement. Pour plus d’informations, consulter *Options avancées* ci-dessous.
1. Lorsque vous avez terminé de configurer la tâche, choisissez **Créer une tâche**.
Studio affiche la page des détails, qui indique le statut de la tâche et tous les paramètres que vous avez appliqués lors de sa création.
### Options avancées
Vous pouvez définir les options avancées suivantes lorsque vous créez une tâche d’optimisation d’inférence.
Sous **Configurations**, vous pouvez définir les options suivantes :
**Degré de parallélisation du tenseur **
Valeur du degré du *parallélisme de tenseur*. Le parallélisme de tenseur est un type de parallélisme des modèles dans lequel des poids, des gradients et des états d’optimiseur spécifiques sont répartis entre les appareils. La valeur doit diviser de manière égale le nombre de GPUs dans votre cluster.
**Longueur maximale de jeton**
Limite du nombre de jetons devant être générés par le modèle. Notez que le modèle peut ne pas toujours générer le nombre maximum de jetons.
**Concurrency**
Possibilité d’exécuter plusieurs instances d’un modèle sur le même matériel sous-jacent. Utilisez la simultanéité pour transmettre des prédictions à plusieurs utilisateurs et optimiser l’utilisation du matériel.
**Taille de lot**
Si votre modèle effectue une *inférence par lots*, utilisez cette option pour contrôler la taille des lots traités par votre modèle.
L’inférence par lots génère des prédictions modélisées sur un lot d’observations. C’est une bonne option pour les jeux de données volumineux, ou si vous n’avez pas besoin d’une réponse immédiate à une demande d’inférence.
Sous **Sécurité**, vous pouvez définir les options suivantes :
**Rôle IAM**
Rôle IAM qui permet à l' SageMaker IA d'effectuer des tâches en votre nom. Lors de l'optimisation du modèle, SageMaker AI a besoin de votre autorisation pour :
+ Lire les données d’entrée à partir d’un compartiment S3
+ Écrire des artefacts de modèle dans un compartiment S3
+ Écrire des journaux sur Amazon CloudWatch Logs
+ Publier des statistiques sur Amazon CloudWatch
Vous accordez les autorisations pour toutes ces tâches à un rôle IAM.
Pour de plus amples informations, veuillez consulter [Comment utiliser les rôles d'exécution de l' SageMaker IA](sagemaker-roles.md).
**Clé KMS de chiffrement**
Une clé dans AWS Key Management Service (AWS KMS). SageMaker L'IA utilise cette clé pour chiffrer les artefacts du modèle optimisé lorsqu'elle SageMaker télécharge le modèle sur Amazon S3.
**VPC**
SageMaker L'IA utilise ces informations pour créer des interfaces réseau et les associer à vos modèles de conteneurs. Les interfaces réseau fournissent à vos conteneurs de modèles une connexion réseau au sein de votre VPC qui n'est pas connecté à Internet. Elles permettent également à votre modèle de se connecter aux ressources de votre VPC privé.
Pour de plus amples informations, veuillez consulter [Donnez aux points de terminaison hébergés par SageMaker IA un accès aux ressources de votre Amazon VPC](host-vpc.md).
**Activer l’isolement réseau**
Activez cette option si vous souhaitez restreindre l’accès Internet de votre conteneur. Les conteneurs qui s’exécutent avec un isolement réseau ne peuvent effectuer aucun appel réseau sortant.
Vous devez activer cette option lorsque vous optimisez avec un décodage spéculatif et que vous utilisez le modèle de brouillon SageMaker AI.
Pour plus d’informations sur l’isolement réseau, consultez [Isolement du réseau](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
Sous **Définition de conteneur avancée**, vous pouvez définir les options suivantes :
**Condition d'arrêt**
Spécifie une limite pour la durée d’exécution d’une tâche. Lorsque la tâche atteint la limite de temps, l' SageMaker IA met fin à la tâche. Utilisez cette option pour plafonner les coûts.
**Étiquettes**
Paires clé-valeur associées à la tâche d’optimisation.
Pour plus d’informations sur les balises, consultez [Balisage de vos ressources AWS](https://docs.aws.amazon.com/tag-editor/latest/userguide/tagging.html) dans la *Références générales AWS*.
**Variables d’environnement**
Paires clé-valeur qui définissent les variables d’environnement à configurer dans le conteneur de modèle.
## SageMaker SDK Python pour IA
Vous pouvez créer une tâche d'optimisation des inférences en utilisant le SDK SageMaker AI Python dans votre projet. Commencez par définir une instance `Model` à l’aide de la classe `ModelBuilder`. Utilisez ensuite la méthode `optimize()` pour exécuter une tâche qui optimise votre modèle par quantification, décodage spéculatif ou compilation. Une fois la tâche terminée, vous déployez le modèle sur un point de terminaison d’inférence à l’aide de la méthode `deploy()`.
Pour plus d'informations sur les classes et les méthodes utilisées dans les exemples suivants, consultez [APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html)la documentation du SDK SageMaker AI Python.
**Pour configurer votre projet**
1. Dans votre code d’application, importez les bibliothèques nécessaires. Les exemples suivants importent le kit SDK pour Python (Boto3). Il importe également les classes du SDK SageMaker AI Python que vous utilisez pour définir et utiliser des modèles :
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
from pathlib import Path
```
1. Initialisez une session SageMaker AI. L’exemple suivant utilise la classe `Session()` :
```
sagemaker_session = Session()
```
**Pour définir votre modèle**
1. Créez une instance `SchemaBuilder` et fournissez des exemples d’entrée et de sortie. Vous fournissez cette instance à la classe `ModelBuilder` lorsque vous définissez un modèle. Grâce à elle, l' SageMaker IA génère automatiquement les fonctions de marshalling pour sérialiser et désérialiser l'entrée et la sortie.
Pour plus d’informations sur les classes `SchemaBuilder` et `ModelBuilder`, consultez [Créez un modèle dans Amazon SageMaker AI avec ModelBuilder](how-it-works-modelbuilder-creation.md).
L’exemple suivant fournit des exemples de chaînes d’entrée et de sortie à la classe `SchemaBuilder` :
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. Définissez votre modèle en fonction de l' SageMaker IA. L’exemple suivant définit les paramètres pour initialiser une instance `ModelBuilder` :
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
Cet exemple utilise un JumpStart modèle. Remplacez `jumpstart-model-id` par l'ID d'un JumpStart modèle, tel que`meta-textgeneration-llama-3-70b`.
**Note**
Si vous souhaitez optimiser avec le décodage spéculatif et utiliser le brouillon SageMaker AI, vous devez activer l'isolation du réseau. Pour ce faire, incluez l’argument suivant lorsque vous initialisez une instance `ModelBuilder` :
```
enable_network_isolation=True,
```
Pour plus d’informations sur l’isolement réseau, consultez [Isolement du réseau](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
**Pour optimiser à l’aide de la quantification**
1. Pour exécuter une tâche de quantification, utilisez la méthode `optimize()` et définissez l’argument `quantization_config`. L’exemple suivant définit `OPTION_QUANTIZE` comme variable d’environnement dans le conteneur d’optimisation :
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
quantization_config={
"OverrideEnvironment": {
"OPTION_QUANTIZE": "awq",
},
},
output_path="s3://output-path",
)
```
Dans cet exemple, remplacez *`instance-type`* par une instance de ML, telle que `ml.p4d.24xlarge`. Remplacez *`s3://output-path`* par le chemin d’accès à l’emplacement S3 où vous stockez le modèle optimisé créé par la tâche.
La méthode `optimize()` renvoie un objet `Model` que vous pouvez utiliser pour déployer votre modèle sur un point de terminaison.
1. Une fois la tâche terminée, déployez le modèle. L’exemple suivant utilise la méthode `deploy()` :
```
predictor = optimized_model.deploy(
instance_type="instance-type",
accept_eula=True,
)
```
Dans cet exemple, remplacez *`instance-type`* par une instance de ML, telle que `ml.p4d.24xlarge`.
La méthode `deploy()` renvoie un objet prédicteur, que vous pouvez utiliser pour envoyer des demandes d’inférence au point de terminaison qui héberge le modèle.
**Pour optimiser avec le décodage spéculatif à l'aide du modèle de brouillon SageMaker AI**
Lorsque vous optimisez votre modèle à l'aide d'un décodage spéculatif, vous pouvez choisir d'utiliser un brouillon de modèle fourni par l' SageMaker IA ou d'utiliser le vôtre. Les exemples suivants utilisent le modèle de brouillon d' SageMaker IA.
**Prérequis**
Pour optimiser avec le décodage spéculatif et le modèle de brouillon d' SageMaker IA, vous devez activer l'isolation du réseau lorsque vous définissez votre modèle.
1. Pour exécuter une tâche de décodage spéculatif, utilisez la méthode `optimize()` et définissez l’argument `speculative_decoding_config`. L'exemple suivant définit la `ModelProvider` clé permettant d'`SAGEMAKER`utiliser le brouillon de modèle fourni par SageMaker l'IA.
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelProvider": "SAGEMAKER",
},
)
```
Dans cet exemple, remplacez *`instance-type`* par une instance de ML, telle que `ml.p4d.24xlarge`.
La méthode `optimize()` renvoie un objet `Model` que vous pouvez utiliser pour déployer votre modèle sur un point de terminaison.
1. Une fois la tâche terminée, déployez le modèle. L’exemple suivant utilise la méthode `deploy()` :
```
predictor = optimized_model.deploy(accept_eula=True)
```
La méthode `deploy()` renvoie un objet prédicteur, que vous pouvez utiliser pour envoyer des demandes d’inférence au point de terminaison qui héberge le modèle.
**Pour optimiser avec le décodage spéculatif à l’aide d’un brouillon de modèle personnalisé**
Avant de pouvoir fournir votre brouillon de modèle personnalisé à SageMaker AI, vous devez d'abord télécharger les artefacts du modèle sur Amazon S3.
Les exemples suivants illustrent une façon de fournir un brouillon de modèle personnalisé. Les exemples téléchargent le brouillon de modèle depuis le Hugging Face Hub, le chargent sur Amazon S3 et fournissent l’URI S3 à l’argument `speculative_decoding_config`.
1. Si vous souhaitez télécharger un modèle depuis le Hugging Face Hub, ajoutez la bibliothèque `huggingface_hub` à votre projet et téléchargez un modèle avec la méthode `snapshot_download()`. L’exemple suivant télécharge un modèle dans un répertoire local :
```
import huggingface_hub
huggingface_hub.snapshot_download(
repo_id="model-id",
revision="main",
local_dir=download-dir,
token=hf-access-token,
)
```
Dans cet exemple, remplacez *`model-id`* avec l’ID d’un modèle du Hugging Face Hub, comme `meta-llama/Meta-Llama-3-8B`. Remplacez *`download-dir`* par un répertoire local. Remplacez *`hf-access-token`* par votre jeton d’accès utilisateur. Pour découvrir comment obtenir votre jeton d’accès, consultez [User access tokens](https://huggingface.co/docs/hub/en/security-tokens) dans la documentation Hugging Face.
Pour plus d’informations sur la bibliothèque `huggingface_hub`, consultez [Hub client library](https://huggingface.co/docs/huggingface_hub/en/index) dans la documentation Hugging Face.
1. Pour que le modèle que vous avez téléchargé soit disponible pour SageMaker AI, chargez-le sur Amazon S3. L’exemple suivant charge le modèle avec l’objet `sagemaker_session` :
```
custom_draft_model_uri = sagemaker_session.upload_data(
path=hf_local_download_dir.as_posix(),
bucket=sagemaker_session.default_bucket(),
key_prefix="prefix",
)
```
Dans cet exemple, remplacez *`prefix`* par un qualificatif qui vous aidera à distinguer le brouillon de modèle dans S3, comme `spec-dec-custom-draft-model`.
La méthode `upload_data()` renvoie l’URI S3 pour les artefacts du modèle.
1. Pour exécuter une tâche de décodage spéculatif, utilisez la méthode `optimize()` et définissez l’argument `speculative_decoding_config`. L’exemple suivant définit la clé `ModelSource` de l’URI S3 du brouillon de modèle personnalisé :
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelSource": custom_draft_model_uri + "/",
},
)
```
Dans cet exemple, remplacez *`instance-type`* par une instance de ML, telle que `ml.p4d.24xlarge`.
La méthode `optimize()` renvoie un objet `Model` que vous pouvez utiliser pour déployer votre modèle sur un point de terminaison.
1. Une fois la tâche terminée, déployez le modèle. L’exemple suivant utilise la méthode `deploy()` :
```
predictor = optimized_model.deploy(accept_eula=True)
```
La méthode `deploy()` renvoie un objet prédicteur, que vous pouvez utiliser pour envoyer des demandes d’inférence au point de terminaison qui héberge le modèle.
**Pour optimiser avec la compilation**
1. Pour exécuter une tâche de compilation, utilisez la méthode `optimize()` et définissez l’argument `compilation_config`. L’exemple suivant utilise la clé `OverrideEnvironment` pour définir les variables d’environnement nécessaires dans le conteneur d’optimisation :
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
compilation_config={
"OverrideEnvironment": {
"OPTION_TENSOR_PARALLEL_DEGREE": "24",
"OPTION_N_POSITIONS": "8192",
"OPTION_DTYPE": "fp16",
"OPTION_ROLLING_BATCH": "auto",
"OPTION_MAX_ROLLING_BATCH_SIZE": "4",
"OPTION_NEURON_OPTIMIZE_LEVEL": "2",
}
},
output_path="s3://output-path",
)
```
Dans cet exemple, définissez *`instance-type`* sur un type d’instance de ML avec accélération matérielle. Par exemple, pour une inférence accélérée avec AWS Inferentia, vous pouvez définir le type sur une instance Inf2, telle que. `ml.inf2.48xlarge` Remplacez *`s3://output-path`* par le chemin d’accès à l’emplacement S3 où vous stockez le modèle optimisé créé par la tâche.
1. Une fois la tâche terminée, déployez le modèle. L’exemple suivant utilise la méthode `deploy()` :
```
predictor = optimized_model.deploy(accept_eula=True)
```
La méthode `deploy()` renvoie un objet prédicteur, que vous pouvez utiliser pour envoyer des demandes d’inférence au point de terminaison qui héberge le modèle.
**Pour tester votre modèle à l’aide d’une demande d’inférence**
+ Pour envoyer une demande d’inférence de test à votre modèle déployé, utilisez la méthode `predict()` d’un objet prédicteur. L’exemple suivant transmet la variable `sample_input`, qui a également été transmise à la classe `SchemaBuilder` dans les exemples, pour définir votre modèle :
```
predictor.predict(sample_input)
```
L’exemple d’entrée contient l’invite `"What is the largest planet in the solar system?"`. La méthode `predict()` renvoie la réponse générée par le modèle, comme l’illustre l’exemple suivant :
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## AWS SDK pour Python (Boto3)
Vous pouvez utiliser le AWS SDK pour Python (Boto3) pour créer et gérer par programmation des tâches d'optimisation des inférences. Cette section fournit des exemples de différentes techniques d'optimisation.
**Conditions préalables**
Avant de créer une tâche d'optimisation avec Boto3, assurez-vous d'avoir :
+ AWS Informations d'identification configurées - Configurez vos AWS informations d'identification avec les autorisations appropriées
+ Création d'un modèle d' SageMaker IA (si vous utilisez un modèle existant)
+ Données d'entraînement préparées dans S3 (pour l'optimisation du décodage spéculatif, longueur de contexte prise en charge jusqu'à 4096)
+ Rôle IAM avec les autorisations nécessaires : votre rôle d'exécution doit disposer des autorisations nécessaires pour accéder à S3 et créer des ressources SageMaker
**Exemple : créer une tâche d'optimisation avec le décodage spéculatif EAGLE (Llama 3.3 70B)**
Cet exemple montre comment créer une tâche d'optimisation pour un grand modèle de langage à l'aide de la technique de décodage spéculatif EAGLE :
```
import boto3
# Initialize SageMaker client
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Step 1: Create a SageMaker model (if not already created)
model_response = sagemaker_client.create_model(
ModelName='meta-llama-3-3-70b-instruct',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/Llama-3.3-70B-Instruct/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'SAGEMAKER_ENV': '1',
'SAGEMAKER_MODEL_SERVER_TIMEOUT': '3600'
}
}
)
# Step 2: Create optimization job with speculative decoding
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'meta-llama-3-3-70b-instruct'
}
},
DeploymentInstanceType='ml.p4d.24xlarge',
# MaxInstanceCount specifies the maximum number of instances for distributed training
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_8k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/llama-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**Exemple : créer une tâche d'optimisation à partir d'artefacts du modèle S3 (Qwen3 32B)**
Cet exemple montre comment créer une tâche d'optimisation à l'aide d'artefacts de modèle provenant directement de S3 :
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Create model from S3 artifacts
model_response = sagemaker_client.create_model(
ModelName='qwen3-32b',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'Mode': 'SingleModel',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/qwen3-32b/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'AWS_REGION': 'us-west-2'
}
}
)
# Create optimization job with smaller training dataset
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='qwen3-optim-job-eagle',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'qwen3-32b'
}
},
DeploymentInstanceType='ml.g6.48xlarge',
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_1k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/qwen3-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**Exemple : surveillance et gestion des tâches d'optimisation**
Après avoir créé une tâche d'optimisation, vous pouvez suivre sa progression et la gérer à l'aide des commandes suivantes :
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Describe optimization job to check status
describe_response = sagemaker_client.describe_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
)
print(f"Job Status: {describe_response['OptimizationJobStatus']}")
# List all optimization jobs (with pagination)
list_response = sagemaker_client.list_optimization_jobs(
MaxResults=10,
SortBy='CreationTime',
SortOrder='Descending'
)
print("\nRecent optimization jobs:")
for job in list_response['OptimizationJobSummaries']:
print(f"- {job['OptimizationJobName']}: {job['OptimizationJobStatus']}")
# Stop a running optimization job if needed
# sagemaker_client.stop_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
# Delete a completed or failed optimization job
# sagemaker_client.delete_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
```
Le décodage spéculatif avec Eagle Heads exécute quatre tâches d'entraînement séquentielles. Chaque tâche produit une sortie qui devient l'entrée de la suivante. Seule la sortie de la tâche finale est transmise à votre compartiment S3. Les sorties intermédiaires sont cryptées et stockées dans un bucket de service SageMaker AI interne pendant 20 jours maximum. SageMaker L'IA n'est pas autorisée à les déchiffrer. Si vous souhaitez que les données intermédiaires soient supprimées avant cette période, assurez-vous que votre tâche est terminée ou arrêtée, puis ouvrez un dossier d'assistance [[https://docs.aws.amazon.com/awssupport/latest/user/case-management.html\$1 creating-a-support-case](https://docs.aws.amazon.com/awssupport/latest/user/case-management.html#creating-a-support-case)] pour que ces données soient supprimées. Incluez dans la demande votre identifiant de AWS compte et l'ARN de la tâche d'optimisation.
## Limites du projet de modèle d' SageMaker IA
Pour tout modèle que vous optimisez à l'aide du modèle d' SageMaker IA brouillon, soyez conscient des exigences, des restrictions et des variables d'environnement prises en charge.
**Exigences**
Vous devez procéder comme suit :
+ Utilisez un modèle fourni par SageMaker JumpStart.
+ Activez l’isolement réseau pour le déploiement du modèle.
+ Si vous déployez le modèle dans un conteneur LMI (Large Model Inference), utilisez un DJLServing conteneur de version 0.28.0 ou supérieure.
Pour connaître les conteneurs disponibles, consultez la section [Large Model Inference Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers) dans le GitHub référentiel Deep Learning Containers.
+ Si vous affinez le JumpStart modèle, utilisez le format Safetensors pour les poids du modèle.
Pour plus d’informations sur ce format, consultez [Safetensors](https://huggingface.co/docs/safetensors/en/index) dans la documentation Hugging Face.
**Restrictions**
Vous ne pouvez pas exécuter les actions suivantes :
+ Utiliser le modèle dans les environnements de test locaux que vous créez avec le mode local.
Pour plus d'informations sur le mode local, consultez la section [Mode local](https://sagemaker.readthedocs.io/en/stable/overview.html#local-mode) dans la documentation du SDK SageMaker AI Python.
+ Accédez au conteneur modèle via l' AWS Systems Manager agent (agent SSM). L'agent SSM fournit un accès au niveau du shell à votre modèle de conteneur afin que vous puissiez déboguer les processus et enregistrer les commandes avec Amazon. CloudWatch
Pour en savoir plus sur cette fonction, consultez [Accès aux conteneurs via SSM](ssm-access.md).
+ Configurer le conteneur de modèle pour un vidage mémoire qui se produit en cas d’incident lors du processus.
Pour plus d'informations sur les vidages de base à partir de modèles de conteneurs, consultez [ProductionVariantCoreDumpConfig](sagemaker/latest/APIReference/API_ProductionVariantCoreDumpConfig.html).
+ Déployer le modèle sur des points de terminaison multimodèles, multiconteneurs ou hébergeant des composants d’inférence.
Pour plus d’informations sur ces types de points de terminaison, consultez [Points de terminaison multimodèles](multi-model-endpoints.md), [Points de terminaison multi-conteneurs](multi-container-endpoints.md) et [Composants Inférence](realtime-endpoints-deploy-models.md#inference-components).
+ Créer un package de modèle pour le modèle. Vous utilisez des packages de modèles pour créer des modèles déployables sur AWS Marketplace lesquels vous publiez.
Pour en savoir plus sur cette fonction, consultez [Création d’une ressource de package de modèle](sagemaker-mkt-create-model-package.md).
+ Utiliser votre propre code d’inférence dans le conteneur de modèle.
+ Utilisez un fichier `requirements.txt` dans le conteneur de modèle. Ce type de fichier répertorie les dépendances des packages.
+ Activer le paramètre `trust_remote_code` Hugging Face.
**Variables d'environnement prises en charge**
Vous pouvez configurer le conteneur avec les variables d’environnement suivantes :
+ Variables d’environnement communes pour les conteneurs d’inférence de modèles de grande taille (LMI).
Pour plus d’informations sur ces variables, consultez [Environment Variable Configurations](https://docs.djl.ai/master/docs/serving/serving/docs/lmi/deployment_guide/configurations.html#environment-variable-configurations) dans la documentation du conteneur LMI.
+ Variables d’environnement communes pour les packages fournis par le Hugging Face Hub dans ses référentiels Git.
Pour les référentiels, voir [Hugging](https://github.com/huggingface) Face on. GitHub
+ Variables d'environnement communes PyTorch et CUDA.
Pour plus d'informations sur ces variables, consultez la section [Variables d'environnement Torch](https://pytorch.org/docs/stable/torch_environment_variables.html) dans la PyTorch documentation.
# Affichage des résultats des tâches d’optimisation
Après avoir créé une ou plusieurs tâches d’optimisation, vous pouvez utiliser Studio pour afficher un tableau récapitulatif de toutes vos tâches, ainsi que les détails de chaque tâche individuelle.
## Amazon SageMaker Studio
**Pour consulter le tableau récapitulatif des tâches d’optimisation**
+ Dans le menu de navigation Studio, sous **Tâches**, choisissez **Optimisation de l’inférence**.
La page **Optimisation de l’inférence** affiche un tableau des tâches que vous avez créées. Pour chaque tâche, il répertorie les configurations d’optimisation que vous avez appliquées et l’état de la tâche.
**Pour afficher les détails d’une tâche**
+ Dans le tableau récapitulatif de la page **Optimisation de l’inférence**, cliquez sur le nom de la tâche.
Studio affiche la page des détails de la tâche, qui indique l’état de la tâche et tous les paramètres que vous avez appliqués lors de sa création. Si la tâche s’est terminée avec succès, SageMaker AI a stocké les artefacts du modèle optimisé dans l’emplacement Amazon S3 sous **URI S3 du modèle optimisé**.
# Évaluation des performances des modèles optimisés
Après avoir utilisé une tâche d’optimisation pour créer un modèle optimisé, vous pouvez exécuter une évaluation des performances du modèle. Cette évaluation fournit des métriques de latence, de débit et de prix. Utilisez ces métriques pour déterminer si le modèle optimisé répond aux besoins de votre cas d’utilisation ou s’il nécessite une optimisation supplémentaire.
Vous ne pouvez exécuter des évaluations de performances qu’à l’aide de Studio. Cette fonctionnalité n'est pas fournie par le biais de l'API Amazon SageMaker AI ou du SDK Python.
## Avant de commencer
Avant de créer une évaluation des performances, vous devez d’abord optimiser un modèle en créant une tâche d’optimisation d’inférence. Dans Studio, vous ne pouvez évaluer que les modèles que vous créez avec ces tâches.
## Création d’une évaluation de performances
Procédez comme suit dans Studio pour créer une évaluation des performances d’un modèle optimisé.
1. Dans le menu de navigation Studio, sous **Tâches**, choisissez **Optimisation de l’inférence**.
1. Choisissez le nom de la tâche qui a permis de créer le modèle optimisé à évaluer.
1. Sur la page des détails de la tâche, choisissez **Évaluer les performances**.
1. Sur la page **Evaluer les performances**, certains JumpStart modèles nécessitent que vous signiez un contrat de licence utilisateur final (EULA) avant de pouvoir continuer. Si nécessaire, consultez les termes du contrat de licence dans la section **Contrat de licence**. Si les conditions sont acceptables pour votre cas d’utilisation, cochez la case **J’accepte le CLUF et j’en ai lu les conditions générales**.
1. Pour **Sélectionnez un modèle comme créateur de jetons**, acceptez le modèle par défaut ou choisissez un modèle spécifique qui servira de créateur de jeton pour votre évaluation.
1. Pour **Jeux de données d’entrée**, choisissez si vous souhaitez :
+ Utilisez les exemples de jeux de données par défaut fournis par SageMaker AI.
+ fournir un URI S3 qui pointe vers vos propres exemples de jeux de données.
1. Pour **URI S3 destiné aux résultats de performances**, fournissez un URI qui pointe vers l’emplacement Amazon S3 où vous souhaitez stocker les résultats de l’évaluation.
1. Choisissez **Évaluer**.
Studio affiche la page **Évaluations des performances**, où votre tâche d’évaluation apparaît dans le tableau. La colonne **Statut** indique le statut de votre évaluation.
1. Lorsque le statut est **Terminé**, cliquez sur le nom de la tâche pour afficher les résultats de l’évaluation.
La page des détails de l’évaluation présente des tableaux qui fournissent les métriques de performances liées à la latence, au débit et au prix. Pour plus d’informations sur chaque métrique, consultez la [Référence des métriques pour les évaluations des performances d’inférence](#performance-eval-metrics-reference).
## Référence des métriques pour les évaluations des performances d’inférence
Une fois que vous avez réussi à évaluer les performances d’un modèle optimisé, la page des détails de l’évaluation affiche les métriques suivantes dans Studio.
### Métriques de latence
La section **Latence** présente les métriques suivantes.
**Concurrency**
Nombre d’utilisateurs simultanés simulés par l’évaluation pour invoquer simultanément le point de terminaison.
**Délai de réception du premier jeton (ms)**
Temps qui s’est écoulé entre l’envoi de la demande et la réception du premier jeton d’une réponse en streaming.
**Latence entre les jetons (ms)**
Temps nécessaire pour générer un jeton de sortie pour chaque demande.
**Latence du client (ms)**
Latence de la demande entre l’envoi de la demande et la réception de la réponse complète.
**Entrée tokens/sec (nombre)**
Nombre total de jetons d’entrée générés pour toutes les demandes, divisé par la durée totale en secondes de la simultanéité.
**Sortie tokens/sec (nombre)**
Nombre total de jetons de sortie générés pour toutes les demandes, divisé par la durée totale en secondes de la simultanéité.
**Invocations de clients (nombre)**
Nombre total de demandes d’inférence envoyées au point de terminaison par tous les utilisateurs simultanément.
**Erreurs d’invocation du client (nombre)**
Nombre total de demandes d’inférence envoyées au point de terminaison par tous les utilisateurs simultanément, qui ont généré une erreur d’invocation.
**Échecs du créateur de jetons (nombre)**
Nombre total de demandes d’inférence pour lesquelles le créateur de jetons n’a pas réussi à analyser la demande ou la réponse.
**Réponse d’inférence vide (nombre)**
Nombre total de demandes d’inférence qui ont entraîné l’absence de jetons de sortie ou l’échec de l’analyse de la réponse par le créateur de jetons.
### Métriques de débit
La section **Débit** présente les métriques suivantes.
**Concurrency**
Nombre d’utilisateurs simultanés simulés par l’évaluation pour invoquer simultanément le point de terminaison.
**Entrée tokens/sec/req (nombre)**
Nombre total de jetons d’entrée générés par seconde et par demande.
**Sortie tokens/sec/req (nombre)**
Nombre total de jetons de sortie générés par seconde et par demande.
**Jetons d’entrée (nombre)**
Nombre total de jetons d’entrée générés par demande.
**Jetons de sortie (nombre)**
Nombre total de jetons de sortie générés par demande.
### Métriques de prix
La section **Prix** présente les métriques suivantes.
**Concurrency**
Nombre d’utilisateurs simultanés simulés par l’évaluation pour invoquer simultanément le point de terminaison.
**Prix par million de jetons d’entrée**
Coût de traitement d’un million de jetons d’entrée.
**Prix par million de jetons de sortie**
Coût de génération d’un million de jetons de sortie.
# Référence des modèles pris en charge
Les tableaux suivants présentent les modèles pour lesquels l' SageMaker IA prend en charge l'optimisation par inférence, ainsi que les techniques d'optimisation prises en charge.
**Modèles Llama pris en charge**
| Nom du modèle | Formats de données pris en charge pour la quantification | Prend en charge le décodage spéculatif | Prend en charge le chargement rapide des modèles | Bibliothèques utilisées pour la compilation |
| --- | --- | --- | --- | --- |
| Meta Llama 2 13B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 2 13B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 2 70B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 2 70B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 2 7B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 2 7B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 3 70B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 3 70B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 3 8B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 3 8B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Code Llama 13B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 13B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 13B Python | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 34B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 34B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 34B Python | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 70B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 70B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 70B Python | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 7B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 7B Python | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Llama 2 13B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 2 13B Chat Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 2 70B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 2 70B Chat Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 2 7B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 2 7B Chat Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3 70B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3 70B Instruct Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3 8B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3 8B Instruct Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Code Llama 70B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Code Llama 7B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Code Llama 7B Python Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3.1 405B FP8 | Aucune | Oui | Oui | Aucune |
| Meta Llama 3.1 405B Instruire FP8 | Aucune | Oui | Oui | Aucune |
| Meta Llama 3.1 70B | INT4-AWQ FP8 | Oui | Oui | Aucune |
| Meta Llama 3.1 70B Instruct | INT4-AWQ FP8 | Oui | Oui | Aucune |
| Meta Llama 3.1 8B | INT4-AWQ FP8 | Oui | Oui | Aucune |
| Meta Llama 3.1 8B Instruct | INT4-AWQ FP8 | Oui | Oui | Aucune |
| Meta Llama 3.1 70B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3.1 70B Instruct Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3 1 8B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3.1 8B Instruct Neuron | Aucune | Non | Non | AWSNeurone |
**Modèles Mistral pris en charge**
| Nom du modèle | Formats de données pris en charge pour la quantification | Prend en charge le décodage spéculatif | Prend en charge le chargement rapide des modèles | Bibliothèques utilisées pour la compilation |
| --- | --- | --- | --- | --- |
| Mistral 7B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Mistral 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Mistral 7B Neuron | Aucune | Non | Non | AWSNeurone |
| Mistral 7B Instruct Neuron | Aucune | Non | Non | AWSNeurone |
**Modèles Mixtral pris en charge**
| Nom du modèle | Formats de données pris en charge pour la quantification | Prend en charge le décodage spéculatif | Prend en charge le chargement rapide des modèles | Bibliothèques utilisées pour la compilation |
| --- | --- | --- | --- | --- |
| Mixtral-8x22B-Instruct-v0.1 | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Mixtral-8x22B V1 | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Mixtral 8x7B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Mixtral 8x7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
**Architectures de modèles prises en charge et type EAGLE**
| Nom de l'architecture du modèle | Type EAGLE |
| --- | --- |
| LlamaForCausalLM | AIGLE 3 |
| Qwen 3 km ForCausal | AIGLE 3 |
| Qwen 3 km NextForCausal | AIGLE 2 |
| Qwen 3 km MoeForCausal | AIGLE 3 |
| Qwen 2 km ForCausal | AIGLE 3 |
| GptOssForCausalLM | AIGLE 3 |