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