Création d’une tâche d’optimisation d’inférence

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.

     2. Sur la page Tous les modèles publics, choisissez un fournisseur de modèles, puis l’un des modèles compatibles avec l’optimisation.

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

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

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

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

     2. Choisissez Create new job (Créer une nouvelle tâche).

     3. Sur la page Créer une tâche d’optimisation d’inférence, sélectionnez Ajouter un modèle.

     4. Dans la fenêtre Ajouter un modèle, sélectionnez Modèle personnalisé.

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

     6. (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.

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

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

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

4. (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.

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

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

2. 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éation d’un modèle dans Amazon SageMaker AI avec ModelBuilder.

   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)

2. 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 quemeta-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.

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.

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

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'SAGEMAKERutiliser 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.

2. 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 dans la documentation Hugging Face.

   Pour plus d’informations sur la bibliothèque huggingface_hub, consultez Hub client library dans la documentation Hugging Face.

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

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

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

2. 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 . . .'}