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. # Options d’hébergement Les rubriques suivantes décrivent les options d'hébergement en temps réel basées sur l' SageMaker IA disponibles, ainsi que la façon de configurer, d'invoquer et de supprimer chaque option d'hébergement. **Topics** + [ # Points de terminaison à modèle unique ](realtime-single-model.md) + [ # Points de terminaison multimodèles ](multi-model-endpoints.md) + [ # Points de terminaison multi-conteneurs ](multi-container-endpoints.md) + [ # Pipelines d'inférence dans Amazon AI SageMaker ](inference-pipelines.md) + [ # Supprimer les points de terminaison et les ressources ](realtime-endpoints-delete-resources.md) # Points de terminaison à modèle unique Vous pouvez créer, mettre à jour et supprimer des points de terminaison d’inférence en temps réel qui hébergent un modèle unique avec Amazon SageMaker Studio, le AWS SDK pour Python (Boto3), le kit SDK Python SageMaker, ou AWS CLI. Pour obtenir les procédures et des exemples de codes, consultez [Déploiement de modèles pour l’inférence en temps réel](realtime-endpoints-deploy-models.md). # Points de terminaison multimodèles Les points de terminaison multimodèles offrent une solution évolutive et économique pour le déploiement d'un grand nombre de modèles. Ils utilisent la même flotte de ressources et un conteneur de service partagé pour héberger tous vos modèles. Cela réduit les coûts d'hébergement en améliorant l'utilisation des points de terminaison par rapport à l'utilisation des points de terminaison à modèle unique. Cela réduit également les frais de déploiement, car Amazon SageMaker AI gère le chargement des modèles en mémoire et leur dimensionnement en fonction des modèles de trafic vers votre terminal. Le diagramme suivant montre comment les points de terminaison multimodèles fonctionnent par rapport aux points de terminaison à modèle unique. ![\[Diagramme illustrant comment les points de terminaison multimodèles hébergent des modèles par rapport aux points de terminaison à modèle unique.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/multi-model-endpoints-diagram.png) Les points de terminaison multimodèles sont idéaux pour héberger un grand nombre de modèles utilisant le même cadre de ML sur un conteneur de service partagé. Si vous disposez d’une combinaison de modèles fréquemment et peu utilisés, un point de terminaison multimodèle peut traiter efficacement ce trafic avec moins de ressources et des économies de coûts plus importantes. Votre application doit être tolérante aux pénalités de latence occasionnelles liées au démarrage à froid qui se produisent lors de l'appel de modèles peu utilisés. Les points de terminaison multimodèles permettent d’héberger à la fois des modèles basés sur des processeurs et des GPU. En utilisant des modèles basés sur des GPU, vous pouvez réduire les coûts de déploiement de vos modèles grâce à une utilisation accrue du point de terminaison et de ses instances de calcul accéléré sous-jacentes. Les points de terminaison multimodèles permettent également le partage du temps des ressources de mémoire sur l'ensemble de vos modèles. Cela fonctionne mieux lorsque les modèles sont assez similaires en taille et en latence d'invocation. Dans ce cas, les points de terminaison multimodèles peuvent utiliser efficacement des instances sur tous les modèles. Si vous avez des modèles qui ont des exigences de transactions par seconde (TPS) significativement plus élevées ou de latence, nous vous recommandons de les héberger sur des points de terminaison dédiés. Vous pouvez utiliser des points de terminaison multimodèles dotés des fonctions suivantes : + [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html)et VPCs + [Auto scaling](multi-model-endpoints-autoscaling.md) (Mise à l'échelle automatique) + [Serial inference pipelines](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html) (Pipelines d’inférence série) (mais un seul conteneur multimodèle peut être inclus dans un pipeline d’inférence) + Test A/B Vous pouvez utiliser la console AWS SDK pour Python (Boto) ou l' SageMaker IA pour créer un point de terminaison multimodèle. Pour les points de terminaison multimodèles basés sur des processeurs, vous pouvez créer votre point de terminaison avec des conteneurs personnalisés en intégrant la bibliothèque [Multi Model Server](https://github.com/awslabs/multi-model-server). **Topics** + [ ## Fonctionnement des points de terminaison multimodèles ](#how-multi-model-endpoints-work) + [ ## Exemples de blocs-notes pour les points de terminaison multimodèles ](#multi-model-endpoint-sample-notebooks) + [ # Algorithmes, cadres et instances pris en charge pour les points de terminaison multimodèles ](multi-model-support.md) + [ # Recommandations d’instance pour les déploiements de points de terminaison multimodèles ](multi-model-endpoint-instance.md) + [ # Créer un point de terminaison multimodèle ](create-multi-model-endpoint.md) + [ # Invoquer un point de terminaison multimodèle ](invoke-multi-model-endpoint.md) + [ # Ajouter ou supprimer des modèles ](add-models-to-endpoint.md) + [ # Créez votre propre conteneur pour les points de terminaison multimodèles basés sur l' SageMaker IA ](build-multi-model-build-container.md) + [ # Sécurité des points de terminaison multimodèles ](multi-model-endpoint-security.md) + [ # CloudWatch Métriques pour les déploiements de terminaux multimodèles ](multi-model-endpoint-cloudwatch-metrics.md) + [ # Définissez le comportement de mise en cache du modèle de terminal multimodèle basé sur l' SageMaker IA ](multi-model-caching.md) + [ # Définition de politiques d’autoscaling pour les déploiements de points de terminaison multimodèles ](multi-model-endpoints-autoscaling.md) ## Fonctionnement des points de terminaison multimodèles SageMaker L'IA gère le cycle de vie des modèles hébergés sur des points de terminaison multimodèles dans la mémoire du conteneur. Au lieu de télécharger tous les modèles d'un compartiment Amazon S3 vers le conteneur lorsque vous créez le point de terminaison, l' SageMaker IA les charge et les met en cache de manière dynamique lorsque vous les invoquez. Lorsque SageMaker l'IA reçoit une demande d'invocation pour un modèle particulier, elle effectue les opérations suivantes : 1. Route la demande vers une instance située derrière le point de terminaison. 1. Télécharge le modèle du compartiment S3 vers le volume de stockage de cette instance. 1. Charge le modèle dans la mémoire du conteneur (processeur ou GPU, selon que vous disposez d'instances basées sur des processeurs ou des GPU) sur cette instance de calcul accéléré. Si le modèle est déjà chargé dans la mémoire du conteneur, l'invocation est plus rapide car l' SageMaker IA n'a pas besoin de le télécharger ni de le charger. SageMaker L'IA continue d'acheminer les demandes de modèle vers l'instance où le modèle est déjà chargé. Toutefois, si le modèle reçoit de nombreuses demandes d'invocation et qu'il existe des instances supplémentaires pour le point de terminaison multimodèle, l' SageMaker IA achemine certaines demandes vers une autre instance pour répondre au trafic. Si le modèle n'est pas déjà chargé sur la deuxième instance, il est téléchargé sur le volume de stockage de cette instance et chargé dans la mémoire du conteneur. Lorsque l'utilisation de la mémoire d'une instance est élevée et que l' SageMaker IA doit charger un autre modèle en mémoire, elle décharge les modèles inutilisés du conteneur de cette instance afin de s'assurer qu'il y a suffisamment de mémoire pour charger le modèle. Les modèles qui sont déchargés restent sur le volume de stockage de l'instance et peuvent être chargés dans la mémoire du conteneur ultérieurement sans être téléchargés à nouveau depuis le compartiment S3. Si le volume de stockage de l'instance atteint sa capacité maximale, SageMaker AI supprime tous les modèles inutilisés du volume de stockage. Pour supprimer un modèle, arrêtez d'envoyer des demandes et supprimez-le du compartiment S3. SageMaker L'IA fournit une fonctionnalité de point de terminaison multimodèle dans un conteneur de service. L'ajout de modèles à un point de terminaison multimodèle et leur suppression ne nécessitent pas la mise à jour du point de terminaison lui-même. Pour ajouter un modèle, vous le chargez dans le compartiment S3 et vous l'appelez. Vous n'avez pas besoin de modifier le code pour l'utiliser. **Note** Lorsque vous mettez à jour un point de terminaison multimodèle, les demandes d’invocation initiales sur le point de terminaison peuvent présenter des latences plus élevées, car le routage intelligent des points de terminaison multimodèles s’adapte à votre modèle de trafic. Cependant, une fois qu'il connaît votre modèle de trafic, vous pouvez constater de faibles latences pour les modèles les plus fréquemment utilisés. Les modèles moins fréquemment utilisés peuvent présenter des latences de démarrage à froid, car les modèles sont chargés dynamiquement dans une instance. ## Exemples de blocs-notes pour les points de terminaison multimodèles Pour en savoir plus sur l’utilisation des points de terminaison multimodèles, vous pouvez essayer les exemples de bloc-notes suivants : + Exemples de points de terminaison multimodèles utilisant des instances basées sur des processeurs : + [ XGBoost Exemple de bloc-notes de point de terminaison multimodèle](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html) : ce bloc-notes explique comment déployer plusieurs XGBoost modèles sur un point de terminaison. + [Exemple de bloc-notes BYOC pour terminaux multimodèles — Ce bloc-notes](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_bring_your_own/multi_model_endpoint_bring_your_own.html) explique comment configurer et déployer un conteneur client qui prend en charge les points de terminaison multimodèles dans l'IA. SageMaker + Exemple de points de terminaison multimodèles utilisant des instances basées sur des GPU : + [Exécutez plusieurs modèles de deep learning GPUs avec Amazon SageMaker AI Multi-model endpoints (MME)](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb) — Ce bloc-notes explique comment utiliser un conteneur NVIDIA Triton Inference pour déployer ResNet -50 modèles sur un point de terminaison multimodèle. Pour savoir comment créer et accéder à des instances de bloc-notes Jupyter que vous pouvez utiliser pour exécuter les exemples précédents dans SageMaker AI, consultez. [Instances de SageMaker blocs-notes Amazon](nbi.md) Après avoir créé une instance de bloc-notes et l'avoir ouverte, choisissez l'onglet **Exemples d'SageMaker IA** pour voir la liste de tous les exemples d' SageMaker IA. Les blocs-notes de points de terminaison multimodèles se trouvent dans la section **FONCTIONNALITÉS AVANCÉES**. Pour ouvrir un bloc-notes, choisissez son onglet **Use** (Utiliser), puis **Create copy** (Créer une copie). Pour plus d’informations sur des cas d’utilisation des points de terminaison multimodèles, consultez les blogs et ressources suivants : + Vidéo : [Hébergement de milliers de modèles grâce à l' SageMaker IA](https://www.youtube.com/watch?v=XqCNTWmHsLc&t=751s) + Vidéo : [SageMaker AI ML pour le SaaS](https://www.youtube.com/watch?v=BytpYlJ3vsQ) + Blog : [How to scale machine learning inference for multi-tenant SaaS use cases](https://aws.amazon.com/blogs/machine-learning/how-to-scale-machine-learning-inference-for-multi-tenant-saas-use-cases/) (Comment mettre à l'échelle l'inférence de machine learning pour les cas d'utilisation SaaS à locataires multiples) + Étude de cas : [Veeva Systems](https://aws.amazon.com/partners/success/advanced-clinical-veeva/) (Systèmes Veeva) # Algorithmes, cadres et instances pris en charge pour les points de terminaison multimodèles Pour en savoir plus sur les algorithmes, les cadres et les types d’instances que vous pouvez utiliser avec des points de terminaison multimodèles, consultez les sections suivantes. ## Algorithmes, cadres et instances pris en charge pour les points de terminaison multimodèles utilisant des instances basées sur des processeurs Les conteneurs d'inférence pour les algorithmes et cadres suivants prennent en charge les points de terminaison multimodèles : + [XGBoost algorithme avec Amazon SageMaker AI](xgboost.md) + [Algorithme k-NN (K-Nearest Neighbors, k plus proches voisins)](k-nearest-neighbors.md) + [Algorithme d'apprentissage linéaire](linear-learner.md) + [Algorithme RCF (Random Cut Forest)](randomcutforest.md) + [Ressources à utiliser TensorFlow avec Amazon SageMaker AI](tf.md) + [Ressources pour utiliser Scikit-learn avec Amazon AI SageMaker](sklearn.md) + [Ressources pour utiliser Apache MXNet avec Amazon SageMaker AI](mxnet.md) + [Ressources à utiliser PyTorch avec Amazon SageMaker AI](pytorch.md) Pour utiliser un autre framework ou algorithme, utilisez la boîte à outils d'inférence SageMaker AI pour créer un conteneur prenant en charge les points de terminaison multimodèles. Pour plus d'informations, consultez [Créez votre propre conteneur pour les points de terminaison multimodèles basés sur l' SageMaker IA](build-multi-model-build-container.md). Les points de terminaison multimodèles prennent en charge tous les types d’instances de processeur. ## Algorithmes, cadres et instances pris en charge pour les points de terminaison multimodèles utilisant des instances basées sur des GPU L'hébergement de plusieurs modèles basés sur un GPU sur des terminaux multimodèles est pris en charge via le serveur [SageMaker AI Triton Inference.](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Cela prend en charge tous les principaux frameworks d'inférence tels que NVIDIA® TensorRT™, Python PyTorch, ONNX MXNet, scikit-learn XGBoost, OpenVINO, le C\$1\$1 personnalisé RandomForest, etc. Pour utiliser un autre cadre ou algorithme, vous pouvez utiliser le backend Triton pour Python ou C\$1\$1 pour écrire la logique de votre modèle et utiliser n'importe quel modèle personnalisé. Une fois le serveur prêt, vous pouvez commencer à déployer des centaines de modèles de deep learning sur un seul point de terminaison. Les points de terminaison multimodèles prennent en charge les types d’instances de GPU suivants : | Famille d’instances | Type d’instance | v CPUs | GiO de mémoire par vCPU | GPUs | Mémoire GPU | | --- | --- | --- | --- | --- | --- | | p2 | ml.p2.xlarge | 4 | 15,25 | 1 | 12 | | p3 | ml.p3.2xlarge | 8 | 7,62 | 1 | 16 | | g5 | ml.g5.xlarge | 4 | 4 | 1 | 24 | | g5 | ml.g5.2xlarge | 8 | 4 | 1 | 24 | | g5 | ml.g5.4xlarge | 16 | 4 | 1 | 24 | | g5 | ml.g5.8xlarge | 32 | 4 | 1 | 24 | | g5 | ml.g5.16xlarge | 64 | 4 | 1 | 24 | | g4dn | ml.g4dn.xlarge | 4 | 4 | 1 | 16 | | g4dn | ml.g4dn.2xlarge | 8 | 4 | 1 | 16 | | g4dn | ml.g4dn.4xlarge | 16 | 4 | 1 | 16 | | g4dn | ml.g4dn.8xlarge | 32 | 4 | 1 | 16 | | g4dn | ml.g4dn.16xlarge | 64 | 4 | 1 | 16 | # Recommandations d’instance pour les déploiements de points de terminaison multimodèles Plusieurs éléments doivent être pris en compte lors de la sélection d'un type d'instance SageMaker AI ML pour un point de terminaison multimodèle : + Provisionnez suffisamment de capacité [Amazon Elastic Block Store (Amazon EBS)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html) pour tous les modèles qui doivent être servis. + Équilibrez les performances (minimisez les démarrages à froid) et les coûts (ne surprovisionnez pas la capacité d'instance). Pour plus d'informations sur la taille du volume de stockage que l' SageMaker IA attache à chaque type d'instance pour un point de terminaison et pour un point de terminaison multimodèle, consultez[Volumes de stockage d’instances](host-instance-storage.md). + Pour un conteneur configuré pour s'exécuter en mode `MultiModel`, le volume de stockage provisionné pour ses instances est supérieur à celui du mode `SingleModel` par défaut. Cela permet à d'autres modèles d'être mis en cache sur le volume de stockage d'instance qu'en mode `SingleModel`. Lorsque vous choisissez un type d'instance SageMaker AI ML, tenez compte des points suivants : + Les points de terminaison multimodèles sont actuellement pris en charge pour tous les types d’instances de processeur et sur les types d’instances à GPU unique. + Pour la distribution du trafic (modèles d’accès) vers les modèles que vous souhaitez héberger derrière le point de terminaison multimodèle, ainsi que la taille du modèle (nombre de modèles pouvant être chargés en mémoire sur l’instance), gardez les informations suivantes à l’esprit : + Considérez la quantité de mémoire d'une instance comme l'espace de cache pour les modèles à charger, et le nombre de v CPUs comme la limite de simultanéité pour effectuer une inférence sur les modèles chargés (en supposant que l'appel d'un modèle est lié au processeur). + Pour les instances soutenues par le processeur, le nombre de v a un CPUs impact sur le nombre maximal d'appels simultanés par instance (en supposant que l'appel d'un modèle est lié au processeur). Une valeur plus élevée de v vous CPUs permet d'invoquer simultanément davantage de modèles uniques. + Pour les instances basées sur des GPU, une capacité de mémoire d'instance et de GPU supérieure vous permet d'avoir plus de modèles chargés et prêts à servir les demandes d'inférence. + Pour les instances basées sur des processeurs et des GPU, une mémoire « slack » disponible permet que les modèles inutilisés puissent être déchargés, en particulier pour les points de terminaison multimodèles avec plusieurs instances. Si une instance ou une zone de disponibilité échoue, les modèles de ces instances seront reroutés vers d'autres instances derrière le point de terminaison. + Déterminez votre tolérance au loading/downloading temps : + Les familles de types d'instances d (par exemple, m5d, c5d ou r5d) et g5s sont équipées d'un SSD NVMe (mémoire express non volatile), qui offre des I/O performances élevées et peut réduire le temps nécessaire pour télécharger les modèles sur le volume de stockage et pour que le conteneur charge le modèle depuis le volume de stockage. + Comme les types d'instances d et g5 sont fournis avec un stockage NVMe SSD, SageMaker AI n'attache aucun volume de stockage Amazon EBS à ces instances de calcul ML hébergeant le point de terminaison multimodèle. Auto Scaling fonctionne mieux lorsque les modèles sont similaires en taille et homogènes, c'est-à-dire lorsqu'ils ont des exigences de ressources et de latence d'inférence similaires. Vous pouvez également utiliser les conseils suivants pour optimiser le chargement des modèles sur vos points de terminaison multimodèles : **Choisir un type d'instance qui ne peut pas contenir tous les modèles ciblés en mémoire** Dans certains cas, vous pouvez choisir de réduire les coûts en choisissant un type d'instance qui ne peut pas conserver tous les modèles ciblés en mémoire en même temps. SageMaker L'IA décharge les modèles de manière dynamique lorsqu'il n'y a plus de mémoire disponible pour faire de la place à un nouveau modèle ciblé. Pour les modèles rarement demandés, vous sacrifiez la latence de charge dynamique. Dans les cas où les besoins de latence sont plus stricts, vous pouvez opter pour des types d'instance plus importants ou pour plus d'instances. Investir du temps à l'avance dans les tests et les analyses des performances vous aide à réussir vos déploiements de production. **Évaluation des accès au cache de votre modèle** CloudWatch Les statistiques Amazon peuvent vous aider à évaluer vos modèles. Pour plus d’informations sur les métriques que vous pouvez utilisez avec des points de terminaison multimodèles, consultez [CloudWatch Métriques pour les déploiements de terminaux multimodèles](multi-model-endpoint-cloudwatch-metrics.md). Vous pouvez utiliser la statistique `Average` de la métrique `ModelCacheHit` pour contrôler le ratio des demandes où le modèle est déjà chargé. Vous pouvez utiliser la statistique `SampleCount` de la métrique `ModelUnloadingTime` pour contrôler le nombre de demandes de déchargement envoyées au conteneur pendant une période donnée. Si les modèles sont déchargés trop fréquemment (indicateur de l’*écrasement*, où les modèles sont déchargés et chargés à nouveau parce qu’il n’y a pas suffisamment d’espace cache pour le jeu de modèles de travail), envisagez d’utiliser un type d’instance plus grand avec plus de mémoire ou d’augmenter le nombre d’instances derrière le point de terminaison multimodèle. Pour les points de terminaison multimodèles avec plusieurs instances, sachez qu’un modèle peut être chargé sur plus d’une instance. # Créer un point de terminaison multimodèle Vous pouvez utiliser la console SageMaker AI ou le AWS SDK pour Python (Boto) pour créer un point de terminaison multimodèle. Pour créer un point de terminaison basé sur un processeur ou un GPU via la console, consultez la procédure de console décrite dans les sections suivantes. Si vous souhaitez créer un point de terminaison multimodèle avec le AWS SDK pour Python (Boto), utilisez la procédure CPU ou GPU décrite dans les sections suivantes. Les flux de travail de processeur et de GPU sont similaires mais présentent plusieurs différences, notamment en ce qui concerne les exigences relatives aux conteneurs. **Topics** + [ ## Créer un point de terminaison multi-modèle (console) ](#create-multi-model-endpoint-console) + [ ## Créez un point de terminaison multimodèle à l' CPUs aide du AWS SDK pour Python (Boto3) ](#create-multi-model-endpoint-sdk-cpu) + [ ## Créez un point de terminaison multimodèle à l' GPUs aide du AWS SDK pour Python (Boto3) ](#create-multi-model-endpoint-sdk-gpu) ## Créer un point de terminaison multi-modèle (console) Vous pouvez créer des points de terminaison multimodèles basés sur des processeurs et des GPU via la console. Utilisez la procédure suivante pour créer un point de terminaison multimodèle via la console SageMaker AI. **Pour créer un point de terminaison multimodèle (console)** 1. Ouvrez la console Amazon SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/). 1. Choisissez **Model (Modèle)**, puis dans le groupe **Inference (Inférence)** choisissez **Create model (Créer un modèle)**. 1. Dans **Model name (Nom du modèle)**, entrez un nom. 1. Pour **IAM role** (Rôle IAM), choisissez ou créez un rôle IAM auquel la politique IAM `AmazonSageMakerFullAccess` est attachée. 1. Dans la section **Container definition** (Définition de conteneur), pour **Provide model artifacts and inference image options** (Fournir les options d'artefacts de modèle et d'image d'inférence), choisissez **Use multiple models** (Utiliser plusieurs modèles). ![\[Section de la page Créer un modèle où vous pouvez choisir l’option Utiliser plusieurs modèles.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/mme-create-model-ux-2.PNG) 1. Pour **Inference container image** (Image du conteneur d'inférence), entrez le chemin Amazon ECR de l'image de conteneur souhaitée. Pour les modèles de GPU, vous devez utiliser un conteneur basé sur le serveur d'inférence NVIDIA Triton. Pour obtenir la liste des images de conteneurs compatibles avec des points de terminaison basés sur des GPU, consultez [NVIDIA Triton Inference Containers (SM support only)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only) (Conteneurs d'inférence NVIDIA Triton (support SM uniquement)). Pour plus d'informations sur le serveur d'inférence NVIDIA Triton, voir [Utiliser le serveur d'inférence Triton](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) avec IA. SageMaker 1. Sélectionnez **Créer un modèle**. 1. Déployez votre point de terminaison multimodèle comme vous le feriez pour un point de terminaison de modèle unique. Pour obtenir des instructions, veuillez consulter [Déployer le modèle sur les services d'hébergement SageMaker AI](ex1-model-deployment.md#ex1-deploy-model). ## Créez un point de terminaison multimodèle à l' CPUs aide du AWS SDK pour Python (Boto3) Utilisez la section suivante pour créer un point de terminaison multimodèle basé sur des instances de processeur. Vous créez un point de terminaison multimodèle à l'aide de l' SageMaker intelligence artificielle d'Amazon [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model), [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) APIs comme vous le feriez pour un point de terminaison à modèle unique, mais avec deux modifications. Lors de la définition du conteneur de modèle, vous devez transmettre une nouvelle valeur de paramètre `Mode`, `MultiModel`. Vous devez également transmettre le champ `ModelDataUrl` qui spécifie le préfixe dans Amazon S3 où se trouvent les artefacts de modèle, au lieu du chemin d'accès à un artefact de modèle unique, comme vous le feriez pour le déploiement d'un modèle unique. Pour un exemple de bloc-notes utilisant l' SageMaker IA pour déployer plusieurs XGBoost modèles sur un point de terminaison, consultez la section [ XGBoost Exemple de bloc-notes de point de terminaison multimodèle](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html). La procédure suivante décrit les étapes clés utilisées dans cet exemple pour créer un point de terminaison multimodèle basé sur un processeur. **Pour déployer le modèle (AWS SDK pour Python (Boto 3))** 1. Obtenez un conteneur avec une image qui prend en charge le déploiement de points de terminaison multimodèles. Pour obtenir la liste des algorithmes intégrés et des conteneurs de cadre qui prennent en charge les points de terminaison multimodèles, consultez [Algorithmes, cadres et instances pris en charge pour les points de terminaison multimodèles](multi-model-support.md). Dans cet exemple, nous utilisons l'algorithme intégré [Algorithme k-NN (K-Nearest Neighbors, k plus proches voisins)](k-nearest-neighbors.md). Nous appelons la fonction utilitaire du [SDK SageMaker Python](https://sagemaker.readthedocs.io/en/stable/v2.html) `image_uris.retrieve()` pour obtenir l'adresse de l'image de l'algorithme intégré K-Nearest Nearest Neighbors. ``` import sagemaker region = sagemaker_session.boto_region_name image = sagemaker.image_uris.retrieve("knn",region=region) container = { 'Image': image, 'ModelDataUrl': 's3:///', 'Mode': 'MultiModel' } ``` 1. Procurez-vous un client AWS SDK pour Python (Boto3) SageMaker AI et créez le modèle qui utilise ce conteneur. ``` import boto3 sagemaker_client = boto3.client('sagemaker') response = sagemaker_client.create_model( ModelName = '', ExecutionRoleArn = role, Containers = [container]) ``` 1. (Facultatif) Si vous utilisez un pipeline d'inférence série, obtenez le ou les conteneurs supplémentaires à inclure dans le pipeline et incluez-le dans l'argument `Containers` de `CreateModel`: ``` preprocessor_container = { 'Image': '.dkr.ecr..amazonaws.com/:' } multi_model_container = { 'Image': '.dkr.ecr..amazonaws.com/:', 'ModelDataUrl': 's3:///', 'Mode': 'MultiModel' } response = sagemaker_client.create_model( ModelName = '', ExecutionRoleArn = role, Containers = [preprocessor_container, multi_model_container] ) ``` **Note** Vous ne pouvez utiliser qu'un seul point de multi-model-enabled terminaison dans un pipeline d'inférence en série. 1. (Facultatif) Si votre cas d'utilisation ne bénéficie pas de la mise en cache des modèles, définissez la valeur du champ `ModelCacheSetting` du paramètre `MultiModelConfig` sur `Disabled`, et incluez-la dans l'argument `Container` de l'appel à `create_model`. La valeur du champ `ModelCacheSetting` est `Enabled` par défaut. ``` container = { 'Image': image, 'ModelDataUrl': 's3:///', 'Mode': 'MultiModel' 'MultiModelConfig': { // Default value is 'Enabled' 'ModelCacheSetting': 'Disabled' } } response = sagemaker_client.create_model( ModelName = '', ExecutionRoleArn = role, Containers = [container] ) ``` 1. Configurez le point de terminaison multimodèle pour le modèle. Nous vous recommandons de configurer vos points de terminaison avec au moins deux instances. Cela permet à l' SageMaker IA de fournir un ensemble de prédictions hautement disponibles sur plusieurs zones de disponibilité pour les modèles. ``` response = sagemaker_client.create_endpoint_config( EndpointConfigName = '', ProductionVariants=[ { 'InstanceType': 'ml.m4.xlarge', 'InitialInstanceCount': 2, 'InitialVariantWeight': 1, 'ModelName': '', 'VariantName': 'AllTraffic' } ] ) ``` **Note** Vous ne pouvez utiliser qu'un seul point de multi-model-enabled terminaison dans un pipeline d'inférence en série. 1. Créez le point de terminaison multimodèle à l'aide des paramètres `EndpointName` et `EndpointConfigName`. ``` response = sagemaker_client.create_endpoint( EndpointName = '', EndpointConfigName = '') ``` ## Créez un point de terminaison multimodèle à l' GPUs aide du AWS SDK pour Python (Boto3) Utilisez la section suivante pour créer un point de terminaison multimodèle basé sur des GPU. Vous créez un point de terminaison multimodèle à l'aide de l' SageMaker intelligence artificielle d'Amazon [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model), et de la [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) APIs même manière que vous créez des points de terminaison à modèle unique, mais plusieurs modifications sont apportées. Lors de la définition du conteneur de modèle, vous devez transmettre une nouvelle valeur de paramètre `Mode`, `MultiModel`. Vous devez également transmettre le champ `ModelDataUrl` qui spécifie le préfixe dans Amazon S3 où se trouvent les artefacts de modèle, au lieu du chemin d'accès à un artefact de modèle unique, comme vous le feriez pour le déploiement d'un modèle unique. Pour les points de terminaison multimodèles basés sur des GPU, vous devez également utiliser un conteneur avec le serveur d’inférence NVIDIA Triton optimisé pour fonctionner sur des instances de GPU. Pour obtenir la liste des images de conteneurs compatibles avec des points de terminaison basés sur des GPU, consultez [NVIDIA Triton Inference Containers (SM support only)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only) (Conteneurs d'inférence NVIDIA Triton (support SM uniquement)). Pour un exemple de bloc-notes expliquant comment créer un point de terminaison multimodèle soutenu par GPUs, voir [Exécuter plusieurs modèles d'apprentissage profond avec des points de terminaison multimodèles (MME) GPUs Amazon SageMaker AI](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb). La procédure suivante décrit les étapes clés pour créer un point de terminaison multimodèle basé sur un GPU. **Pour déployer le modèle (AWS SDK pour Python (Boto 3))** 1. Définissez l'image de conteneur. Pour créer un point de terminaison multimodèle prenant en charge les ResNet modèles par GPU, définissez le conteneur qui utilisera l'image du [serveur NVIDIA Triton](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html). Ce conteneur prend en charge les points de terminaison multimodèles et est optimisé pour s’exécuter sur des instances de GPU. Nous appelons la fonction utilitaire [SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/v2.html) `image_uris.retrieve()` pour obtenir l'adresse de l'image. Par exemple : ``` import sagemaker region = sagemaker_session.boto_region_name // Find the sagemaker-tritonserver image at // https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-triton/resnet50/triton_resnet50.ipynb // Find available tags at https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only image = ".dkr.ecr..amazonaws.com/sagemaker-tritonserver:".format( account_id=account_id_map[region], region=region ) container = { 'Image': image, 'ModelDataUrl': 's3:///', 'Mode': 'MultiModel', "Environment": {"SAGEMAKER_TRITON_DEFAULT_MODEL_NAME": "resnet"}, } ``` 1. Procurez-vous un client AWS SDK pour Python (Boto3) SageMaker AI et créez le modèle qui utilise ce conteneur. ``` import boto3 sagemaker_client = boto3.client('sagemaker') response = sagemaker_client.create_model( ModelName = '', ExecutionRoleArn = role, Containers = [container]) ``` 1. (Facultatif) Si vous utilisez un pipeline d'inférence série, obtenez le ou les conteneurs supplémentaires à inclure dans le pipeline et incluez-le dans l'argument `Containers` de `CreateModel`: ``` preprocessor_container = { 'Image': '.dkr.ecr..amazonaws.com/:' } multi_model_container = { 'Image': '.dkr.ecr..amazonaws.com/:', 'ModelDataUrl': 's3:///', 'Mode': 'MultiModel' } response = sagemaker_client.create_model( ModelName = '', ExecutionRoleArn = role, Containers = [preprocessor_container, multi_model_container] ) ``` **Note** Vous ne pouvez utiliser qu'un seul point de multi-model-enabled terminaison dans un pipeline d'inférence en série. 1. (Facultatif) Si votre cas d'utilisation ne bénéficie pas de la mise en cache des modèles, définissez la valeur du champ `ModelCacheSetting` du paramètre `MultiModelConfig` sur `Disabled`, et incluez-la dans l'argument `Container` de l'appel à `create_model`. La valeur du champ `ModelCacheSetting` est `Enabled` par défaut. ``` container = { 'Image': image, 'ModelDataUrl': 's3:///', 'Mode': 'MultiModel' 'MultiModelConfig': { // Default value is 'Enabled' 'ModelCacheSetting': 'Disabled' } } response = sagemaker_client.create_model( ModelName = '', ExecutionRoleArn = role, Containers = [container] ) ``` 1. Configurez le point de terminaison multimodèle avec des instances basées sur des GPU pour le modèle. Nous vous recommandons de configurer vos points de terminaison avec plusieurs instances afin de garantir une haute disponibilité et un plus grand nombre d'accès au cache. ``` response = sagemaker_client.create_endpoint_config( EndpointConfigName = '', ProductionVariants=[ { 'InstanceType': 'ml.g4dn.4xlarge', 'InitialInstanceCount': 2, 'InitialVariantWeight': 1, 'ModelName': '', 'VariantName': 'AllTraffic' } ] ) ``` 1. Créez le point de terminaison multimodèle à l'aide des paramètres `EndpointName` et `EndpointConfigName`. ``` response = sagemaker_client.create_endpoint( EndpointName = '', EndpointConfigName = '') ``` # Invoquer un point de terminaison multimodèle Pour appeler un point de terminaison multimodèle, utilisez le point de terminaison [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint)depuis l' SageMaker AI Runtime comme vous appelleriez un point de terminaison à modèle unique, avec une seule modification. Transmettez un nouveau paramètre `TargetModel` qui spécifie le modèle au point de terminaison à cibler. La `InvokeEndpoint` demande SageMaker AI Runtime est prise en charge `X-Amzn-SageMaker-Target-Model` sous la forme d'un nouvel en-tête qui prend le chemin relatif du modèle spécifié pour l'invocation. Le système d' SageMaker IA construit le chemin absolu du modèle en combinant le préfixe fourni dans le cadre de l'appel d'`CreateModel`API avec le chemin relatif du modèle. Les procédures suivantes sont les mêmes pour les points de terminaison multimodèles basés sur des processeurs et des GPU. ------ #### [ AWS SDK for Python (Boto 3) ] L'exemple de demande de prédiction suivant utilise le [kit SDK AWS pour Python (Boto 3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html) dans l'exemple de bloc-notes. ``` response = runtime_sagemaker_client.invoke_endpoint( EndpointName = "", ContentType = "text/csv", TargetModel = ".tar.gz", Body = body) ``` ------ #### [ AWS CLI ] L'exemple suivant montre comment effectuer une demande CSV avec deux lignes à l'aide de la AWS Command Line Interface (AWS CLI) : ``` aws sagemaker-runtime invoke-endpoint \ --endpoint-name "" \ --body "1.0,2.0,5.0"$'\n'"2.0,3.0,4.0" \ --content-type "text/csv" \ --target-model ".tar.gz" output_file.txt ``` Un `output_file.txt` contenant des informations sur vos demandes d'inférence est créé si l'inférence a réussi. Pour plus d'exemples sur la façon de faire des prédictions avec le AWS CLI, consultez la section [Faire des prédictions avec le AWS CLI](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#making-predictions-with-the-aws-cli) dans la documentation du SDK SageMaker Python. ------ Le point de terminaison multimodèle charge dynamiquement les modèles cibles selon les besoins. Vous pouvez observer cela lors de l'exécution de l'[Exemple de bloc-notes MME](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html), car il itère à travers des invocations aléatoires sur plusieurs modèles cibles hébergés derrière un seul point de terminaison. La première demande relative à un modèle donné prend plus de temps, car le modèle doit être téléchargé depuis Amazon Simple Storage Service (Amazon S3) et chargé en mémoire. C’est ce que l’on appelle un *démarrage à froid*, et il doit optimiser les points de terminaison multimodèles pour offrir un meilleur rapport prix-performances aux clients. Les appels suivants se terminent plus rapidement, car il n'y a pas de surcharge supplémentaire après le chargement du modèle. **Note** Pour les instances basées sur des GPU, le code de réponse HTTP 507 provenant du conteneur GPU indique un manque de mémoire ou d'autres ressources. Cela entraîne le déchargement des modèles non utilisés du conteneur afin de charger les modèles les plus fréquemment utilisés. ## Réessayer les demandes en cas d'erreur ModelNotReadyException La première fois que vous appelez `invoke_endpoint` pour un modèle, le modèle est téléchargé depuis Amazon Simple Storage Service et chargé dans le conteneur d'inférence. Le renvoi du premier appel est donc plus long. Les appels suivants au même modèle se terminent plus rapidement, car le modèle est déjà chargé. SageMaker L'IA renvoie une réponse à un appel `invoke_endpoint` dans les 60 secondes. Certains modèles sont trop volumineux pour être téléchargés en 60 secondes. Si le chargement du modèle ne se termine pas dans les 60 secondes prévues, la demande de `invoke_endpoint` revient avec le code d'erreur `ModelNotReadyException`, et le téléchargement et le chargement du modèle dans le conteneur d'inférence se poursuivent pendant une durée maximale de 360 secondes. Si vous obtenez un code d'erreur `ModelNotReadyException` pour une demande `invoke_endpoint`, relancez la demande. Par défaut, les `invoke_endpoint` demandes de nouvelle tentative AWS SDKs pour Python (Boto 3) (utilisant le [mode de nouvelle tentative Legacy](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/retries.html#legacy-retry-mode)) et Java qui entraînent des erreurs. `ModelNotReadyException` Vous pouvez configurer la stratégie de relance pour continuer de relancer la demande pendant une durée maximale de 360 secondes. Si vous pensez que le téléchargement et le chargement de votre modèle dans le conteneur prendront plus de 60 secondes, définissez le délai d'expiration du socket SDK sur 70 secondes. Pour plus d'informations sur la configuration de la stratégie de relance pour le AWS SDK pour Python (Boto3), consultez [Configuring a retry mode](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/retries.html#configuring-a-retry-mode) (Configuration d'un mode de relance). Le code suivant montre un exemple de configuration de la politique de relance pour relancer des appels à`invoke_endpoint` pendant 180 secondes maximum. ``` import boto3 from botocore.config import Config # This example retry strategy sets the retry attempts to 2. # With this setting, the request can attempt to download and/or load the model # for upto 180 seconds: 1 orginal request (60 seconds) + 2 retries (120 seconds) config = Config( read_timeout=70, retries={ 'max_attempts': 2 # This value can be adjusted to 5 to go up to the 360s max timeout } ) runtime_sagemaker_client = boto3.client('sagemaker-runtime', config=config) ``` # Ajouter ou supprimer des modèles Vous pouvez déployer des modèles supplémentaires sur un point de terminaison multimodèle et les appeler immédiatement via ce point de terminaison. Lorsque vous ajoutez un nouveau modèle, vous n'avez pas besoin de mettre à jour ou de supprimer le point de terminaison. Vous évitez ainsi le coût de création et d'exécution d'un point de terminaison distinct pour chaque nouveau modèle. Le processus d’ajout et de suppression de modèles est le même pour les points de terminaison multimodèles basés sur un processeur et un GPU. SageMaker L'IA décharge les modèles inutilisés du conteneur lorsque l'instance atteint sa capacité de mémoire et que d'autres modèles doivent être téléchargés dans le conteneur. SageMaker L'IA supprime également les artefacts de modèle inutilisés du volume de stockage de l'instance lorsque celui-ci atteint sa capacité maximale et que de nouveaux modèles doivent être téléchargés. La première invocation d'un modèle nouvellement ajouté prend plus de temps car le point de terminaison prend du temps pour télécharger le modèle de S3 vers la mémoire du conteneur dans l'instance hébergeant le point de terminaison. Lorsque le point de terminaison est déjà en cours d'exécution, copiez un nouvel ensemble d'artefacts de modèle à l'emplacement Amazon S3 où vous stockez vos modèles. ``` # Add an AdditionalModel to the endpoint and exercise it aws s3 cp AdditionalModel.tar.gz s3://amzn-s3-demo-bucket/path/to/artifacts/ ``` **Important** Pour mettre à jour un modèle, procédez comme vous le feriez lors de l'ajout d'un nouveau modèle. Utilisez un nom nouveau et unique. Ne remplacez pas les artefacts de modèle dans Amazon S3, car l'ancienne version du modèle peut toujours être chargée dans les conteneurs ou sur le volume de stockage des instances sur le point de terminaison. Les appels vers le nouveau modèle pourraient alors invoquer l'ancienne version du modèle. Les applications clientes peuvent demander des prédictions à partir du modèle cible supplémentaire dès qu'il est stocké dans S3. ``` response = runtime_sagemaker_client.invoke_endpoint( EndpointName='', ContentType='text/csv', TargetModel='AdditionalModel.tar.gz', Body=body) ``` Pour supprimer un modèle d'un point de terminaison multimodèle, arrêtez d'appeler le modèle auprès des clients et supprimez-le de l'emplacement S3 où les artefacts de modèle sont stockés. # Créez votre propre conteneur pour les points de terminaison multimodèles basés sur l' SageMaker IA Reportez-vous aux sections suivantes pour apporter votre propre conteneur et vos dépendances à des points de terminaison multimodèles. **Topics** + [ ## Apportez vos propres dépendances pour les points de terminaison multimodèles sur les instances basées sur un processeur ](#build-multi-model-container-cpu) + [ ## Apport de vos propres dépendances pour les points de terminaison multimodèles sur les instances basées sur un GPU ](#build-multi-model-container-gpu) + [ ## Utiliser la boîte à SageMaker outils d'inférence AI ](#multi-model-inference-toolkit) + [ # Contrat pour les conteneurs personnalisés pour les points de terminaison multimodèles ](mms-container-apis.md) ## Apportez vos propres dépendances pour les points de terminaison multimodèles sur les instances basées sur un processeur Si aucune des images de conteneur prédéfinies ne répond à vos besoins, vous pouvez créer votre propre conteneur à utiliser avec des points de terminaison multimodèles soutenus par le processeur. Les images Amazon Elastic Container Registry (Amazon ECR) personnalisées déployées dans SageMaker Amazon AI sont censées respecter le contrat de base décrit [Code d’inférence personnalisé avec les services d’hébergement](your-algorithms-inference-code.md) dans ce document, qui régit la SageMaker manière dont l'IA interagit avec un conteneur Docker qui exécute votre propre code d'inférence. Pour qu'un conteneur soit capable de charger et de desservir plusieurs modèles simultanément, APIs d'autres comportements doivent être suivis. Ce contrat supplémentaire inclut de nouveaux modèles APIs à charger, répertorier, obtenir et décharger, ainsi qu'une API différente pour invoquer des modèles. Il existe également différents comportements pour les scénarios d'erreur auxquels APIs il faut se conformer. Pour indiquer que le conteneur satisfait aux exigences supplémentaires, vous pouvez ajouter la commande suivante à votre fichier Docker : ``` LABEL com.amazonaws.sagemaker.capabilities.multi-models=true ``` SageMaker L'IA injecte également une variable d'environnement dans le conteneur ``` SAGEMAKER_MULTI_MODEL=true ``` Si vous créez un point de terminaison multimodèle pour un pipeline d'inférence série, votre fichier Docker doit avoir les étiquettes requises pour les pipelines multimodèles et d'inférence série. Pour plus d’informations sur les pipelines d’informations série, consultez [Réalisation de prédictions en temps réel avec un pipeline d'inférence](inference-pipeline-real-time.md). Pour vous aider à implémenter ces exigences pour un conteneur personnalisé, deux bibliothèques sont disponibles : + [Multi Model Server](https://github.com/awslabs/multi-model-server) est un framework open source destiné à servir des modèles d'apprentissage automatique qui peuvent être installés dans des conteneurs afin de fournir le front-end répondant aux exigences du nouveau conteneur de points de terminaison multimodèles. APIs Il fournit les capacités de gestion frontale et de modèle HTTP requises par les points de terminaison multimodèles pour héberger plusieurs modèles dans un conteneur unique, y charger des modèles et décharger dynamiquement des modèles hors du conteneur, et effectuer une inférence sur un modèle chargé spécifié. Il fournit également un backend enfichable qui prend en charge un gestionnaire backend personnalisé enfichable où vous pouvez implémenter votre propre algorithme. + [SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit) est une bibliothèque qui démarre un serveur multimodèle avec une configuration et des paramètres qui le rendent compatible avec les points de terminaison multi-modèles d' SageMaker IA. Il vous permet également de modifier des paramètres de performance importants, tels que le nombre de employés par modèle, en fonction des besoins de votre scénario. ## Apport de vos propres dépendances pour les points de terminaison multimodèles sur les instances basées sur un GPU La fonctionnalité BYOC (Bring your own container) sur les terminaux multimodèles dotés d'instances basées sur le GPU n'est actuellement pas prise en charge par les bibliothèques Multi Model Server et SageMaker AI Inference Toolkit. Pour créer des points de terminaison multimodèles avec des instances basées sur le GPU, vous pouvez utiliser le [serveur d'inférence NVIDIA Triton compatible avec l' SageMaker IA avec les conteneurs d'inférence](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) [NVIDIA](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only) Triton. Pour créer vos propres dépendances, vous pouvez créer votre propre conteneur avec le [serveur d'inférence NVIDIA Triton](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) compatible avec l' SageMaker IA comme image de base de votre fichier Docker : ``` FROM 301217895009.dkr.ecr.us-west-2.amazonaws.com/sagemaker-tritonserver:22.07-py3 ``` **Important** Les conteneurs équipés du serveur d’inférence Triton sont les seuls conteneurs pris en charge que vous pouvez utiliser pour les points de terminaison multimodèles basés sur des GPU. ## Utiliser la boîte à SageMaker outils d'inférence AI **Note** L' SageMaker AI Inference Toolkit n'est pris en charge que pour les points de terminaison multimodèles dotés d'un processeur. L' SageMaker AI Inference Toolkit n'est actuellement pas pris en charge pour les points de terminaison multimodèles dotés d'un processeur graphique. Les conteneurs prédéfinis qui prennent en charge les points de terminaison multimodèles sont répertoriés dans [Algorithmes, cadres et instances pris en charge pour les points de terminaison multimodèles](multi-model-support.md). Si vous voulez utiliser un autre framework ou algorithme, vous devez créer un conteneur. Le moyen le plus simple d'y parvenir est d'utiliser l'[SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit) pour étendre un conteneur prédéfini existant. Le kit d'outils d'inférence SageMaker AI est une implémentation pour le serveur multimodèle (MMS) qui crée des points de terminaison pouvant être déployés dans l'IA. SageMaker Pour un exemple de bloc-notes expliquant comment configurer et déployer un conteneur personnalisé prenant en charge les points de terminaison multimodèles dans l' SageMaker IA, consultez le bloc-notes [BYOC pour terminaux multimodèles](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/multi_model_bring_your_own). **Note** La boîte à outils d'inférence SageMaker AI ne prend en charge que les gestionnaires de modèles Python. Si vous souhaitez implémenter votre gestionnaire dans un autre langage, vous devez créer votre propre conteneur qui implémente le point de terminaison multimodèle supplémentaire. APIs Pour plus d'informations, consultez [Contrat pour les conteneurs personnalisés pour les points de terminaison multimodèles](mms-container-apis.md). **Pour étendre un conteneur à l'aide de la boîte à outils d'inférence SageMaker AI** 1. Créez un gestionnaire de modèles. Le serveur MMS attend un gestionnaire de modèles, qui est un fichier Python implémentant des fonctions pour prétraiter, obtenir des prédictions à partir du modèle et traiter la sortie dans un gestionnaire de modèles. Pour obtenir un exemple de gestionnaire de modèles, consultez [model\$1handler.py](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/multi_model_bring_your_own/container/model_handler.py) dans l’exemple de bloc-notes. 1. Importez la boîte à outils d'inférence et utilisez sa fonction `model_server.start_model_server` pour démarrer le serveur MMS. L'exemple suivant provient du fichier `dockerd-entrypoint.py` de l'exemple de bloc-notes. Notez que l'appel à `model_server.start_model_server` transmet le gestionnaire de modèles décrit à l'étape précédente : ``` import subprocess import sys import shlex import os from retrying import retry from subprocess import CalledProcessError from sagemaker_inference import model_server def _retry_if_error(exception): return isinstance(exception, CalledProcessError or OSError) @retry(stop_max_delay=1000 * 50, retry_on_exception=_retry_if_error) def _start_mms(): # by default the number of workers per model is 1, but we can configure it through the # environment variable below if desired. # os.environ['SAGEMAKER_MODEL_SERVER_WORKERS'] = '2' model_server.start_model_server(handler_service='/home/model-server/model_handler.py:handle') def main(): if sys.argv[1] == 'serve': _start_mms() else: subprocess.check_call(shlex.split(' '.join(sys.argv[1:]))) # prevent docker exit subprocess.call(['tail', '-f', '/dev/null']) main() ``` 1. Dans votre fichier `Dockerfile`, copiez le gestionnaire de modèles de la première étape et spécifiez le fichier Python de l'étape précédente comme point d'entrée dans votre `Dockerfile`. Les lignes suivantes proviennent du fichier [Dockerfile](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/multi_model_bring_your_own/container/Dockerfile) utilisé dans l'exemple de bloc-notes : ``` # Copy the default custom service file to handle incoming data and inference requests COPY model_handler.py /home/model-server/model_handler.py # Define an entrypoint script for the docker image ENTRYPOINT ["python", "/usr/local/bin/dockerd-entrypoint.py"] ``` 1. Créez et enregistrez votre conteneur. Le script shell suivant provenant de l'exemple de bloc-notes crée le conteneur et le charge dans un référentiel Elastic Container Registry de votre compte AWS  : ``` %%sh # The name of our algorithm algorithm_name=demo-sagemaker-multimodel cd container account=$(aws sts get-caller-identity --query Account --output text) # Get the region defined in the current configuration (default to us-west-2 if none defined) region=$(aws configure get region) region=${region:-us-west-2} fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest" # If the repository doesn't exist in ECR, create it. aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1 if [ $? -ne 0 ] then aws ecr create-repository --repository-name "${algorithm_name}" > /dev/null fi # Get the login command from ECR and execute it directly $(aws ecr get-login --region ${region} --no-include-email) # Build the docker image locally with the image name and then push it to ECR # with the full name. docker build -q -t ${algorithm_name} . docker tag ${algorithm_name} ${fullname} docker push ${fullname} ``` Vous pouvez désormais utiliser ce conteneur pour déployer des points de terminaison multimodèles dans SageMaker l'IA. **Topics** + [ ## Apportez vos propres dépendances pour les points de terminaison multimodèles sur les instances basées sur un processeur ](#build-multi-model-container-cpu) + [ ## Apport de vos propres dépendances pour les points de terminaison multimodèles sur les instances basées sur un GPU ](#build-multi-model-container-gpu) + [ ## Utiliser la boîte à SageMaker outils d'inférence AI ](#multi-model-inference-toolkit) + [ # Contrat pour les conteneurs personnalisés pour les points de terminaison multimodèles ](mms-container-apis.md) # Contrat pour les conteneurs personnalisés pour les points de terminaison multimodèles Pour gérer plusieurs modèles, votre conteneur doit prendre en charge un ensemble de modèles APIs permettant à Amazon SageMaker AI de communiquer avec le conteneur pour charger, répertorier, obtenir et décharger les modèles selon les besoins. Le `model_name` est utilisé dans le nouvel ensemble de APIs comme paramètre d'entrée clé. Le conteneur client doit suivre les modèles chargés en utilisant `model_name` comme clé de mappage. En outre, le `model_name` est un identificateur opaque et n'est pas nécessairement la valeur du paramètre `TargetModel` passé dans l'API `InvokeEndpoint`. La `TargetModel` valeur d'origine de la `InvokeEndpoint` demande est transmise au conteneur APIs sous forme d'`X-Amzn-SageMaker-Target-Model`en-tête qui peut être utilisé à des fins de journalisation. **Note** Les points de terminaison multimodèles pour les instances basées sur le GPU ne sont actuellement pris en charge qu'avec le conteneur [NVIDIA Triton Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Server d' SageMaker AI. Ce conteneur met déjà en œuvre le contrat défini ci-dessous. Les clients peuvent utiliser ce conteneur directement avec leurs points de terminaison sur GPU multimodèles, sans aucune intervention supplémentaire. Vous pouvez configurer les éléments suivants APIs sur vos conteneurs pour les points de terminaison multimodèles soutenus par le processeur. **Topics** + [ ## API Load Model (Charger un modèle) ](#multi-model-api-load-model) + [ ## API List Model (Afficher un modèle) ](#multi-model-api-list-model) + [ ## API Get Model (Obtenir un modèle) ](#multi-model-api-get-model) + [ ## API Unload Model (Décharger un modèle) ](#multi-model-api-unload-model) + [ ## API Invoke Model (Appeler un modèle) ](#multi-model-api-invoke-model) ## API Load Model (Charger un modèle) Indique au conteneur de charger un modèle particulier présent dans le champ `url` du corps dans la mémoire du conteneur client et de garder une trace de celui-ci avec le `model_name` assigné. Après le chargement d'un modèle, le conteneur doit être prêt à servir les demandes d'inférence en utilisant ce `model_name`. ``` POST /models HTTP/1.1 Content-Type: application/json Accept: application/json { "model_name" : "{model_name}", "url" : "/opt/ml/models/{model_name}/model", } ``` **Note** Si le `model_name` est déjà chargée, l'API doit retourner 409. Chaque fois qu'un modèle ne peut pas être chargé en raison d'un manque de mémoire ou d'une autre ressource, cette API doit renvoyer un code d'état HTTP 507 à SageMaker AI, qui lance ensuite le déchargement des modèles inutilisés pour les récupérer. ## API List Model (Afficher un modèle) Renvoie la liste des modèles chargés dans la mémoire du conteneur client. ``` GET /models HTTP/1.1 Accept: application/json Response = { "models": [ { "modelName" : "{model_name}", "modelUrl" : "/opt/ml/models/{model_name}/model", }, { "modelName" : "{model_name}", "modelUrl" : "/opt/ml/models/{model_name}/model", }, .... ] } ``` Cette API prend également en charge la pagination. ``` GET /models HTTP/1.1 Accept: application/json Response = { "models": [ { "modelName" : "{model_name}", "modelUrl" : "/opt/ml/models/{model_name}/model", }, { "modelName" : "{model_name}", "modelUrl" : "/opt/ml/models/{model_name}/model", }, .... ] } ``` SageMaker L'IA peut initialement appeler l'API List Models sans fournir de valeur pour`next_page_token`. Si un champ `nextPageToken` est renvoyé dans le cadre de la réponse, il sera fourni comme valeur pour `next_page_token` dans un appel de l'API List Models ultérieur. Si un `nextPageToken` n'est pas retourné, cela signifie qu'il n'y a plus de modèles à retourner. ## API Get Model (Obtenir un modèle) Il s'agit d'une API de lecture simple sur l'entité `model_name`. ``` GET /models/{model_name} HTTP/1.1 Accept: application/json { "modelName" : "{model_name}", "modelUrl" : "/opt/ml/models/{model_name}/model", } ``` **Note** Si `model_name` n'est pas chargé, l'API doit retourner 404. ## API Unload Model (Décharger un modèle) Demande à la plateforme d' SageMaker IA de demander au conteneur client de décharger un modèle de la mémoire. Cela initie l'expulsion d'un modèle candidat tel que déterminé par la plate-forme lors du démarrage du processus de chargement d'un nouveau modèle. Les ressources provisionnées dans `model_name` doivent être récupérées par le conteneur lorsque l'API renvoie une réponse. ``` DELETE /models/{model_name} ``` **Note** Si `model_name` n'est pas chargé, l'API doit retourner 404. ## API Invoke Model (Appeler un modèle) Fait une demande de prédiction à partir du `model_name` particulier fourni. La `InvokeEndpoint` demande SageMaker AI Runtime est prise en charge `X-Amzn-SageMaker-Target-Model` sous la forme d'un nouvel en-tête qui prend le chemin relatif du modèle spécifié pour l'invocation. Le système d' SageMaker IA construit le chemin absolu du modèle en combinant le préfixe fourni dans le cadre de l'appel d'`CreateModel`API avec le chemin relatif du modèle. ``` POST /models/{model_name}/invoke HTTP/1.1 Content-Type: ContentType Accept: Accept X-Amzn-SageMaker-Custom-Attributes: CustomAttributes X-Amzn-SageMaker-Target-Model: [relativePath]/{artifactName}.tar.gz ``` **Note** Si `model_name` n'est pas chargé, l'API doit retourner 404. De plus, sur les instances GPU, en cas d'`InvokeEndpoint`échec dû à un manque de mémoire ou à d'autres ressources, cette API doit renvoyer un code d'état HTTP 507 à l' SageMaker IA, qui lance ensuite le déchargement des modèles inutilisés pour les récupérer. # Sécurité des points de terminaison multimodèles Les modèles et les données d'un point de terminaison multimodèle sont co-localisés sur le volume du stockage d'instance et dans la mémoire du conteneur. Toutes les instances des points de terminaison Amazon SageMaker AI s'exécutent sur un conteneur client unique dont vous êtes le propriétaire. Seuls vos modèles peuvent s'exécuter sur votre point de terminaison multimodèle. Il est de votre responsabilité de gérer le mappage des demandes vers les modèles et de permettre aux utilisateurs d'accéder aux modèles cibles appropriés. SageMaker L'IA utilise [les rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) pour fournir des politiques basées sur l'identité IAM que vous utilisez pour spécifier les actions et les ressources autorisées ou refusées, ainsi que les conditions dans lesquelles les actions sont autorisées ou refusées. Par défaut, un principal IAM disposant d'autorisations [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) sur un point de terminaison multimodèles peut appeler n'importe quel modèle à l'adresse du préfixe S3 défini dans l'opération [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), sous réserve que le rôle d'exécution IAM défini dans l'opération dispose des autorisations pour télécharger le modèle. Si vous devez restreindre l'accès à [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) à un ensemble limité de modèles dans S3, vous pouvez effectuer l'une des opérations suivantes : + Restreindre les appels `InvokeEndpont` à des modèles spécifiques hébergés sur le point de terminaison à l'aide de la clé de condition IAM `sagemaker:TargetModel`. Par exemple, la stratégie suivante autorise les demandes `InvokeEndpont` uniquement lorsque la valeur du champ `TargetModel` correspond à l'une des expressions régulières spécifiées : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Action": [ "sagemaker:InvokeEndpoint" ], "Effect": "Allow", "Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name", "Condition": { "StringLike": { "sagemaker:TargetModel": ["company_a/*", "common/*"] } } } ] } ``` ------ Pour plus d'informations sur les clés de condition SageMaker AI, consultez la section [Clés de condition pour Amazon SageMaker AI](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html#amazonsagemaker-policy-keys) dans le *guide de Gestion des identités et des accès AWS l'utilisateur*. + Créez des points de terminaison à plusieurs modèles avec des préfixes S3 plus restrictifs. Pour plus d'informations sur la manière dont l' SageMaker IA utilise les rôles pour gérer l'accès aux points de terminaison et effectuer des opérations en votre nom, consultez[Comment utiliser les rôles d'exécution de l' SageMaker IA](sagemaker-roles.md). Vos clients peuvent également avoir certaines exigences d'isolement des données dictées par leurs propres exigences de conformité qui peuvent être satisfaites à l'aide d'identités IAM. # CloudWatch Métriques pour les déploiements de terminaux multimodèles Amazon SageMaker AI fournit des métriques pour les points de terminaison afin que vous puissiez surveiller le taux de réussite du cache, le nombre de modèles chargés et les temps d'attente des modèles pour le chargement, le téléchargement et le chargement sur un point de terminaison multimodèle. Certaines métriques sont différentes pour les points de terminaison multimodèles soutenus par le processeur et le GPU. Les sections suivantes décrivent donc les CloudWatch métriques Amazon que vous pouvez utiliser pour chaque type de point de terminaison multimodèle. Pour plus d’informations, consultez **Métriques de chargement du modèle de point de terminaison multimodèle** et **Métriques d’instance de modèles de points de terminaison multimodèles** dans [Métriques Amazon SageMaker AI sur Amazon CloudWatch](monitoring-cloudwatch.md). Les métriques par modèle ne sont pas prises en charge. ## CloudWatch métriques pour les points de terminaison multimodèles dotés d'un processeur Vous pouvez surveiller les métriques suivantes sur les points de terminaison multimodèles basés sur des processeurs. L'espace de `AWS/SageMaker` noms inclut les métriques de chargement du modèle suivantes à partir d'appels vers [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html). Les métriques sont disponibles à la fréquence d'une (1) minute. Pour plus d'informations sur la durée de conservation des CloudWatch métriques, consultez [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)le *Amazon CloudWatch API Reference*. **Métriques de chargement du modèle de point de terminaison multimodèle** | Métrique | Description | | --- | --- | | ModelLoadingWaitTime | Intervalle de temps pendant lequel une demande d'invocation attend le téléchargement ou le chargement du modèle cible, ou les deux, pour effectuer une inférence. Unités : microsecondes Statistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage | | ModelUnloadingTime | Intervalle de temps nécessaire pour décharger le modèle via l'appel d'API `UnloadModel` du conteneur. Unités : microsecondes Statistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage | | ModelDownloadingTime | Intervalle de temps nécessaire pour télécharger le modèle depuis Amazon Simple Storage Service (Amazon S3). Unités : microsecondes Statistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage | | ModelLoadingTime | Intervalle de temps nécessaire pour charger le modèle via l'appel de l'API `LoadModel` du conteneur. Unités : microsecondes Statistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage | | ModelCacheHit | Nombre de demandes `InvokeEndpoint` envoyées au point de terminaison multimodèle pour lequel le modèle était déjà chargé. La statistique Average (Moyenne) indique le ratio des demandes pour lesquelles le modèle a déjà été chargé. Unités : aucune Statistiques valides : Average (Moyenne), Sum (Somme), Sample Count (Nombre d'exemples) | **Dimensions for Multi-Model Endpoint Model Loading Metrics (Dimensions des métriques de chargement du modèle de point de terminaison multimodèle)** | Dimension | Description | | --- | --- | | EndpointName, VariantName | Filtre les métriques d'appel de point de terminaison pour un `ProductionVariant` du point de terminaison et de la variante spécifiés. | Les espaces de noms `/aws/sagemaker/Endpoints` incluent les métriques d'instance suivantes des appels vers [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html). Les métriques sont disponibles à la fréquence d'une (1) minute. Pour plus d'informations sur la durée de conservation des CloudWatch métriques, consultez [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)le *Amazon CloudWatch API Reference*. **Métriques d'instance de modèle de point de terminaison multimodèle** | Métrique | Description | | --- | --- | | LoadedModelCount | Nombre de modèles chargés dans les conteneurs du point de terminaison multimodèle. Cette métrique est émise par instance. La statistique Average (Moyenne) avec une période de 1 minute indique le nombre moyen de modèles chargés par instance. La statistique Sum (Somme) indique le nombre total de modèles chargés sur toutes les instances du point de terminaison. Les modèles que cette métrique suit ne sont pas nécessairement uniques, car un modèle peut être chargé dans plusieurs conteneurs au point de terminaison. Unités : aucune Statistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage | | CPUUtilization | La somme de l'utilisation de chaque cœur de processeur individuel. L'utilisation du processeur de chaque cœur peut aller de 0 à 100. Par exemple, s'il y en a quatre CPUs, la `CPUUtilization` plage est comprise entre 0 % et 400 %. Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation de l'UC du conteneur principal et des conteneurs supplémentaires sur l'instance. Unités : pourcentage | | MemoryUtilization | Pourcentage de mémoire utilisée par les conteneurs sur une instance. Cette plage de valeurs est comprise entre 0 % et 100 %. Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation de la mémoire du conteneur principal et des conteneurs supplémentaires sur l'instance. Unités : pourcentage | | DiskUtilization | Le pourcentage d'espace disque utilisé par les conteneurs sur une instance. Cette plage de valeurs est comprise entre 0 % et 100 %. Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation de l'espace disque du conteneur principal et des conteneurs supplémentaires sur l'instance. Unités : pourcentage | ## CloudWatch métriques pour les déploiements de terminaux multi-modèles GPU Vous pouvez surveiller les métriques suivantes sur les points de terminaison multimodèles basés sur des GPU. L'espace de `AWS/SageMaker` noms inclut les métriques de chargement du modèle suivantes à partir d'appels vers [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html). Les métriques sont disponibles à la fréquence d'une (1) minute. Pour plus d'informations sur la durée de conservation des CloudWatch métriques, consultez [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)le *Amazon CloudWatch API Reference*. **Métriques de chargement du modèle de point de terminaison multimodèle** | Métrique | Description | | --- | --- | | ModelLoadingWaitTime | Intervalle de temps pendant lequel une demande d'invocation attend le téléchargement ou le chargement du modèle cible, ou les deux, pour effectuer une inférence. Unités : microsecondes Statistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage | | ModelUnloadingTime | Intervalle de temps nécessaire pour décharger le modèle via l'appel d'API `UnloadModel` du conteneur. Unités : microsecondes Statistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage | | ModelDownloadingTime | Intervalle de temps nécessaire pour télécharger le modèle depuis Amazon Simple Storage Service (Amazon S3). Unités : microsecondes Statistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage | | ModelLoadingTime | Intervalle de temps nécessaire pour charger le modèle via l'appel de l'API `LoadModel` du conteneur. Unités : microsecondes Statistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage | | ModelCacheHit | Nombre de demandes `InvokeEndpoint` envoyées au point de terminaison multimodèle pour lequel le modèle était déjà chargé. La statistique Average (Moyenne) indique le ratio des demandes pour lesquelles le modèle a déjà été chargé. Unités : aucune Statistiques valides : Average (Moyenne), Sum (Somme), Sample Count (Nombre d'exemples) | **Dimensions for Multi-Model Endpoint Model Loading Metrics (Dimensions des métriques de chargement du modèle de point de terminaison multimodèle)** | Dimension | Description | | --- | --- | | EndpointName, VariantName | Filtre les métriques d'appel de point de terminaison pour un `ProductionVariant` du point de terminaison et de la variante spécifiés. | Les espaces de noms `/aws/sagemaker/Endpoints` incluent les métriques d'instance suivantes des appels vers [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html). Les métriques sont disponibles à la fréquence d'une (1) minute. Pour plus d'informations sur la durée de conservation des CloudWatch métriques, consultez [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)le *Amazon CloudWatch API Reference*. **Métriques d'instance de modèle de point de terminaison multimodèle** | Métrique | Description | | --- | --- | | LoadedModelCount | Nombre de modèles chargés dans les conteneurs du point de terminaison multimodèle. Cette métrique est émise par instance. La statistique Average (Moyenne) avec une période de 1 minute indique le nombre moyen de modèles chargés par instance. La statistique Sum (Somme) indique le nombre total de modèles chargés sur toutes les instances du point de terminaison. Les modèles que cette métrique suit ne sont pas nécessairement uniques, car un modèle peut être chargé dans plusieurs conteneurs au point de terminaison. Unités : aucune Statistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage | | CPUUtilization | La somme de l'utilisation de chaque cœur de processeur individuel. L'utilisation du processeur de chaque cœur peut aller de 0 à 100. Par exemple, s'il y en a quatre CPUs, la `CPUUtilization` plage est comprise entre 0 % et 400 %. Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation de l'UC du conteneur principal et des conteneurs supplémentaires sur l'instance. Unités : pourcentage | | MemoryUtilization | Pourcentage de mémoire utilisée par les conteneurs sur une instance. Cette plage de valeurs est comprise entre 0 % et 100 %. Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation de la mémoire du conteneur principal et des conteneurs supplémentaires sur l'instance. Unités : pourcentage | | GPUUtilization | Pourcentage d'unités GPU utilisées par les conteneurs sur une instance. La valeur comprise entre 0 et 100 est multipliée par le nombre de. GPUs Par exemple, s'il y en a quatre GPUs, la `GPUUtilization` plage est comprise entre 0 % et 400 %. Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation d'unités GPU du conteneur principal et des conteneurs supplémentaires sur l'instance. Unités : pourcentage | | GPUMemoryUtilization | Pourcentage de mémoire GPU utilisée par les conteneurs sur une instance. La plage de valeurs est comprise entre 0 et 100 et est multipliée par le nombre de. GPUs Par exemple, s'il y en a quatre GPUs, la `GPUMemoryUtilization` plage est comprise entre 0 % et 400 %. Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation de la mémoire GPU du conteneur principal et des conteneurs supplémentaires sur l'instance. Unités : pourcentage | | DiskUtilization | Le pourcentage d'espace disque utilisé par les conteneurs sur une instance. Cette plage de valeurs est comprise entre 0 % et 100 %. Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation de l'espace disque du conteneur principal et des conteneurs supplémentaires sur l'instance. Unités : pourcentage | # Définissez le comportement de mise en cache du modèle de terminal multimodèle basé sur l' SageMaker IA Par défaut, les points de terminaison multimodèles mettent en cache des modèles fréquemment utilisés en mémoire (processeur ou GPU, selon que vous disposez d’instances basées sur des processeurs ou des GPU) et sur disque pour fournir une inférence de faible latence. Les modèles mis en cache sont déchargés et and/or supprimés du disque uniquement lorsqu'un conteneur manque de mémoire ou d'espace disque pour accueillir un nouveau modèle ciblé. Vous pouvez modifier le comportement de mise en cache d'un point de terminaison multimodèles et activer ou désactiver explicitement la mise en cache de modèle en définissant le paramètre `ModelCacheSetting` lorsque vous appelez [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model). Nous vous recommandons de définir la valeur du paramètre `ModelCacheSetting` sur `Disabled` pour les cas d'utilisation qui ne bénéficient pas de la mise en cache des modèles. Par exemple, lorsqu'un grand nombre de modèles doivent être servis à partir du point de terminaison, mais que chaque modèle n'est appelé qu'une seule fois (ou très rarement). Dans de tels cas d'utilisation, définir la valeur du paramètre `ModelCacheSetting` sur `Disabled` permet des transactions par seconde (TPS) plus élevées pour des requêtes `invoke_endpoint` par rapport au mode de mise en cache par défaut. Dans ces cas d'utilisation, le TPS est plus élevé parce que l' SageMaker IA effectue les opérations suivantes après la `invoke_endpoint` demande : + Décharge de manière asynchrone le modèle de la mémoire et le supprime du disque immédiatement après qu'il a été appelé. + Propose une concurrence plus élevée pour le téléchargement et le chargement de modèles dans le conteneur d'inférence. Pour les points de terminaison basés sur le processeur et le GPU, la simultanéité est un facteur du nombre de v de l'CPUs instance de conteneur. Pour obtenir des instructions sur le choix d'un type d'instance SageMaker AI ML pour un point de terminaison multimodèle, consultez[Recommandations d’instance pour les déploiements de points de terminaison multimodèles](multi-model-endpoint-instance.md). # Définition de politiques d’autoscaling pour les déploiements de points de terminaison multimodèles SageMaker Les terminaux multimodèles basés sur l'IA prennent entièrement en charge le dimensionnement automatique, qui gère les répliques de modèles afin de garantir que les modèles évoluent en fonction des modèles de trafic. Nous vous recommandons de configurer votre point de terminaison multimodèle et la taille de vos instances sur [Recommandations d’instance pour les déploiements de points de terminaison multimodèles](multi-model-endpoint-instance.md) et de configurer également l’autoscaling basé sur une instance pour votre point de terminaison. Les taux d'invocation utilisés pour déclencher un événement de mise à l'échelle automatique sont basés sur l'ensemble agrégé des prédictions à travers l'ensemble complet des modèles servis par le point de terminaison. Pour plus d'informations sur la configuration de la mise à l'échelle automatique des terminaux, consultez la section Mise [à l'échelle automatique des modèles Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html). Vous pouvez configurer des politiques d’autoscaling à l’aide de métriques prédéfinies et personnalisées sur des points de terminaison multimodèles basés sur des processeurs et des GPU. **Note** SageMaker Les métriques multi-modèles des terminaux basées sur l'IA sont disponibles avec une granularité d'une minute. ## Définition d’une stratégie de mise à l’échelle Pour spécifier les métriques et les valeurs cibles d'une stratégie de mise à l'échelle automatique, vous configurez une stratégie de mise à l'échelle automatique avec suivi de cible. Vous pouvez utiliser une métrique prédéfinie ou une métrique personnalisée. La configuration d'une stratégie de dimensionnement est représentée par un bloc JSON. Vous enregistrez votre configuration de stratégie de dimensionnement sous forme de bloc JSON dans un fichier texte. Vous utilisez ce fichier texte lorsque vous appelez l'API Application Auto Scaling AWS CLI ou l'API Application Auto Scaling. Pour plus d’informations sur la syntaxe de la configuration d’une stratégie, consultez `[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)` dans le manuel *Référence d’API Application Auto Scaling*. Les options suivantes sont disponibles pour définir une configuration de stratégie de dimensionnement Suivi de la cible. ### Utilisation d'une métrique prédéfinie Pour définir rapidement une stratégie de mise à l'échelle avec suivi de la cible pour une variante, utilisez la métrique prédéfinie `SageMakerVariantInvocationsPerInstance`. `SageMakerVariantInvocationsPerInstance` est le nombre moyen de fois par minute que chaque instance d'une variante est appelée. Nous vous recommandons vivement d'utiliser cette métrique. Pour utiliser une métrique prédéfinie dans une stratégie de dimensionnement, créez une configuration de suivi de cible pour votre stratégie. Dans la configuration de suivi de cible, incluez une `PredefinedMetricSpecification` pour la métrique prédéfinie et une `TargetValue` pour la valeur cible de la métrique. L'exemple suivant décrit une configuration de stratégie classique pour le dimensionnement avec suivi de cible d'une variante. Dans cette configuration, nous utilisons la métrique prédéfinie `SageMakerVariantInvocationsPerInstance` pour ajuster le nombre d'instances de variantes afin que chaque instance ait une métrique `InvocationsPerInstance` égale à `70`. ``` {"TargetValue": 70.0, "PredefinedMetricSpecification": { "PredefinedMetricType": "InvocationsPerInstance" } } ``` **Note** Nous vous recommandons d’utiliser `InvocationsPerInstance` lorsque vous utilisez des points de terminaison multimodèles. La `TargetValue` de cette métrique dépend des exigences de latence de votre application. Nous vous recommandons également de tester le chargement de vos points de terminaison afin de définir des valeurs de paramètres de mise à l'échelle appropriées. Pour en savoir plus sur les tests de charge et la configuration du dimensionnement automatique pour vos points de terminaison, consultez le blog [Configuration des points de terminaison d'inférence à dimensionnement automatique dans Amazon](https://aws.amazon.com/blogs/machine-learning/configuring-autoscaling-inference-endpoints-in-amazon-sagemaker/) AI. SageMaker ### Utilisation d'une métrique personnalisée Si vous devez définir une stratégie de dimensionnement avec suivi de cible qui répond à vos exigences personnelles, définissez une métrique personnalisée. Vous pouvez définir une métrique personnalisée basée sur une métrique de variante de production qui évolue en fonction du dimensionnement. Toutes les métriques de SageMaker l'IA ne fonctionnent pas pour le suivi des cibles. La métrique doit être une métrique d'utilisation valide et décrire le degré d'occupation d'une instance. La valeur de la métrique doit augmenter ou diminuer en proportion inverse du nombre d'instances de variantes. En d'autres termes, la valeur de la métrique doit diminuer lorsque le nombre d'instances augmente. **Important** Avant de déployer le dimensionnement automatique dans un environnement de production, vous devez tester le dimensionnement automatique avec vos métriques personnalisées. #### Exemple de métrique personnalisée pour un point de terminaison multimodèle basé sur un processeur L'exemple suivant décrit une configuration de suivi de cible pour une stratégie de dimensionnement. Dans cette configuration, pour un modèle nommé `my-model`, une métrique personnalisée de `CPUUtilization` ajuste le nombre d'instances sur le point de terminaison en fonction d'une utilisation moyenne du processeur de 50 % sur toutes les instances. ``` {"TargetValue": 50, "CustomizedMetricSpecification": {"MetricName": "CPUUtilization", "Namespace": "/aws/sagemaker/Endpoints", "Dimensions": [ {"Name": "EndpointName", "Value": "my-endpoint" }, {"Name": "ModelName","Value": "my-model"} ], "Statistic": "Average", "Unit": "Percent" } } ``` #### Exemple de métrique personnalisée pour un point de terminaison multimodèle basé sur un GPU L'exemple suivant décrit une configuration de suivi de cible pour une stratégie de dimensionnement. Dans cette configuration, pour un modèle nommé `my-model`, une métrique personnalisée de `GPUUtilization` ajuste le nombre d'instances sur le point de terminaison en fonction d'une utilisation moyenne du GPU de 50 % sur toutes les instances. ``` {"TargetValue": 50, "CustomizedMetricSpecification": {"MetricName": "GPUUtilization", "Namespace": "/aws/sagemaker/Endpoints", "Dimensions": [ {"Name": "EndpointName", "Value": "my-endpoint" }, {"Name": "ModelName","Value": "my-model"} ], "Statistic": "Average", "Unit": "Percent" } } ``` ## Ajout d'un temps de stabilisation Pour ajouter un temps de stabilisation pour la montée en charge de votre point de terminaison, spécifiez une valeur, en secondes, pour `ScaleOutCooldown`. De même, pour ajouter un temps de stabilisation pour la diminution de charge de votre modèle, ajoutez une valeur, en secondes, pour `ScaleInCooldown`. Pour plus d’informations sur `ScaleInCooldown` et `ScaleOutCooldown`, consultez `[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)` dans le manuel *Référence d’API Application Auto Scaling*. L'exemple suivant illustre une configuration avec suivi de cible d'une stratégie de mise à l'échelle. Dans cette configuration, la métrique prédéfinie `SageMakerVariantInvocationsPerInstance` sert à ajuster la mise à l'échelle en fonction d'une moyenne de `70` sur toutes les instances de cette variante. La configuration indique un temps de stabilisation de diminution en charge de 10 minutes et un temps de stabilisation de montée en charge de 5 minutes. ``` {"TargetValue": 70.0, "PredefinedMetricSpecification": {"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance" }, "ScaleInCooldown": 600, "ScaleOutCooldown": 300 } ``` # Points de terminaison multi-conteneurs SageMaker Les points de terminaison multi-conteneurs basés sur l'IA permettent aux clients de déployer plusieurs conteneurs, qui utilisent différents modèles ou frameworks, sur un seul point de terminaison d' SageMaker IA. Les conteneurs peuvent être exécutés en séquence en tant que pipeline d’inférence, ou être invoqués directement pour un accès individuel afin d’améliorer l’utilisation du point de terminaison et d’optimiser les coûts. Pour obtenir des informations sur l’appel des conteneurs dans un point de terminaison multi-conteneurs en séquence, consultez [Pipelines d'inférence dans Amazon AI SageMaker](inference-pipelines.md). Pour obtenir des informations sur l’appel d’un conteneur spécifique dans un point de terminaison multi-conteneurs, consultez [Invocation d’un point de terminaison multi-conteneurs avec invocation directe](multi-container-direct.md) **Topics** + [ # Pour créer un point de terminaison multi-conteneurs (Boto 3) ](multi-container-create.md) + [ # Mise à jour d’un point de terminaison multi-conteneurs ](multi-container-update.md) + [ # Invocation d’un point de terminaison multi-conteneurs avec invocation directe ](multi-container-direct.md) + [ # Sécurité avec les terminaux multi-conteneurs avec invocation directe ](multi-container-security.md) + [ # Métriques pour les points de terminaison multi-conteneurs avec appel direct ](multi-container-metrics.md) + [ # Scalabilité automatique de points de terminaison multi-conteneurs ](multi-container-auto-scaling.md) + [ # Résolution des erreurs associées aux points de terminaison multi-conteneurs ](multi-container-troubleshooting.md) # Pour créer un point de terminaison multi-conteneurs (Boto 3) Créez un point de terminaison multi-conteneurs en appelant [CreateModel[CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), et [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) APIs comme vous le feriez pour créer n'importe quel autre point de terminaison. Vous pouvez exécuter ces conteneurs en séquence en tant que pipeline d’inférence, ou les exécuter individuellement à l’aide de l’invocation directe. Les points de terminaison multi-conteneurs ont les exigences suivantes lorsque vous appelez `create_model` : + Utilisez le paramètre `Containers` au lieu de `PrimaryContainer`, et incluez plus d’un conteneur dans le paramètre `Containers`. + Le paramètre `ContainerHostname` est requis pour chaque conteneur d’un point de terminaison multi-conteneurs avec invocation directe. + Définissez le paramètre `Mode` du champ `InferenceExecutionConfig` sur `Direct` pour invoquer directement chaque conteneur, ou sur `Serial` pour utiliser les conteneurs en tant que pipeline d’inférence. Le mode par défaut est `Serial`. **Note** Actuellement, un point de terminaison multi-conteneurs peut prendre en charge un maximum de 15 conteneurs. L’exemple suivant crée un modèle multi-conteneurs pour l’invocation directe. 1. Créez des éléments de conteneur et `InferenceExecutionConfig` avec appel direct. ``` container1 = { 'Image': '123456789012.dkr.ecr.us-east-1.amazonaws.com/myimage1:mytag', 'ContainerHostname': 'firstContainer' } container2 = { 'Image': '123456789012.dkr.ecr.us-east-1.amazonaws.com/myimage2:mytag', 'ContainerHostname': 'secondContainer' } inferenceExecutionConfig = {'Mode': 'Direct'} ``` 1. Créez le modèle avec les éléments de conteneur et définissez le champ `InferenceExecutionConfig`. ``` import boto3 sm_client = boto3.Session().client('sagemaker') response = sm_client.create_model( ModelName = 'my-direct-mode-model-name', InferenceExecutionConfig = inferenceExecutionConfig, ExecutionRoleArn = role, Containers = [container1, container2] ) ``` Pour créer un point de terminaison, appelez [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) et [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) comme vous le feriez pour créer d’autres points de terminaison. # Mise à jour d’un point de terminaison multi-conteneurs Pour mettre à jour un point de terminaison multi-conteneurs Amazon SageMaker AI, procédez comme suit. 1. Appelez [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) pour créer un modèle avec une nouvelle valeur pour le paramètre `Mode` dans le champ `InferenceExecutionConfig`. 1. Appelez [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) pour créer une configuration de point de terminaison avec un nom différent à l’aide du modèle que vous avez créé à l’étape précédente. 1. Appelez [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_endpoint) pour mettre à jour le point de terminaison avec la nouvelle configuration de point de terminaison que vous avez créée à l’étape précédente. # Invocation d’un point de terminaison multi-conteneurs avec invocation directe SageMaker Les points de terminaison multi-conteneurs basés sur l'IA permettent aux clients de déployer plusieurs conteneurs pour déployer différents modèles sur un point de terminaison SageMaker IA. Vous pouvez héberger 15 conteneurs d’inférence différents au maximum sur un seul point de terminaison. L’invocation directe vous permet d’envoyer une demande à un conteneur d’inférence spécifique hébergé sur un point de terminaison multi-conteneurs. Pour invoquer un point de terminaison multi-conteneurs avec invocation directe, appelez [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint) comme vous invoqueriez n’importe quel autre point de terminaison, et spécifiez le conteneur que vous voulez invoquer à l’aide du paramètre `TargetContainerHostname`. L’exemple suivant invoque directement le `secondContainer` d’un point de terminaison multi-conteneurs afin d’obtenir une prédiction. ``` import boto3 runtime_sm_client = boto3.Session().client('sagemaker-runtime') response = runtime_sm_client.invoke_endpoint( EndpointName ='my-endpoint', ContentType = 'text/csv', TargetContainerHostname='secondContainer', Body = body) ``` Pour chaque demande d’invocation directe envoyée à un point de terminaison multi-conteneurs, seul le conteneur portant le `TargetContainerHostname` traite la demande d’invocation. Des erreurs de validation se produiront si vous effectuez l’une des opérations suivantes : + Vous spécifiez un `TargetContainerHostname` qui n’existe pas dans le point de terminaison. + Vous ne spécifiez pas de valeur pour `TargetContainerHostname` dans une demande envoyée à un point de terminaison configuré pour l’invocation directe. + Vous spécifiez une valeur pour `TargetContainerHostname` dans une demande envoyée à un point de terminaison qui n’est pas configuré pour l’invocation directe. # Sécurité avec les terminaux multi-conteneurs avec invocation directe Pour les points de terminaison multi-conteneurs avec invocation directe, plusieurs conteneurs sont hébergés dans une seule instance, et partagent la mémoire et un volume de stockage. Il est de votre responsabilité d'utiliser des conteneurs sécurisés, de maintenir le mappage correct des demandes vers les conteneurs cibles et de fournir aux utilisateurs l'accès correct aux conteneurs cibles. SageMaker L'IA utilise les rôles IAM pour fournir des politiques basées sur l'identité IAM que vous utilisez pour spécifier si l'accès à une ressource est autorisé ou refusé à ce rôle, et dans quelles conditions. Pour obtenir des informations sur les rôles IAM, consultez [Rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) dans le *Guide de l’utilisateur Gestion des identités et des accès AWS *. Pour obtenir des informations sur les politiques basées sur l’identité, consultez [Politiques basées sur l’identité et politiques basées sur les ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html). Par défaut, un principal IAM disposant d’autorisations `InvokeEndpoint` sur un point de terminaison multi-conteneurs avec invocation directe peut invoquer n’importe quel conteneur à l’intérieur du point de terminaison avec le nom de point de terminaison que vous spécifiez lorsque vous appelez `invoke_endpoint`. Si vous devez restreindre l’accès `invoke_endpoint` à un ensemble limité de conteneurs à l’intérieur d’un point de terminaison multi-conteneurs, utilisez la clé de condition IAM `sagemaker:TargetContainerHostname`. Les politiques suivantes montrent comment limiter les appels à des conteneurs spécifiques au sein d’un point de terminaison. La politique suivante autorise les demandes `invoke_endpoint` uniquement lorsque la valeur du champ `TargetContainerHostname` correspond à l’une des expressions régulières spécifiées. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Action": [ "sagemaker:InvokeEndpoint" ], "Effect": "Allow", "Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name", "Condition": { "StringLike": { "sagemaker:TargetModel": [ "customIps*", "common*" ] } } } ] } ``` ------ La politique suivante refuse les demandes `invoke_endpoint` lorsque la valeur du champ `TargetContainerHostname` correspond à l’une des expressions régulières spécifiées dans l’énoncé `Deny`. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Action": [ "sagemaker:InvokeEndpoint" ], "Effect": "Allow", "Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name", "Condition": { "StringLike": { "sagemaker:TargetModel": [ "model_name*" ] } } }, { "Action": [ "sagemaker:InvokeEndpoint" ], "Effect": "Deny", "Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name", "Condition": { "StringLike": { "sagemaker:TargetModel": [ "special-model_name*" ] } } } ] } ``` ------ Pour plus d'informations sur les clés de condition SageMaker AI, voir [Clés de condition pour SageMaker IA](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html#amazonsagemaker-policy-keys) dans le *guide de Gestion des identités et des accès AWS l'utilisateur*. # Métriques pour les points de terminaison multi-conteneurs avec appel direct Outre les mesures relatives aux points de terminaison répertoriées dans[Métriques Amazon SageMaker AI sur Amazon CloudWatch](monitoring-cloudwatch.md), l' SageMaker IA fournit également des mesures par conteneur. Les métriques par conteneur pour les points de terminaison multi-conteneurs avec invocation directe sont situées CloudWatch et classées dans deux espaces de noms : et. `AWS/SageMaker` `aws/sagemaker/Endpoints` L’espace de noms `AWS/SageMaker` inclut des métriques liées à l’invocation, et l’espace de noms `aws/sagemaker/Endpoints` inclut les métriques d’utilisation de la mémoire et de l’UC. Le tableau suivant répertorie les métriques par conteneur pour les points de terminaison multi-conteneurs avec appel direct. Toutes les métriques utilisent la dimension [`EndpointName, VariantName, ContainerName`], qui filtre les métriques au niveau d’un point de terminaison spécifique, pour une variante spécifique et correspondant à un conteneur spécifique. Ces métriques partagent les mêmes noms de métriques que les pipelines d’inférence, mais par conteneur [`EndpointName, VariantName, ContainerName`]. | | | | | | --- |--- |--- |--- | | Nom de la métrique | Description | Dimension | NameSpace | | Invocations | Nombre de demandes InvokeEndpoint envoyées à un conteneur à l’intérieur d’un point de terminaison. Pour obtenir le nombre total de demandes envoyées à ce conteneur, utilisez la statistique Sum. Unités : aucune. Statistiques valides :Sum, Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker | | Invocation4XX Errors | Nombre de demandes InvokeEndpoint pour lesquelles le modèle a retourné un code de réponse HTTP 4xx pour un conteneur spécifique. Pour chaque 4xx réponse, l' SageMaker IA envoie un1. Unités : aucune. Statistiques valides :Average, Sum | EndpointName, VariantName, ContainerName | AWS/SageMaker | | Invocation5XX Errors | Nombre de demandes InvokeEndpoint pour lesquelles le modèle a retourné un code de réponse HTTP 5xx pour un conteneur spécifique. Pour chaque 5xx réponse, l' SageMaker IA envoie un1. Unités : aucune. Statistiques valides :Average, Sum | EndpointName, VariantName, ContainerName | AWS/SageMaker | | ContainerLatency | Le temps qu'il a fallu au conteneur cible pour répondre, vu par l' SageMaker IA. ContainerLatencyinclut le temps nécessaire pour envoyer la demande, récupérer la réponse dans le conteneur du modèle et terminer l'inférence dans le conteneur. Unités : microsecondes. Statistiques valides : Average, Sum, Min, Max, Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker | | OverheadLatency | Le temps ajouté au temps nécessaire pour répondre à une demande d'un client par l' SageMaker IA concernant les frais généraux. OverheadLatencyest mesuré à partir du moment où l' SageMaker IA reçoit la demande jusqu'à ce qu'elle renvoie une réponse au client, moins leModelLatency. La latence de surcharge peut varier en fonction de différents facteurs, dont les tailles des données utiles de demande et de réponse, la fréquence des demandes, ainsi que l’authentification ou l’autorisation de la demande. Unités : microsecondes. Statistiques valides : Average, Sum, Min, Max, « nombre d’échantillons » | EndpointName, VariantName, ContainerName | AWS/SageMaker | | CPUUtilization | Pourcentage d’unités d’UC utilisées par chaque conteneur en cours d’exécution sur une instance. La valeur est comprise entre 0 % et 100 % et est multipliée par le nombre de CPUs. Par exemple, s'il y en a quatre CPUs, cela CPUUtilization peut aller de 0 % à 400 %. Pour les points de terminaison dotés d'un appel direct, le nombre de CPUUtilization métriques est égal au nombre de conteneurs contenus dans ce point de terminaison. Unités : pourcentage | EndpointName, VariantName, ContainerName | aws/sagemaker/Endpoints | | MemoryUtilizaton | Pourcentage de mémoire utilisée par chaque conteneur en cours d’exécution sur une instance. Cette valeur est comprise entre 0 % et 100 %. De même CPUUtilization, dans les points de terminaison dotés d'un appel direct, le nombre de MemoryUtilization métriques est égal au nombre de conteneurs contenus dans ce point de terminaison. Unités : pourcentage | EndpointName, VariantName, ContainerName | aws/sagemaker/Endpoints | Toutes les métriques du tableau précédent sont spécifiques aux points de terminaison multi-conteneurs avec appel direct. Outre ces métriques spéciales par conteneur, il existe des métriques au niveau de la variante avec la dimension `[EndpointName, VariantName]` pour toutes les métriques du tableau qui attendent `ContainerLatency`. # Scalabilité automatique de points de terminaison multi-conteneurs Si vous voulez configurer la scalabilité automatique pour un point de terminaison multi-conteneurs à l’aide de la métrique `InvocationsPerInstance`, veillez à ce que le modèle de chaque conteneur présente une utilisation de l’UC et une latence similaires pour chaque demande d’inférence. En effet, si le trafic vers le point de terminaison multi-conteneurs passe d’un modèle d’utilisation d’UC faible à un modèle d’utilisation d’UC élevée, mais que le volume d’appel global ne change pas, le point de terminaison n’augmente pas horizontalement et le nombre d’instances peut ne pas suffire pour traiter toutes les demandes envoyées au modèle d’utilisation d’UC élevée. Pour obtenir des informations sur la capacité de mise à l’échelle automatique des points de terminaison, consultez [Mise à l'échelle automatique des modèles Amazon SageMaker AI](endpoint-auto-scaling.md). # Résolution des erreurs associées aux points de terminaison multi-conteneurs Les sections suivantes peuvent vous aider à résoudre les erreurs associées aux points de terminaison multi-conteneurs. ## Erreurs de surveillance de l’état du ping Avec des conteneurs multiples, la mémoire et l’UC du point de terminaison subissent une pression plus élevée lors de la création des points de terminaison. Plus précisément, les métriques `MemoryUtilization` et `CPUUtilization` sont plus élevées que pour les points de terminaison à conteneur unique, car la pression d’utilisation est proportionnelle au nombre de conteneurs. Voilà pourquoi nous vous recommandons de choisir des types d’instance disposant d’une capacité de mémoire et d’UC suffisante pour qu’il y ait suffisamment de mémoire sur l’instance pour que tous les modèles soient chargés (c’est la même chose pour le déploiement d’un pipeline d’inférence). Sinon, la création de votre point de terminaison peut ne pas aboutir, avec une erreur telle que `XXX did not pass the ping health check`. ## Étiquette Docker accept-bind-to-port =true manquante Les conteneurs présents dans des points de terminaison multi-conteneurs sont à l’écoute sur le port spécifié dans la variable d’environnement `SAGEMAKER_BIND_TO_PORT` (au lieu du port 8080). Lorsqu'un conteneur s'exécute sur un point de terminaison multi-conteneurs, l' SageMaker IA fournit automatiquement cette variable d'environnement au conteneur. Si cette variable d’environnement n’est pas présente, les conteneurs utilisent par défaut le port 8080. Pour indiquer que votre conteneur répond à cette exigence, utilisez la commande suivante pour ajouter une étiquette à votre fichier Dockerfile : ``` LABEL com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true ``` Sinon, un message d’erreur s’affichera, tel que `Your Ecr Image XXX does not contain required com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true Docker label(s).` Si votre conteneur doit être à l’écoute sur un second port, choisissez un port dans la plage spécifiée par la variable d’environnement `SAGEMAKER_SAFE_PORT_RANGE`. Spécifiez la valeur sous forme de plage inclusive au format *XXXX* -*YYYY*, où XXXX et YYYY sont des entiers à plusieurs chiffres. SageMaker L'IA fournit cette valeur automatiquement lorsque vous exécutez le conteneur dans un point de terminaison multi-conteneurs. # Pipelines d'inférence dans Amazon AI SageMaker Un *pipeline d'inférence* est un modèle Amazon SageMaker AI composé d'une séquence linéaire de deux à quinze conteneurs qui traitent les demandes d'inférences sur des données. Vous utilisez un pipeline d'inférence pour définir et déployer n'importe quelle combinaison d'algorithmes intégrés à l' SageMaker IA préentraînés et de vos propres algorithmes personnalisés intégrés dans des conteneurs Docker. Vous pouvez utiliser un pipeline d'inférence pour combiner les tâches de science des données de prétraitement, prédictions et post-traitement. Les pipelines d'inférence sont entièrement gérés. Vous pouvez ajouter des conteneurs SageMaker AI Spark ML Serving et scikit-learn qui réutilisent les transformateurs de données développés pour les modèles d'entraînement. L'ensemble du pipeline d'inférence assemblé peut être considéré comme un modèle d' SageMaker IA que vous pouvez utiliser pour effectuer des prédictions en temps réel ou pour traiter directement des transformations par lots sans aucun prétraitement externe. Dans un modèle de pipeline d'inférence, l' SageMaker IA gère les invocations sous la forme d'une séquence de requêtes HTTP. Le premier conteneur du pipeline gère la demande initiale, puis la réponse intermédiaire est envoyée sous forme de demande au second conteneur, et ainsi de suite, pour chaque conteneur du pipeline. SageMaker L'IA renvoie la réponse finale au client. Lorsque vous déployez le modèle de pipeline, l' SageMaker IA installe et exécute tous les conteneurs sur chaque instance Amazon Elastic Compute Cloud (Amazon EC2) du point de terminaison ou de la tâche de transformation. Le traitement de fonctionnalité et les inférences s'exécutent avec une faible latence, car les conteneurs sont colocalisés sur les mêmes instances EC2. Vous définissez les conteneurs pour un modèle de pipeline à l'aide de l'opération [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) ou à partir de la console. Au lieu de définir un `PrimaryContainer`, vous utilisez le paramètre `Containers` pour définir les conteneurs qui constituent le pipeline. Vous spécifiez également l’ordre dans lequel les conteneurs sont exécutés. Un modèle de pipeline est immuable, mais vous pouvez mettre à jour un pipeline d'inférence en en déployant un nouveau à l'aide de l'opération [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html). Cette modularité prend en charge une plus grande flexibilité dans le cadre de l'expérimentation. Pour plus d'informations sur la création d'un pipeline d'inférence avec le SageMaker Model Registry, consultez[Déploiement de l’enregistrement de modèles à l’aide du registre de modèles](model-registry.md). Cette fonctionnalité est disponible sans coûts supplémentaires. Vous payez uniquement pour les instances qui s'exécutent sur un point de terminaison. **Topics** + [ ## Exemples de blocs-notes pour les pipelines d'inférence ](#inference-pipeline-sample-notebooks) + [ # Traitement de fonctionnalité avec Spark ML et Scikit-learn ](inference-pipeline-mleap-scikit-learn-containers.md) + [ # Création d'un modèle de pipeline ](inference-pipeline-create-console.md) + [ # Réalisation de prédictions en temps réel avec un pipeline d'inférence ](inference-pipeline-real-time.md) + [ # Transformations par lots avec pipelines d’inférence ](inference-pipeline-batch.md) + [ # Journaux et métriques des pipelines d’inférence ](inference-pipeline-logs-metrics.md) + [ # Résolution des problèmes de pipelines d'inférence ](inference-pipeline-troubleshoot.md) ## Exemples de blocs-notes pour les pipelines d'inférence Pour obtenir un exemple illustrant comment créer et déployer des pipelines d'inférence, consultez l'exemple de bloc-notes [Pipeline d'inférence avec Scikit-learn et Linear Learner](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-python-sdk/scikit_learn_inference_pipeline) (langue française non garantie). Pour obtenir des instructions sur la création et l'accès aux instances de bloc-notes Jupyter que vous pouvez utiliser pour exécuter l'exemple dans SageMaker AI, consultez. [Instances de SageMaker blocs-notes Amazon](nbi.md) Pour voir la liste de tous les exemples d' SageMaker IA, après avoir créé et ouvert une instance de bloc-notes, choisissez l'onglet **Exemples d'SageMaker IA**. Il existe trois blocs-notes de pipelines d'inférence. Les deux premiers blocs-notes de pipelines d'inférence sont situés dans le dossier `advanced_functionality` et le troisième dans le dossier `sagemaker-python-sdk`. Pour ouvrir un bloc-notes, choisissez l’onglet **Use (Utiliser)** correspondant, puis **Create copy (Créer une copie)**. # Traitement de fonctionnalité avec Spark ML et Scikit-learn Avant de former un modèle à l'aide d'algorithmes intégrés d'Amazon SageMaker AI ou d'algorithmes personnalisés, vous pouvez utiliser les préprocesseurs Spark et scikit-learn pour transformer vos données et concevoir des fonctionnalités. ## Traitement de fonctionnalité avec Spark ML Vous pouvez exécuter des tâches Spark ML avec [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html), un service ETL (extraction, transformation, chargement) sans serveur, depuis votre bloc-notes SageMaker AI. Vous pouvez également vous connecter à des clusters EMR existants pour exécuter des tâches Spark ML avec [Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-what-is-emr.html). Pour ce faire, vous avez besoin d'un rôle Gestion des identités et des accès AWS (IAM) autorisant à passer des appels depuis votre bloc-notes SageMaker AI à AWS Glue. **Note** Pour savoir quelles versions de Python et de Spark sont prises AWS Glue en charge, reportez-vous aux [notes de version de AWS Glue](/glue/latest/dg/release-notes.html). Après les fonctionnalités d'ingénierie, vous pouvez empaqueter et sérialiser les tâches Spark ML MLeap dans MLeap des conteneurs que vous pouvez ajouter à un pipeline d'inférence. Vous n'avez pas besoin d'utiliser des clusters Spark gérés de façon externe. Avec cette approche, vous pouvez passer aisément de quelques lignes à plusieurs téraoctets de données. Les mêmes outils de transformation fonctionnent pour l'entraînement et l'inférence. Vous n'avez donc pas besoin de dupliquer la logique de prétraitement ni d'ingénierie de fonctionnalité, ni de développer une solution unique pour conserver ces modèles. Avec les pipelines d'inférence, vous n'avez pas besoin de gérer d'infrastructure extérieure et vous pouvez effectuer des prédictions directement à partir des entrées de données. Lorsque vous exécutez une tâche Spark ML sur AWS Glue, un pipeline Spark ML est sérialisé [MLeap](https://github.com/combust/mleap)au format. Vous pouvez ensuite utiliser le job avec le [SparkML Model Serving](https://github.com/aws/sagemaker-sparkml-serving-container) Container dans SageMaker un pipeline d'inférence AI. *MLeap*est un format de sérialisation et un moteur d'exécution pour les pipelines d'apprentissage automatique. Il prend en charge Spark, Scikit-learn et permet de former TensorFlow des pipelines et de les exporter vers un pipeline sérialisé appelé Bundle. MLeap Vous pouvez désérialiser les bundles dans Spark pour une évaluation par lots ou dans le MLeap runtime pour alimenter les services d'API en temps réel. Pour un exemple illustrant comment intégrer un processus avec Spark ML, consultez le carnet d'exemples de [formation d'un modèle ML à l'aide d'Apache Spark dans Amazon EMR et déployez-le dans un bloc-notes d'exemples d' SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-python-sdk/sparkml_serving_emr_mleap_abalone). ## Traitement de fonction avec Scikit-Learn Vous pouvez exécuter et empaqueter des tâches scikit-learn dans des conteneurs directement dans Amazon AI. SageMaker Pour obtenir un exemple de code Python permettant de générer un modèle de description scikit-learn qui s’entraîne sur [le jeu de données d’iris de Fisher](http://archive.ics.uci.edu/ml/datasets/Iris) et prédit les espèces d’iris selon les mesures morphologiques, consultez [Entraînement et prédiction d’iris avec Sagemaker Scikit-learn](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/scikit_learn_iris). # Création d'un modèle de pipeline Pour créer un modèle de pipeline qui peut être déployé sur un point de terminaison ou utilisé pour une tâche de transformation par lots, utilisez la console Amazon SageMaker AI ou l'`CreateModel`opération. **Pour créer un pipeline d'inférence (console)** 1. Ouvrez la console Amazon SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/). 1. Choisissez **Modèles**, puis **Créer des modèles** depuis le groupe **Déduction**. 1. Sur la page **Créer un modèle**, fournissez un nom de modèle, choisissez un rôle IAM et, si vous voulez utiliser un VPC privé, spécifiez les valeurs de VPC. ![\[Page de création d'un modèle pour un pipeline d'inférence.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/create-pipeline-model.png) 1. Pour ajouter des informations sur les conteneurs dans le pipeline d'inférence, choisissez **Add container (Ajouter un conteneur)**, puis **Suivant**. 1. Complétez les champs pour chaque conteneur dans l'ordre où vous voulez les exécuter (quinze maximum). Complétez les champs **Container input options (Options d'entrée du conteneur)**, **Emplacement de l'image du code d'inférence** et, le cas échant, **URL des données du modèle**, **Nom d'hôte du conteneur**, ainsi que **Environmental variables (Variables d'environnement)**. ![\[Création d'un modèle de pipeline avec des conteneurs.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/create-pipeline-model-containers.png) La **MyInferencePipelineModel**page récapitule les paramètres des conteneurs qui fournissent des entrées pour le modèle. Si vous avez fourni les variables d'environnement dans une définition de conteneur correspondante, SageMaker AI les affiche dans le champ **Variables d'environnement**. ![\[Résumé des paramètres de conteneur pour le modèle de pipeline.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/pipeline-MyInferencePipelinesModel-recap.png) # Réalisation de prédictions en temps réel avec un pipeline d'inférence Vous pouvez utiliser des modèles entraînés dans un pipeline d'inférence pour réaliser des prédictions en temps réel directement, sans effectuer de prétraitement externe. Lorsque vous configurez le pipeline, vous pouvez choisir d'utiliser les transformateurs de fonctionnalités intégrés déjà disponibles dans Amazon SageMaker AI. Vous pouvez également implémenter votre propre logique de transformation en utilisant simplement quelques lignes de code Scikit-learn ou Spark. [MLeap](https://combust.github.io/mleap-docs/), un format de sérialisation et un moteur d'exécution pour les pipelines d'apprentissage automatique, prend en charge Spark, scikit-learn, ainsi que TensorFlow pour les pipelines de formation et leur exportation vers un pipeline sérialisé appelé Bundle. MLeap Vous pouvez désérialiser les bundles dans Spark pour une évaluation par lots ou dans le MLeap runtime pour alimenter les services d'API en temps réel. Les conteneurs figurant dans un pipeline sont à l'écoute sur le port spécifié dans la variable d'environnement `SAGEMAKER_BIND_TO_PORT` (au lieu de 8080). Lorsqu'elle est exécutée dans un pipeline d'inférence, l' SageMaker IA fournit automatiquement cette variable d'environnement aux conteneurs. Si cette variable d’environnement n’est pas présente, les conteneurs utilisent par défaut le port 8080. Pour indiquer que votre conteneur répond à cette exigence, utilisez la commande suivante pour ajouter une étiquette à votre fichier Dockerfile : ``` LABEL com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true ``` Si votre conteneur doit être à l’écoute sur un second port, choisissez un port dans la plage spécifiée par la variable d’environnement `SAGEMAKER_SAFE_PORT_RANGE`. Spécifiez la valeur sous forme de plage inclusive au format**"XXXX-YYYY"**, où `XXXX` et `YYYY` sont des entiers à plusieurs chiffres. SageMaker L'IA fournit cette valeur automatiquement lorsque vous exécutez le conteneur dans un pipeline multiconteneur. **Note** Pour utiliser des images Docker personnalisées dans un pipeline qui inclut des [algorithmes intégrés à l'SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html), vous avez besoin d'une politique [Amazon Elastic Container Registry (Amazon ECR)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html). Votre référentiel Amazon ECR doit autoriser SageMaker AI à extraire l'image. Pour de plus amples informations, veuillez consulter [Résolution des problèmes d'autorisations Amazon ECR pour les pipelines d'inférence](inference-pipeline-troubleshoot.md#inference-pipeline-troubleshoot-permissions). ## Création et déploiement d'un point de terminaison de pipeline d'inférence Le code suivant crée et déploie un modèle de pipeline d'inférence en temps réel avec SparkML et des XGBoost modèles en série à l'aide du SDK AI. SageMaker ``` from sagemaker.model import Model from sagemaker.pipeline_model import PipelineModel from sagemaker.sparkml.model import SparkMLModel sparkml_data = 's3://{}/{}/{}'.format(s3_model_bucket, s3_model_key_prefix, 'model.tar.gz') sparkml_model = SparkMLModel(model_data=sparkml_data) xgb_model = Model(model_data=xgb_model.model_data, image=training_image) model_name = 'serial-inference-' + timestamp_prefix endpoint_name = 'serial-inference-ep-' + timestamp_prefix sm_model = PipelineModel(name=model_name, role=role, models=[sparkml_model, xgb_model]) sm_model.deploy(initial_instance_count=1, instance_type='ml.c4.xlarge', endpoint_name=endpoint_name) ``` ## Demande d'inférence en temps réel à partir d'un point de terminaison de pipeline d'inférence L'exemple suivant montre comment réaliser des prédictions en temps réel en appelant un point de terminaison d'inférence et en transmettant une charge utile de demande au format JSON : ``` import sagemaker from sagemaker.predictor import json_serializer, json_deserializer, Predictor payload = { "input": [ { "name": "Pclass", "type": "float", "val": "1.0" }, { "name": "Embarked", "type": "string", "val": "Q" }, { "name": "Age", "type": "double", "val": "48.0" }, { "name": "Fare", "type": "double", "val": "100.67" }, { "name": "SibSp", "type": "double", "val": "1.0" }, { "name": "Sex", "type": "string", "val": "male" } ], "output": { "name": "features", "type": "double", "struct": "vector" } } predictor = Predictor(endpoint=endpoint_name, sagemaker_session=sagemaker.Session(), serializer=json_serializer, content_type='text/csv', accept='application/json') print(predictor.predict(payload)) ``` La réponse que vous obtenez de `predictor.predict(payload)` est le résultat d'inférence du modèle. ## Exemple de pipeline d'inférence en temps réel Vous pouvez exécuter cet [exemple de bloc-notes à l'aide du SKLearn prédicteur](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-python-sdk/scikit_learn_randomforest/Sklearn_on_SageMaker_end2end.ipynb) qui indique comment déployer un point de terminaison, exécuter une demande d'inférence, puis désérialiser la réponse. Retrouvez ce carnet et d'autres exemples dans le [ GitHub référentiel d' SageMaker exemples Amazon](https://github.com/awslabs/amazon-sagemaker-examples). # Transformations par lots avec pipelines d’inférence Pour obtenir des inférences sur un jeu de données entier, vous exécutez une transformation par lots sur un modèle entraîné. Le même modèle de pipeline d'inférence créé et déployé sur un point de terminaison pour un traitement en temps réel peut également être utilisé dans une tâche de transformation par lots, afin de traiter des inférences sur un ensemble de données complet. Pour exécuter une tâche de transformation par lots dans un pipeline, vous devez télécharger les données d'entrée depuis Amazon S3 et les envoyer dans une ou plusieurs demandes HTTP au modèle de pipeline d'inférence. Pour un exemple montrant comment préparer les données pour une transformation par lots, consultez la section « Section 2 - Prétraiter les données brutes du logement à l'aide de Scikit Learn » du carnet d'exemples [Amazon SageMaker Multi-Model Endpoints using Linear Learner](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/multi_model_linear_learner_home_value). Pour plus d'informations sur les transformations par lots Amazon SageMaker AI, consultez[Transformation par lots à des fins d'inférence avec Amazon AI SageMaker](batch-transform.md). **Note** Pour utiliser des images Docker personnalisées dans un pipeline qui inclut les [algorithmes intégrés d'Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html), vous avez besoin d'une politique [Amazon Elastic Container Registry (ECR).](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) Votre référentiel Amazon ECR doit autoriser SageMaker AI à extraire l'image. Pour de plus amples informations, veuillez consulter [Résolution des problèmes d'autorisations Amazon ECR pour les pipelines d'inférence](inference-pipeline-troubleshoot.md#inference-pipeline-troubleshoot-permissions). L'exemple suivant montre comment exécuter une tâche de transformation à l'aide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Dans cet exemple, `model_name` il s'agit du pipeline d'inférence qui combine SparkML XGBoost et des modèles (créés dans les exemples précédents). L'emplacement Amazon S3 spécifié par `input_data_path` contient les données d'entrée, au format CSV, devant être téléchargées et envoyées au modèle Spark ML. Une fois le travail de transformation terminé, l'emplacement Amazon S3 spécifié par `output_data_path` contient les données de sortie renvoyées par le XGBoost modèle au format CSV. ``` import sagemaker input_data_path = 's3://{}/{}/{}'.format(default_bucket, 'key', 'file_name') output_data_path = 's3://{}/{}'.format(default_bucket, 'key') transform_job = sagemaker.transformer.Transformer( model_name = model_name, instance_count = 1, instance_type = 'ml.m4.xlarge', strategy = 'SingleRecord', assemble_with = 'Line', output_path = output_data_path, base_transform_job_name='inference-pipelines-batch', sagemaker_session=sagemaker.Session(), accept = CONTENT_TYPE_CSV) transform_job.transform(data = input_data_path, content_type = CONTENT_TYPE_CSV, split_type = 'Line') ``` # Journaux et métriques des pipelines d’inférence La surveillance est importante pour garantir la fiabilité, la disponibilité et les performances des ressources Amazon SageMaker AI. Pour surveiller et résoudre les problèmes liés aux performances du pipeline d'inférence, utilisez les CloudWatch journaux et les messages d'erreur Amazon. Pour plus d'informations sur les outils de surveillance fournis par l' SageMaker IA, consultez[Surveillance AWS des ressources dans Amazon SageMaker AI](monitoring-overview.md). ## Utilisation de métriques pour contrôler des modèles multi-conteneur Pour surveiller les modèles à conteneurs multiples dans Inference Pipelines, utilisez Amazon. CloudWatch CloudWatchcollecte des données brutes et les transforme en indicateurs lisibles en temps quasi réel. SageMaker Les tâches de formation et les points de terminaison liés à l'IA écrivent CloudWatch des métriques et des journaux dans l'espace de `AWS/SageMaker` noms. Les tableaux suivants répertorient les métriques et les dimensions pour les éléments suivants : + Appels de point de terminaison + Tâches d'entraînement, tâches de transformation par lots et instances de point de terminaison Une *dimension* est une name/value paire qui identifie une métrique de manière unique. Vous pouvez associer jusqu'à 10 dimensions à une métrique. Pour plus d'informations sur la surveillance avec CloudWatch, voir[Métriques Amazon SageMaker AI sur Amazon CloudWatch](monitoring-cloudwatch.md). **Endpoint Invocation Metrics (Métriques d'appel de point de terminaison)** L'espace de noms `AWS/SageMaker` inclut les métriques de demandes suivantes depuis les appels vers [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) . Les métriques sont présentées à des intervalles d'une minute. | Métrique | Description | | --- | --- | | Invocation4XXErrors | Nombre de demandes `InvokeEndpoint` pour lesquelles le modèle a retourné un code de réponse HTTP `4xx`. Pour chaque `4xx` réponse, l' SageMaker IA envoie un`1`. Unités : aucune Statistiques valides : `Average`, `Sum` | | Invocation5XXErrors | Nombre de demandes `InvokeEndpoint` pour lesquelles le modèle a retourné un code de réponse HTTP `5xx`. Pour chaque `5xx` réponse, l' SageMaker IA envoie un`1`. Unités : aucune Statistiques valides : `Average`, `Sum` | | Invocations | Les requêtes `number of InvokeEndpoint` envoyées à un point de terminaison de modèle. Pour obtenir le nombre total de demandes envoyées à un point de terminaison de modèle, utilisez la statistique `Sum`. Unités : aucune Statistiques valides : `Sum`, `Sample Count` | | InvocationsPerInstance | Le nombre d'appels de point de terminaison envoyés à un modèle, normalisé par `InstanceCount` dans chacun d'eux. `ProductionVariant` SageMaker L'IA envoie 1/ `numberOfInstances` comme valeur pour chaque demande, où `numberOfInstances` est le nombre d'instances actives pour le ProductionVariant au point de terminaison au moment de la demande. Unités : aucune Statistiques valides : `Sum` | | ModelLatency | Temps qu'il a fallu au(x) modèle(s) pour répondre. Cela inclut le temps qu'il a fallu pour envoyer la demande, pour récupérer la réponse à partir du conteneur de modèles et pour terminer l'inférence dans le conteneur. ModelLatency est le temps total qu'il a fallu à tous les conteneurs dans un pipeline d'inférence.Unités : microsecondesStatistiques valides : `Average`, `Sum`, `Min`, `Max`, Nombre d'échantillons | | OverheadLatency | Le temps ajouté au temps nécessaire pour répondre à une demande d'un client par l' SageMaker IA concernant les frais généraux. `OverheadLatency`est mesuré à partir du moment où l' SageMaker IA reçoit la demande jusqu'à ce qu'elle renvoie une réponse au client, moins le`ModelLatency`. La latence de surcharge peut varier en fonction de différents facteurs, dont les tailles des données utiles de demande et de réponse, la fréquence des demandes, ainsi que l’authentification ou l’autorisation de la demande. Unités : microsecondes Statistiques valides : `Average`, `Sum`, `Min`, `Max`, `Sample Count` | | ContainerLatency | Le temps qu'il a fallu à un conteneur Inference Pipelines pour répondre, vu par l' SageMaker IA. ContainerLatencyinclut le temps nécessaire pour envoyer la demande, récupérer la réponse dans le conteneur du modèle et terminer l'inférence dans le conteneur.Unités : microsecondesStatistiques valides : `Average`, `Sum`, `Min`, `Max`, `Sample Count` | **Dimensions for Endpoint Invocation Metrics (Dimensions des métriques d'appel de point de terminaison)** | Dimension | Description | | --- | --- | | EndpointName, VariantName, ContainerName | Filtres des métriques d'appel de point de terminaison pour un objet `ProductionVariant` au point de terminaison spécifié et pour la variante spécifiée. | Pour un point de terminaison de pipeline d'inférence, CloudWatch répertorie les mesures de latence par conteneur de votre compte sous forme de métriques de **conteneur de point de terminaison et de mesures** de **variantes de point de terminaison** dans l'espace de noms **SageMaker AI**, comme suit. La métrique `ContainerLatency` apparaît uniquement pour les pipelines d'inférence. ![\[Le CloudWatch tableau de bord d'un pipeline d'inférence.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/pipeline-endpoint-metrics.png) Pour chaque point de terminaison et chaque conteneur, les métriques de latence affichent les noms du conteneur, du point de terminaison, de la variante et de la métrique. ![\[Métriques de latence pour un point de terminaison.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/pipeline-endpoint-metrics-details.png) **Métriques de tâches d'entraînement, de tâches de transformation par lots et d'instances de point de terminaison** Les espaces de noms `/aws/sagemaker/TrainingJobs`, `/aws/sagemaker/TransformJobs` et `/aws/sagemaker/Endpoints` incluent les métriques suivantes pour les tâches d'entraînement et les instances de point de terminaison. Les métriques sont présentées à des intervalles d'une minute. | Métrique | Description | | --- | --- | | CPUUtilization | Pourcentage d'unités UC utilisées par les conteneurs qui s'exécutent sur une instance. La valeur est comprise entre 0 % et 100 % et est multipliée par le nombre de CPUs. Par exemple, s'il y en a quatre CPUs, cela `CPUUtilization` peut aller de 0 % à 400 %. Pour des tâches d'entraînement, `CPUUtilization` correspond à l'utilisation d'UC du conteneur d'algorithme en cours d'exécution sur l'instance. Pour les tâches de transformation par lots, `CPUUtilization` correspond à l'utilisation d'UC du conteneur de transformation en cours d'exécution sur l'instance. Pour les modèles à plusieurs conteneurs, `CPUUtilization` est la somme de l'utilisation d'UC de tous les conteneurs en cours d'exécution sur l'instance. Pour les variantes de point de terminaison, `CPUUtilization` est la somme de l'utilisation d'UC de tous les conteneurs en cours d'exécution sur l'instance. Unités : pourcentage | | MemoryUtilization | Pourcentage de mémoire utilisée par les conteneurs en cours d'exécution sur une instance. Cette valeur est comprise entre 0 % et 100 %.Pour les tâches d'entraînement, `MemoryUtilization` correspond à la mémoire utilisée par le conteneur d'algorithme en cours d'exécution sur l'instance.Pour les tâches de transformation par lots, `MemoryUtilization` correspond à la mémoire utilisée par le conteneur de transformation en cours d'exécution sur l'instance.Pour les modèles à plusieurs conteneurs, MemoryUtilization est la somme de la mémoire utilisée par tous les conteneurs en cours d'exécution sur l'instance.Pour les variantes de point de terminaison, `MemoryUtilization` est la somme de la mémoire utilisée par tous les conteneurs en cours d'exécution sur l'instance.Unités : pourcentage | | GPUUtilization | Pourcentage d'unités GPU utilisées par les conteneurs exécutés sur une instance. `GPUUtilization`varie de 0 % à 100 % et est multiplié par le nombre de GPUs. Par exemple, s'il y en a quatre GPUs, cela `GPUUtilization` peut aller de 0 % à 400 %. Pour les tâches d'entraînement, `GPUUtilization` correspond à l'utilisation de processeur graphique par le conteneur d'algorithme qui s'exécute sur l'instance. Pour les tâches de transformation par lots, `GPUUtilization` correspond à l'utilisation de processeur graphique par le conteneur de transformation en cours d'exécution sur l'instance. Pour les modèles à plusieurs conteneurs, `GPUUtilization` est la somme de l'utilisation de processeur graphique par tous les conteneurs en cours d'exécution sur l'instance. Pour les variantes de point de terminaison, `GPUUtilization` est la somme de l'utilisation de processeur graphique par tous les conteneurs en cours d'exécution sur l'instance. Unités : pourcentage | | GPUMemoryUtilization | Pourcentage de mémoire GPU utilisé par les conteneurs exécutés sur une instance. GPUMemoryL'utilisation varie de 0 % à 100 % et est multipliée par le nombre de GPUs. Par exemple, s'il y en a quatre GPUs, cela `GPUMemoryUtilization` peut aller de 0 % à 400 %. Pour les tâches d'entraînement, `GPUMemoryUtilization` correspond à la mémoire GPU utilisée par le conteneur d'algorithme en cours d'exécution sur l'instance. Pour les tâches de transformation par lots, `GPUMemoryUtilization` correspond à la mémoire GPU utilisée par le conteneur de transformation en cours d'exécution sur l'instance. Pour les modèles à plusieurs conteneurs, `GPUMemoryUtilization` est la somme de l'utilisation de processeur graphique par tous les conteneurs en cours d'exécution sur l'instance. Pour les variantes de point de terminaison, `GPUMemoryUtilization` est la somme de la mémoire GPU utilisée par tous les conteneurs en cours d'exécution sur l'instance. Unités : pourcentage | | DiskUtilization | Pourcentage d'espace disque utilisé par les conteneurs exécutés sur une instance. DiskUtilization varie de 0 % à 100 %. Cette métrique n'est pas prise en charge pour les tâches de transformation par lots. Pour les tâches d'entraînement, `DiskUtilization` correspond à l'espace disque utilisé par le conteneur d'algorithme en cours d'exécution sur l'instance. Pour les variantes de point de terminaison, `DiskUtilization` est la somme de l'espace disque utilisé par tous les conteneurs fournis en cours d'exécution sur l'instance. Unités : pourcentage | **Dimensions des métriques de tâches d'entraînement, de tâches de transformation par lots et d'instances de point de terminaison** | Dimension | Description | | --- | --- | | Host | Pour les tâches d'entraînement, `Host` a le format `[training-job-name]/algo-[instance-number-in-cluster]`. Utilisez cette dimension pour filtrer les métriques d'instance pour la tâche d'entraînement et l'instance spécifiées. Ce format de dimension est présent uniquement dans l'espace de noms `/aws/sagemaker/TrainingJobs`. Pour les tâches de transformation par lots, `Host` a le format `[transform-job-name]/[instance-id]`. Utilisez cette dimension pour filtrer les métriques d'instance pour la tâche de transformation par lots et l'instance spécifiées. Ce format de dimension est présent uniquement dans l'espace de noms `/aws/sagemaker/TransformJobs`. Pour les points de terminaison, `Host` a le format `[endpoint-name]/[ production-variant-name ]/[instance-id]`. Utilisez cette dimension pour filtrer les métriques d'instance pour le point de terminaison, la variante et l'instance spécifiés. Ce format de dimension est présent uniquement dans l'espace de noms `/aws/sagemaker/Endpoints`. | Pour vous aider à déboguer vos tâches de formation, vos points de terminaison et les configurations du cycle de vie de vos instances de bloc-notes, l' SageMaker IA envoie également tout ce qu'un conteneur d'algorithmes, un conteneur de modèles ou une configuration du cycle de vie d'une instance de bloc-notes envoie à `stdout` ou vers `stderr` Amazon CloudWatch Logs. Vous pouvez utiliser ces informations pour le débogage et pour analyser la progression. ## Utilisation des journaux pour contrôler un pipeline d'inférence Le tableau suivant répertorie les groupes de journaux et les flux de journaux qu' SageMaker AI envoie à Amazon. CloudWatch Un *flux de journaux* est une séquence d'événements de journaux qui partagent la même source. Chaque source distincte de connexions CloudWatch constitue un flux de journaux distinct. Un *groupe de journaux* est un groupe de flux de journaux qui partagent les mêmes paramètres de conservation, de surveillance et de contrôle d’accès. **Journaux** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/inference-pipeline-logs-metrics.html) **Note** SageMaker L'IA crée le groupe de `/aws/sagemaker/NotebookInstances` journaux lorsque vous créez une instance de bloc-notes avec une configuration de cycle de vie. Pour de plus amples informations, veuillez consulter [Personnalisation d'une instance de SageMaker bloc-notes à l'aide d'un script LCC](notebook-lifecycle-config.md). Pour plus d'informations sur la journalisation par SageMaker IA, consultez[CloudWatch Journaux pour Amazon SageMaker AI](logging-cloudwatch.md). # Résolution des problèmes de pipelines d'inférence Pour résoudre les problèmes liés au pipeline d'inférence, utilisez les CloudWatch journaux et les messages d'erreur. Si vous utilisez des images Docker personnalisées dans un pipeline qui inclut des algorithmes intégrés à Amazon SageMaker AI, vous pouvez également rencontrer des problèmes d'autorisations. Pour accorder les autorisations requises, créez une politique Amazon Elastic Container Registry (Amazon ECR). **Topics** + [ ## Résolution des problèmes d'autorisations Amazon ECR pour les pipelines d'inférence ](#inference-pipeline-troubleshoot-permissions) + [ ## Utiliser CloudWatch les journaux pour résoudre les problèmes liés aux pipelines d'inférence SageMaker basés sur l'IA ](#inference-pipeline-troubleshoot-logs) + [ ## Utilisation des messages d'erreur pour résoudre les problèmes de pipelines d'inférence. ](#inference-pipeline-troubleshoot-errors) ## Résolution des problèmes d'autorisations Amazon ECR pour les pipelines d'inférence Lorsque vous utilisez des images Docker personnalisées dans un pipeline qui inclut des [algorithmes intégrés à l'SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html), vous avez besoin d'une politique [Amazon ECR.](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) Cette politique permet à votre référentiel Amazon ECR d'autoriser l' SageMaker IA à extraire l'image. La stratégie doit ajouter les autorisations suivantes : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "allowSageMakerToPull", "Effect": "Allow", "Principal": { "Service": "sagemaker.amazonaws.com" }, "Action": [ "ecr:GetDownloadUrlForLayer", "ecr:BatchGetImage", "ecr:BatchCheckLayerAvailability" ], "Resource": "*" } ] } ``` ------ ## Utiliser CloudWatch les journaux pour résoudre les problèmes liés aux pipelines d'inférence SageMaker basés sur l'IA SageMaker AI publie les journaux des conteneurs pour les points de terminaison qui déploient un pipeline d'inférence vers Amazon CloudWatch sur le chemin suivant pour chaque conteneur. ``` /aws/sagemaker/Endpoints/{EndpointName}/{Variant}/{InstanceId}/{ContainerHostname} ``` Par exemple, les journaux pour ce point de terminaison sont publiés dans les flux et les groupes de journaux suivants : ``` EndpointName: MyInferencePipelinesEndpoint Variant: MyInferencePipelinesVariant InstanceId: i-0179208609ff7e488 ContainerHostname: MyContainerName1 and MyContainerName2 ``` ``` logGroup: /aws/sagemaker/Endpoints/MyInferencePipelinesEndpoint logStream: MyInferencePipelinesVariant/i-0179208609ff7e488/MyContainerName1 logStream: MyInferencePipelinesVariant/i-0179208609ff7e488/MyContainerName2 ``` Un *flux de journaux* est une séquence d'événements de journaux qui partagent la même source. Chaque source distincte de connexions CloudWatch constitue un flux de journaux distinct. Un *groupe de journaux* est un groupe de flux de journaux qui partagent les mêmes paramètres de conservation, de surveillance et de contrôle d’accès. **Pour voir les flux et les groupes de journaux** 1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Dans la page de navigation, choisissez **Logs (Journaux)**. 1. Dans **Groupes de journaux**, filtrez sur **MyInferencePipelinesEndpoint** : ![\[Les groupes de CloudWatch journaux ont été filtrés en fonction du point de terminaison du pipeline d'inférence.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/pipeline-log-group-filter.png) 1. Pour voir les flux de journaux, sur la page **Groupes de CloudWatch journaux**, choisissez**MyInferencePipelinesEndpoint**, puis **Rechercher un groupe de journaux**. ![\[Le flux de CloudWatch log du pipeline d'inférence.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/pipeline-log-streams-2.png) Pour obtenir la liste des journaux publiés par SageMaker AI, consultez[Journaux et métriques des pipelines d’inférence](inference-pipeline-logs-metrics.md). ## Utilisation des messages d'erreur pour résoudre les problèmes de pipelines d'inférence. Les messages d'erreur des pipelines d'inférence indiquent les conteneurs qui ont échoué. Si une erreur se produit alors que l' SageMaker IA appelle un point de terminaison, le service renvoie un `ModelError` (code d'erreur 424), qui indique quel conteneur a échoué. Si la charge utile de la demande (la réponse du conteneur précédent) dépasse la limite de 5 Mo, SageMaker AI fournit un message d'erreur détaillé, tel que : Réponse reçue de MyContainerName 1 avec le code d'état 200. Cependant, la charge utile de la demande comprise entre MyContainerName 1 et MyContainerName 2 est de 600 000 octets, ce qui dépasse la limite maximale de 5 Mo. `` Si un conteneur échoue à la vérification de l'état du ping alors que l' SageMaker IA crée un point de terminaison, il renvoie un `ClientError` et indique tous les conteneurs qui ont échoué à la vérification du ping lors du dernier contrôle d'état. # Supprimer les points de terminaison et les ressources Supprimer des points de terminaison pour arrêter l'application de frais. ## Supprimer un point de terminaison Supprimez votre point de terminaison par programmation à l'aide AWS SDK pour Python (Boto3), avec ou de AWS CLI manière interactive à l'aide de la SageMaker console AI. SageMaker L'IA libère toutes les ressources déployées lors de la création du point de terminaison. La suppression d'un point de terminaison ne supprimera pas la configuration du point de terminaison ni le modèle d' SageMaker IA. Consultez [Supprimer la configuration du point de terminaison](#realtime-endpoints-delete-endpoint-config) et [Supprimer un modèle](#realtime-endpoints-delete-model) pour plus d'informations sur la façon de supprimer la configuration de votre point de terminaison et votre modèle d' SageMaker IA. ------ #### [ AWS SDK pour Python (Boto3) ] Utilisez l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) pour supprimer votre point de terminaison. Spécifiez le nom de votre point de terminaison pour le champ `EndpointName`. ``` import boto3 # Specify your AWS Region aws_region='' # Specify the name of your endpoint endpoint_name='' # Create a low-level SageMaker service client. sagemaker_client = boto3.client('sagemaker', region_name=aws_region) # Delete endpoint sagemaker_client.delete_endpoint(EndpointName=endpoint_name) ``` ------ #### [ AWS CLI ] Utilisez utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint.html) pour supprimer un point de terminaison. Spécifiez le nom de votre point de terminaison pour l'indicateur `endpoint-name`. ``` aws sagemaker delete-endpoint --endpoint-name ``` ------ #### [ SageMaker AI Console ] Supprimez votre point de terminaison de manière interactive à l'aide de la console SageMaker AI. 1. Dans le menu de [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)navigation de la console SageMaker AI, choisissez **Inference**. 1. Choisissez **Endpoints** (Points de terminaison) dans le menu déroulant. Une liste des points de terminaison créés dans votre AWS compte apparaîtra par nom, nom de ressource Amazon (ARN), heure de création, statut et date de dernière mise à jour du point de terminaison. 1. Sélectionnez le point de terminaison à supprimer. 1. Sélectionnez le bouton de la liste déroulante **Actions** dans le coin supérieur droit. 1. Sélectionnez **Supprimer**. ------ ## Supprimer la configuration du point de terminaison Supprimez la configuration de votre point de terminaison par programmation à l'aide AWS SDK pour Python (Boto3), avec ou de manière interactive à l' AWS CLI aide de la console AI. SageMaker La suppression d'une configuration de point de terminaison ne supprime pas les points de terminaison créés à l'aide de cette configuration. Consultez [Supprimer un point de terminaison](#realtime-endpoints-delete-endpoint) pour plus d'informations sur la façon de supprimer votre point de terminaison. Ne supprimez pas une configuration de point de terminaison utilisée par un point de terminaison qui est en direct ou pendant qu'il est en cours de mise à jour ou de création. Vous risquez de perdre de la visibilité sur le type d'instance utilisé par le point de terminaison si vous supprimez la configuration du point de terminaison d'un point de terminaison actif ou en cours de création ou de mise à jour. ------ #### [ AWS SDK pour Python (Boto3) ] Utilisez l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpointConfig.html) pour supprimer votre point de terminaison. Spécifiez le nom de votre configuration de point de terminaison pour le champ `EndpointConfigName`. ``` import boto3 # Specify your AWS Region aws_region='' # Specify the name of your endpoint configuration endpoint_config_name='' # Create a low-level SageMaker service client. sagemaker_client = boto3.client('sagemaker', region_name=aws_region) # Delete endpoint configuration sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name) ``` Vous pouvez éventuellement utiliser l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) pour renvoyer des informations sur le nom des modèles déployés (variantes de production) telles que le nom de votre modèle et le nom de la configuration du point de terminaison associée à ce modèle déployé. Attribuez un nom à votre point de terminaison pour le champ `EndpointConfigName`. ``` # Specify the name of your endpoint endpoint_name='' # Create a low-level SageMaker service client. sagemaker_client = boto3.client('sagemaker', region_name=aws_region) # Store DescribeEndpointConfig response into a variable that we can index in the next step. response = sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_name) # Delete endpoint endpoint_config_name = response['ProductionVariants'][0]['EndpointConfigName'] # Delete endpoint configuration sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name) ``` Pour plus d'informations sur les autres éléments de réponse renvoyés par`DescribeEndpointConfig`, consultez [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html)le [guide de référence des SageMaker API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html). ------ #### [ AWS CLI ] Utilisez utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint-config.html) pour supprimer ma configuration de votre point de terminaison. Spécifiez le nom de votre configuration de point de terminaison pour l'indicateur `endpoint-config-name`. ``` aws sagemaker delete-endpoint-config \ --endpoint-config-name ``` Vous pouvez éventuellement utiliser la commande [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html) pour renvoyer des informations sur le nom des modèles déployés (variantes de production) telles que le nom de votre modèle et le nom de la configuration du point de terminaison associée à ce modèle déployé. Attribuez un nom à votre point de terminaison pour l'indicateur `endpoint-config-name`. ``` aws sagemaker describe-endpoint-config --endpoint-config-name ``` Cela renvoie une réponse JSON. Vous pouvez copier et coller, utiliser un analyseur JSON ou utiliser un outil conçu pour l'analyse JSON afin d'obtenir le nom de configuration du point de terminaison associé à ce point de terminaison. ------ #### [ SageMaker AI Console ] Supprimez la configuration de votre point de terminaison de manière interactive à l'aide de la console SageMaker AI. 1. Dans le menu de [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)navigation de la console SageMaker AI, choisissez **Inference**. 1. Choisissez **Endpoint configurations** (Configuration de point de terminaison) depuis le menu déroulant. Une liste des configurations de points de terminaison créées dans votre compte AWS s'affiche par nom, Amazon Resource Name (ARN) et le moment de création. 1. Sélectionnez la configuration de point de terminaison à supprimer. 1. Sélectionnez le bouton de la liste déroulante **Actions** dans le coin supérieur droit. 1. Sélectionnez **Delete (Supprimer)**. ------ ## Supprimer un modèle Supprimez votre modèle d' SageMaker IA par programmation à l'aide AWS SDK pour Python (Boto3), avec ou de manière interactive à l' AWS CLI aide de la console d'IA. SageMaker La suppression d'un modèle d' SageMaker IA supprime uniquement l'entrée de modèle créée dans SageMaker AI. Supprimer un modèle ne supprime pas les artefacts de modèles, le code d'inférence, ni le rôle IAM spécifiés lors de la création du modèle. ------ #### [ AWS SDK pour Python (Boto3) ] Utilisez l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html)API pour supprimer votre modèle d' SageMaker IA. Spécifiez le nom de votre modèle pour le champ `ModelName`. ``` import boto3 # Specify your AWS Region aws_region='' # Specify the name of your endpoint configuration model_name='' # Create a low-level SageMaker service client. sagemaker_client = boto3.client('sagemaker', region_name=aws_region) # Delete model sagemaker_client.delete_model(ModelName=model_name) ``` Vous pouvez éventuellement utiliser l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) pour renvoyer des informations sur le nom des modèles déployés (variantes de production) telles que le nom de votre modèle et le nom de la configuration du point de terminaison associée à ce modèle déployé. Attribuez un nom à votre point de terminaison pour le champ `EndpointConfigName`. ``` # Specify the name of your endpoint endpoint_name='' # Create a low-level SageMaker service client. sagemaker_client = boto3.client('sagemaker', region_name=aws_region) # Store DescribeEndpointConfig response into a variable that we can index in the next step. response = sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_name) # Delete endpoint model_name = response['ProductionVariants'][0]['ModelName'] sagemaker_client.delete_model(ModelName=model_name) ``` Pour plus d'informations sur les autres éléments de réponse renvoyés par`DescribeEndpointConfig`, consultez [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html)le [guide de référence des SageMaker API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html). ------ #### [ AWS CLI ] Utilisez la [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model.html)commande pour supprimer votre modèle d' SageMaker IA. Spécifiez le nom de votre modèle pour l'indicateur `model-name`. ``` aws sagemaker delete-model \ --model-name ``` Vous pouvez éventuellement utiliser la commande [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html) pour renvoyer des informations sur le nom des modèles déployés (variantes de production) telles que le nom de votre modèle et le nom de la configuration du point de terminaison associée à ce modèle déployé. Attribuez un nom à votre point de terminaison pour l'indicateur `endpoint-config-name`. ``` aws sagemaker describe-endpoint-config --endpoint-config-name ``` Cela renvoie une réponse JSON. Vous pouvez copier et coller, utiliser un analyseur JSON ou utiliser un outil conçu pour l'analyse JSON afin d'obtenir le nom du modèle associé à ce point de terminaison. ------ #### [ SageMaker AI Console ] Supprimez votre modèle d' SageMaker IA de manière interactive à l'aide de la console d' SageMaker IA. 1. Dans le menu de [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)navigation de la console SageMaker AI, choisissez **Inference**. 1. Choisissez **Models** dans le menu déroulant. Une liste des modèles créés dans votre AWS compte s'affichera par nom, Amazon Resource Name (ARN) et heure de création. 1. Sélectionnez le modèle à supprimer. 1. Sélectionnez le bouton de la liste déroulante **Actions** dans le coin supérieur droit. 1. Sélectionnez **Supprimer**. ------