Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Déploiement de modèles pour l'inférence
Avec Amazon SageMaker AI, vous pouvez commencer à obtenir des prédictions, ou des *inférences*, à partir de vos modèles d'apprentissage automatique entraînés. SageMaker L'IA propose une large sélection d'options de déploiement d'infrastructures et de modèles de machine learning pour répondre à tous vos besoins en matière d'inférence de machine learning. Avec SageMaker AI Inference, vous pouvez étendre le déploiement de vos modèles, gérer les modèles plus efficacement en production et réduire la charge opérationnelle. SageMaker L'IA vous propose diverses options d'inférence, telles que des points de terminaison en temps réel pour obtenir une inférence à faible latence, des points de terminaison sans serveur pour une infrastructure entièrement gérée et un dimensionnement automatique, et des points de terminaison asynchrones pour des lots de demandes. En tirant parti de l’option d’inférence adaptée à votre cas d’utilisation, vous pouvez garantir des déploiements et des inférences de modèles efficaces.
## Choix d’une caractéristique
Il existe plusieurs cas d'utilisation pour déployer des modèles de machine learning avec SageMaker l'IA. Cette section décrit ces cas d'utilisation, ainsi que la fonctionnalité d' SageMaker intelligence artificielle que nous recommandons pour chaque cas d'utilisation.
### Cas d’utilisation
Voici les principaux cas d'utilisation du déploiement de modèles de machine learning avec l' SageMaker IA.
+ **Cas d’utilisation 1 : déployer un modèle de machine learning dans un environnement à programmation schématisée ou sans programmation.** Pour les débutants ou les novices en SageMaker matière d'IA, vous pouvez déployer des modèles préentraînés à l'aide d'Amazon SageMaker JumpStart via l'interface Amazon SageMaker Studio, sans avoir besoin de configurations complexes.
+ **Cas d’utilisation 2 : utiliser le code pour déployer des modèles de machine learning offrant plus de flexibilité et de contrôle.** Les praticiens du ML expérimentés peuvent déployer leurs propres modèles avec des paramètres personnalisés adaptés aux besoins de leurs applications à l'aide de la `ModelBuilder` classe du SDK SageMaker AI Python, qui fournit un contrôle précis sur divers paramètres, tels que les types d'instances, l'isolation du réseau et l'allocation des ressources.
+ **Cas d’utilisation 3 : déployer des modèles de machine learning à grande échelle.** Pour les utilisateurs avancés et les organisations qui souhaitent gérer des modèles à grande échelle en production, utilisez l' AWS SDK pour Python (Boto3) infrastructure en tant que code (iAc) et les CI/CD outils souhaités pour provisionner les ressources et automatiser la gestion des ressources. CloudFormation
### Fonctionnalités recommandées
Le tableau suivant décrit les principales considérations et les compromis relatifs aux fonctionnalités d' SageMaker IA correspondant à chaque cas d'utilisation.
| | Cas d’utilisation 1 | Cas d’utilisation 2 | Cas d’utilisation 3 |
| --- | --- | --- | --- |
| SageMaker Fonctionnalité d'IA | Utilisez-le [ JumpStart dans Studio](jumpstart-foundation-models-use-studio-updated.md) pour accélérer le déploiement de votre modèle de base. | Déployez des modèles [ModelBuilder à l'aide du SDK SageMaker Python](how-it-works-modelbuilder-creation.md). | [Déployez et gérez des modèles à grande échelle avec CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_SageMaker.html). |
| Description | Utilisez l’interface utilisateur de Studio pour déployer des modèles pré-entraînés à partir d’un catalogue vers des points de terminaison d’inférence préconfigurés. Cette option est idéale pour les scientifiques des données citoyens ou pour tous ceux qui souhaitent déployer un modèle sans configurer de paramètres complexes. | Utilisez la ModelBuilder classe du SDK Amazon SageMaker AI Python pour déployer votre propre modèle et configurer les paramètres de déploiement. Cette option est idéale pour les scientifiques des données expérimentés ou pour tous ceux qui ont leur propre modèle à déployer et ont besoin d’un contrôle précis. | Utilisation de CloudFormation l'infrastructure en tant que code (IaC) pour le contrôle programmatique et l'automatisation du déploiement et de la gestion de modèles d' SageMaker IA. Cette option est idéale pour les utilisateurs expérimentés qui ont besoin de déploiements cohérents et reproductibles. |
| Optimisé pour | Le déploiements rapides et rationalisés de modèles open source populaires | Le déploiement de vos propres modèles | La gestion continue des modèles en production |
| Considérations | Manque de personnalisation des paramètres du conteneur et pour les besoins spécifiques des applications | Aucune interface utilisateur, vous devez être à l’aise avec le développement et la maintenance du code Python | Nécessite une gestion de l'infrastructure et des ressources organisationnelles, ainsi qu'une connaissance du AWS SDK pour Python (Boto3) ou des CloudFormation modèles. |
| Environnement recommandé | Un domaine d' SageMaker IA | Un environnement de développement Python configuré avec vos AWS informations d'identification et le SDK SageMaker Python installé, ou un IDE SageMaker AI tel que [SageMaker JupyterLab](studio-updated-jl.md) | Le AWS CLI, un environnement de développement local, une infrastructure en tant que code (IaC) et CI/CD des outils |
### Options supplémentaires
SageMaker L'IA propose différentes options pour vos cas d'utilisation d'inférence, vous permettant ainsi de choisir l'étendue technique et la profondeur de vos déploiements :
+ **Déploiement d’un modèle sur un point de terminaison.** Envisagez les options suivantes lorsque vous déployez votre modèle :
+ [Inférence en temps réel](realtime-endpoints.md). L’inférence en temps réel est idéale pour les charges de travail d’inférence où vous avez des exigences interactives et à faible latence.
+ [Déployez des modèles avec Amazon SageMaker Serverless Inference](serverless-endpoints.md). Utilisez des inférences sans serveur pour déployer des modèles sans configurer ni gérer aucune infrastructure sous-jacente. Cette option est idéale pour les charges de travail qui ont des périodes d’inactivité entre les pics de trafic et qui peuvent tolérer des démarrages à froid.
+ [Inférence asynchrone](async-inference.md). Met les demandes entrantes en file d’attente et les traite de manière asynchrone. Cette option est idéale pour les demandes avec des charges utiles importantes (allant jusqu'à 1 Go), des temps de traitement longs (allant jusqu'à une heure) et des exigences de latence en temps quasi réel.
+ **Optimisation des coûts.** Envisagez les options suivantes pour optimiser vos coûts d’inférence :
+ [Optimisation des performances des modèles avec SageMaker Neo](neo.md). Utilisez SageMaker Neo pour optimiser et exécuter vos modèles d'apprentissage automatique avec de meilleures performances et une meilleure efficacité, ce qui vous aide à minimiser les coûts de calcul en optimisant automatiquement les modèles pour qu'ils s'exécutent dans des environnements tels que les puces AWS Inferentia.
+ [Mise à l'échelle automatique des modèles Amazon SageMaker AI](endpoint-auto-scaling.md). Utilisez l’autoscaling pour ajuster dynamiquement les ressources de calcul de vos points de terminaison en fonction des modèles de trafic entrant, ce qui vous permet d’optimiser les coûts en ne payant que pour les ressources que vous utilisez à un moment donné.
# Options de déploiement de modèles dans Amazon SageMaker AI
Après avoir entraîné votre modèle de machine learning, vous pouvez le déployer à l’aide d’Amazon SageMaker AI afin d’obtenir des prédictions. Amazon SageMaker AI prend en charge les méthodes suivantes pour déployer un modèle et dépendent de votre cas d’utilisation :
+ Pour les points de terminaison en temps réel persistants qui font une prédiction à la fois, utilisez les services d’hébergement en temps réel SageMaker AI. Consultez [Inférence en temps réel](realtime-endpoints.md).
+ Pour les charges de travail qui ont des périodes d’inactivité entre les pics de trafic et qui peuvent tolérer des démarrages à froid, utilisez l’inférence sans serveur. Consultez [Déployez des modèles avec Amazon SageMaker Serverless Inference](serverless-endpoints.md).
+ Pour les demandes avec des données utiles importantes allant jusqu’à 1 Go, des temps de traitement longs et des exigences de latence en temps quasi réel, utilisez Amazon SageMaker Asynchronous Inference. Consultez [Inférence asynchrone](async-inference.md).
+ Pour obtenir des prédictions pour un jeu de données tout entier, utilisez la transformation par lots SageMaker AI. Consultez [Transformation par lots à des fins d'inférence avec Amazon AI SageMaker](batch-transform.md).
SageMaker AI propose également des fonctions permettant de gérer les ressources et d’optimiser les performances d’inférence lors du déploiement de modèles de machine learning :
+ Pour gérer les modèles sur les appareils en périphérie afin de vous permettre d’optimiser, de sécuriser, de contrôler et de maintenir des modèles de machine learning sur des flottes d’appareils en périphérie, consultez [Modélisez le déploiement à la périphérie avec SageMaker Edge Manager](edge.md). Cela s’applique aux appareils en périphérie tels que les caméras intelligentes, les robots, les ordinateurs personnels et les appareils mobiles.
+ Pour optimiser les modèles Gluon, Keras, MXNet, PyTorch, TensorFlow, TensorFlow-Lite et ONNX pour l’inférence sur les machines Android, Linux et Windows basées sur des processeurs Ambarella, ARM, Intel, Nvidia, NXP, Qualcomm, Texas Instruments et Xilinx, consultez [Optimisation des performances des modèles avec SageMaker Neo](neo.md).
Pour plus d’informations sur l’ensemble de ces options de déploiement, consultez [Déploiement de modèles pour l'inférence](deploy-model.md).
# Découvrez les options de déploiement de modèles et d'obtention d'inférences dans Amazon AI SageMaker
Pour vous aider à démarrer avec SageMaker AI Inference, consultez les sections suivantes qui expliquent les options qui s'offrent à vous pour déployer votre modèle dans l' SageMaker IA et obtenir des inférences. La section [Options d'inférence dans Amazon AI SageMaker](deploy-model-options.md) peut vous aider à déterminer quelle caractéristique correspond le mieux à votre cas d’utilisation pour l’inférence.
Vous pouvez consulter [Ressources](inference-resources.md) cette section pour plus d'informations de dépannage et de référence, des blogs et des exemples pour vous aider à démarrer, ainsi que des informations courantes FAQs.
**Topics**
+ [Avant de commencer](#deploy-model-prereqs)
+ [Étapes du déploiement d'un modèle](#deploy-model-steps)
+ [Options d'inférence dans Amazon AI SageMaker](deploy-model-options.md)
+ [Options de point de terminaison avancées pour l'inférence avec Amazon AI SageMaker](deploy-model-advanced.md)
+ [Prochaines étapes pour l'inférence avec Amazon AI SageMaker](deploy-model-next-steps.md)
## Avant de commencer
Ces rubriques supposent que vous avez créé et entraîné un modèle de machine learning, et que vous êtes prêt à le déployer. Vous n'avez pas besoin de former votre modèle à l' SageMaker IA pour le déployer et obtenir des SageMaker inférences. Si vous ne possédez pas votre propre modèle, vous pouvez également utiliser les [algorithmes intégrés de l' SageMaker IA ou les modèles préentraînés](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html).
Si vous débutez dans le domaine de l' SageMaker IA et que vous n'avez pas encore choisi de modèle à déployer, suivez les étapes du didacticiel [Get Started with Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/gs.html). Utilisez le didacticiel pour vous familiariser avec la façon dont l' SageMaker IA gère le processus de science des données et comment elle gère le déploiement des modèles. Pour plus d'informations sur l'entraînement d'un modèle, consultez [Entraîner des modèles](https://docs.aws.amazon.com/sagemaker/latest/dg/train-model.html).
Pour obtenir des informations, des références et des exemples supplémentaires, consultez [Ressources](inference-resources.md).
## Étapes du déploiement d'un modèle
Pour les points de terminaison d'inférence, le flux de travail général se compose des opérations suivantes :
+ Créez un modèle dans SageMaker AI Inference en pointant vers des artefacts de modèle stockés dans Amazon S3 et une image de conteneur.
+ Sélectionnez une option d'inférence. Pour de plus amples informations, veuillez consulter [Options d'inférence dans Amazon AI SageMaker](deploy-model-options.md).
+ Créez une configuration de point de terminaison SageMaker AI Inference en choisissant le type d'instance et le nombre d'instances dont vous avez besoin derrière le point de terminaison. Vous pouvez utiliser [Amazon SageMaker Inference Recommender](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender.html) pour obtenir des recommandations pour les types d'instances. Pour l'inférence sans serveur, il vous suffit de fournir la configuration de mémoire dont vous avez besoin en fonction de la taille de votre modèle.
+ Créez un point de terminaison SageMaker AI Inference.
+ Invoquez votre point de terminaison pour recevoir une inférence en tant que réponse.
Le schéma suivant illustre le flux de travail précédent.
![\[Le flux de travail décrit dans le paragraphe précédent montre comment obtenir des inférences à partir de l' SageMaker IA.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inference-workflow-flowchart.png)
Vous pouvez effectuer ces actions à l'aide de la AWS console AWS SDKs, du SDK SageMaker Python CloudFormation ou du AWS CLI.
Pour l'inférence par lots avec transformation par lots, pointez sur les artefacts de votre modèle et les données d'entrée, puis créez une tâche d'inférence par lots. Au lieu d'héberger un point de terminaison à des fins d'inférence, l' SageMaker IA transmet vos inférences à l'emplacement Amazon S3 de votre choix.
# Options d'inférence dans Amazon AI SageMaker
SageMaker L'IA propose plusieurs options d'inférence afin que vous puissiez choisir celle qui convient le mieux à votre charge de travail :
+ [Inférence en temps réel](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html) : l'*inférence en temps réel* est idéale pour les inférences en ligne nécessitant une faible latence ou un débit élevé. Utilisez l'inférence en temps réel pour un point de terminaison persistant et entièrement géré (API REST) capable de gérer un trafic soutenu, soutenu par le type d'instance de votre choix. L’inférence en temps réel peut prendre en charge des tailles de données utiles allant jusqu’à 25 Mo ainsi que des durées de traitement de 60 secondes pour les réponses régulières et de 8 minutes pour les réponses en streaming.
+ [Inférence sans serveur : L'inférence](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html) *sans serveur* est idéale lorsque les modèles de trafic sont intermittents ou imprévisibles. SageMaker L'IA gère l'ensemble de l'infrastructure sous-jacente, il n'est donc pas nécessaire de gérer les instances ou de mettre à l'échelle les politiques. Vous ne payez que pour ce que vous utilisez et non pour le temps d'inactivité. Elle peut prendre en charge des charges utiles allant jusqu'à 4 Mo et des temps de traitement allant jusqu'à 60 secondes.
+ [Transformation par lots](https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html) : la *transformation par lots* convient au traitement hors ligne lorsque de grandes quantités de données sont disponibles à l'avance et que vous n'avez pas besoin d'un point de terminaison persistant. Vous pouvez également utiliser la transformation par lots pour le prétraitement des jeux de données. Il peut prendre en charge de grands ensembles de données dont la taille et GBs les délais de traitement se chiffrent en jours.
+ [Inférence asynchrone](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference.html) : l'*inférence asynchrone* est idéale lorsque vous souhaitez mettre en file d'attente des demandes et disposer de charges utiles importantes avec de longs délais de traitement. L'inférence asynchrone peut prendre en charge des charges utiles allant jusqu'à 1 Go et des temps de traitement longs allant jusqu'à une heure. Vous pouvez également réduire votre point de terminaison à 0 lorsqu'il n'y a aucune demande à traiter.
# Options de point de terminaison avancées pour l'inférence avec Amazon AI SageMaker
L'inférence en temps réel vous permet d'optimiser davantage les performances et les coûts grâce aux options d'inférence avancées suivantes :
+ [Points de terminaison multimodèles](multi-model-endpoints.md) : choisissez cette option si vous possédez plusieurs modèles qui utilisent le même cadre et peuvent partager un conteneur. Cette option vous permet d'optimiser les coûts en améliorant l'utilisation des points de terminaison et en réduisant les frais de déploiement.
+ [Points de terminaison multi-conteneurs](multi-container-endpoints.md) : choisissez cette option si vous possédez plusieurs modèles qui utilisent des cadres différents et nécessitent leurs propres conteneurs. Vous bénéficierez des nombreux avantages des points de terminaison multimodèles et pourrez déployer divers cadres et modèles.
+ [Pipelines d’inférence en série](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html) : utilisez cette option si vous souhaitez héberger des modèles avec une logique de prétraitement et de post-traitement derrière un point de terminaison. Les pipelines d'inférence sont entièrement gérés par l' SageMaker IA et offrent une latence plus faible car tous les conteneurs sont hébergés sur les mêmes instances Amazon EC2.
# Prochaines étapes pour l'inférence avec Amazon AI SageMaker
Une fois que vous avez un point de terminaison et que vous avez compris le flux de travail d'inférence général, vous pouvez utiliser les fonctionnalités suivantes de l' SageMaker IA pour améliorer votre flux de travail d'inférence.
## Contrôle
Pour suivre votre modèle au fil du temps à l'aide de métriques telles que la précision et la dérive du modèle, vous pouvez utiliser Model Monitor. Model Monitor vous permet de définir des alertes qui vous avertiront en cas d'écarts dans la qualité du modèle. Pour en savoir plus, consultez la [documentation sur Model Monitor](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html).
Pour en savoir plus sur les outils qui peuvent être utilisés pour surveiller les déploiements de modèles et les événements qui modifient votre point de terminaison, consultez [Monitor Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-overview.html). Par exemple, vous pouvez surveiller l'état de santé de votre terminal grâce à des indicateurs tels que les erreurs d'invocation et la latence du modèle à l'aide CloudWatch des métriques Amazon. Les [indicateurs d'invocation des terminaux basés sur l'SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-endpoint-invocation) peuvent vous fournir des informations précieuses sur les performances de votre terminal.
## CI/CD pour le déploiement d'un modèle
Pour créer des solutions d'apprentissage automatique dans le domaine de l' SageMaker IA, vous pouvez utiliser l'[SageMaker IA MLOps](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects.html). Vous pouvez utiliser cette fonctionnalité pour automatiser les étapes de votre flux de travail de machine learning et pratiquer la CI/CD. Vous pouvez utiliser des [modèles de MLOps projet](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects-templates.html) pour faciliter la configuration et la mise en œuvre de MLOps projets d' SageMaker IA. SageMaker L'IA prend également en charge l'utilisation de votre propre [dépôt Git tiers](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects-walkthrough-3rdgit.html) pour créer un CI/CD système.
Pour vos pipelines ML, utilisez [Model Registry](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry.html) pour gérer vos versions de modèle ainsi que le déploiement et l'automatisation de vos modèles.
## Barrières de protection de déploiement
Si vous souhaitez mettre à jour votre modèle pendant qu'il est en production sans affecter la production, vous pouvez utiliser des barrières de protection de déploiement. Les garde-fous de déploiement sont un ensemble d'options de déploiement de modèles dans SageMaker AI Inference pour mettre à jour vos modèles d'apprentissage automatique en production. À l'aide des options de déploiement entièrement gérées, vous pouvez contrôler le passage du modèle actuel en production à un nouveau. Les modes de déplacement de trafic vous permettent de contrôler précisément le processus de déplacement de trafic, et des dispositifs de protection intégrés tels que les restaurations automatiques favorisent la détection précoce des problèmes.
Pour en savoir plus sur les barrières de protection de déploiement, consultez la [documentation sur les barrières de protection de déploiement](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails.html).
## Inferentia
Si vous devez exécuter des applications de machine learning et de deep learning à grande échelle, vous pouvez utiliser une instance `Inf1` avec un point de terminaison en temps réel. Ce type d’instance convient aux cas d’utilisation tels que la reconnaissance vocale ou d’images, le traitement du langage naturel (NLP), la personnalisation, les prévisions ou la détection des fraudes.
`Inf1`les instances sont conçues pour prendre en charge les applications d'inférence d'apprentissage automatique et comportent les puces AWS Inferentia. `Inf1`les instances fournissent un débit plus élevé et un coût par inférence inférieur à celui des instances basées sur un GPU.
Pour déployer un modèle sur `Inf1` des instances, compilez votre modèle avec SageMaker Neo et choisissez une `Inf1` instance pour votre option de déploiement. Pour en savoir plus, voir [Optimiser les performances du modèle à l'aide de SageMaker Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).
## Optimisation des performances de modèle
SageMaker L'IA fournit des fonctionnalités permettant de gérer les ressources et d'optimiser les performances d'inférence lors du déploiement de modèles d'apprentissage automatique. Vous pouvez utiliser les [algorithmes intégrés et les modèles prédéfinis](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html) de l' SageMaker IA, ainsi que les [images Docker prédéfinies](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-prebuilt.html), développées pour l'apprentissage automatique.
Pour entraîner les modèles et les optimiser pour le déploiement, consultez les [images Docker prédéfinies](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-prebuilt.html) [Optimisez les performances des modèles à l'aide SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) de Neo. Avec SageMaker Neo, vous pouvez vous entraîner TensorFlow, Apache MXNet PyTorch, ONNX et XGBoost modéliser. Vous pouvez ensuite les optimiser et les déployer sur des processeurs ARM, Intel et Nvidia.
## Autoscaling
Si le trafic vers vos points de terminaison est variable, vous pouvez essayer la mise à l'échelle automatique. Par exemple, pendant les heures de pointe, vous pouvez avoir besoin de davantage d’instances pour traiter les demandes. Vous pouvez toutefois réduire votre utilisation des ressources de calcul pendant les périodes de faible trafic. Pour ajuster dynamiquement le nombre d'instances mises en service en réponse aux modifications apportées à votre charge de travail, consultez [Mise à l'échelle automatique des modèles Amazon SageMaker AI](endpoint-auto-scaling.md).
Si vos modèles de trafic sont imprévisibles ou si vous ne souhaitez pas configurer de politiques de mise à l’échelle, vous pouvez également utiliser l’inférence sans serveur pour un point de terminaison. L' SageMaker IA gère ensuite l'autoscaling pour vous. Pendant les périodes de faible trafic, l' SageMaker IA réduit votre point de terminaison, et si le trafic augmente, l' SageMaker IA fait évoluer votre point de terminaison vers le haut. Pour plus d’informations, consultez la documentation [Déployez des modèles avec Amazon SageMaker Serverless Inference](serverless-endpoints.md).
# Créez un modèle dans Amazon SageMaker AI avec ModelBuilder
La préparation de votre modèle pour le déploiement sur un point de terminaison basé sur l' SageMaker IA nécessite plusieurs étapes, notamment le choix d'une image de modèle, la configuration du point de terminaison, le codage de vos fonctions de sérialisation et de désérialisation pour transférer les données vers et depuis le serveur et le client, l'identification des dépendances du modèle et leur téléchargement sur Amazon S3. `ModelBuilder`peut réduire la complexité de la configuration initiale et du déploiement pour vous aider à créer un modèle déployable en une seule étape.
`ModelBuilder` effectue les tâches suivantes pour vous :
+ Convertit les modèles d'apprentissage automatique formés à l'aide de divers frameworks tels que XGBoost ou PyTorch en modèles déployables en une seule étape.
+ Effectue une sélection automatique du conteneur en fonction du cadre de modèle afin que vous n’ayez pas à spécifier manuellement votre conteneur. Vous pouvez tout de même apporter votre propre conteneur en transmettant votre propre URI à `ModelBuilder`.
+ Gère la sérialisation des données côté client avant de les envoyer au serveur pour inférence et désérialisation des résultats renvoyés par le serveur. Les données sont correctement formatées sans traitement manuel.
+ Permet la capture automatique des dépendances et crée un package du modèle en fonction des attentes du serveur de modèles. La capture automatique des dépendances de `ModelBuilder` est une approche optimale pour charger les dépendances de manière dynamique. (Nous vous recommandons de tester la capture automatique localement et de mettre à jour les dépendances en fonction de vos besoins.)
+ Pour les cas d'utilisation d'un modèle de langage étendu (LLM), effectue éventuellement un réglage des paramètres locaux des propriétés de service qui peuvent être déployées pour améliorer les performances lors de l'hébergement sur un point de terminaison SageMaker AI.
+ Supporte la plupart des modèles de serveurs et de conteneurs populaires tels que TorchServe Triton DJLServing et TGI Container.
## Construisez votre modèle avec ModelBuilder
`ModelBuilder`est une classe Python qui prend un modèle de framework, tel que XGBoost ou PyTorch, ou une spécification d'inférence spécifiée par l'utilisateur, et le convertit en un modèle déployable. `ModelBuilder`fournit une fonction de génération qui génère les artefacts pour le déploiement. L’artefact de modèle généré est spécifique au serveur de modèles, que vous pouvez également spécifier comme l’une des entrées. Pour plus de détails sur le `ModelBuilder` cours, voir [ModelBuilder](https://sagemaker.readthedocs.io/en/stable/api/inference/model_builder.html#sagemaker.serve.builder.model_builder.ModelBuilder).
Le schéma suivant illustre le flux de travail global de création de modèle lorsque vous utilisez `ModelBuilder`. `ModelBuilder` accepte un modèle ou une spécification d’inférence avec votre schéma pour créer un modèle déployable que vous pouvez tester localement avant le déploiement.
![\[Flux de création et de déploiement de modèle à l’aide de ModelBuilder.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model-builder-flow.png)
`ModelBuilder` peut gérer toute personnalisation que vous souhaitez appliquer. Toutefois, pour déployer un modèle de cadre, le générateur de modèle attend au minimum un modèle, des exemples d’entrée et de sortie, ainsi que le rôle. Dans l’exemple de code suivant, `ModelBuilder` est appelé avec un modèle de cadre et une instance de `SchemaBuilder` avec un minimum d’arguments (afin de déduire les fonctions correspondantes pour la sérialisation et la désérialisation de l’entrée et de la sortie de point de terminaison). Aucun conteneur n'est spécifié et aucune dépendance packagée n'est transmise. SageMaker L'IA déduit automatiquement ces ressources lorsque vous créez votre modèle.
```
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
model_builder = ModelBuilder(
model=model,
schema_builder=SchemaBuilder(input, output),
role_arn="execution-role",
)
```
L’exemple de code suivant invoque `ModelBuilder` avec une spécification d’inférence (sous forme d’instance `InferenceSpec`) au lieu d’un modèle, avec une personnalisation supplémentaire. Dans ce cas, l’appel au générateur de modèle inclut un chemin pour stocker les artefacts de modèle et active également la capture automatique de toutes les dépendances disponibles. Pour en savoir plus sur `InferenceSpec`, consultez [Personnalisation du chargement du modèle et du traitement des demandes](#how-it-works-modelbuilder-creation-is).
```
model_builder = ModelBuilder(
mode=Mode.LOCAL_CONTAINER,
model_path=model-artifact-directory,
inference_spec=your-inference-spec,
schema_builder=SchemaBuilder(input, output),
role_arn=execution-role,
dependencies={"auto": True}
)
```
## Définition des méthodes de sérialisation et de désérialisation
Lors de l'appel d'un point de terminaison SageMaker AI, les données sont envoyées via des charges utiles HTTP avec différents types MIME. Par exemple, une image envoyée au point de terminaison pour inférence doit être convertie en octets côté client et envoyée par l’intermédiaire de données utiles HTTP au point de terminaison. Lorsque le point de terminaison reçoit les données utiles, il doit désérialiser la chaîne d’octets pour revenir au type de données attendu par le modèle (ce processus est également appelé désérialisation côté serveur). Une fois que le modèle a terminé la prédiction, les résultats doivent également être sérialisés en octets qui peuvent être renvoyés par le biais de données utiles HTTP à l’utilisateur ou au client. Une fois que le client reçoit les données d’octets de réponse, il doit effectuer une désérialisation côté client pour reconvertir les données d’octets au format de données attendu, tel que JSON. Au minimum, vous devez convertir les données pour les tâches suivantes :
1. Sérialisation de demande d’inférence (gérée par le client)
1. Désérialisation de demande d’inférence (gérée par le serveur ou l’algorithme)
1. Invocation du modèle par rapport aux données utiles et renvoi des données utiles de réponse
1. Sérialisation de réponse d’inférence (gérée par le serveur ou l’algorithme)
1. Désérialisation de réponse d’inférence (gérée par le client)
Le schéma suivant montre les processus de sérialisation et de désérialisation qui se produisent lorsque vous invoquez le point de terminaison.
![\[Schéma de sérialisation et de désérialisation des données du client vers le serveur.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model-builder-serialization.png)
Lorsque vous fournissez des exemples d’entrée et de sortie à `SchemaBuilder`, le générateur de schéma génère les fonctions de conversion correspondantes pour sérialiser et désérialiser l’entrée et la sortie. Vous pouvez personnaliser davantage vos fonctions de sérialisation avec `CustomPayloadTranslator`. Mais dans la plupart des cas, un simple sérialiseur tel que le suivant fonctionnerait :
```
input = "How is the demo going?"
output = "Comment la démo va-t-elle?"
schema = SchemaBuilder(input, output)
```
Pour plus de détails sur`SchemaBuilder`, voir [SchemaBuilder](https://sagemaker.readthedocs.io/en/stable/api/inference/model_builder.html#sagemaker.serve.builder.schema_builder.SchemaBuilder).
L’extrait de code suivant décrit un exemple dans lequel vous souhaitez personnaliser les fonctions de sérialisation et de désérialisation côté client et côté serveur. Vous pouvez définir vos propres traducteurs de demandes et de réponses avec `CustomPayloadTranslator` et transmettre ces traducteurs à `SchemaBuilder`.
En incluant les entrées et les sorties dans les traducteurs, le générateur de modèle peut extraire le format de données attendu par le modèle. Supposons, par exemple, que l’exemple d’entrée soit une image brute et que vos traducteurs personnalisés recadrent l’image et envoient l’image recadrée au serveur sous forme de tenseur. `ModelBuilder` a besoin à la fois de l’entrée brute et de tout code de prétraitement ou de post-traitement personnalisé pour obtenir une méthode permettant de convertir les données à la fois côté client et côté serveur.
```
from sagemaker.serve import CustomPayloadTranslator
# request translator
class MyRequestTranslator(CustomPayloadTranslator):
# This function converts the payload to bytes - happens on client side
def serialize_payload_to_bytes(self, payload: object) -> bytes:
# converts the input payload to bytes
... ...
return //return object as bytes
# This function converts the bytes to payload - happens on server side
def deserialize_payload_from_stream(self, stream) -> object:
# convert bytes to in-memory object
... ...
return //return in-memory object
# response translator
class MyResponseTranslator(CustomPayloadTranslator):
# This function converts the payload to bytes - happens on server side
def serialize_payload_to_bytes(self, payload: object) -> bytes:
# converts the response payload to bytes
... ...
return //return object as bytes
# This function converts the bytes to payload - happens on client side
def deserialize_payload_from_stream(self, stream) -> object:
# convert bytes to in-memory object
... ...
return //return in-memory object
```
Vous transmettez les exemples d’entrée et de sortie ainsi que les traducteurs personnalisés définis précédemment lorsque vous créez l’objet `SchemaBuilder`, comme indiqué dans l’exemple suivant :
```
my_schema = SchemaBuilder(
sample_input=image,
sample_output=output,
input_translator=MyRequestTranslator(),
output_translator=MyResponseTranslator()
)
```
Vous transmettez ensuite les exemples d’entrée et de sortie, ainsi que les traducteurs personnalisés définis précédemment, à l’objet `SchemaBuilder`.
```
my_schema = SchemaBuilder(
sample_input=image,
sample_output=output,
input_translator=MyRequestTranslator(),
output_translator=MyResponseTranslator()
)
```
Les sections suivantes expliquent en détail comment créer votre modèle avec `ModelBuilder` et utiliser ses classes de support pour personnaliser l’expérience en fonction de votre cas d’utilisation.
**Topics**
+ [Construisez votre modèle avec ModelBuilder](#how-it-works-modelbuilder-creation-mb)
+ [Définition des méthodes de sérialisation et de désérialisation](#how-it-works-modelbuilder-creation-sb)
+ [Personnalisation du chargement du modèle et du traitement des demandes](#how-it-works-modelbuilder-creation-is)
+ [Création de votre modèle et déploiement](#how-it-works-modelbuilder-creation-deploy)
+ [Apport de votre propre conteneur](#how-it-works-modelbuilder-creation-mb-byoc)
+ [Utilisation ModelBuilder en mode local](#how-it-works-modelbuilder-creation-local)
+ [ModelBuilder exemples](#how-it-works-modelbuilder-creation-example)
## Personnalisation du chargement du modèle et du traitement des demandes
Le fait de fournir votre propre code d’inférence via `InferenceSpec` offre une couche supplémentaire de personnalisation. Avec `InferenceSpec`, vous pouvez personnaliser le mode de chargement du modèle et la manière dont il gère les demandes d’inférence entrantes, en contournant ses mécanismes de chargement et de gestion des inférences par défaut. Cette flexibilité est particulièrement utile lorsque vous travaillez avec des modèles non standard ou des pipelines d’inférence personnalisés. Vous pouvez personnaliser la méthode `invoke` pour contrôler la manière dont le modèle prétraite et post-traite les demandes entrantes. La méthode `invoke` garantit que le modèle gère correctement les demandes d’inférence. L'exemple suivant permet `InferenceSpec` de générer un modèle avec le HuggingFace pipeline. Pour plus de détails sur`InferenceSpec`, reportez-vous au [InferenceSpec](https://sagemaker.readthedocs.io/en/stable/api/inference/model_builder.html#sagemaker.serve.spec.inference_spec.InferenceSpec).
```
from sagemaker.serve.spec.inference_spec import InferenceSpec
from transformers import pipeline
class MyInferenceSpec(InferenceSpec):
def load(self, model_dir: str):
return pipeline("translation_en_to_fr", model="t5-small")
def invoke(self, input, model):
return model(input)
inf_spec = MyInferenceSpec()
model_builder = ModelBuilder(
inference_spec=your-inference-spec,
schema_builder=SchemaBuilder(X_test, y_pred)
)
```
L’exemple suivant illustre une variante plus personnalisée d’un exemple précédent. Un modèle est défini avec une spécification d’inférence comportant des dépendances. Dans ce cas, le code de la spécification d’inférence dépend du package *lang-segment*. L’argument pour `dependencies` contient une instruction qui demande au générateur d’installer *lang-segment* à l’aide de Git. Étant donné que l’utilisateur demande au générateur de modèle d’installer une dépendance de manière personnalisée, la clé `auto` est `False` pour désactiver la capture automatique des dépendances.
```
model_builder = ModelBuilder(
mode=Mode.LOCAL_CONTAINER,
model_path=model-artifact-directory,
inference_spec=your-inference-spec,
schema_builder=SchemaBuilder(input, output),
role_arn=execution-role,
dependencies={"auto": False, "custom": ["-e git+https://github.com/luca-medeiros/lang-segment-anything.git#egg=lang-sam"],}
)
```
## Création de votre modèle et déploiement
Appelez la fonction `build` pour créer votre modèle déployable. Cette étape crée un code d’inférence (tel que `inference.py`) dans votre répertoire de travail avec le code nécessaire pour créer votre schéma, exécuter la sérialisation et la désérialisation des entrées et des sorties, et exécuter d’autres logiques personnalisées spécifiées par l’utilisateur.
À titre de contrôle d'intégrité, l' SageMaker IA empaquète et sélectionne les fichiers nécessaires au déploiement dans le cadre de la fonction de `ModelBuilder` génération. Au cours de ce processus, SageMaker AI crée également une signature HMAC pour le fichier pickle et ajoute la clé secrète dans l'[CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API en tant que variable d'environnement pendant `deploy` (ou`create`). Le lancement du point de terminaison utilise la variable d’environnement pour valider l’intégrité du fichier pickle.
```
# Build the model according to the model server specification and save it as files in the working directory
model = model_builder.build()
```
Déployez votre modèle avec la méthode `deploy` existante du modèle. Au cours de cette étape, l' SageMaker IA configure un point de terminaison pour héberger votre modèle lorsqu'il commence à faire des prédictions sur les demandes entrantes. Bien que `ModelBuilder` déduise les ressources de point de terminaison nécessaires au déploiement de votre modèle, vous pouvez remplacer ces estimations par vos propres valeurs de paramètres. L'exemple suivant indique à SageMaker AI de déployer le modèle sur une seule `ml.c6i.xlarge` instance. Un modèle construit à partir de `ModelBuilder` permet la journalisation en direct pendant le déploiement en tant que fonctionnalité supplémentaire.
```
predictor = model.deploy(
initial_instance_count=1,
instance_type="ml.c6i.xlarge"
)
```
Si vous souhaitez contrôler de manière plus précise les ressources de point de terminaison attribuées à votre modèle, vous pouvez utiliser un objet `ResourceRequirements`. Avec l'`ResourceRequirements`objet, vous pouvez demander un nombre minimum de modèles CPUs, d'accélérateurs et de copies des modèles que vous souhaitez déployer. Vous pouvez également demander une limite de mémoire minimale et maximale (en Mo). Pour utiliser cette fonctionnalité, vous devez spécifier le type de point de terminaison `EndpointType.INFERENCE_COMPONENT_BASED`. L’exemple suivant demande le déploiement de quatre accélérateurs, d’une taille de mémoire minimale de 1 024 Mo et d’une copie de votre modèle sur un point de terminaison de type `EndpointType.INFERENCE_COMPONENT_BASED`.
```
resource_requirements = ResourceRequirements(
requests={
"num_accelerators": 4,
"memory": 1024,
"copies": 1,
},
limits={},
)
predictor = model.deploy(
mode=Mode.SAGEMAKER_ENDPOINT,
endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED,
resources=resource_requirements,
role="role"
)
```
## Apport de votre propre conteneur
Si vous souhaitez apporter votre propre conteneur (étendu à partir d'un conteneur SageMaker AI), vous pouvez également spécifier l'URI de l'image comme indiqué dans l'exemple suivant. Vous devez également identifier le serveur de modèles correspondant à l’image pour que `ModelBuilder` génère des artefacts spécifiques au serveur de modèles.
```
model_builder = ModelBuilder(
model=model,
model_server=ModelServer.TORCHSERVE,
schema_builder=SchemaBuilder(X_test, y_pred),
image_uri="123123123123.dkr.ecr.ap-southeast-2.amazonaws.com/byoc-image:xgb-1.7-1")
)
```
## Utilisation ModelBuilder en mode local
Vous pouvez déployer votre modèle localement en utilisant l’argument `mode` pour passer du test local au déploiement vers un point de terminaison. Vous devez stocker les artefacts de modèle dans le répertoire de travail, comme illustré dans l’extrait suivant :
```
model = XGBClassifier()
model.fit(X_train, y_train)
model.save_model(model_dir + "/my_model.xgb")
```
Transmettez l’objet modèle, une instance `SchemaBuilder` et définissez le mode sur `Mode.LOCAL_CONTAINER`. Lorsque vous appelez la fonction `build`, `ModelBuilder` identifie automatiquement le conteneur de cadre pris en charge et analyse les dépendances. L'exemple suivant illustre la création d'un modèle avec un XGBoost modèle en mode local.
```
model_builder_local = ModelBuilder(
model=model,
schema_builder=SchemaBuilder(X_test, y_pred),
role_arn=execution-role,
mode=Mode.LOCAL_CONTAINER
)
xgb_local_builder = model_builder_local.build()
```
Appelez la fonction `deploy` pour effectuer le déploiement local, comme illustré dans l’extrait suivant. Si vous spécifiez des paramètres pour le type ou le nombre d’instances, ces arguments sont ignorés.
```
predictor_local = xgb_local_builder.deploy()
```
### Résolution des problèmes en mode local
En fonction de votre configuration locale individuelle, vous pouvez rencontrer des difficultés pour exécuter correctement `ModelBuilder` dans votre environnement. Consultez la liste suivante pour connaître les problèmes que vous pourriez rencontrer et pour savoir comment les résoudre.
+ **Adresse déjà utilisée** : une erreur `Address already in use` peut se produire. Dans ce cas, il est possible qu’un conteneur Docker s’exécute sur ce port ou qu’un autre processus l’utilise. Vous pouvez suivre l’approche décrite dans la [documentation Linux](https://www.cyberciti.biz/faq/what-process-has-open-linux-port/) pour identifier le processus et rediriger correctement votre processus local du port 8080 vers un autre port ou nettoyer l’instance Docker.
+ **Problème d’autorisation IAM** : vous pouvez rencontrer un problème d’autorisation lorsque vous essayez d’extraire une image Amazon ECR ou d’accéder à Amazon S3. Dans ce cas, accédez au rôle d’exécution du bloc-notes ou de l’instance Studio Classic pour vérifier la stratégie pour `SageMakerFullAccess` ou les autorisations d’API respectives.
+ **Problème de capacité du volume EBS** : si vous déployez un grand modèle de langage (LLM), vous risquez de manquer d’espace lors de l’exécution de Docker en mode local ou de rencontrer des limites d’espace pour le cache Docker. Dans ce cas, vous pouvez essayer de déplacer votre volume Docker vers un système de fichiers disposant de suffisamment d’espace. Pour déplacer votre volume Docker, procédez comme suit :
1. Ouvrez un terminal et exécutez `df` pour afficher l’utilisation du disque, comme indiqué dans la sortie suivante :
```
(python3) sh-4.2$ df
Filesystem 1K-blocks Used Available Use% Mounted on
devtmpfs 195928700 0 195928700 0% /dev
tmpfs 195939296 0 195939296 0% /dev/shm
tmpfs 195939296 1048 195938248 1% /run
tmpfs 195939296 0 195939296 0% /sys/fs/cgroup
/dev/nvme0n1p1 141545452 135242112 6303340 96% /
tmpfs 39187860 0 39187860 0% /run/user/0
/dev/nvme2n1 264055236 76594068 176644712 31% /home/ec2-user/SageMaker
tmpfs 39187860 0 39187860 0% /run/user/1002
tmpfs 39187860 0 39187860 0% /run/user/1001
tmpfs 39187860 0 39187860 0% /run/user/1000
```
1. Déplacez le répertoire Docker par défaut de `/dev/nvme0n1p1` vers `/dev/nvme2n1` afin de pouvoir utiliser pleinement le volume SageMaker AI de 256 Go. Pour en savoir plus, consultez la documentation sur le [déplacement de votre répertoire Docker](https://www.guguweb.com/2019/02/07/how-to-move-docker-data-directory-to-another-location-on-ubuntu/).
1. Arrêtez Docker avec la commande suivante :
```
sudo service docker stop
```
1. Ajoutez un `daemon.json` à `/etc/docker` ou ajoutez le blob JSON suivant au blob existant.
```
{
"data-root": "/home/ec2-user/SageMaker/{created_docker_folder}"
}
```
1. Déplacez le répertoire Docker de `/var/lib/docker` vers `/home/ec2-user/SageMaker AI` avec la commande suivante :
```
sudo rsync -aP /var/lib/docker/ /home/ec2-user/SageMaker/{created_docker_folder}
```
1. Démarrez Docker avec la commande suivante :
```
sudo service docker start
```
1. Nettoyez la corbeille avec la commande suivante :
```
cd /home/ec2-user/SageMaker/.Trash-1000/files/*
sudo rm -r *
```
1. Si vous utilisez une instance de SageMaker bloc-notes, vous pouvez suivre les étapes du [fichier de préparation Docker](https://github.com/melanie531/amazon-sagemaker-pytorch-lightning-distributed-training/blob/main/prepare-docker.sh) pour préparer Docker au mode local.
## ModelBuilder exemples
Pour d'autres exemples d'utilisation `ModelBuilder` pour créer vos modèles, consultez les [ModelBuilderexemples de blocs-notes](https://github.com/aws-samples/sagemaker-hosting/blob/main/SageMaker-Model-Builder).
# Optimisation des inférences pour les modèles Amazon SageMaker AI
Avec Amazon SageMaker AI, vous pouvez améliorer les performances de vos modèles d’IA générative en appliquant des techniques d’optimisation des inférences. En optimisant vos modèles, vous pouvez obtenir un meilleur rapport coût-performance pour votre cas d’utilisation. Lorsque vous optimisez un modèle, vous choisissez quelles techniques d’optimisation appliquer parmi celles prises en charge, telles que la quantification, le décodage spéculatif et la compilation. Une fois votre modèle optimisé, vous pouvez exécuter une évaluation pour consulter les métriques de performance en termes de latence, de débit et de prix.
Pour de nombreux modèles, SageMaker AI propose également plusieurs versions préoptimisées, chacune répondant aux différents besoins des applications en termes de latence et de débit. Pour de tels modèles, vous pouvez déployer l’une des versions optimisées sans avoir préalablement optimisé le modèle vous-même.
## Techniques d’optimisation
Amazon SageMaker AI prend en charge les techniques d’optimisation suivantes.
### Compilation
La *compilation* optimise le modèle pour obtenir les meilleures performances disponibles sur le type de matériel choisi sans perte de précision. Vous pouvez appliquer la compilation de modèle afin d’optimiser les LLM pour le matériel accéléré, tel que les instances GPU, les instances AWS Trainium ou les instances AWS Inferentia.
Lorsque vous optimisez un modèle via la compilation, vous bénéficiez d’une compilation anticipée. Vous réduisez le temps de déploiement du modèle et la latence d’autoscaling, car les poids du modèle ne nécessitent pas de compilation en flux tendu quand le modèle est déployé sur une nouvelle instance.
Si vous choisissez de compiler votre modèle pour une instance GPU, SageMaker AI utilise la bibliothèque TensorRT-LLM pour exécuter la compilation. Si vous choisissez de compiler votre modèle pour une instance AWS Trainium ou AWS Inferentia, SageMaker AI utilise le kit AWS Neuron SDK pour exécuter la compilation.
### Quantification
La *quantification* est une technique qui permet de réduire les exigences matérielles d’un modèle en utilisant un type de données moins précis pour les poids et les activations. Après avoir optimisé un modèle avec la quantification, vous pouvez l’héberger sur des GPU moins coûteux et plus disponibles. Cependant, le modèle quantifié peut être moins précis que le modèle source que vous avez optimisé.
Les formats de données pris en charge par SageMaker AI pour la quantification varient d’un modèle à l’autre. Les formats pris en charge comprennent :
+ INT4-AWQ : format de données 4 bits. La quantification du poids sensible à l’activation (AWQ) est une technique de quantification des LLM efficace, précise, faible en bits et uniquement axée sur le poids.
+ FP8 : format à virgule flottante 8 bits (FP8) de faible précision pour les nombres à virgule flottante. Il équilibre efficacité de la mémoire et précision du modèle en représentant des valeurs avec moins de bits que le format à virgule flottante FP16 standard.
+ INT8-SmoothQuant : format de données 8 bits. SmoothQuant est une méthode de quantification à précision mixte qui permet de mettre à l’échelle les activations et les poids conjointement en équilibrant leurs plages dynamiques.
### Décodage spéculatif
Le *décodage spéculatif* est une technique permettant d’accélérer le processus de décodage des grands modèles de langage (LLM). Il optimise les modèles pour réduire la latence sans compromettre la qualité du texte généré.
Cette technique utilise un modèle plus petit, mais plus rapide, appelé *brouillon* de modèle. Le brouillon de modèle génère des jetons candidats, qui sont ensuite validés par le modèle *cible* plus grand, mais plus lent. À chaque itération, le brouillon de modèle génère plusieurs jetons candidats. Le modèle cible vérifie les jetons, et s’il trouve qu’un jeton en particulier n’est pas acceptable, il le rejette et le génère à nouveau. Ainsi, le modèle cible vérifie les jetons et en génère une petite quantité.
Le brouillon de modèle est nettement plus rapide que le modèle cible. Il génère rapidement tous les jetons, puis en envoie des lots au modèle cible pour vérification. Le modèle cible les évalue tous en parallèle, ce qui accélère la réponse finale.
SageMaker AI propose un brouillon de modèle prédéfini que vous pouvez utiliser pour ne pas avoir à concevoir le vôtre. Si vous préférez utiliser votre propre brouillon de modèle personnalisé, SageMaker AI prend également en charge cette option.
### Chargement rapide des modèles
La technique du *chargement rapide des modèles* prépare un LLM afin que SageMaker AI puisse le charger plus rapidement sur une instance de ML.
Pour préparer le modèle, SageMaker AI le partitionne à l’avance en le divisant en portions pouvant chacune résider sur un GPU distinct pour une inférence distribuée. SageMaker AI stocke également les poids du modèle sous forme de segments de taille égale pour pouvoir les charger simultanément sur l’instance.
Lorsque SageMaker AI charge le modèle optimisé sur l’instance, les poids du modèle sont directement diffusés depuis Amazon S3 vers les GPU de l’instance. En diffusant les poids, SageMaker AI omet plusieurs étapes chronophages qui sont normalement nécessaires. Ces étapes incluent le téléchargement des artefacts du modèle depuis Amazon S3 sur le disque, le chargement des artefacts du modèle sur la mémoire de l’hôte et le partitionnement du modèle sur l’hôte avant de finalement charger les partitions sur les GPU.
Après avoir optimisé votre modèle pour accélérer le chargement, vous pouvez le déployer plus rapidement sur un point de terminaison SageMaker AI. De plus, si vous configurez le point de terminaison pour utiliser l’autoscaling, il augmente horizontalement plus rapidement pour s’adapter à la hausse du trafic.
# Déploiement d’un modèle préoptimisé
Certains modèles JumpStart sont préoptimisés par SageMaker AI, ce qui signifie que vous pouvez déployer des versions optimisées de ces modèles sans créer au préalable une tâche d’optimisation d’inférence.
Pour obtenir la liste des modèles avec options préoptimisées, consultez [Modèles JumpStart préoptimisés](#pre-optimized-js).
## Amazon SageMaker Studio
Utilisez la procédure suivante pour déployer un modèle JumpStart préoptimisé à l’aide d’Amazon SageMaker Studio.
**Pour déployer un modèle préoptimisé**
1. Dans le menu de navigation de gauche de Studio, choisissez **JumpStart**.
1. Sur la page **Tous les modèles publics**, choisissez l’un des modèles préoptimisés.
1. Sur la page des détails du modèle, choisissez **Déployer**.
1. Sur la page de déploiement, certains modèles JumpStart nécessitent que vous signiez un contrat de licence d’utilisateur final (CLUF) avant de pouvoir continuer. Si nécessaire, consultez les termes du contrat de licence dans la section **Contrat de licence**. Si les conditions sont acceptables pour votre cas d’utilisation, cochez la case **J’accepte le CLUF et j’en ai lu les conditions générales**.
Pour plus d’informations, consultez [Contrats de licence de l'utilisateur final](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula).
1. Pour **Nom du point de terminaison** et **Nombre d’instances initiales**, acceptez les valeurs par défaut ou définissez les valeurs personnalisées.
1. For **Type d’instance**, conservez la valeur par défaut. Sinon, vous ne pouvez pas déployer de configuration préoptimisée.
1. Sous **Modèles**, développez la configuration du modèle. Studio affiche un tableau qui répertorie les configurations préoptimisées que vous pouvez choisir. Chaque option comporte des métriques de latence et de débit. Choisissez l’option qui correspond le mieux aux besoins de votre application.
1. Choisissez **Déployer**.
## SageMaker AI Python SDK
Vous pouvez déployer un modèle préoptimisé en utilisant le kit SageMaker AI Python SDK dans votre projet. Commencez par définir une instance `Model` à l’aide de la classe `ModelBuilder`. Vous utilisez ensuite la méthode `set_deployment_config()` pour définir la configuration préoptimisée que vous souhaitez déployer. Puis vous utilisez la méthode `build()` pour créer le modèle. Enfin, vous utilisez la méthode `deploy()` pour le déployer sur un point de terminaison d’inférence.
Pour plus d’informations sur les classes et les méthodes utilisées dans les exemples suivants, consultez [API](https://sagemaker.readthedocs.io/en/stable/api/index.html) dans la documentation du kit SageMaker AI Python SDK.
**Pour configurer votre projet**
1. Dans votre code d’application, importez les bibliothèques nécessaires. Les exemples suivants importent le kit SDK pour Python (Boto3). Il importe également les modules du kit SageMaker AI Python SDK que vous utilisez pour définir des modèles et travailler avec :
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
```
1. Initialisez une session SageMaker AI. L’exemple suivant utilise la classe `Session()` :
```
sagemaker_session = Session()
```
**Pour définir votre modèle**
1. Créez une instance `SchemaBuilder` et fournissez des exemples d’entrée et de sortie. Vous fournissez cette instance à la classe `ModelBuilder` lorsque vous définissez un modèle. Avec celle-ci, SageMaker AI génère automatiquement les fonctions de transformation pour sérialiser et désérialiser l’entrée et la sortie.
Pour plus d’informations sur les classes `SchemaBuilder` et `ModelBuilder`, consultez [Créez un modèle dans Amazon SageMaker AI avec ModelBuilder](how-it-works-modelbuilder-creation.md).
L’exemple suivant fournit des exemples de chaînes d’entrée et de sortie à la classe `SchemaBuilder` :
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. Définissez votre modèle pour SageMaker AI. L’exemple suivant définit les paramètres pour initialiser une instance `ModelBuilder` :
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
Cet exemple utilise un modèle JumpStart. Remplacez `jumpstart-model-id` par l’ID d’un modèle JumpStart, tel que `meta-textgeneration-llama-3-70b`.
**Pour extraire des métriques de référence**
1. Pour déterminer quelle configuration préoptimisée vous souhaitez déployer, examinez les options proposées par SageMaker AI. L’exemple suivant les affiche :
```
model_builder.display_benchmark_metrics()
```
Cette méthode `display_benchmark_metrics()` imprime un tableau comme celui-ci :
```
| Instance Type | Config Name | Concurrent Users | Latency, TTFT (P50 in sec) | Throughput (P50 in tokens/sec/user) |
|:----------------|:--------------|-------------------:|-----------------------------:|--------------------------------------:|
| ml.g5.48xlarge | lmi-optimized | 1 | 2.25 | 49.70 |
| ml.g5.48xlarge | lmi-optimized | 2 | 2.28 | 21.10 |
| ml.g5.48xlarge | lmi-optimized | 4 | 2.37 | 14.10 |
. . .
| ml.p4d.24xlarge | lmi-optimized | 1 | 0.10 | 137.40 |
| ml.p4d.24xlarge | lmi-optimized | 2 | 0.11 | 109.20 |
| ml.p4d.24xlarge | lmi-optimized | 4 | 0.13 | 85.00 |
. . .
```
La première colonne répertorie les types d’instances potentiels que vous pouvez utiliser pour héberger le modèle JumpStart que vous avez choisi. Pour chaque type d’instance, la colonne `Config Name` répertorie les noms des configurations préoptimisées. Les configurations fournies par SageMaker AI sont nommées `lmi-optimized`. Pour chaque type d’instance et chaque configuration, le tableau fournit des métriques de référence. Ces métriques indiquent le débit et la latence que votre modèle prendra en charge pour différents nombres d’utilisateurs simultanés.
1. Sur la base des indicateurs de référence, choisissez le type d’instance et le nom de configuration qui répondent le mieux à vos besoins en matière de performances. Vous utiliserez ces valeurs lorsque vous créerez une configuration de déploiement.
**Pour déployer un modèle préoptimisé**
1. Créez une configuration de déploiement. L’exemple suivant utilise une instance `ModelBuilder`. Il transmet un type d’instance et un nom de configuration à la méthode `set_deployment_config()` :
```
model_builder.set_deployment_config(
config_name="config-name",
instance_type="instance-type",
)
```
Remplacez *`config-name`* par un nom de configuration figurant dans le tableau, tel que `lmi-optimized`. Remplacez `instance-type` par un type d’instance figurant dans le tableau, tel que `ml.p4d.24xlarge`.
1. Créez votre modèle. L’exemple suivant utilise la méthode `.build()` de l’instance `ModelBuilder` :
```
optimized_model = model_builder.build()
```
La méthode `.build()` renvoie une instance `Model` déployable.
1. Déployez votre modèle sur un point de terminaison d’inférence. L’exemple suivant utilise la méthode `.deploy()` de l’instance `Model` :
```
predictor = optimized_model.deploy(accept_eula=True)
```
La méthode `deploy()` renvoie une instance `Predictor` que vous pouvez utiliser pour envoyer des demandes d’inférence au modèle.
**Pour tester votre modèle à l’aide d’une demande d’inférence**
+ Après avoir déployé votre modèle sur un point de terminaison d’inférence, testez les prédictions du modèle. L’exemple suivant envoie une demande d’inférence à l’aide de l’instance `Predictor` :
```
predictor.predict(sample_input)
```
Le modèle renvoie le texte qu’il génère avec une réponse comme suit :
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## Modèles JumpStart préoptimisés
Les modèles JumpStart dont les configurations sont préoptimisées sont les suivants.
**Meta**
+ Llama 3.1 70B Instruct
+ Llama 3.1 70B
+ Llama 3.1 405B Instruct FP8
+ Llama 3.1 405B FP8
+ Llama 3 8B Instruct
+ Llama 3 8B
+ Llama 3 70B Instruct
+ Llama 3 70B
+ Llama 2 70B Chat
+ Llama 2 7B Chat
+ Llama 2 13B Chat
**HuggingFace**
+ Mixtral 8x7B Instruct
+ Mixtral 8x7B
+ Mistral 7B Instruct
+ Mistral 7B
### Modèles JumpStart précompilés
Pour certains modèles et configurations, SageMaker AI fournit des modèles précompilés pour des instances AWS Inferentia et AWS Trainium spécifiques. Dans ce cas, si vous créez une tâche d’optimisation de compilation et que vous choisissez ml.inf2.48xlarge ou ml.trn1.32xlarge comme type d’instance de déploiement, SageMaker AI récupère les artefacts compilés. Comme la tâche utilise un modèle déjà compilé, elle s’exécute rapidement sans que la compilation parte de zéro.
Voici les modèles JumpStart pour lesquels SageMaker AI propose des modèles précompilés :
**Meta**
+ Llama3 8B
+ Llama3 70B
+ Llama2 7B
+ Llama2 70B
+ Llama2 13B
+ Code Llama 7B
+ Code Llama 70B
**HuggingFace**
+ Mistral 7B
# Création d’une tâche d’optimisation d’inférence
Vous pouvez créer une tâche d'optimisation des inférences à l'aide de Studio ou du SDK SageMaker AI Python. La tâche optimise votre modèle en appliquant les techniques que vous choisissez. Pour de plus amples informations, veuillez consulter [Techniques d’optimisation](model-optimize.md#optimization-techniques).
**Tarification des instances pour les tâches d’optimisation d’inférences**
Lorsque vous créez une tâche d'optimisation des inférences qui applique la quantification ou la compilation, SageMaker AI choisit le type d'instance à utiliser pour exécuter la tâche. Vous êtes facturé en fonction de l’instance utilisée.
Pour connaître les types d'instances possibles et les détails de leur tarification, consultez les informations tarifaires relatives à l'optimisation des inférences sur la page de [ SageMaker tarification d'Amazon](https://aws.amazon.com/sagemaker/pricing/).
Vous n’encourez aucun coût supplémentaire pour les tâches qui appliquent un décodage spéculatif.
Pour connaître les modèles pris en charge que vous pouvez optimiser, consultez [Référence des modèles pris en charge](optimization-supported-models.md).
## Amazon SageMaker Studio
Procédez comme suit pour créer une tâche d’optimisation d’inférence dans Studio.
**Pour commencer la création d’une tâche d’optimisation**
1. Dans SageMaker AI Studio, créez une tâche d'optimisation en utilisant l'un des chemins suivants :
+ Pour créer une tâche pour un JumpStart modèle, procédez comme suit :
1. Dans le menu de navigation, choisissez **JumpStart**.
1. Sur la page **Tous les modèles publics**, choisissez un fournisseur de modèles, puis l’un des modèles compatibles avec l’optimisation.
1. Sur la page des détails du modèle, choisissez **Optimiser**. Ce bouton est activé uniquement pour les modèles qui prennent en charge l’optimisation.
1. Sur la page **Créer une tâche d'optimisation des inférences**, certains JumpStart modèles nécessitent que vous signiez un contrat de licence utilisateur final (EULA) avant de pouvoir continuer. Si nécessaire, consultez les termes du contrat de licence dans la section **Contrat de licence**. Si les conditions sont acceptables pour votre cas d’utilisation, cochez la case **J’accepte le CLUF et j’en ai lu les conditions générales**.
+ Pour créer une tâche pour un JumpStart modèle affiné, procédez comme suit :
1. Dans le panneau de navigation, sous **Tâches**, choisissez **Entraînement**.
1. Sur la page **Tâches de formation**, choisissez le nom d'une tâche que vous avez utilisée pour peaufiner un JumpStart modèle. Le type **JumpStartTraining** de ces tâches est indiqué dans la colonne **Type de tâche**.
1. Sur la page de détails de la tâche d’entraînement, choisissez **Optimiser**.
+ Pour créer une tâche pour un modèle personnalisé, procédez comme suit :
1. Dans le menu de navigation, sous **Tâches**, choisissez **Optimisation de l’inférence**.
1. Choisissez **Create new job** (Créer une nouvelle tâche).
1. Sur la page **Créer une tâche d’optimisation d’inférence**, sélectionnez **Ajouter un modèle**.
1. Dans la fenêtre **Ajouter un modèle**, sélectionnez **Modèle personnalisé**.
1. Choisissez l’une des options suivantes :
**Utiliser votre modèle existant** : sélectionnez cette option pour optimiser un modèle que vous avez déjà créé dans SageMaker AI.
**Nom du modèle existant** : entrez le nom de votre modèle d' SageMaker IA.
**Depuis S3** : sélectionnez cette option pour fournir des artefacts de modèle provenant d'Amazon S3. Pour l’**URI S3**, entrez l’URI de l’emplacement Amazon S3 où vous avez stocké les artefacts de votre modèle.
1. (Facultatif) Pour le ****nom du modèle de sortie****, vous pouvez entrer un nom personnalisé pour le modèle optimisé créé par la tâche. Si vous ne fournissez pas de nom, Studio en génère un automatiquement en fonction de votre sélection.
1. Sur la page **Créer une tâche d'optimisation des inférences**, pour **Nom de la tâche**, vous pouvez accepter le nom par défaut attribué par SageMaker AI. Ou, pour saisir un nom de tâche personnalisé, choisissez le champ **Nom de la tâche**, puis choisissez **Saisir le nom de la tâche**.
**Pour définir les configurations d’optimisation**
1. Pour **Type d’instance de déploiement**, choisissez le type d’instance pour lequel vous souhaitez optimiser le modèle.
Le type d’instance influe sur les techniques d’optimisation que vous pouvez choisir. Pour la plupart des types utilisant du matériel GPU, les techniques prises en charge sont la **quantification** et le **décodage spéculatif**. Si vous choisissez une instance qui utilise du silicium personnalisé, comme l'instance AWS Inferentia ml.inf2.8xlarge, la technique prise en charge est la **compilation**, que vous pouvez utiliser pour compiler le modèle pour ce type de matériel spécifique.
1. Sélectionnez une ou plusieurs des techniques d’optimisation proposées par Studio :
+ Si vous sélectionnez **Quantification**, choisissez un type de données pour le **type de données Précision**.
+ Si vous sélectionnez le **décodage spéculatif**, choisissez l’une des options suivantes :
+ **Utiliser le modèle de brouillon d' SageMaker IA** — Choisissez d'utiliser le modèle de brouillon fourni par l' SageMaker IA.
**Note**
Si vous choisissez d'utiliser le modèle de brouillon SageMaker AI, vous devez également activer l'isolation du réseau. Studio propose cette option sous **Sécurité**.
+ **Choisir un modèle JumpStart de brouillon** : choisissez de sélectionner un modèle dans le JumpStart catalogue à utiliser comme modèle de brouillon.
+ **Choisir mon propre brouillon de modèle** : choisissez d’utiliser votre propre brouillon de modèle et fournissez l’URI S3 qui le localise.
+ Si vous choisissez **Chargement rapide du modèle**, Studio affiche la variable d’environnement `OPTION_TENSOR_PARALLEL_DEGREE`. Utilisez le champ **Valeur** pour définir le degré de parallélisme de tenseur. La valeur doit diviser de manière égale le nombre de GPUs dans l'instance que vous avez choisie pour le **type d'instance de déploiement**. Par exemple, pour fragmenter votre modèle lors de l'utilisation d'une instance avec 8 GPUs, utilisez les valeurs 2, 4 ou 8.
+ Si vous définissez **le type d'instance de déploiement** sur une instance AWS Inferentia ou AWS Trainium, Studio peut indiquer que la **compilation** est la seule option prise en charge. Dans ce cas, Studio sélectionne cette option pour vous.
1. Pour **Sortie**, entrez l’URI d’un emplacement Amazon S3. L' SageMaker IA y stocke les artefacts du modèle optimisé créé par votre travail.
1. (Facultatif) Développez les **options avancées** pour un contrôle plus précis des paramètres tels que le rôle IAM, le VPC et les variables d’environnement. Pour plus d’informations, consulter *Options avancées* ci-dessous.
1. Lorsque vous avez terminé de configurer la tâche, choisissez **Créer une tâche**.
Studio affiche la page des détails, qui indique le statut de la tâche et tous les paramètres que vous avez appliqués lors de sa création.
### Options avancées
Vous pouvez définir les options avancées suivantes lorsque vous créez une tâche d’optimisation d’inférence.
Sous **Configurations**, vous pouvez définir les options suivantes :
**Degré de parallélisation du tenseur **
Valeur du degré du *parallélisme de tenseur*. Le parallélisme de tenseur est un type de parallélisme des modèles dans lequel des poids, des gradients et des états d’optimiseur spécifiques sont répartis entre les appareils. La valeur doit diviser de manière égale le nombre de GPUs dans votre cluster.
**Longueur maximale de jeton**
Limite du nombre de jetons devant être générés par le modèle. Notez que le modèle peut ne pas toujours générer le nombre maximum de jetons.
**Concurrency**
Possibilité d’exécuter plusieurs instances d’un modèle sur le même matériel sous-jacent. Utilisez la simultanéité pour transmettre des prédictions à plusieurs utilisateurs et optimiser l’utilisation du matériel.
**Taille de lot**
Si votre modèle effectue une *inférence par lots*, utilisez cette option pour contrôler la taille des lots traités par votre modèle.
L’inférence par lots génère des prédictions modélisées sur un lot d’observations. C’est une bonne option pour les jeux de données volumineux, ou si vous n’avez pas besoin d’une réponse immédiate à une demande d’inférence.
Sous **Sécurité**, vous pouvez définir les options suivantes :
**Rôle IAM**
Rôle IAM qui permet à l' SageMaker IA d'effectuer des tâches en votre nom. Lors de l'optimisation du modèle, SageMaker AI a besoin de votre autorisation pour :
+ Lire les données d’entrée à partir d’un compartiment S3
+ Écrire des artefacts de modèle dans un compartiment S3
+ Écrire des journaux sur Amazon CloudWatch Logs
+ Publier des statistiques sur Amazon CloudWatch
Vous accordez les autorisations pour toutes ces tâches à un rôle IAM.
Pour de plus amples informations, veuillez consulter [Comment utiliser les rôles d'exécution de l' SageMaker IA](sagemaker-roles.md).
**Clé KMS de chiffrement**
Une clé dans AWS Key Management Service (AWS KMS). SageMaker L'IA utilise cette clé pour chiffrer les artefacts du modèle optimisé lorsqu'elle SageMaker télécharge le modèle sur Amazon S3.
**VPC**
SageMaker L'IA utilise ces informations pour créer des interfaces réseau et les associer à vos modèles de conteneurs. Les interfaces réseau fournissent à vos conteneurs de modèles une connexion réseau au sein de votre VPC qui n'est pas connecté à Internet. Elles permettent également à votre modèle de se connecter aux ressources de votre VPC privé.
Pour de plus amples informations, veuillez consulter [Donnez aux points de terminaison hébergés par SageMaker IA un accès aux ressources de votre Amazon VPC](host-vpc.md).
**Activer l’isolement réseau**
Activez cette option si vous souhaitez restreindre l’accès Internet de votre conteneur. Les conteneurs qui s’exécutent avec un isolement réseau ne peuvent effectuer aucun appel réseau sortant.
Vous devez activer cette option lorsque vous optimisez avec un décodage spéculatif et que vous utilisez le modèle de brouillon SageMaker AI.
Pour plus d’informations sur l’isolement réseau, consultez [Isolement du réseau](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
Sous **Définition de conteneur avancée**, vous pouvez définir les options suivantes :
**Condition d'arrêt**
Spécifie une limite pour la durée d’exécution d’une tâche. Lorsque la tâche atteint la limite de temps, l' SageMaker IA met fin à la tâche. Utilisez cette option pour plafonner les coûts.
**Étiquettes**
Paires clé-valeur associées à la tâche d’optimisation.
Pour plus d’informations sur les balises, consultez [Balisage de vos ressources AWS](https://docs.aws.amazon.com/tag-editor/latest/userguide/tagging.html) dans la *Références générales AWS*.
**Variables d’environnement**
Paires clé-valeur qui définissent les variables d’environnement à configurer dans le conteneur de modèle.
## SageMaker SDK Python pour IA
Vous pouvez créer une tâche d'optimisation des inférences en utilisant le SDK SageMaker AI Python dans votre projet. Commencez par définir une instance `Model` à l’aide de la classe `ModelBuilder`. Utilisez ensuite la méthode `optimize()` pour exécuter une tâche qui optimise votre modèle par quantification, décodage spéculatif ou compilation. Une fois la tâche terminée, vous déployez le modèle sur un point de terminaison d’inférence à l’aide de la méthode `deploy()`.
Pour plus d'informations sur les classes et les méthodes utilisées dans les exemples suivants, consultez [APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html)la documentation du SDK SageMaker AI Python.
**Pour configurer votre projet**
1. Dans votre code d’application, importez les bibliothèques nécessaires. Les exemples suivants importent le kit SDK pour Python (Boto3). Il importe également les classes du SDK SageMaker AI Python que vous utilisez pour définir et utiliser des modèles :
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
from pathlib import Path
```
1. Initialisez une session SageMaker AI. L’exemple suivant utilise la classe `Session()` :
```
sagemaker_session = Session()
```
**Pour définir votre modèle**
1. Créez une instance `SchemaBuilder` et fournissez des exemples d’entrée et de sortie. Vous fournissez cette instance à la classe `ModelBuilder` lorsque vous définissez un modèle. Grâce à elle, l' SageMaker IA génère automatiquement les fonctions de marshalling pour sérialiser et désérialiser l'entrée et la sortie.
Pour plus d’informations sur les classes `SchemaBuilder` et `ModelBuilder`, consultez [Créez un modèle dans Amazon SageMaker AI avec ModelBuilder](how-it-works-modelbuilder-creation.md).
L’exemple suivant fournit des exemples de chaînes d’entrée et de sortie à la classe `SchemaBuilder` :
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. Définissez votre modèle en fonction de l' SageMaker IA. L’exemple suivant définit les paramètres pour initialiser une instance `ModelBuilder` :
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
Cet exemple utilise un JumpStart modèle. Remplacez `jumpstart-model-id` par l'ID d'un JumpStart modèle, tel que`meta-textgeneration-llama-3-70b`.
**Note**
Si vous souhaitez optimiser avec le décodage spéculatif et utiliser le brouillon SageMaker AI, vous devez activer l'isolation du réseau. Pour ce faire, incluez l’argument suivant lorsque vous initialisez une instance `ModelBuilder` :
```
enable_network_isolation=True,
```
Pour plus d’informations sur l’isolement réseau, consultez [Isolement du réseau](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation).
**Pour optimiser à l’aide de la quantification**
1. Pour exécuter une tâche de quantification, utilisez la méthode `optimize()` et définissez l’argument `quantization_config`. L’exemple suivant définit `OPTION_QUANTIZE` comme variable d’environnement dans le conteneur d’optimisation :
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
quantization_config={
"OverrideEnvironment": {
"OPTION_QUANTIZE": "awq",
},
},
output_path="s3://output-path",
)
```
Dans cet exemple, remplacez *`instance-type`* par une instance de ML, telle que `ml.p4d.24xlarge`. Remplacez *`s3://output-path`* par le chemin d’accès à l’emplacement S3 où vous stockez le modèle optimisé créé par la tâche.
La méthode `optimize()` renvoie un objet `Model` que vous pouvez utiliser pour déployer votre modèle sur un point de terminaison.
1. Une fois la tâche terminée, déployez le modèle. L’exemple suivant utilise la méthode `deploy()` :
```
predictor = optimized_model.deploy(
instance_type="instance-type",
accept_eula=True,
)
```
Dans cet exemple, remplacez *`instance-type`* par une instance de ML, telle que `ml.p4d.24xlarge`.
La méthode `deploy()` renvoie un objet prédicteur, que vous pouvez utiliser pour envoyer des demandes d’inférence au point de terminaison qui héberge le modèle.
**Pour optimiser avec le décodage spéculatif à l'aide du modèle de brouillon SageMaker AI**
Lorsque vous optimisez votre modèle à l'aide d'un décodage spéculatif, vous pouvez choisir d'utiliser un brouillon de modèle fourni par l' SageMaker IA ou d'utiliser le vôtre. Les exemples suivants utilisent le modèle de brouillon d' SageMaker IA.
**Prérequis**
Pour optimiser avec le décodage spéculatif et le modèle de brouillon d' SageMaker IA, vous devez activer l'isolation du réseau lorsque vous définissez votre modèle.
1. Pour exécuter une tâche de décodage spéculatif, utilisez la méthode `optimize()` et définissez l’argument `speculative_decoding_config`. L'exemple suivant définit la `ModelProvider` clé permettant d'`SAGEMAKER`utiliser le brouillon de modèle fourni par SageMaker l'IA.
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelProvider": "SAGEMAKER",
},
)
```
Dans cet exemple, remplacez *`instance-type`* par une instance de ML, telle que `ml.p4d.24xlarge`.
La méthode `optimize()` renvoie un objet `Model` que vous pouvez utiliser pour déployer votre modèle sur un point de terminaison.
1. Une fois la tâche terminée, déployez le modèle. L’exemple suivant utilise la méthode `deploy()` :
```
predictor = optimized_model.deploy(accept_eula=True)
```
La méthode `deploy()` renvoie un objet prédicteur, que vous pouvez utiliser pour envoyer des demandes d’inférence au point de terminaison qui héberge le modèle.
**Pour optimiser avec le décodage spéculatif à l’aide d’un brouillon de modèle personnalisé**
Avant de pouvoir fournir votre brouillon de modèle personnalisé à SageMaker AI, vous devez d'abord télécharger les artefacts du modèle sur Amazon S3.
Les exemples suivants illustrent une façon de fournir un brouillon de modèle personnalisé. Les exemples téléchargent le brouillon de modèle depuis le Hugging Face Hub, le chargent sur Amazon S3 et fournissent l’URI S3 à l’argument `speculative_decoding_config`.
1. Si vous souhaitez télécharger un modèle depuis le Hugging Face Hub, ajoutez la bibliothèque `huggingface_hub` à votre projet et téléchargez un modèle avec la méthode `snapshot_download()`. L’exemple suivant télécharge un modèle dans un répertoire local :
```
import huggingface_hub
huggingface_hub.snapshot_download(
repo_id="model-id",
revision="main",
local_dir=download-dir,
token=hf-access-token,
)
```
Dans cet exemple, remplacez *`model-id`* avec l’ID d’un modèle du Hugging Face Hub, comme `meta-llama/Meta-Llama-3-8B`. Remplacez *`download-dir`* par un répertoire local. Remplacez *`hf-access-token`* par votre jeton d’accès utilisateur. Pour découvrir comment obtenir votre jeton d’accès, consultez [User access tokens](https://huggingface.co/docs/hub/en/security-tokens) dans la documentation Hugging Face.
Pour plus d’informations sur la bibliothèque `huggingface_hub`, consultez [Hub client library](https://huggingface.co/docs/huggingface_hub/en/index) dans la documentation Hugging Face.
1. Pour que le modèle que vous avez téléchargé soit disponible pour SageMaker AI, chargez-le sur Amazon S3. L’exemple suivant charge le modèle avec l’objet `sagemaker_session` :
```
custom_draft_model_uri = sagemaker_session.upload_data(
path=hf_local_download_dir.as_posix(),
bucket=sagemaker_session.default_bucket(),
key_prefix="prefix",
)
```
Dans cet exemple, remplacez *`prefix`* par un qualificatif qui vous aidera à distinguer le brouillon de modèle dans S3, comme `spec-dec-custom-draft-model`.
La méthode `upload_data()` renvoie l’URI S3 pour les artefacts du modèle.
1. Pour exécuter une tâche de décodage spéculatif, utilisez la méthode `optimize()` et définissez l’argument `speculative_decoding_config`. L’exemple suivant définit la clé `ModelSource` de l’URI S3 du brouillon de modèle personnalisé :
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelSource": custom_draft_model_uri + "/",
},
)
```
Dans cet exemple, remplacez *`instance-type`* par une instance de ML, telle que `ml.p4d.24xlarge`.
La méthode `optimize()` renvoie un objet `Model` que vous pouvez utiliser pour déployer votre modèle sur un point de terminaison.
1. Une fois la tâche terminée, déployez le modèle. L’exemple suivant utilise la méthode `deploy()` :
```
predictor = optimized_model.deploy(accept_eula=True)
```
La méthode `deploy()` renvoie un objet prédicteur, que vous pouvez utiliser pour envoyer des demandes d’inférence au point de terminaison qui héberge le modèle.
**Pour optimiser avec la compilation**
1. Pour exécuter une tâche de compilation, utilisez la méthode `optimize()` et définissez l’argument `compilation_config`. L’exemple suivant utilise la clé `OverrideEnvironment` pour définir les variables d’environnement nécessaires dans le conteneur d’optimisation :
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
compilation_config={
"OverrideEnvironment": {
"OPTION_TENSOR_PARALLEL_DEGREE": "24",
"OPTION_N_POSITIONS": "8192",
"OPTION_DTYPE": "fp16",
"OPTION_ROLLING_BATCH": "auto",
"OPTION_MAX_ROLLING_BATCH_SIZE": "4",
"OPTION_NEURON_OPTIMIZE_LEVEL": "2",
}
},
output_path="s3://output-path",
)
```
Dans cet exemple, définissez *`instance-type`* sur un type d’instance de ML avec accélération matérielle. Par exemple, pour une inférence accélérée avec AWS Inferentia, vous pouvez définir le type sur une instance Inf2, telle que. `ml.inf2.48xlarge` Remplacez *`s3://output-path`* par le chemin d’accès à l’emplacement S3 où vous stockez le modèle optimisé créé par la tâche.
1. Une fois la tâche terminée, déployez le modèle. L’exemple suivant utilise la méthode `deploy()` :
```
predictor = optimized_model.deploy(accept_eula=True)
```
La méthode `deploy()` renvoie un objet prédicteur, que vous pouvez utiliser pour envoyer des demandes d’inférence au point de terminaison qui héberge le modèle.
**Pour tester votre modèle à l’aide d’une demande d’inférence**
+ Pour envoyer une demande d’inférence de test à votre modèle déployé, utilisez la méthode `predict()` d’un objet prédicteur. L’exemple suivant transmet la variable `sample_input`, qui a également été transmise à la classe `SchemaBuilder` dans les exemples, pour définir votre modèle :
```
predictor.predict(sample_input)
```
L’exemple d’entrée contient l’invite `"What is the largest planet in the solar system?"`. La méthode `predict()` renvoie la réponse générée par le modèle, comme l’illustre l’exemple suivant :
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## AWS SDK pour Python (Boto3)
Vous pouvez utiliser le AWS SDK pour Python (Boto3) pour créer et gérer par programmation des tâches d'optimisation des inférences. Cette section fournit des exemples de différentes techniques d'optimisation.
**Conditions préalables**
Avant de créer une tâche d'optimisation avec Boto3, assurez-vous d'avoir :
+ AWS Informations d'identification configurées - Configurez vos AWS informations d'identification avec les autorisations appropriées
+ Création d'un modèle d' SageMaker IA (si vous utilisez un modèle existant)
+ Données d'entraînement préparées dans S3 (pour l'optimisation du décodage spéculatif, longueur de contexte prise en charge jusqu'à 4096)
+ Rôle IAM avec les autorisations nécessaires : votre rôle d'exécution doit disposer des autorisations nécessaires pour accéder à S3 et créer des ressources SageMaker
**Exemple : créer une tâche d'optimisation avec le décodage spéculatif EAGLE (Llama 3.3 70B)**
Cet exemple montre comment créer une tâche d'optimisation pour un grand modèle de langage à l'aide de la technique de décodage spéculatif EAGLE :
```
import boto3
# Initialize SageMaker client
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Step 1: Create a SageMaker model (if not already created)
model_response = sagemaker_client.create_model(
ModelName='meta-llama-3-3-70b-instruct',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/Llama-3.3-70B-Instruct/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'SAGEMAKER_ENV': '1',
'SAGEMAKER_MODEL_SERVER_TIMEOUT': '3600'
}
}
)
# Step 2: Create optimization job with speculative decoding
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'meta-llama-3-3-70b-instruct'
}
},
DeploymentInstanceType='ml.p4d.24xlarge',
# MaxInstanceCount specifies the maximum number of instances for distributed training
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_8k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/llama-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**Exemple : créer une tâche d'optimisation à partir d'artefacts du modèle S3 (Qwen3 32B)**
Cet exemple montre comment créer une tâche d'optimisation à l'aide d'artefacts de modèle provenant directement de S3 :
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Create model from S3 artifacts
model_response = sagemaker_client.create_model(
ModelName='qwen3-32b',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'Mode': 'SingleModel',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/qwen3-32b/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'AWS_REGION': 'us-west-2'
}
}
)
# Create optimization job with smaller training dataset
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='qwen3-optim-job-eagle',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'qwen3-32b'
}
},
DeploymentInstanceType='ml.g6.48xlarge',
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_1k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/qwen3-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**Exemple : surveillance et gestion des tâches d'optimisation**
Après avoir créé une tâche d'optimisation, vous pouvez suivre sa progression et la gérer à l'aide des commandes suivantes :
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Describe optimization job to check status
describe_response = sagemaker_client.describe_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
)
print(f"Job Status: {describe_response['OptimizationJobStatus']}")
# List all optimization jobs (with pagination)
list_response = sagemaker_client.list_optimization_jobs(
MaxResults=10,
SortBy='CreationTime',
SortOrder='Descending'
)
print("\nRecent optimization jobs:")
for job in list_response['OptimizationJobSummaries']:
print(f"- {job['OptimizationJobName']}: {job['OptimizationJobStatus']}")
# Stop a running optimization job if needed
# sagemaker_client.stop_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
# Delete a completed or failed optimization job
# sagemaker_client.delete_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
```
Le décodage spéculatif avec Eagle Heads exécute quatre tâches d'entraînement séquentielles. Chaque tâche produit une sortie qui devient l'entrée de la suivante. Seule la sortie de la tâche finale est transmise à votre compartiment S3. Les sorties intermédiaires sont cryptées et stockées dans un bucket de service SageMaker AI interne pendant 20 jours maximum. SageMaker L'IA n'est pas autorisée à les déchiffrer. Si vous souhaitez que les données intermédiaires soient supprimées avant cette période, assurez-vous que votre tâche est terminée ou arrêtée, puis ouvrez un dossier d'assistance [[https://docs.aws.amazon.com/awssupport/latest/user/case-management.html\$1 creating-a-support-case](https://docs.aws.amazon.com/awssupport/latest/user/case-management.html#creating-a-support-case)] pour que ces données soient supprimées. Incluez dans la demande votre identifiant de AWS compte et l'ARN de la tâche d'optimisation.
## Limites du projet de modèle d' SageMaker IA
Pour tout modèle que vous optimisez à l'aide du modèle d' SageMaker IA brouillon, soyez conscient des exigences, des restrictions et des variables d'environnement prises en charge.
**Exigences**
Vous devez procéder comme suit :
+ Utilisez un modèle fourni par SageMaker JumpStart.
+ Activez l’isolement réseau pour le déploiement du modèle.
+ Si vous déployez le modèle dans un conteneur LMI (Large Model Inference), utilisez un DJLServing conteneur de version 0.28.0 ou supérieure.
Pour connaître les conteneurs disponibles, consultez la section [Large Model Inference Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers) dans le GitHub référentiel Deep Learning Containers.
+ Si vous affinez le JumpStart modèle, utilisez le format Safetensors pour les poids du modèle.
Pour plus d’informations sur ce format, consultez [Safetensors](https://huggingface.co/docs/safetensors/en/index) dans la documentation Hugging Face.
**Restrictions**
Vous ne pouvez pas exécuter les actions suivantes :
+ Utiliser le modèle dans les environnements de test locaux que vous créez avec le mode local.
Pour plus d'informations sur le mode local, consultez la section [Mode local](https://sagemaker.readthedocs.io/en/stable/overview.html#local-mode) dans la documentation du SDK SageMaker AI Python.
+ Accédez au conteneur modèle via l' AWS Systems Manager agent (agent SSM). L'agent SSM fournit un accès au niveau du shell à votre modèle de conteneur afin que vous puissiez déboguer les processus et enregistrer les commandes avec Amazon. CloudWatch
Pour en savoir plus sur cette fonction, consultez [Accès aux conteneurs via SSM](ssm-access.md).
+ Configurer le conteneur de modèle pour un vidage mémoire qui se produit en cas d’incident lors du processus.
Pour plus d'informations sur les vidages de base à partir de modèles de conteneurs, consultez [ProductionVariantCoreDumpConfig](sagemaker/latest/APIReference/API_ProductionVariantCoreDumpConfig.html).
+ Déployer le modèle sur des points de terminaison multimodèles, multiconteneurs ou hébergeant des composants d’inférence.
Pour plus d’informations sur ces types de points de terminaison, consultez [Points de terminaison multimodèles](multi-model-endpoints.md), [Points de terminaison multi-conteneurs](multi-container-endpoints.md) et [Composants Inférence](realtime-endpoints-deploy-models.md#inference-components).
+ Créer un package de modèle pour le modèle. Vous utilisez des packages de modèles pour créer des modèles déployables sur AWS Marketplace lesquels vous publiez.
Pour en savoir plus sur cette fonction, consultez [Création d’une ressource de package de modèle](sagemaker-mkt-create-model-package.md).
+ Utiliser votre propre code d’inférence dans le conteneur de modèle.
+ Utilisez un fichier `requirements.txt` dans le conteneur de modèle. Ce type de fichier répertorie les dépendances des packages.
+ Activer le paramètre `trust_remote_code` Hugging Face.
**Variables d'environnement prises en charge**
Vous pouvez configurer le conteneur avec les variables d’environnement suivantes :
+ Variables d’environnement communes pour les conteneurs d’inférence de modèles de grande taille (LMI).
Pour plus d’informations sur ces variables, consultez [Environment Variable Configurations](https://docs.djl.ai/master/docs/serving/serving/docs/lmi/deployment_guide/configurations.html#environment-variable-configurations) dans la documentation du conteneur LMI.
+ Variables d’environnement communes pour les packages fournis par le Hugging Face Hub dans ses référentiels Git.
Pour les référentiels, voir [Hugging](https://github.com/huggingface) Face on. GitHub
+ Variables d'environnement communes PyTorch et CUDA.
Pour plus d'informations sur ces variables, consultez la section [Variables d'environnement Torch](https://pytorch.org/docs/stable/torch_environment_variables.html) dans la PyTorch documentation.
# Affichage des résultats des tâches d’optimisation
Après avoir créé une ou plusieurs tâches d’optimisation, vous pouvez utiliser Studio pour afficher un tableau récapitulatif de toutes vos tâches, ainsi que les détails de chaque tâche individuelle.
## Amazon SageMaker Studio
**Pour consulter le tableau récapitulatif des tâches d’optimisation**
+ Dans le menu de navigation Studio, sous **Tâches**, choisissez **Optimisation de l’inférence**.
La page **Optimisation de l’inférence** affiche un tableau des tâches que vous avez créées. Pour chaque tâche, il répertorie les configurations d’optimisation que vous avez appliquées et l’état de la tâche.
**Pour afficher les détails d’une tâche**
+ Dans le tableau récapitulatif de la page **Optimisation de l’inférence**, cliquez sur le nom de la tâche.
Studio affiche la page des détails de la tâche, qui indique l’état de la tâche et tous les paramètres que vous avez appliqués lors de sa création. Si la tâche s’est terminée avec succès, SageMaker AI a stocké les artefacts du modèle optimisé dans l’emplacement Amazon S3 sous **URI S3 du modèle optimisé**.
# Évaluation des performances des modèles optimisés
Après avoir utilisé une tâche d’optimisation pour créer un modèle optimisé, vous pouvez exécuter une évaluation des performances du modèle. Cette évaluation fournit des métriques de latence, de débit et de prix. Utilisez ces métriques pour déterminer si le modèle optimisé répond aux besoins de votre cas d’utilisation ou s’il nécessite une optimisation supplémentaire.
Vous ne pouvez exécuter des évaluations de performances qu’à l’aide de Studio. Cette fonctionnalité n'est pas fournie par le biais de l'API Amazon SageMaker AI ou du SDK Python.
## Avant de commencer
Avant de créer une évaluation des performances, vous devez d’abord optimiser un modèle en créant une tâche d’optimisation d’inférence. Dans Studio, vous ne pouvez évaluer que les modèles que vous créez avec ces tâches.
## Création d’une évaluation de performances
Procédez comme suit dans Studio pour créer une évaluation des performances d’un modèle optimisé.
1. Dans le menu de navigation Studio, sous **Tâches**, choisissez **Optimisation de l’inférence**.
1. Choisissez le nom de la tâche qui a permis de créer le modèle optimisé à évaluer.
1. Sur la page des détails de la tâche, choisissez **Évaluer les performances**.
1. Sur la page **Evaluer les performances**, certains JumpStart modèles nécessitent que vous signiez un contrat de licence utilisateur final (EULA) avant de pouvoir continuer. Si nécessaire, consultez les termes du contrat de licence dans la section **Contrat de licence**. Si les conditions sont acceptables pour votre cas d’utilisation, cochez la case **J’accepte le CLUF et j’en ai lu les conditions générales**.
1. Pour **Sélectionnez un modèle comme créateur de jetons**, acceptez le modèle par défaut ou choisissez un modèle spécifique qui servira de créateur de jeton pour votre évaluation.
1. Pour **Jeux de données d’entrée**, choisissez si vous souhaitez :
+ Utilisez les exemples de jeux de données par défaut fournis par SageMaker AI.
+ fournir un URI S3 qui pointe vers vos propres exemples de jeux de données.
1. Pour **URI S3 destiné aux résultats de performances**, fournissez un URI qui pointe vers l’emplacement Amazon S3 où vous souhaitez stocker les résultats de l’évaluation.
1. Choisissez **Évaluer**.
Studio affiche la page **Évaluations des performances**, où votre tâche d’évaluation apparaît dans le tableau. La colonne **Statut** indique le statut de votre évaluation.
1. Lorsque le statut est **Terminé**, cliquez sur le nom de la tâche pour afficher les résultats de l’évaluation.
La page des détails de l’évaluation présente des tableaux qui fournissent les métriques de performances liées à la latence, au débit et au prix. Pour plus d’informations sur chaque métrique, consultez la [Référence des métriques pour les évaluations des performances d’inférence](#performance-eval-metrics-reference).
## Référence des métriques pour les évaluations des performances d’inférence
Une fois que vous avez réussi à évaluer les performances d’un modèle optimisé, la page des détails de l’évaluation affiche les métriques suivantes dans Studio.
### Métriques de latence
La section **Latence** présente les métriques suivantes.
**Concurrency**
Nombre d’utilisateurs simultanés simulés par l’évaluation pour invoquer simultanément le point de terminaison.
**Délai de réception du premier jeton (ms)**
Temps qui s’est écoulé entre l’envoi de la demande et la réception du premier jeton d’une réponse en streaming.
**Latence entre les jetons (ms)**
Temps nécessaire pour générer un jeton de sortie pour chaque demande.
**Latence du client (ms)**
Latence de la demande entre l’envoi de la demande et la réception de la réponse complète.
**Entrée tokens/sec (nombre)**
Nombre total de jetons d’entrée générés pour toutes les demandes, divisé par la durée totale en secondes de la simultanéité.
**Sortie tokens/sec (nombre)**
Nombre total de jetons de sortie générés pour toutes les demandes, divisé par la durée totale en secondes de la simultanéité.
**Invocations de clients (nombre)**
Nombre total de demandes d’inférence envoyées au point de terminaison par tous les utilisateurs simultanément.
**Erreurs d’invocation du client (nombre)**
Nombre total de demandes d’inférence envoyées au point de terminaison par tous les utilisateurs simultanément, qui ont généré une erreur d’invocation.
**Échecs du créateur de jetons (nombre)**
Nombre total de demandes d’inférence pour lesquelles le créateur de jetons n’a pas réussi à analyser la demande ou la réponse.
**Réponse d’inférence vide (nombre)**
Nombre total de demandes d’inférence qui ont entraîné l’absence de jetons de sortie ou l’échec de l’analyse de la réponse par le créateur de jetons.
### Métriques de débit
La section **Débit** présente les métriques suivantes.
**Concurrency**
Nombre d’utilisateurs simultanés simulés par l’évaluation pour invoquer simultanément le point de terminaison.
**Entrée tokens/sec/req (nombre)**
Nombre total de jetons d’entrée générés par seconde et par demande.
**Sortie tokens/sec/req (nombre)**
Nombre total de jetons de sortie générés par seconde et par demande.
**Jetons d’entrée (nombre)**
Nombre total de jetons d’entrée générés par demande.
**Jetons de sortie (nombre)**
Nombre total de jetons de sortie générés par demande.
### Métriques de prix
La section **Prix** présente les métriques suivantes.
**Concurrency**
Nombre d’utilisateurs simultanés simulés par l’évaluation pour invoquer simultanément le point de terminaison.
**Prix par million de jetons d’entrée**
Coût de traitement d’un million de jetons d’entrée.
**Prix par million de jetons de sortie**
Coût de génération d’un million de jetons de sortie.
# Référence des modèles pris en charge
Les tableaux suivants présentent les modèles pour lesquels l' SageMaker IA prend en charge l'optimisation par inférence, ainsi que les techniques d'optimisation prises en charge.
**Modèles Llama pris en charge**
| Nom du modèle | Formats de données pris en charge pour la quantification | Prend en charge le décodage spéculatif | Prend en charge le chargement rapide des modèles | Bibliothèques utilisées pour la compilation |
| --- | --- | --- | --- | --- |
| Meta Llama 2 13B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 2 13B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 2 70B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 2 70B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 2 7B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 2 7B Chat | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 3 70B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 3 70B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 3 8B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Llama 3 8B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Meta Code Llama 13B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 13B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 13B Python | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 34B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 34B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 34B Python | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 70B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 70B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 70B Python | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 7B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Code Llama 7B Python | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Meta Llama 2 13B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 2 13B Chat Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 2 70B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 2 70B Chat Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 2 7B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 2 7B Chat Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3 70B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3 70B Instruct Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3 8B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3 8B Instruct Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Code Llama 70B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Code Llama 7B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Code Llama 7B Python Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3.1 405B FP8 | Aucune | Oui | Oui | Aucune |
| Meta Llama 3.1 405B Instruire FP8 | Aucune | Oui | Oui | Aucune |
| Meta Llama 3.1 70B | INT4-AWQ FP8 | Oui | Oui | Aucune |
| Meta Llama 3.1 70B Instruct | INT4-AWQ FP8 | Oui | Oui | Aucune |
| Meta Llama 3.1 8B | INT4-AWQ FP8 | Oui | Oui | Aucune |
| Meta Llama 3.1 8B Instruct | INT4-AWQ FP8 | Oui | Oui | Aucune |
| Meta Llama 3.1 70B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3.1 70B Instruct Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3 1 8B Neuron | Aucune | Non | Non | AWSNeurone |
| Meta Llama 3.1 8B Instruct Neuron | Aucune | Non | Non | AWSNeurone |
**Modèles Mistral pris en charge**
| Nom du modèle | Formats de données pris en charge pour la quantification | Prend en charge le décodage spéculatif | Prend en charge le chargement rapide des modèles | Bibliothèques utilisées pour la compilation |
| --- | --- | --- | --- | --- |
| Mistral 7B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Mistral 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | AWSNeurone TensorRT-LLM |
| Mistral 7B Neuron | Aucune | Non | Non | AWSNeurone |
| Mistral 7B Instruct Neuron | Aucune | Non | Non | AWSNeurone |
**Modèles Mixtral pris en charge**
| Nom du modèle | Formats de données pris en charge pour la quantification | Prend en charge le décodage spéculatif | Prend en charge le chargement rapide des modèles | Bibliothèques utilisées pour la compilation |
| --- | --- | --- | --- | --- |
| Mixtral-8x22B-Instruct-v0.1 | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Mixtral-8x22B V1 | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Mixtral 8x7B | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
| Mixtral 8x7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | Oui | Oui | TensorRT-LLM |
**Architectures de modèles prises en charge et type EAGLE**
| Nom de l'architecture du modèle | Type EAGLE |
| --- | --- |
| LlamaForCausalLM | AIGLE 3 |
| Qwen 3 km ForCausal | AIGLE 3 |
| Qwen 3 km NextForCausal | AIGLE 2 |
| Qwen 3 km MoeForCausal | AIGLE 3 |
| Qwen 2 km ForCausal | AIGLE 3 |
| GptOssForCausalLM | AIGLE 3 |
# Options pour évaluer votre modèle d'apprentissage automatique dans Amazon SageMaker AI
Après avoir entraîné un modèle, évaluez-le pour déterminer si ses performances et sa précision vous permettent d’atteindre vos objectifs métier. Vous pouvez générer plusieurs modèles à l’aide de différentes méthodes et évaluer chacun d’eux. Par exemple, vous pouvez appliquer des règles métier différentes pour chaque modèle, puis appliquer diverses mesures pour déterminer l’adéquation de chaque modèle. Vous pouvez déterminer si votre modèle doit être plus sensible que spécifique (ou inversement).
Vous pouvez évaluer votre modèle à l’aide de données historiques (hors connexion) ou de données en temps réel :
+ **Tests hors ligne** : utilisez des données historiques, et non en temps réel, pour envoyer des demandes au modèle pour des inférences.
Déployez votre modèle entraîné sur un point de terminaison alpha, et utilisez les données historiques pour lui envoyer des demandes d’inférence. Pour envoyer les demandes, utilisez un bloc-notes Jupyter dans votre instance de bloc-notes Amazon SageMaker AI et la bibliothèque Python de haut niveau AWS SDK pour Python (Boto) ou la bibliothèque Python de haut niveau fournie par SageMaker AI.
+ **Tests en ligne avec des données en temps réel** — SageMaker L'IA permet de A/B tester des modèles en production en utilisant des variantes de production. Les variantes de production sont des modèles qui utilisent le même code d'inférence et sont déployés sur le même point de terminaison d' SageMaker IA. Vous configurez les variantes de production afin qu’une petite partie du trafic en temps réel soit acheminé vers le modèle que vous souhaitez valider. Par exemple, vous pouvez choisir d’envoyer 10 % du trafic vers une variante de modèle pour évaluation. Lorsque vous êtes satisfait des performances du modèle, vous pouvez acheminer 100 % du trafic vers le modèle mis à jour. Pour obtenir un exemple de test de modèles en production, consultez [Test de modèles avec des variantes de production](model-ab-testing.md).
Pour plus d’informations, consultez les articles et les livres sur la façon d’évaluer les modèles, par exemple, [Évaluation des modèles de machine learning](http://www.oreilly.com/data/free/evaluating-machine-learning-models.csp).
Les options pour l’évaluation des modèles hors connexion sont les suivantes :
+ **Validation à l’aide d’un jeu de données d’exclusion** : les professionnels du machine learning mettent souvent de côté une partie des données sous la forme d’un « jeu de données d’exclusion ». Ils n’utilisent pas ces données pour l’entraînement des modèles.
Avec cette approche, vous pouvez évaluer combien votre modèle fournit d’inférences sur les données d’exclusion. Vous pouvez ensuite évaluer l’efficacité avec laquelle le modèle généralise ce qu’il a appris pendant l’entraînement initial, par opposition à l’utilisation d’une mémoire de modèles. Cette approche de la validation vous donne une idée de la fréquence à laquelle le modèle est en mesure de déduire la réponse correcte.
D’une certaine manière, cette approche est similaire à un enseignement pour des élèves de niveau élémentaire. Vous commencez par leur donner un ensemble d’exemples à apprendre, puis vous testez leur capacité à généraliser à partir de cet apprentissage. Par des tests et des devoirs personnels, vous posez des problèmes qui ne figuraient pas dans l’apprentissage initial, et déterminez s’ils sont capables de généraliser de manière efficace. Les étudiants avec une mémoire parfaite peuvent mémoriser les problèmes, plutôt que d’apprendre les règles.
En général, le jeu de données d’exclusion représente 20 à 30 % des données d’entraînement.
+ **Validation k-fold** : dans cette approche de validation, vous divisez l’exemple de jeu de données en *k* parties. Vous traitez chacune de ces parties en tant que jeu de données d’exclusion pour* k* exécutions d’entraînement, et utilisez les *k*-1 autres parties comme jeu de données d’entraînement pour cette exécution. Vous produisez* k* modèles à l’aide d’un processus similaire, et regroupez les modèles pour générer votre modèle final. La valeur *k* est généralement de l’ordre de 5 à 10.
# Amazon SageMaker Inference Recommender
Amazon SageMaker Inference Recommender est une fonctionnalité d'Amazon SageMaker AI. Il réduit le temps nécessaire à la mise en production des modèles d'apprentissage automatique (ML) en automatisant les tests de charge et le réglage des modèles sur les instances SageMaker AI ML. Vous pouvez utiliser Inference Recommender pour déployer votre modèle sur un point de terminaison d’inférence en temps réel ou sans serveur qui offre les meilleures performances au moindre coût. Inference Recommender vous aide à sélectionner le meilleur type d’instance et la meilleure configuration pour vos modèles et charges de travail de ML. Elle prend en compte des facteurs tels que le nombre d’instances, les paramètres du conteneur, les optimisations du modèle, la simultanéité maximale et la taille de la mémoire.
Amazon SageMaker Inference Recommender ne vous facture que les instances utilisées pendant l'exécution de vos tâches.
## Fonctionnement
Pour utiliser Amazon SageMaker Inference Recommender, vous pouvez [créer un modèle d' SageMaker IA ou enregistrer un modèle](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) dans le registre des modèles avec les SageMaker artefacts de votre modèle. Utilisez la console AWS SDK pour Python (Boto3) ou l' SageMaker IA pour exécuter des tâches d'analyse comparative pour différentes configurations de terminaux SageMaker AI. Les tâches Inference Recommender vous aident à collecter et à visualiser des métriques de performance et d’utilisation des ressources afin de vous aider à déterminer le type de point de terminaison et la configuration à choisir.
## Comment démarrer
Si vous utilisez Amazon SageMaker Inference Recommender pour la première fois, nous vous recommandons de procéder comme suit :
1. Lisez [Conditions préalables à l'utilisation d'Amazon SageMaker Inference Recommender](inference-recommender-prerequisites.md) cette section pour vous assurer que vous remplissez les conditions requises pour utiliser Amazon SageMaker Inference Recommender.
1. Lisez la section [Emplois de recommandation avec Amazon SageMaker Inference Recommender](inference-recommender-recommendation-jobs.md) pour lancer vos premières tâches de recommandation Inference Recommender.
1. Découvrez l'exemple d'introduction du [bloc-notes Jupyter](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-inference-recommender/inference-recommender.ipynb) d'Amazon SageMaker Inference Recommender, ou consultez les exemples de blocs-notes dans la section suivante.
## Exemples de blocs-notes
Les exemples de blocs-notes Jupyter suivants peuvent vous aider à gérer les flux de travail pour plusieurs cas d’utilisation dans Inference Recommender :
+ Si vous recherchez un bloc-notes d'introduction qui compare un TensorFlow modèle, consultez le bloc-notes [SageMaker Inference Recommender TensorFlow](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/inference-recommender.ipynb).
+ Si vous souhaitez comparer un HuggingFace modèle, consultez l'[SageMaker Inference Recommender pour HuggingFace](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/huggingface-inference-recommender/huggingface-inference-recommender.ipynb) ordinateur portable.
+ Si vous souhaitez comparer un XGBoost modèle, consultez le bloc-notes [SageMaker Inference Recommender XGBoost](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/xgboost/xgboost-inference-recommender.ipynb).
+ Si vous souhaitez consulter les CloudWatch métriques de vos tâches Inference Recommender, consultez le bloc-notes des métriques [SageMaker Inference CloudWatch Recommender](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/tensorflow-cloudwatch/tf-cloudwatch-inference-recommender.ipynb).
# Conditions préalables à l'utilisation d'Amazon SageMaker Inference Recommender
Avant de pouvoir utiliser Amazon SageMaker Inference Recommender, vous devez suivre les étapes préalables. À titre d'exemple, nous montrons comment utiliser un modèle pré-entraîné PyTorch (v1.7.1) ResNet -18 pour les deux types de tâches de recommandation Amazon SageMaker Inference Recommender. Les exemples présentés utilisent le kit AWS SDK pour Python (Boto3).
**Note**
Les exemples de code suivants utilisent Python. Supprimez le caractère de préfixe `!` si vous exécutez l’un des exemples de code suivants dans votre terminal ou AWS CLI.
Vous pouvez exécuter les exemples suivants avec le noyau Python 3 (TensorFlow 2.6 Python 3.8 optimisé pour le processeur) dans un bloc-notes Amazon SageMaker Studio. Pour plus d’informations sur Studio, consultez [Amazon SageMaker Studio](studio-updated.md).
1. **Créez un rôle IAM pour Amazon SageMaker AI.**
Créez un rôle IAM pour Amazon SageMaker AI auquel est attachée la politique gérée par `AmazonSageMakerFullAccess` IAM.
1. **Configurez votre environnement.**
Importez des dépendances et créez des variables pour vous Région AWS, votre rôle SageMaker AI IAM (à partir de l'étape 1) et le client SageMaker AI.
```
!pip install --upgrade pip awscli botocore boto3 --quiet
from sagemaker import get_execution_role, Session, image_uris
import boto3
region = boto3.Session().region_name
role = get_execution_role()
sagemaker_client = boto3.client("sagemaker", region_name=region)
sagemaker_session = Session()
```
1. **(Facultatif) Examinez les modèles existants évalués par Inference Recommender.**
Inference Recommender compare les modèles de zoos de modèles populaires. Inference Recommender prend en charge votre modèle même s’il n’est pas déjà étalonné.
Utilisez `ListModelMetaData` pour obtenir un objet de réponse qui répertorie le domaine, le cadre, la tâche et le nom de modèle des modèles de machine learning trouvés dans les zoos de modèles courants.
Vous utiliserez le domaine, le framework, la version du framework, la tâche et le nom du modèle dans les étapes ultérieures pour sélectionner une image Docker d'inférence et enregistrer votre modèle auprès SageMaker de Model Registry. Voici comment répertorier les métadonnées de modèle avec le kit SDK Python (Boto3) :
```
list_model_metadata_response=sagemaker_client.list_model_metadata()
```
La sortie comprend des résumés de modèle (`ModelMetadataSummaries`) et des métadonnées de réponse (`ResponseMetadata`) similaires à l’exemple suivant :
```
{
'ModelMetadataSummaries': [{
'Domain': 'NATURAL_LANGUAGE_PROCESSING',
'Framework': 'PYTORCH:1.6.0',
'Model': 'bert-base-cased',
'Task': 'FILL_MASK'
},
{
'Domain': 'NATURAL_LANGUAGE_PROCESSING',
'Framework': 'PYTORCH:1.6.0',
'Model': 'bert-base-uncased',
'Task': 'FILL_MASK'
},
{
'Domain': 'COMPUTER_VISION',
'Framework': 'MXNET:1.8.0',
'Model': 'resnet18v2-gluon',
'Task': 'IMAGE_CLASSIFICATION'
},
{
'Domain': 'COMPUTER_VISION',
'Framework': 'PYTORCH:1.6.0',
'Model': 'resnet152',
'Task': 'IMAGE_CLASSIFICATION'
}],
'ResponseMetadata': {
'HTTPHeaders': {
'content-length': '2345',
'content-type': 'application/x-amz-json-1.1',
'date': 'Tue, 19 Oct 2021 20:52:03 GMT',
'x-amzn-requestid': 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
},
'HTTPStatusCode': 200,
'RequestId': 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
'RetryAttempts': 0
}
}
```
Pour cette démonstration, nous utilisons un modèle PyTorch (v1.7.1) ResNet -18 pour effectuer la classification des images. L’exemple de code Python suivant stocke le framework, la version du framework, le domaine et la tâche dans des variables pour une utilisation ultérieure :
```
# ML framework details
framework = 'pytorch'
framework_version = '1.7.1'
# ML model details
ml_domain = 'COMPUTER_VISION'
ml_task = 'IMAGE_CLASSIFICATION'
```
1. **Chargez votre modèle de machine learning sur Amazon S3.**
Utilisez ce modèle PyTorch (v1.7.1) ResNet -18 si vous ne disposez pas d'un modèle d'apprentissage automatique pré-entraîné :
```
# Optional: Download a sample PyTorch model
import torch
from torchvision import models, transforms, datasets
# Create an example input for tracing
image = torch.zeros([1, 3, 256, 256], dtype=torch.float32)
# Load a pretrained resnet18 model from TorchHub
model = models.resnet18(pretrained=True)
# Tell the model we are using it for evaluation (not training). Note this is required for Inferentia compilation.
model.eval()
model_trace = torch.jit.trace(model, image)
# Save your traced model
model_trace.save('model.pth')
```
Téléchargez un exemple de script d’inférence `inference.py`. Créez un répertoire `code` et déplacez le script d’inférence vers le répertoire `code`.
```
# Download the inference script
!wget https://aws-ml-blog-artifacts.s3.us-east-2.amazonaws.com/inference.py
# move it into a code/ directory
!mkdir code
!mv inference.py code/
```
Amazon SageMaker AI nécessite que les modèles d'apprentissage automatique préformés soient regroupés sous forme de fichier TAR compressé (`*.tar.gz`). Compressez votre modèle et votre script d’inférence pour répondre à cette exigence :
```
!tar -czf test.tar.gz model.pth code/inference.py
```
Lorsque votre point de terminaison est approvisionné, les fichiers de l’archive sont extraits dans `/opt/ml/model/` sur le point de terminaison.
Après avoir compressé votre modèle et les artefacts de modèle en tant que fichier `.tar.gz`, chargez-les dans votre compartiment Amazon S3. L’exemple suivant montre comment charger votre modèle sur Amazon S3 à l’aide de l’ AWS CLI :
```
!aws s3 cp test.tar.gz s3://{your-bucket}/models/
```
1. **Sélectionnez une image d’inférence Docker prédéfinie ou créez votre propre image Docker d’inférence.**
SageMaker L'IA fournit des conteneurs pour ses algorithmes intégrés et des images Docker prédéfinies pour certains des frameworks d'apprentissage automatique les plus courants, tels qu'Apache MXNet, TensorFlow PyTorch, et Chainer. Pour une liste complète des images d' SageMaker IA disponibles, consultez [Available Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Si aucun des conteneurs SageMaker AI existants ne répond à vos besoins et que vous n'avez pas de conteneur existant, créez une nouvelle image Docker. Consultez [Conteneurs avec code d’inférence personnalisé](your-algorithms-inference-main.md) pour savoir comment créer votre image Docker.
Ce qui suit montre comment récupérer une image d'inférence de PyTorch la version 1.7.1 à l'aide du SDK SageMaker Python :
```
from sagemaker import image_uris
## Uncomment and replace with your own values if you did not define
## these variables a previous step.
#framework = 'pytorch'
#framework_version = '1.7.1'
# Note: you can use any CPU-based instance here,
# this is just to set the arch as CPU for the Docker image
instance_type = 'ml.m5.2xlarge'
image_uri = image_uris.retrieve(framework,
region,
version=framework_version,
py_version='py3',
instance_type=instance_type,
image_scope='inference')
```
Pour obtenir la liste des instances SageMaker AI disponibles, consultez [Amazon SageMaker AI Pricing](https://aws.amazon.com/sagemaker/pricing/).
1. **Créez un exemple d’archive de données utiles.**
Créez une archive contenant des fichiers individuels que l'outil de test de charge peut envoyer à vos points de terminaison d' SageMaker IA. Votre code d’inférence doit être capable de lire les formats de fichier à partir de l’exemple de données utiles.
Ce qui suit télécharge une image .jpg que cet exemple utilisera ultérieurement pour le modèle ResNet -18.
```
!wget https://cdn.pixabay.com/photo/2020/12/18/05/56/flowers-5841251_1280.jpg
```
Compressez l’exemple de données utiles en tant qu’archive :
```
!tar -cvzf payload.tar.gz flowers-5841251_1280.jpg
```
Chargez l’exemple de données utiles sur Amazon S3 et notez l’URI Amazon S3 :
```
!aws s3 cp payload.tar.gz s3://{bucket}/models/
```
Vous aurez besoin de l’URI Amazon S3 dans une étape ultérieure, alors stockez-le dans une variable :
```
bucket_prefix='models'
bucket = '' # Provide the name of your S3 bucket
payload_s3_key = f"{bucket_prefix}/payload.tar.gz"
sample_payload_url= f"s3://{bucket}/{payload_s3_key}"
```
1. **Préparez l’entrée de votre modèle pour la tâche de recommandation.**
Pour ce dernier prérequis, deux options s’offrent à vous pour préparer votre entrée de modèle. Vous pouvez soit enregistrer votre modèle auprès du SageMaker Model Registry, que vous pouvez utiliser pour cataloguer les modèles destinés à la production, soit créer un modèle d' SageMaker IA et le spécifier dans le `ContainerConfig` champ lors de la création d'une tâche de recommandation. La première option est la meilleure si vous souhaitez tirer parti des fonctionnalités fournies par le [registre de modèles](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry.html), telles que la gestion des versions de modèle et l’automatisation du déploiement de modèle. La deuxième option est idéale si vous souhaitez commencer rapidement. Pour la première option, passez à l’étape 7. Pour la deuxième option, ignorez l’étape 7 et passez à l’étape 8.
1. **Option 1 : enregistrez votre modèle dans le registre de modèles.**
Avec SageMaker Model Registry, vous pouvez cataloguer les modèles destinés à la production, gérer les versions des modèles, associer des métadonnées (telles que les indicateurs de formation) à un modèle, gérer le statut d'approbation d'un modèle, déployer des modèles en production et automatiser le déploiement de modèles avec CI/CD.
Lorsque vous utilisez SageMaker Model Registry pour suivre et gérer vos modèles, ceux-ci sont représentés sous la forme d'un package de modèles versionné au sein de groupes de packages de modèles. Les packages de modèle non versionné ne font pas partie d’un groupe de modèles. Les groupes de packages de modèle contiennent plusieurs versions ou itérations d’un modèle. Bien qu’il ne soit pas obligatoire de les créer pour chaque modèle du registre, ils aident à organiser divers modèles qui ont tous le même objectif et fournissent la gestion automatique des versions.
Pour utiliser Amazon SageMaker Inference Recommender, vous devez disposer d'un modèle de package versionné. Vous pouvez créer un package de modèle versionné par programmation avec ou AWS SDK pour Python (Boto3) avec Amazon SageMaker Studio Classic. Pour créer un package de modèle versionné par programmation, créez d’abord un groupe de packages de modèle avec l’API `CreateModelPackageGroup`. Ensuite, créez un package de modèle à l’aide de l’API `CreateModelPackage`. L’appel de cette méthode crée un package de modèle versionné.
Consultez [Création d’un groupe de modèles](model-registry-model-group.md) et [Enregistrement d’une version de modèle](model-registry-version.md) pour obtenir des instructions détaillées sur la création programmatique et interactive d'un groupe de packages de modèles et sur la manière de créer un package de modèles versionné, respectivement, avec Amazon Studio Classic et AWS SDK pour Python (Boto3) Amazon Studio. SageMaker
L’exemple de code suivant montre comment créer un package de modèle versionné à l’aide du kit AWS SDK pour Python (Boto3).
**Note**
Vous n’avez pas besoin d’approuver le package de modèle pour créer une tâche Inference Recommender.
1. **Création d’un groupe de packages de modèle**
Créez un groupe de packages de modèle avec l’API `CreateModelPackageGroup`. Fournissez un nom au groupe de package de modèle pour le `ModelPackageGroupName` et fournissez éventuellement une description du package de modèle dans le champ `ModelPackageGroupDescription`.
```
model_package_group_name = ''
model_package_group_description = ''
model_package_group_input_dict = {
"ModelPackageGroupName" : model_package_group_name,
"ModelPackageGroupDescription" : model_package_group_description,
}
model_package_group_response = sagemaker_client.create_model_package_group(**model_package_group_input_dict)
```
Consultez le [guide de référence des SageMaker API Amazon](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html) pour obtenir la liste complète des arguments facultatifs et obligatoires auxquels vous pouvez passer [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackageGroup.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackageGroup.html).
Créez un package de modèle en spécifiant une image Docker qui exécute votre code d’inférence et l’emplacement Amazon S3 de vos artefacts de modèle, et fournissez des valeurs pour `InferenceSpecification`. `InferenceSpecification` doit contenir des informations sur les tâches d’inférence pouvant être exécutées avec des modèles basés sur ce package de modèle, notamment :
+ Chemins Amazon ECR des images qui exécutent votre code d’inférence.
+ (Facultatif) Les types d’instances pris en charge par le package de modèle pour les tâches de transformation et les points de terminaison en temps réel utilisés pour l’inférence.
+ Les formats de contenu d’entrée et de sortie que le package de modèle prend en charge pour l’inférence.
En outre, vous devez spécifier les paramètres suivants lorsque vous créez un package de modèle :
+ [Domain](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-Domain) : domaine de machine learning de votre package de modèle et de ses composants. Les domaines de machine learning courants incluent la reconnaissance d’image et le traitement du langage naturel.
+ [Task](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-Task) : tâche de machine learning effectuée par votre package de modèle. Les tâches de machine learning courantes incluent la détection d’objets et la classification des images. Indiquez « OTHER » (AUTRE) si aucune des tâches répertoriées dans le [Guide de référence des API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html) ne correspond à votre cas d’utilisation. Consultez les descriptions des champs de l’API [Task](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-Task) (Tâche) pour obtenir une liste des tâches de machine learning prises en charge.
+ [SamplePayloadUrl](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-SamplePayloadUrl): le chemin Amazon Simple Storage Service (Amazon S3) où l'échantillon de charge utile est stocké. Ce chemin doit pointer vers une seule archive TAR compressée GZIP (suffixe .tar.gz).
+ [Framework](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelPackageContainerDefinition.html#sagemaker-Type-ModelPackageContainerDefinition-Framework) : cadre de machine learning de l’image de conteneur du package de modèle.
+ [FrameworkVersion](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelPackageContainerDefinition.html#sagemaker-Type-ModelPackageContainerDefinition-FrameworkVersion): version framework de l'image du conteneur du package modèle.
Si vous fournissez une liste autorisée de types d'instances à utiliser pour générer des inférences en temps réel pour le [SupportedRealtimeInferenceInstanceTypes](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InferenceSpecification.html#sagemaker-Type-InferenceSpecification-SupportedRealtimeInferenceInstanceTypes), Inference Recommender limite l'espace de recherche pour les types d'instances au cours d'une tâche. `Default` Utilisez ce paramètre si vous avez des contraintes budgétaires ou si vous savez qu’un ensemble spécifique de types d’instances peut prendre en charge votre modèle et votre image de conteneur.
Lors d'une étape précédente, nous avons téléchargé un modèle ResNet 18 pré-entraîné et l'avons stocké dans un compartiment Amazon S3 dans un répertoire appelé`models`. Nous avons récupéré une image d'inférence du conteneur Deep Learning PyTorch (v1.7.1) et stocké l'URI dans une variable appelée. `image_uri` Utilisez ces variables dans l’exemple de code suivant pour définir un dictionnaire utilisé comme entrée de l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html).
```
# Provide the Amazon S3 URI of your compressed tarfile
# so that Model Registry knows where to find your model artifacts
bucket_prefix='models'
bucket = '' # Provide the name of your S3 bucket
model_s3_key = f"{bucket_prefix}/test.tar.gz"
model_url= f"s3://{bucket}/{model_s3_key}"
# Similar open source model to the packaged model
# The name of the ML model as standardized by common model zoos
nearest_model_name = 'resnet18'
# The supported MIME types for input and output data. In this example,
# we are using images as input.
input_content_type='image/jpeg'
# Optional - provide a description of your model.
model_package_description = ''
## Uncomment if you did not store the domain and task in an earlier
## step
#ml_domain = 'COMPUTER_VISION'
#ml_task = 'IMAGE_CLASSIFICATION'
## Uncomment if you did not store the framework and framework version
## in a previous step.
#framework = 'PYTORCH'
#framework_version = '1.7.1'
# Optional: Used for optimizing your model using SageMaker Neo
# PyTorch uses NCHW format for images
data_input_configuration = "[[1,3,256,256]]"
# Create a dictionary to use as input for creating a model pacakge group
model_package_input_dict = {
"ModelPackageGroupName" : model_package_group_name,
"ModelPackageDescription" : model_package_description,
"Domain": ml_domain,
"Task": ml_task,
"SamplePayloadUrl": sample_payload_url,
"InferenceSpecification": {
"Containers": [
{
"Image": image_uri,
"ModelDataUrl": model_url,
"Framework": framework.upper(),
"FrameworkVersion": framework_version,
"NearestModelName": nearest_model_name,
"ModelInput": {"DataInputConfig": data_input_configuration}
}
],
"SupportedContentTypes": [input_content_type]
}
}
```
1. **Création d’un package de modèle**
Utilisez l’API `CreateModelPackage` pour créer un package de modèle. Transmettez le dictionnaire d’entrée défini à l’étape précédente :
```
model_package_response = sagemaker_client.create_model_package(**model_package_input_dict)
```
Vous avez besoin du modèle ARN du package pour utiliser Amazon SageMaker Inference Recommender. Notez l’ARN du package de modèle ou stockez-le dans une variable :
```
model_package_arn = model_package_response["ModelPackageArn"]
print('ModelPackage Version ARN : {}'.format(model_package_arn))
```
1. **Option 2 : créez un modèle et configurez le champ `ContainerConfig`**
Utilisez cette option si vous souhaitez démarrer une tâche de recommandation d’inférence et que vous n’avez pas besoin d’enregistrer votre modèle dans le registre de modèles. Dans les étapes suivantes, vous créez un modèle dans SageMaker AI et configurez le `ContainerConfig` champ comme entrée pour la tâche de recommandation.
1. **Création d’un modèle**
Créez un modèle avec l’API `CreateModel`. Pour un exemple qui appelle cette méthode lors du déploiement d'un modèle sur SageMaker AI Hosting, voir [Create a Model (AWS SDK pour Python (Boto3))](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html#realtime-endpoints-deployment-create-model).
Lors d'une étape précédente, nous avons téléchargé un modèle ResNet 18 pré-entraîné et l'avons stocké dans un compartiment Amazon S3 dans un répertoire appelé`models`. Nous avons récupéré une image d'inférence du conteneur Deep Learning PyTorch (v1.7.1) et stocké l'URI dans une variable appelée. `image_uri` Nous utilisons ces variables dans l’exemple de code suivant où nous définissons un dictionnaire utilisé comme entrée de l’API `[CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html#sagemaker-CreateModel-request-ModelName)`.
```
model_name = ''
# Role to give SageMaker permission to access AWS services.
sagemaker_role= "arn:aws:iam::::role/*"
# Provide the Amazon S3 URI of your compressed tarfile
# so that Model Registry knows where to find your model artifacts
bucket_prefix='models'
bucket = '' # Provide the name of your S3 bucket
model_s3_key = f"{bucket_prefix}/test.tar.gz"
model_url= f"s3://{bucket}/{model_s3_key}"
#Create model
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
'Image': image_uri,
'ModelDataUrl': model_url,
})
```
1. **Configuration du champ `ContainerConfig`**
Ensuite, vous devez configurer le [ContainerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RecommendationJobInputConfig.html#sagemaker-Type-RecommendationJobInputConfig-ContainerConfig)champ avec le modèle que vous venez de créer et y spécifier les paramètres suivants :
+ `Domain` : domaine de machine learning du modèle et de ses composants, tels que la vision par ordinateur ou le traitement du langage naturel.
+ `Task` : tâche de machine learning exécutée par le modèle, telle que la classification d’images ou la détection d’objets.
+ `PayloadConfig` : configuration des données utiles pour une tâche de recommandation. Pour plus d’informations sur les sous-champs, consultez `[RecommendationJobPayloadConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RecommendationJobPayloadConfig.html#sagemaker-Type-RecommendationJobPayloadConfig-SamplePayloadUrl)`.
+ `Framework`: le cadre d'apprentissage automatique de l'image du conteneur, tel que PyTorch.
+ `FrameworkVersion` : version du cadre de l’image de conteneur.
+ (Facultatif) `SupportedInstanceTypes` : liste des types d’instance utilisés pour générer des inférences en temps réel.
Si vous utilisez le paramètre `SupportedInstanceTypes`, Inference Recommender limite l’espace de recherche pour les types d’instance au cours d’une tâche `Default`. Utilisez ce paramètre si vous avez des contraintes budgétaires ou si vous savez qu’un ensemble spécifique de types d’instances peut prendre en charge votre modèle et votre image de conteneur.
Dans l’exemple de code suivant, nous utilisons les paramètres définis précédemment, ainsi que `NearestModelName`, pour définir un dictionnaire utilisé comme entrée de l’API `[CreateInferenceRecommendationsJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html)`.
```
## Uncomment if you did not store the domain and task in a previous step
#ml_domain = 'COMPUTER_VISION'
#ml_task = 'IMAGE_CLASSIFICATION'
## Uncomment if you did not store the framework and framework version in a previous step
#framework = 'PYTORCH'
#framework_version = '1.7.1'
# The name of the ML model as standardized by common model zoos
nearest_model_name = 'resnet18'
# The supported MIME types for input and output data. In this example,
# we are using images as input
input_content_type='image/jpeg'
# Optional: Used for optimizing your model using SageMaker Neo
# PyTorch uses NCHW format for images
data_input_configuration = "[[1,3,256,256]]"
# Create a dictionary to use as input for creating an inference recommendation job
container_config = {
"Domain": ml_domain,
"Framework": framework.upper(),
"FrameworkVersion": framework_version,
"NearestModelName": nearest_model_name,
"PayloadConfig": {
"SamplePayloadUrl": sample_payload_url,
"SupportedContentTypes": [ input_content_type ]
},
"DataInputConfig": data_input_configuration
"Task": ml_task,
}
```
# Emplois de recommandation avec Amazon SageMaker Inference Recommender
Amazon SageMaker Inference Recommender peut émettre deux types de recommandations :
1. Les recommandations d’inférence (type de tâche `Default`) exécutent un ensemble de tests de charge sur les types d’instances recommandés. Vous pouvez également effectuer un test de charge pour un point de terminaison sans serveur. Il vous suffit de fournir un package de modèle Amazon Resource Name (ARN) pour lancer ce type de tâche de recommandation. Les tâches de recommandation d’inférence sont terminées en 45 minutes.
1. Les recommandations de point de terminaison (type de tâche `Advanced`) sont basées sur un test de charge personnalisé dans lequel vous sélectionnez les instances de machine learning que vous voulez ou un point de terminaison sans serveur, fournissez un modèle de trafic personnalisé et des exigences de latence et de débit en fonction de vos exigences de production. Cette tâche dure en moyenne 2 heures en fonction de la durée de la tâche définie et du nombre total de configurations d’inférences testées.
Les deux types de recommandations utilisent la même APIs méthode pour créer, décrire et arrêter des tâches. La sortie est une liste de recommandation de configuration d’instance avec les variables d’environnement associées, les métriques de coût, de débit et de latence. Les tâches de recommandation fournissent également un nombre d’instances initial, que vous pouvez utiliser pour configurer une politique de mise à l’échelle automatique. Pour différencier les deux types de tâches, lorsque vous créez une tâche via la console SageMaker AI ou le, spécifiez de créer des recommandations préliminaires sur les points `Default` de terminaison APIs, des tests de charge personnalisés et `Advanced` des recommandations de point de terminaison.
**Note**
Vous n’avez pas besoin d’effectuer les deux types de tâches de recommandation dans votre propre flux de travail. Vous pouvez faire l’un ou l’autre indépendamment.
Inference Recommender peut également vous fournir une liste d’instances potentielles, ou les cinq principaux types d’instances optimisés en termes de coût, de débit et de latence pour le déploiement du modèle, ainsi qu’un score de confiance. Vous pouvez choisir ces instances lors du déploiement de votre modèle. Inference Recommender effectue automatiquement une analyse comparative par rapport à votre modèle afin que vous puissiez fournir les instances potentielles. Comme il s’agit de recommandations préliminaires, nous vous recommandons d’exécuter d’autres tâches de recommandation d’instance pour obtenir des résultats plus précis. Pour consulter les instances potentielles, rendez-vous sur la page de détails de votre modèle d' SageMaker IA. Pour de plus amples informations, veuillez consulter [Obtention d’instances potentielles instantanées](inference-recommender-prospective.md).
**Topics**
+ [Obtention d’instances potentielles instantanées](inference-recommender-prospective.md)
+ [Recommandations d’inférence](inference-recommender-instance-recommendation.md)
+ [Obtention d’une recommandation d’inférence pour un point de terminaison existant](inference-recommender-existing-endpoint.md)
+ [Arrêt de votre recommandation d’inférence](instance-recommendation-stop.md)
+ [Recommandations compilées avec Neo](inference-recommender-neo-compilation.md)
+ [Résultats des recommandations](inference-recommender-interpret-results.md)
+ [Obtention de recommandations en matière de politique de mise à l’échelle automatique](inference-recommender-autoscaling.md)
+ [Exécuter un test de charge personnalisé](inference-recommender-load-test.md)
+ [Arrêt de votre test de charge](load-test-stop.md)
+ [Résolution des erreurs Inference Recommender](inference-recommender-troubleshooting.md)
# Obtention d’instances potentielles instantanées
Inference Recommender peut également vous fournir une liste d'*instances potentielles, ou de types d'instances* susceptibles de convenir à votre modèle, sur la page de détails de votre modèle d' SageMaker IA. Inference Recommender effectue automatiquement une analyse comparative préliminaire par rapport à votre modèle afin que vous puissiez fournir les cinq principales instances potentielles. Comme il s'agit de recommandations préliminaires, nous vous recommandons d'exécuter d'autres tâches de recommandation d'instance pour obtenir des résultats plus précis.
Vous pouvez afficher la liste des instances potentielles de votre modèle par programmation à l'aide de l'[DescribeModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModel.html)API, du SDK SageMaker Python ou de la SageMaker console AI.
**Note**
Vous n'obtiendrez pas d'instances potentielles pour les modèles que vous avez créés dans SageMaker AI avant que cette fonctionnalité ne soit disponible.
Pour afficher les instances potentielles de votre modèle via la console, procédez comme suit :
1. Accédez à la SageMaker console à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Dans le panneau de navigation de gauche, choisissez **Inférence**, puis **Modèles**.
1. Dans la liste des modèles, choisissez votre modèle.
Sur la page de détails de votre modèle, accédez à la section **Instances potentielles pour déployer le modèle**. La capture d’écran suivante montre cette section.
![\[Capture d’écran de la liste des instances potentielles sur la page de détails du modèle.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inf-rec-prospective.png)
Dans cette section, vous pouvez afficher les instances potentielles optimisées en termes de coût, de débit et de latence pour le déploiement du modèle, ainsi que des informations supplémentaires pour chaque type d’instance, telles que la taille de la mémoire, le nombre de CPU et de GPU et le coût par heure.
Si vous décidez d’analyser un exemple de données utiles et d’exécuter une tâche de recommandation d’inférence complète pour votre modèle, vous pouvez démarrer une tâche de recommandation d’inférence par défaut à partir de cette page. Pour démarrer une tâche par défaut via la console, procédez comme suit :
1. Sur la page de détails de votre modèle, dans la **section Instances potentielles pour déployer le modèle**, choisissez **Exécuter la tâche Inference Recommender**.
1. Dans la boîte de dialogue qui apparaît, pour le **compartiment S3 destiné à l’analyse comparative des données utiles**, entrez l’emplacement Amazon S3 où vous avez stocké un exemple de données utiles pour votre modèle.
1. Pour **Type de contenu de la charge utile**, entrez les types MIME pour vos données de charge utile.
1. (Facultatif) Dans la section **Compilation du modèle à l'aide de SageMaker Neo**, pour la **configuration de saisie** des données, entrez une forme de données au format dictionnaire.
1. Choisissez **Exécuter la tâche**.
Inference Recommender démarre la tâche, et vous pouvez consulter la tâche et ses résultats sur la page de liste des **recommandations d'inférence** de la console AI. SageMaker
Si vous souhaitez exécuter une tâche avancée et effectuer des tests de charge personnalisés, ou si vous souhaitez configurer des réglages et des paramètres supplémentaires pour votre tâche, consultez [Exécuter un test de charge personnalisé](inference-recommender-load-test.md).
# Recommandations d’inférence
Les tâches de recommandation d’inférence exécutent un ensemble de tests de charge sur les types d’instance recommandés ou un point de terminaison sans serveur. Les tâches de recommandation d’inférence utilisent des métriques de performance basées sur des tests de charge utilisant les exemples de données que vous avez fournis lors de l’enregistrement de la version du modèle.
**Note**
Avant de créer une tâche de recommandation Inference Recommender, assurez-vous que les [Conditions préalables à l'utilisation d'Amazon SageMaker Inference Recommender](inference-recommender-prerequisites.md) sont satisfaits.
Ce qui suit montre comment utiliser Amazon SageMaker Inference Recommender pour créer une recommandation d'inférence basée sur votre type de modèle à l'aide de AWS SDK pour Python (Boto3), AWS CLI et d'Amazon SageMaker Studio Classic et de la console AI SageMaker
**Topics**
+ [Création d’une recommandation d’inférence](instance-recommendation-create.md)
+ [Obtention des résultats de votre tâche de recommandation d’inférence](instance-recommendation-results.md)
# Création d’une recommandation d’inférence
Créez une recommandation d'inférence par programmation à l'aide du AWS SDK pour Python (Boto3) ou du AWS CLI, ou de manière interactive à l'aide de Studio Classic ou de la console AI. SageMaker Spécifiez un nom de tâche pour votre recommandation d'inférence, un ARN de rôle AWS IAM, une configuration d'entrée et soit un ARN de package de modèle lorsque vous avez enregistré votre modèle dans le registre des modèles, soit le nom de votre modèle et un `ContainerConfig` dictionnaire utilisés lors de la création de votre modèle dans la section **Prérequis**.
------
#### [ AWS SDK pour Python (Boto3) ]
Utilisez l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html) pour démarrer une tâche de recommandation d’inférence. Définissez le champ `JobType` sur `'Default'` pour les tâches de recommandation d’inférence. En outre, fournissez les éléments suivants :
+ L’Amazon Resource Name (ARN) d’un rôle IAM qui permet à Inference Recommender d’effectuer des tâches en votre nom. Définissez-le pour le champ `RoleArn`.
+ Un ARN de package de modèle ou un nom de modèle. Inference Recommender prend en charge l’ARN d’un package de modèle ou un nom de modèle en entrée. Spécifiez l’un des éléments suivants :
+ L'ARN du package de modèles versionné que vous avez créé lorsque vous avez enregistré votre modèle dans le registre des modèles SageMaker AI. Définissez-le pour `ModelPackageVersionArn` dans le champ `InputConfig`.
+ Le nom du modèle que vous avez créé. Définissez-le pour `ModelName` dans le champ `InputConfig`. Fournissez également le dictionnaire `ContainerConfig`, qui inclut les champs obligatoires qui doivent être fournis avec le nom du modèle. Définissez-le pour `ContainerConfig` dans le champ `InputConfig`. Dans `ContainerConfig`, vous pouvez également éventuellement spécifier le champ `SupportedEndpointType` comme `RealTime` ou `Serverless`. Si vous spécifiez ce champ, Inference Recommender renvoie des recommandations uniquement pour ce type de point de terminaison. Si vous ne spécifiez pas ce champ, Inference Recommender renvoie des recommandations pour les deux types de point de terminaison.
+ Un nom à votre tâche de recommandation Inference Recommender pour le champ `JobName`. Le nom du poste Inference Recommender doit être unique dans la AWS région et dans votre AWS compte.
Importez le AWS SDK pour Python (Boto3) package et créez un objet client SageMaker AI à l'aide de la classe client. Si vous avez suivi les étapes de la section **Prerequisites** (Prérequis), spécifiez uniquement l’un des éléments suivants :
+ Option 1 : si vous souhaitez créer une tâche de recommandation d’inférence avec l’ARN d’un package de modèle, stockez l’ARN du groupe de packages de modèle dans une variable nommée `model_package_arn`.
+ Option 2 : si vous souhaitez créer une tâche de recommandation d’inférence avec un nom de modèle et `ContainerConfig`, stockez le nom du modèle dans une variable nommée `model_name` et le dictionnaire `ContainerConfig` dans une variable nommée `container_config`.
```
# Create a low-level SageMaker service client.
import boto3
aws_region = ''
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Provide only one of model package ARN or model name, not both.
# Provide your model package ARN that was created when you registered your
# model with Model Registry
model_package_arn = ''
## Uncomment if you would like to create an inference recommendations job with a
## model name instead of a model package ARN, and comment out model_package_arn above
## Provide your model name
# model_name = ''
## Provide your container config
# container_config = ''
# Provide a unique job name for SageMaker Inference Recommender job
job_name = ''
# Inference Recommender job type. Set to Default to get an initial recommendation
job_type = 'Default'
# Provide an IAM Role that gives SageMaker Inference Recommender permission to
# access AWS services
role_arn = 'arn:aws:iam:::role/*'
sagemaker_client.create_inference_recommendations_job(
JobName = job_name,
JobType = job_type,
RoleArn = role_arn,
# Provide only one of model package ARN or model name, not both.
# If you would like to create an inference recommendations job with a model name,
# uncomment ModelName and ContainerConfig, and comment out ModelPackageVersionArn.
InputConfig = {
'ModelPackageVersionArn': model_package_arn
# 'ModelName': model_name,
# 'ContainerConfig': container_config
}
)
```
Consultez le [guide de référence des SageMaker API Amazon](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html) pour obtenir la liste complète des arguments facultatifs et obligatoires auxquels vous pouvez passer [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html).
------
#### [ AWS CLI ]
Utilisez l’API `create-inference-recommendations-job` pour démarrer une tâche de recommandation d’inférence. Définissez le champ `job-type` sur `'Default'` pour les tâches de recommandation d’inférence. En outre, fournissez les éléments suivants :
+ Le nom de ressource Amazon (ARN) d'un rôle IAM qui permet à Amazon SageMaker Inference Recommender d'effectuer des tâches en votre nom. Définissez-le pour le champ `role-arn`.
+ Un ARN de package de modèle ou un nom de modèle. Inference Recommender prend en charge l’ARN d’un package de modèle ou un nom de modèle en entrée. Spécifiez l’un des éléments suivants :
+ L’ARN du package de modèle versionné que vous avez créé lorsque vous avez enregistré votre modèle dans le registre de modèles. Définissez-le pour `ModelPackageVersionArn` dans le champ `input-config`.
+ Le nom du modèle que vous avez créé. Définissez-le pour `ModelName` dans le champ `input-config`. Fournissez également le dictionnaire `ContainerConfig`, qui inclut les champs obligatoires qui doivent être fournis avec le nom du modèle. Définissez-le pour `ContainerConfig` dans le champ `input-config`. Dans `ContainerConfig`, vous pouvez également éventuellement spécifier le champ `SupportedEndpointType` comme `RealTime` ou `Serverless`. Si vous spécifiez ce champ, Inference Recommender renvoie des recommandations uniquement pour ce type de point de terminaison. Si vous ne spécifiez pas ce champ, Inference Recommender renvoie des recommandations pour les deux types de point de terminaison.
+ Un nom à votre tâche de recommandation Inference Recommender pour le champ `job-name`. Le nom du poste Inference Recommender doit être unique dans la AWS région et dans votre AWS compte.
Pour créer une tâche de recommandation d’inférence avec l’ARN d’un package de modèle, utilisez l’exemple suivant :
```
aws sagemaker create-inference-recommendations-job
--region \
--job-name \
--job-type Default\
--role-arn arn:aws:iam::\
--input-config "{
\"ModelPackageVersionArn\": \"arn:aws:sagemaker:\",
}"
```
Pour créer une tâche de recommandation d’inférence avec un nom de modèle et `ContainerConfig`, utilisez l’exemple suivant. L’exemple utilise le champ `SupportedEndpointType` pour indiquer que nous voulons uniquement renvoyer des recommandations d’inférence en temps réel :
```
aws sagemaker create-inference-recommendations-job
--region \
--job-name \
--job-type Default\
--role-arn arn:aws:iam::\
--input-config "{
\"ModelName\": \"model-name\",
\"ContainerConfig\" : {
\"Domain\": \"COMPUTER_VISION\",
\"Framework\": \"PYTORCH\",
\"FrameworkVersion\": \"1.7.1\",
\"NearestModelName\": \"resnet18\",
\"PayloadConfig\":
{
\"SamplePayloadUrl\": \"s3://{bucket}/{payload_s3_key}\",
\"SupportedContentTypes\": [\"image/jpeg\"]
},
\"SupportedEndpointType\": \"RealTime\",
\"DataInputConfig\": \"[[1,3,256,256]]\",
\"Task\": \"IMAGE_CLASSIFICATION\",
},
}"
```
------
#### [ Amazon SageMaker Studio Classic ]
Créez une tâche de recommandation d’inférence dans Studio Classic.
1. Dans votre application Studio Classic, choisissez l’icône d’accueil (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Dans la barre latérale gauche de Studio Classic, sélectionnez **Modèles**.
1. Choisissez **Registre de modèles** dans la liste déroulante pour afficher les modèles que vous avez enregistrés dans le registre de modèles.
Le panneau de gauche affiche une liste de groupes de modèles. La liste comprend tous les groupes de modèles enregistrés dans le registre de modèles de votre compte, y compris les modèles enregistrés en dehors de Studio Classic.
1. Sélectionnez le nom de votre groupe de modèles. Lorsque vous sélectionnez votre groupe de modèles, le volet droit de Studio Classic affiche les en-têtes de colonne tels que **Versions** et **Paramètre**.
Si vous avez un ou plusieurs packages de modèle dans votre groupe de modèles, vous voyez la liste de ces packages de modèle dans la colonne **Versions**.
1. Sélectionnez la colonne **Inference Recommender**.
1. Choisissez un rôle IAM qui accorde à Inference Recommender l'autorisation d'accéder aux services. AWS Vous pouvez créer un rôle et attacher la politique gérée IAM `AmazonSageMakerFullAccess` pour y parvenir. Vous pouvez également laisser Studio Classic créer un rôle pour vous.
1. Choisissez **Obtenir des recommandations**.
La recommandation d’inférence peut prendre jusqu’à 45 minutes.
**Avertissement**
Ne fermez pas cet onglet. Si vous fermez cet onglet, la tâche de recommandation d’instance sera annulée.
------
#### [ SageMaker AI console ]
Créez une tâche de recommandation d'instance via la console SageMaker AI en procédant comme suit :
1. Accédez à la console SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Dans le panneau de navigation de gauche, choisissez **Inférence**, puis **Inference Recommender**.
1. Sur la page **Tâches Inference Recommender**, choisissez **Créer une tâche**.
1. Pour **Étape 1 : Configuration du modèle**, procédez comme suit :
1. Pour **Type de tâche**, choisissez **Tâche Recommender par défaut**.
1. Si vous utilisez un modèle enregistré dans le registre des modèles d' SageMaker IA, activez le bouton **Choisir un modèle dans le registre des modèles** et procédez comme suit :
1. Dans la liste déroulante des **groupes de modèles**, choisissez le groupe de modèles dans le registre des modèles SageMaker AI où se trouve votre modèle.
1. Dans la liste déroulante **Version du modèle**, choisissez la version souhaitée de votre modèle.
1. Si vous utilisez un modèle que vous avez créé dans SageMaker AI, désactivez le **bouton Choisir un modèle dans le registre des modèles** et procédez comme suit :
1. Dans le champ **Nom du modèle**, entrez le nom de votre modèle d' SageMaker IA.
1. Dans la liste déroulante des **rôles IAM**, vous pouvez sélectionner un rôle AWS IAM existant disposant des autorisations nécessaires pour créer une tâche de recommandation d'instance. Sinon, si vous n'avez pas de rôle existant, vous pouvez choisir **Créer un nouveau rôle** pour ouvrir la fenêtre contextuelle de création de rôle, et SageMaker AI ajoute les autorisations nécessaires au nouveau rôle que vous créez.
1. Pour **Compartiment S3 destiné à l’analyse comparative des données utiles**, entrez le chemin Amazon S3 vers votre archive d’exemples de données utiles, qui doit contenir des exemples de fichiers de données utiles qu’Inference Recommender utilise pour analyser votre modèle sur différents types d’instances.
1. Pour **Type de contenu des données utiles**, entrez les types MIME pour votre exemple de données utiles.
1. (Facultatif) Si vous avez désactivé le bouton **Choisir un modèle dans le registre des modèles et que** vous avez spécifié un modèle d' SageMaker IA, procédez comme suit pour la **configuration du conteneur** :
1. Dans la liste déroulante **Domaine**, sélectionnez le domaine de machine learning du modèle, tel que la vision par ordinateur, le traitement du langage naturel ou le machine learning.
1. **Dans la liste déroulante Framework**, sélectionnez le framework de votre conteneur, tel que TensorFlow ou XGBoost.
1. Pour **Version de framework**, entrez la version de framework de votre image de conteneur.
1. Dans la liste déroulante **Nom du modèle le plus proche**, sélectionnez le modèle préentraîné qui correspond le plus souvent au vôtre.
1. Dans la liste déroulante **Tâche**, sélectionnez la tâche de machine learning exécutée par le modèle, telle que la classification d’images ou la régression.
1. (Facultatif) Pour la **compilation de modèles à l'aide de SageMaker Neo**, vous pouvez configurer la tâche de recommandation pour un modèle que vous avez compilé à l'aide de SageMaker Neo. Pour **Configuration d’entrée de données**, entrez la forme de données d’entrée correcte pour votre modèle dans un format similaire à `{'input':[1,1024,1024,3]}`.
1. Choisissez **Suivant**.
1. Pour **Étape 2 : Instances et paramètres d’environnement**, procédez comme suit :
1. (Facultatif) Pour **Sélectionner des instances à des fins de comparaison**, vous pouvez sélectionner jusqu’à 8 types d’instances que vous souhaitez comparer. Si vous ne sélectionnez aucune instance, Inference Recommender prend en compte tous les types d’instances.
1. Choisissez **Suivant**.
1. Pour **Étape 3 : Paramètres de tâche**, procédez comme suit :
1. (Facultatif) Dans le champ **Nom de la tâche**, entrez le nom de la tâche de recommandation de votre instance. Lorsque vous créez la tâche, SageMaker AI ajoute un horodatage à la fin de ce nom.
1. (Facultatif) Dans le champ **Description de la tâche**, entrez une brève description de la tâche.
1. (Facultatif) Dans la liste déroulante des **clés de chiffrement**, choisissez une AWS KMS clé par son nom ou entrez son ARN pour chiffrer vos données.
1. (Facultatif) Pour **Durée (s) maximale (s) de test**, entrez le nombre maximal de secondes pendant lequel vous souhaitez que chaque test s’exécute.
1. (Facultatif) Pour **Invocations par minute**, entrez le nombre maximal de demandes par minute que le point de terminaison peut atteindre avant d’arrêter la tâche de recommandation. Une fois cette limite atteinte, l' SageMaker IA met fin au travail.
1. (Facultatif) Pour **Seuil de latence du modèle P99 (ms)**, entrez le percentile de latence du modèle en millisecondes.
1. Choisissez **Suivant**.
1. Pour **Étape 4 : Vérification de la tâche**, passez en revue vos configurations, puis choisissez **Soumettre**.
------
# Obtention des résultats de votre tâche de recommandation d’inférence
Collectez les résultats de votre tâche de recommandation d'inférence par programmation à l' AWS CLI aide AWS SDK pour Python (Boto3) de Studio Classic ou de la SageMaker console AI.
------
#### [ AWS SDK pour Python (Boto3) ]
Une fois qu’une recommandation d’inférence est terminée, vous pouvez utiliser `DescribeInferenceRecommendationsJob` pour obtenir les détails de la tâche et les recommandations. Fournissez le nom de tâche que vous avez utilisé lorsque vous avez créé la tâche de recommandation d’inférence.
```
job_name=''
response = sagemaker_client.describe_inference_recommendations_job(
JobName=job_name)
```
Imprimez l’objet de réponse. L’exemple de code précédent a stocké la réponse dans une variable appelée `response`.
```
print(response['Status'])
```
Cela renvoie une réponse JSON semblable à l’exemple suivant. Notez que cet exemple montre les types d’instances recommandés pour l’inférence en temps réel (pour un exemple illustrant les recommandations d’inférence sans serveur, consultez l’exemple suivant celui-ci).
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Default',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 20, 4, 57, 627000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 20, 25, 1, 997000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 0
},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.20399999618530273,
'CostPerInference': 5.246913588052848e-06,
'MaximumInvocations': 648,
'ModelLatency': 263596
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5.xlarge',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 2.92620870823157e-06,
'MaximumInvocations': 655,
'ModelLatency': 826019
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 3.3625731248321244e-06,
'MaximumInvocations': 570,
'ModelLatency': 1085446
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.m5.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1685',
'date': 'Tue, 26 Oct 2021 20:31:10 GMT'
},
'RetryAttempts': 0
}
}
```
Les premières lignes fournissent des informations sur la tâche de recommandation d’inférence elle-même. Celles-ci incluent le nom de la tâche, l’ARN du rôle et les heures de création et de suppression.
Le dictionnaire `InferenceRecommendations` contient une liste de recommandations d’inférences Inference Recommender.
Le dictionnaire `EndpointConfiguration` imbriqué contient la recommandation du type d'instance (`InstanceType`) ainsi que le nom du point de terminaison et de la variante (un modèle d'apprentissage AWS automatique déployé) qui ont été utilisés lors de la tâche de recommandation. Vous pouvez utiliser le nom du point de terminaison et de la variante pour la surveillance dans Amazon CloudWatch Events. Pour plus d’informations, consultez [Métriques Amazon SageMaker AI sur Amazon CloudWatch](monitoring-cloudwatch.md).
Le dictionnaire `Metrics` imbriqué contient des informations sur le coût horaire estimé (`CostPerHour`) pour votre point de terminaison en temps réel en dollars américains, le coût estimé par inférence (`CostPerInference`) en dollars américains pour votre point de terminaison en temps réel, le nombre maximum attendu de `InvokeEndpoint` demandes par minute envoyées au point de terminaison (`MaxInvocations`) et la latence du modèle (`ModelLatency`), qui est l'intervalle de temps (en microsecondes) que votre modèle a mis pour répondre à l'IA. SageMaker La latence du modèle inclut le temps de communication local pris pour envoyer la requête et pour récupérer la réponse du conteneur d’un modèle et le temps nécessaire pour terminer l’inférence dans le conteneur.
L’exemple suivant montre la partie `InferenceRecommendations` de la réponse pour une tâche de recommandation d’inférence configurée pour renvoyer des recommandations d’inférence sans serveur :
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
Vous pouvez interpréter les recommandations pour l’inférence sans serveur de la même manière que les résultats pour l’inférence en temps réel, à l’exception de `ServerlessConfig`, qui vous indique les métriques renvoyées pour un point de terminaison sans serveur avec la `MemorySizeInMB` donnée et quand `MaxConcurrency = 1`. Pour augmenter le débit possible sur le point de terminaison, augmentez la valeur de `MaxConcurrency` de façon linéaire. Par exemple, si la recommandation d’inférence affiche `MaxInvocations` comme `1000`, l’augmentation de `MaxConcurrency` à `2` prendrait en compte 2 000 `MaxInvocations`. Notez que cela n’est vrai que jusqu’à un certain point, qui peut varier en fonction de votre modèle et de votre code. Les recommandations sans serveur mesurent également la métrique `ModelSetupTime`, qui mesure (en microsecondes) le temps nécessaire au lancement des ressources informatiques sur un point de terminaison sans serveur. Pour plus d’informations sur la configuration des points de terminaison sans serveur, consultez la [documentation Inférence sans serveur](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
------
#### [ AWS CLI ]
Une fois qu’une recommandation d’inférence est terminée, vous pouvez utiliser `describe-inference-recommendations-job` pour obtenir les détails de la tâche et les types d’instances recommandés. Fournissez le nom de tâche que vous avez utilisé lorsque vous avez créé la tâche de recommandation d'inférence.
```
aws sagemaker describe-inference-recommendations-job\
--job-name \
--region
```
La réponse JSON similaire doit ressembler à l’exemple suivant. Notez que cet exemple montre les types d'instances recommandés pour l'inférence en temps réel (pour un exemple illustrant les recommandations d'inférence sans serveur, consultez l'exemple suivant celui-ci).
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Default',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 20, 4, 57, 627000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 20, 25, 1, 997000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 0
},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.20399999618530273,
'CostPerInference': 5.246913588052848e-06,
'MaximumInvocations': 648,
'ModelLatency': 263596
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5.xlarge',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 2.92620870823157e-06,
'MaximumInvocations': 655,
'ModelLatency': 826019
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 3.3625731248321244e-06,
'MaximumInvocations': 570,
'ModelLatency': 1085446
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.m5.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1685',
'date': 'Tue, 26 Oct 2021 20:31:10 GMT'
},
'RetryAttempts': 0
}
}
```
Les premières lignes fournissent des informations sur la tâche de recommandation d'inférence elle-même. Celles-ci incluent le nom de la tâche, l’ARN du rôle, l’heure de création et de suppression.
Le dictionnaire `InferenceRecommendations` contient une liste de recommandations d’inférences Inference Recommender.
Le dictionnaire `EndpointConfiguration` imbriqué contient la recommandation du type d'instance (`InstanceType`) ainsi que le nom du point de terminaison et de la variante (un modèle d'apprentissage AWS automatique déployé) utilisés lors de la tâche de recommandation. Vous pouvez utiliser le nom du point de terminaison et de la variante pour la surveillance dans Amazon CloudWatch Events. Pour plus d’informations, consultez [Métriques Amazon SageMaker AI sur Amazon CloudWatch](monitoring-cloudwatch.md).
Le dictionnaire `Metrics` imbriqué contient des informations sur le coût horaire estimé (`CostPerHour`) pour votre point de terminaison en temps réel en dollars américains, le coût estimé par inférence (`CostPerInference`) en dollars américains pour votre point de terminaison en temps réel, le nombre maximum attendu de `InvokeEndpoint` demandes par minute envoyées au point de terminaison (`MaxInvocations`) et la latence du modèle (`ModelLatency`), qui est l'intervalle de temps (en millisecondes) nécessaire à votre modèle pour répondre à l'IA. SageMaker La latence du modèle inclut le temps de communication local pris pour envoyer la requête et pour récupérer la réponse du conteneur d’un modèle et le temps nécessaire pour terminer l’inférence dans le conteneur.
L’exemple suivant montre la partie `InferenceRecommendations` de la réponse pour une tâche de recommandation d’inférence configurée pour renvoyer des recommandations d’inférence sans serveur :
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
Vous pouvez interpréter les recommandations pour l’inférence sans serveur de la même manière que les résultats pour l’inférence en temps réel, à l’exception de `ServerlessConfig`, qui vous indique les métriques renvoyées pour un point de terminaison sans serveur avec la `MemorySizeInMB` donnée et quand `MaxConcurrency = 1`. Pour augmenter le débit possible sur le point de terminaison, augmentez la valeur de `MaxConcurrency` de façon linéaire. Par exemple, si la recommandation d’inférence affiche `MaxInvocations` comme `1000`, l’augmentation de `MaxConcurrency` à `2` prendrait en compte 2 000 `MaxInvocations`. Notez que cela n’est vrai que jusqu’à un certain point, qui peut varier en fonction de votre modèle et de votre code. Les recommandations sans serveur mesurent également la métrique `ModelSetupTime`, qui mesure (en microsecondes) le temps nécessaire au lancement des ressources informatiques sur un point de terminaison sans serveur. Pour plus d’informations sur la configuration des points de terminaison sans serveur, consultez la [documentation Inférence sans serveur](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
------
#### [ Amazon SageMaker Studio Classic ]
Les recommandations d’inférence sont renseignées dans un nouvel onglet **Recommandations d’inférence** dans Studio Classic. L’affichage des résultats peut prendre jusqu’à 45 minutes. Cet onglet contient les en-têtes des colonnes **Results** (Résultats) et **Details** (Détails).
La colonne **Détails** fournit des informations sur la tâche de recommandation d’inférence, telles que le nom de la recommandation d’inférence, la date de création de la tâche (**Heure de création**), etc. Elle fournit également des informations sur les **Settings** (Paramètres), telles que le nombre maximal d’invocations qui se sont produits par minute et des informations sur les Amazon Resource Names utilisés.
La colonne **Résultats** fournit une fenêtre d'**objectifs de déploiement** et de **recommandations d'SageMaker IA** dans laquelle vous pouvez ajuster l'ordre d'affichage des résultats en fonction de l'importance du déploiement. Il existe trois menus déroulants que vous pouvez utiliser pour fournir le niveau d’importance du **Coût**, de la **Latence** et du **Débit** pour votre cas d’utilisation. Pour chaque objectif (coût, latence et débit), vous pouvez définir le niveau d'importance : **Lowest Importance** (Importance la plus faible), **Low Importance** (Importance faible), **Moderate importance** (Importance modérée), **High importance** (Importance élevée) ou **Highest importance** (Importance la plus élevée).
En fonction de l'importance que vous avez sélectionnée pour chaque objectif, Inference Recommender affiche sa principale recommandation dans le champ de **SageMakerrecommandation** situé à droite du panneau, ainsi que le coût horaire estimé et la demande d'inférence. Il fournit également des informations sur la latence attendue du modèle, le nombre maximal d’invocations et le nombre d’instances. Pour les recommandations sans serveur, vous pouvez voir les valeurs idéales pour la simultanéité maximale et la taille de mémoire du point de terminaison.
En plus de la recommandation principale affichée, vous pouvez également voir les mêmes informations affichées pour toutes les instances testées par l’outil de recommandation d’inférence dans la section **Toutes les exécutions**.
------
#### [ SageMaker AI console ]
Vous pouvez consulter les tâches de recommandation de votre instance dans la console SageMaker AI en procédant comme suit :
1. Accédez à la console SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Dans le panneau de navigation de gauche, choisissez **Inférence**, puis **Inference Recommender**.
1. Sur la page **Tâches Inference Recommender**, choisissez le nom de votre tâche de recommandation d’inférence.
Sur la page de détails de votre tâche, vous pouvez consulter les **recommandations d'inférence**, qui sont les types d'instances recommandés par l' SageMaker IA pour votre modèle, comme indiqué dans la capture d'écran suivante.
![\[Capture d'écran de la liste des recommandations d'inférence sur la page des détails de la tâche dans la console SageMaker AI.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inf-rec-instant-recs.png)
Dans cette section, vous pouvez comparer les types d’instances en fonction de différents facteurs tels que la **Latence du modèle**, le **Coût horaire**, le **Coût par inférence** et les **Invocations par minute**.
Sur cette page, vous pouvez également afficher les configurations que vous avez spécifiées pour votre tâche. Dans la section **Monitor**, vous pouvez consulter les CloudWatch métriques Amazon enregistrées pour chaque type d'instance. Pour en savoir plus sur l’interprétation de ces métriques, consultez [Interprétation des résultats](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-interpret-results.html).
------
Pour plus d’informations sur l’interprétation des résultats de votre tâche de recommandation, consultez [Résultats des recommandations](inference-recommender-interpret-results.md).
# Obtention d’une recommandation d’inférence pour un point de terminaison existant
Les tâches de recommandation d’inférence exécutent un ensemble de tests de charge sur les types d’instance recommandés et le point de terminaison existant. Les tâches de recommandation d’inférence utilisent des métriques de performance basées sur des tests de charge utilisant les exemples de données que vous avez fournis lors de l’enregistrement de la version du modèle.
Vous pouvez comparer et obtenir des recommandations d'inférence pour un point de terminaison SageMaker AI Inference existant afin de vous aider à améliorer les performances de votre point de terminaison. La procédure d'obtention de recommandations pour un point de terminaison SageMaker AI Inference existant est similaire à la procédure d'[obtention de recommandations d'inférence](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-instance-recommendation.html) sans point de terminaison. Il existe plusieurs exclusions de caractéristiques à prendre en compte lors de l’analyse comparative d’un point de terminaison existant :
+ Vous ne pouvez utiliser qu’un seul point de terminaison existant par tâche Inference Recommender.
+ Vous ne pouvez avoir qu’une seule variante sur votre point de terminaison.
+ Vous ne pouvez pas utiliser un point de terminaison qui active la mise à l’échelle automatique.
+ Cette fonctionnalité n’est prise en charge que pour l’[Inférence en temps réel](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html).
+ Cette fonction ne prend pas en charge [Real-Time Multi-Model Endpoints](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) (Points de terminaison multi-modèles en temps réel).
**Avertissement**
Nous vous déconseillons fortement d’exécuter une tâche Inference Recommender sur un point de terminaison de production qui gère le trafic réel. La charge synthétique lors de l’analyse comparative peut affecter votre point de terminaison de production et provoquer des limitations ou fournir des résultats d’évaluation inexacts. Nous vous recommandons d’utiliser un point de terminaison externe à la production ou de développement à des fins de comparaison.
Les sections suivantes montrent comment utiliser Amazon SageMaker Inference Recommender pour créer une recommandation d'inférence pour un point de terminaison existant en fonction de votre type de modèle à l'aide du AWS SDK pour Python (Boto3) et du. AWS CLI
**Note**
Avant de créer une tâche de recommandation Inference Recommender, assurez-vous que les [Conditions préalables à l'utilisation d'Amazon SageMaker Inference Recommender](inference-recommender-prerequisites.md) sont satisfaits.
## Conditions préalables
Si vous ne possédez pas encore de point de terminaison SageMaker AI Inference, vous pouvez soit [obtenir une recommandation d'inférence](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-instance-recommendation.html) sans point de terminaison, soit créer un point de terminaison d'inférence en temps réel en suivant les instructions de la section [Création de votre point de terminaison et déploiement de votre](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html) modèle.
## Création d’une tâche de recommandation d’inférence pour un point de terminaison existant
Créez une recommandation d'inférence par programmation à l'aide de AWS SDK pour Python (Boto3), ou du. AWS CLI Spécifiez un nom de tâche pour votre recommandation d'inférence, le nom d'un point de terminaison SageMaker AI Inference existant, un ARN de AWS rôle IAM, une configuration d'entrée et l'ARN de votre package de modèles à partir du moment où vous avez enregistré votre modèle dans le registre des modèles.
------
#### [ AWS SDK pour Python (Boto3) ]
Utilisez l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html) pour obtenir une recommandation d’inférence. Définissez le champ `JobType` sur `'Default'` pour les tâches de recommandation d'inférence. En outre, fournissez les éléments suivants :
+ Donnez un nom à votre tâche de recommandation Inference Recommender pour le champ `JobName`. Le nom du poste Inference Recommender doit être unique dans la AWS région et dans votre AWS compte.
+ L’Amazon Resource Name (ARN) d’un rôle IAM qui permet à Inference Recommender d’effectuer des tâches en votre nom. Définissez-le pour le champ `RoleArn`.
+ L’ARN du package de modèle versionné que vous avez créé lorsque vous avez enregistré votre modèle auprès du registre de modèles. Définissez-le pour `ModelPackageVersionArn` dans le champ `InputConfig`.
+ Indiquez le nom d'un point de terminaison SageMaker AI Inference existant que vous souhaitez comparer dans Inference Recommender sur le terrain`Endpoints`. `InputConfig`
Importez le AWS SDK pour Python (Boto3) package et créez un objet client SageMaker AI à l'aide de la classe client. Si vous avez suivi les étapes de la section **Prerequisites** (Prérequis), l’ARN du groupe de packages de modèle a été stocké dans une variable nommée `model_package_arn`.
```
# Create a low-level SageMaker service client.
import boto3
aws_region = ''
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Provide your model package ARN that was created when you registered your
# model with Model Registry
model_package_arn = ''
# Provide a unique job name for SageMaker Inference Recommender job
job_name = ''
# Inference Recommender job type. Set to Default to get an initial recommendation
job_type = 'Default'
# Provide an IAM Role that gives SageMaker Inference Recommender permission to
# access AWS services
role_arn = ':role/*>'
# Provide endpoint name for your endpoint that want to benchmark in Inference Recommender
endpoint_name = ''
sagemaker_client.create_inference_recommendations_job(
JobName = job_name,
JobType = job_type,
RoleArn = role_arn,
InputConfig = {
'ModelPackageVersionArn': model_package_arn,
'Endpoints': [{'EndpointName': endpoint_name}]
}
)
```
Consultez le [guide de référence des SageMaker API Amazon](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html) pour obtenir la liste complète des arguments facultatifs et obligatoires auxquels vous pouvez passer [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html).
------
#### [ AWS CLI ]
Utilisez l’API `create-inference-recommendations-job` pour obtenir une recommandation de point de terminaison d’instance. Définissez le champ `job-type` sur `'Default'` pour les tâches de recommandation de point de terminaison d’instance. En outre, fournissez les éléments suivants :
+ Donnez un nom à votre tâche de recommandation Inference Recommender pour le champ `job-name`. Le nom du poste Inference Recommender doit être unique dans la AWS région et dans votre AWS compte.
+ Le nom de ressource Amazon (ARN) d'un rôle IAM qui permet à Amazon SageMaker Inference Recommender d'effectuer des tâches en votre nom. Définissez-le pour le champ `role-arn`.
+ L’ARN du package de modèle versionné que vous avez créé lorsque vous avez enregistré votre modèle dans le registre de modèles. Définissez-le pour `ModelPackageVersionArn` dans le champ `input-config`.
+ Indiquez le nom d'un point de terminaison SageMaker AI Inference existant que vous souhaitez comparer dans Inference Recommender sur le terrain`Endpoints`. `input-config`
```
aws sagemaker create-inference-recommendations-job
--region \
--job-name \
--job-type Default\
--role-arn arn:aws:iam::\
--input-config "{
\"ModelPackageVersionArn\": \"arn:aws:sagemaker:\",
\"Endpoints\": [{\"EndpointName\": }]
}"
```
------
## Obtention des résultats de votre tâche de recommandation d'inférence
Vous pouvez collecter les résultats de votre tâche de recommandation d’inférence par programmation avec la même procédure que pour les tâches de recommandation d’inférence standard. Pour de plus amples informations, veuillez consulter [Obtention des résultats de votre tâche de recommandation d’inférence](instance-recommendation-results.md).
Lorsque vous obtenez les résultats d’une tâche de recommandation d’inférence pour un point de terminaison existant, vous devez recevoir une réponse JSON similaire à la suivante :
```
{
"JobName": "job-name",
"JobType": "Default",
"JobArn": "arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id",
"RoleArn": "iam-role-arn",
"Status": "COMPLETED",
"CreationTime": 1664922919.2,
"LastModifiedTime": 1664924208.291,
"InputConfig": {
"ModelPackageVersionArn": "arn:aws:sagemaker:region:account-id:model-package/resource-id",
"Endpoints": [
{
"EndpointName": "endpoint-name"
}
]
},
"InferenceRecommendations": [
{
"Metrics": {
"CostPerHour": 0.7360000014305115,
"CostPerInference": 7.456940238625975e-06,
"MaxInvocations": 1645,
"ModelLatency": 171
},
"EndpointConfiguration": {
"EndpointName": "sm-endpoint-name",
"VariantName": "variant-name",
"InstanceType": "ml.g4dn.xlarge",
"InitialInstanceCount": 1
},
"ModelConfiguration": {
"EnvironmentParameters": [
{
"Key": "TS_DEFAULT_WORKERS_PER_MODEL",
"ValueType": "string",
"Value": "4"
}
]
}
}
],
"EndpointPerformances": [
{
"Metrics": {
"MaxInvocations": 184,
"ModelLatency": 1312
},
"EndpointConfiguration": {
"EndpointName": "endpoint-name"
}
}
]
}
```
Les premières lignes fournissent des informations sur la tâche de recommandation d'inférence elle-même. Celles-ci incluent le nom de la tâche, l’ARN du rôle et les dernières heures de création et de modification.
Le dictionnaire `InferenceRecommendations` contient une liste de recommandations d'inférences Inference Recommender.
Le dictionnaire `EndpointConfiguration` imbriqué contient la recommandation du type d'instance (`InstanceType`) ainsi que le nom du point de terminaison et de la variante (un modèle d'apprentissage AWS automatique déployé) qui ont été utilisés lors de la tâche de recommandation.
Le dictionnaire `Metrics` imbriqué contient des informations sur le coût horaire estimé (`CostPerHour`) pour votre point de terminaison en temps réel en dollars américains, le coût estimé par inférence (`CostPerInference`) en dollars américains pour votre point de terminaison en temps réel, le nombre maximum attendu de `InvokeEndpoint` demandes par minute envoyées au point de terminaison (`MaxInvocations`) et la latence du modèle (`ModelLatency`), qui est l'intervalle de temps (en millisecondes) nécessaire à votre modèle pour répondre à l'IA. SageMaker La latence du modèle inclut le temps de communication local pris pour envoyer la requête et pour récupérer la réponse du conteneur d’un modèle et le temps nécessaire pour terminer l’inférence dans le conteneur.
Le dictionnaire imbriqué `EndpointPerformances` contient le nom de votre point de terminaison existant sur lequel la tâche de recommandation a été exécutée (`EndpointName`) et les métriques de performance de votre point de terminaison (`MaxInvocations` et `ModelLatency`).
# Arrêt de votre recommandation d’inférence
Vous souhaiterez peut-être arrêter une tâche en cours d’exécution si vous l’avez démarrée par erreur ou si vous n’avez plus besoin de l’exécuter. Arrêtez vos tâches de recommandation d’inférence Inference Recommender par programmation avec l’API `StopInferenceRecommendationsJob` ou avec Studio Classic.
------
#### [ AWS SDK pour Python (Boto3) ]
Spécifiez le nom de la tâche de recommandation d’inférence pour le champ `JobName` :
```
sagemaker_client.stop_inference_recommendations_job(
JobName=''
)
```
------
#### [ AWS CLI ]
Spécifiez le nom de la tâche de recommandation d’inférence pour l’indicateur `job-name` :
```
aws sagemaker stop-inference-recommendations-job --job-name
```
------
#### [ Amazon SageMaker Studio Classic ]
Fermez l’onglet dans lequel vous avez lancé la recommandation d’inférence pour arrêter votre recommandation d’inférence Inference Recommender.
------
#### [ SageMaker AI console ]
Pour arrêter votre tâche de recommandation d'instance via la console SageMaker AI, procédez comme suit :
1. Accédez à la console SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Dans le panneau de navigation de gauche, choisissez **Inférence**, puis **Inference Recommender**.
1. Sur la page **Tâches Inference Recommender**, sélectionnez la tâche de recommandation de votre instance.
1. Choisissez **Arrêter la tâche**.
1. Dans la boîte de dialogue qui s’affiche, choisissez **Confirmer**.
Après avoir arrêté votre tâche, le **Statut** de la tâche devrait passer à **Arrêt en cours**.
------
# Recommandations compilées avec Neo
Dans Inference Recommender, vous pouvez compiler votre modèle avec Neo et obtenir des recommandations de points de terminaison pour votre modèle compilé. [SageMaker Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) est un service qui permet d'optimiser votre modèle pour une plate-forme matérielle cible (c'est-à-dire un type d'instance ou un environnement spécifique). L’optimisation d’un modèle avec Neo peut améliorer les performances de votre modèle hébergé.
Pour les conteneurs et les frameworks pris en charge par Neo, Inference Recommender suggère automatiquement des recommandations optimisées par Neo. Pour être éligible à la compilation Neo, votre entrée doit remplir les conditions préalables suivantes :
+ Vous utilisez un [DLC](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) ou un XGBoost conteneur appartenant à l' SageMaker IA.
+ Vous utilisez une version de framework prise en charge par Neo. Pour les versions du framework prises en charge par Neo, consultez [Instances cloud](neo-supported-cloud.md#neo-supported-cloud-instances) la documentation de SageMaker Neo.
+ Neo exige que vous fournissiez une forme de données d’entrée correcte pour votre modèle. Vous pouvez spécifier cette forme de données en tant que `[DataInputConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelInput.html#sagemaker-Type-ModelInput-DataInputConfig)` dans `[InferenceSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-InferenceSpecification)` lorsque vous créez un package de modèle. Pour plus d'informations sur les formes de données correctes pour chaque framework, voir [Préparer le modèle pour la compilation](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-compilation-preparing-model.html) dans la documentation SageMaker Neo.
L’exemple suivant montre comment spécifier le champ `DataInputConfig` dans `InferenceSpecification`, où `data_input_configuration` est une variable qui contient la forme de données dans un format dictionnaire (par exemple, `{'input':[1,1024,1024,3]}`).
```
"InferenceSpecification": {
"Containers": [
{
"Image": dlc_uri,
"Framework": framework.upper(),
"FrameworkVersion": framework_version,
"NearestModelName": model_name,
"ModelInput": {"DataInputConfig": data_input_configuration},
}
],
"SupportedContentTypes": input_mime_types, # required, must be non-null
"SupportedResponseMIMETypes": [],
"SupportedRealtimeInferenceInstanceTypes": supported_realtime_inference_types, # optional
}
```
Si ces conditions sont remplies dans votre demande, Inference Recommender exécute des scénarios pour les versions compilées et non compilées de votre modèle, vous offrant ainsi plusieurs combinaisons de recommandations parmi lesquelles choisir. Vous pouvez comparer les configurations des versions compilées et non compilées de la même recommandation d’inférence et déterminer celle qui convient le mieux à votre cas d’utilisation. Les recommandations sont classées en fonction de leur coût par inférence.
Pour obtenir les recommandations de compilation Neo, vous n’avez pas à effectuer de configuration supplémentaire en plus de veiller à ce que votre entrée répond aux exigences qui précèdent. Inference Recommender exécute automatiquement la compilation Neo sur votre modèle si votre entrée répond aux exigences et vous recevez une réponse incluant les recommandations Neo.
Si vous rencontrez des erreurs au cours de la compilation Neo, consultez [Résolution des erreurs de compilation Neo](neo-troubleshooting-compilation.md).
Le tableau suivant est un exemple de réponse que vous pouvez obtenir à partir d’une tâche Inference Recommender, qui inclut des recommandations pour les modèles compilés. Si le champ `InferenceSpecificationName` a pour valeur `None`, la recommandation est un modèle non compilé. La dernière ligne, dans laquelle se trouve la valeur du **InferenceSpecificationName**champ`neo-00011122-2333-4445-5566-677788899900`, correspond à un modèle compilé avec Neo. La valeur du champ est le nom de la tâche Neo utilisée pour compiler et optimiser votre modèle.
| EndpointName | InstanceType | InitialInstanceCount | EnvironmentParameters | CostPerHour | CostPerInference | MaxInvocations | ModelLatency | InferenceSpecificationName |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| sm-epc-example-000111222 | ml.c5.9xlarge | 1 | [] | 1,836 | 9,15E-07 | 33456 | 7 | Aucune |
| sm-epc-example-111222333 | ml.c5.2xlarge | 1 | [] | 0,408 | 2,11E-07 | 32211 | 21 | Aucune |
| sm-epc-example-222333444 | ml.c5.xlarge | 1 | [] | 0,204 | 1,86E-07 | 18276 | 92 | Aucune |
| sm-epc-example-333444555 | ml.c5.xlarge | 1 | [] | 0,204 | 1,60E-07 | 21286 | 42 | neo-00011122-2333-4445-5566-677788899900 |
## Mise en route
Les étapes générales pour créer une tâche Inference Recommender qui inclut des recommandations optimisées par Neo sont les suivantes :
+ Préparez votre modèle de machine learning pour la compilation. Pour plus d’informations, consultez [Préparation d’un modèle pour la compilation](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-compilation-preparing-model.html) dans la documentation sur Neo.
+ Empaquetez votre modèle dans une archive de modèle (fichier `.tar.gz`).
+ Créez un exemple d’archive de données utiles.
+ Enregistrez votre modèle dans le SageMaker Model Registry.
+ Créez une tâche Inference Recommender.
+ Affichez les résultats de la tâche Inference Recommender et choisissez une configuration.
+ Déboguez les échecs de compilation, le cas échéant Pour plus d’informations, consultez [Résolution des erreurs de compilation Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting-compilation.html).
Pour un exemple illustrant le flux de travail précédent et expliquant comment obtenir des recommandations optimisées pour Neo XGBoost, consultez l'[exemple de bloc-notes](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/xgboost/xgboost-inference-recommender.ipynb) suivant. Pour un exemple montrant comment obtenir des recommandations optimisées pour Neo à l'aide de Neo TensorFlow, consultez l'[exemple de bloc-notes](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/inference-recommender.ipynb) suivant.
# Résultats des recommandations
Le résultat de chaque tâche Inference Recommender inclut `InstanceType`, `InitialInstanceCount` et `EnvironmentParameters`, qui sont des paramètres de variables d’environnement ajustés pour votre conteneur afin d’améliorer sa latence et son débit. Les résultats incluent également des métriques de performances et de coûts telles que `MaxInvocations`, `ModelLatency`, `CostPerHour`, `CostPerInference`, `CpuUtilization` et `MemoryUtilization`.
Dans le tableau ci-dessous, nous fournissons une description de ces métriques. Ces métriques peuvent vous aider à affiner votre recherche pour trouver la configuration de point de terminaison la mieux adaptée à votre cas d’utilisation. Par exemple, si votre motivation est la performance globale en termes de prix en mettant l’accent sur le débit, vous devez vous concentrer sur `CostPerInference`.
| Métrique | Description | Cas d’utilisation |
| --- | --- | --- |
| `ModelLatency` | Intervalle de temps nécessaire à un modèle pour répondre tel qu'il est vu par l' SageMaker IA. Cet intervalle inclut le temps de communication local pris pour envoyer la requête et pour récupérer la réponse du conteneur d’un modèle et le temps nécessaire pour terminer l’inférence dans le conteneur. Unités : millisecondes | Charges de travail sensibles à la latence, telles que la diffusion d’annonces et les diagnostics médicaux |
| `MaximumInvocations` | Le nombre maximum de demandes `InvokeEndpoint` envoyées à un point de terminaison de modèle en une minute. Unités : aucune | Charges de travail axées sur le débit, telles que le traitement vidéo ou l’inférence par lots |
| `CostPerHour` | Le coût horaire estimé pour votre point de terminaison en temps réel. Unités : dollars américains | Charges de travail sensibles aux coûts sans délais de latence |
| `CostPerInference` | Le coût horaire estimé par appel d’inférence pour votre point de terminaison en temps réel. Unités : dollars américains | Optimiser le rapport prix-performance global en mettant l’accent sur le débit |
| `CpuUtilization` | Utilisation prévue du processeur pour un nombre maximal d’appels par minute pour l’instance de point de terminaison. Unités : pourcentage | Comprendre l’état de santé de l’instance lors de l’analyse comparative en ayant une visibilité sur l’utilisation du processeur principal de l’instance |
| `MemoryUtilization` | Utilisation prévue de la mémoire pour un nombre maximal d’appels par minute pour l’instance de point de terminaison. Unités : pourcentage | Comprendre l’état de santé de l’instance lors de l’analyse comparative en ayant une visibilité sur l’utilisation de la mémoire principale de l’instance |
Dans certains cas, vous souhaiterez peut-être explorer d'autres [métriques SageMaker AI Endpoint Invocation](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-endpoint-invocation), telles que`CPUUtilization`. Les résultats de chaque tâche Inference Recommender incluent les noms des points de terminaison générés lors du test de charge. Vous pouvez l'utiliser CloudWatch pour consulter les journaux de ces points de terminaison même après leur suppression.
L'image suivante est un exemple de CloudWatch mesures et de graphiques que vous pouvez consulter pour un seul point de terminaison à partir du résultat de vos recommandations. Le résultat de cette recommandation provient d’une tâche par défaut. Pour interpréter les valeurs scalaires à partir des résultats des recommandations, elles sont basées sur le moment où le graphe Invocations commence à se stabiliser pour la première fois. Par exemple, la valeur `ModelLatency` signalée se trouve au début du plateau autour de `03:00:31`.
![\[Graphiques pour CloudWatch les métriques.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inference-recommender-cw-metrics.png)
Pour une description complète des CloudWatch métriques utilisées dans les graphiques précédents, voir [SageMaker AI Endpoint Invocation metrics](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-endpoint-invocation).
Vous pouvez également consulter les métriques de performances telles que `ClientInvocations` et `NumberOfUsers` publiées par Inference Recommender dans l’espace de noms `/aws/sagemaker/InferenceRecommendationsJobs`. Pour obtenir la liste complète des métriques et des descriptions publiées par Inference Recommender, consultez [SageMaker Indicateurs des emplois Inference Recommender](monitoring-cloudwatch.md#cloudwatch-metrics-inference-recommender).
Consultez le bloc-notes [Amazon SageMaker Inference Recommender - CloudWatch Metrics](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/tensorflow-cloudwatch/tf-cloudwatch-inference-recommender.ipynb) Jupyter dans le référentiel [amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples)Github pour découvrir comment utiliser le AWS SDK pour Python (Boto3) afin d'explorer les métriques de vos points de terminaison. CloudWatch
# Obtention de recommandations en matière de politique de mise à l’échelle automatique
Avec Amazon SageMaker Inference Recommender, vous pouvez obtenir des recommandations concernant les politiques de mise à l'échelle automatique de votre point de terminaison d' SageMaker IA en fonction de votre schéma de trafic prévu. Si vous avez déjà effectué une tâche de recommandation d’inférence, vous pouvez fournir les détails de la tâche afin d’obtenir une recommandation pour une politique de mise à l’échelle automatique que vous pouvez appliquer à votre point de terminaison.
Inference Recommender compare différentes valeurs pour chaque métrique afin de déterminer la configuration de mise à l’échelle automatique idéale pour votre point de terminaison. La recommandation de mise à l’échelle automatique renvoie une politique de mise à l’échelle automatique recommandée pour chaque métrique définie dans votre tâche de recommandation d’inférence. Vous pouvez enregistrer les politiques et les appliquer à votre terminal à l'aide de l'[PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)API.
Pour commencer, consultez les conditions préalables suivantes.
## Conditions préalables
Avant de commencer, vous devez avoir terminé avec succès une tâche de recommandation d’inférence. Dans la section suivante, vous pouvez fournir un ID de recommandation d'inférence ou le nom d'un point de terminaison d' SageMaker IA qui a été comparé lors d'une tâche de recommandation d'inférence.
Pour récupérer l'ID de votre tâche de recommandation ou le nom de votre point de terminaison, vous pouvez soit consulter les détails de votre tâche de recommandation d'inférence dans la console SageMaker AI, soit utiliser les `EndpointName` champs `RecommendationId` ou renvoyés par l'[DescribeInferenceRecommendationsJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeInferenceRecommendationsJob.html)API.
## Création d’une recommandation de configuration de mise à l’échelle automatique
Pour créer une politique de recommandation de mise à l’échelle automatique, vous pouvez utiliser le kit AWS SDK pour Python (Boto3).
L'exemple suivant montre les champs de l'[ GetScalingConfigurationRecommendation](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_GetScalingConfigurationRecommendation.html)API. Utilisez les champs suivants lorsque vous appelez l’API :
+ `InferenceRecommendationsJobName` : entrez le nom de votre tâche de recommandation d’inférence.
+ `RecommendationId` : entrez l’ID d’une recommandation d’inférence issue d’une tâche de recommandation. Ceci est facultatif si vous avez spécifié le champ `EndpointName`.
+ `EndpointName` : entrez le nom d’un point de terminaison qui a été comparé lors d’une tâche de recommandation d’inférence. Ceci est facultatif si vous avez spécifié le champ `RecommendationId`.
+ `TargetCpuUtilizationPerCore` : (facultatif) entrez une valeur en pourcentage du taux d’utilisation que vous souhaitez qu’une instance de votre point de terminaison utilise avant la mise à l’échelle automatique. La valeur par défaut si vous ne spécifiez pas ce champ est de 50 %.
+ `ScalingPolicyObjective` : (facultatif) objet dans lequel vous spécifiez le modèle de trafic prévu.
+ `MinInvocationsPerMinute` : (facultatif) nombre minimum de demandes attendues vers votre point de terminaison par minute.
+ `MaxInvocationsPerMinute` : (facultatif) nombre maximum de demandes attendues vers votre point de terminaison par minute.
```
{
"InferenceRecommendationsJobName": "string", // Required
"RecommendationId": "string", // Optional, provide one of RecommendationId or EndpointName
"EndpointName": "string", // Optional, provide one of RecommendationId or EndpointName
"TargetCpuUtilizationPerCore": number, // Optional
"ScalingPolicyObjective": { // Optional
"MinInvocationsPerMinute": number,
"MaxInvocationsPerMinute": number
}
}
```
Après avoir soumis votre demande, vous recevrez une réponse contenant des politiques de mise à l’échelle automatique définies pour chaque métrique. Consultez la section suivante pour plus d’informations sur l’interprétation de la réponse.
## Révision de vos résultats de recommandation de configuration de mise à l’échelle automatique
L'exemple suivant montre la réponse de l'[ GetScalingConfigurationRecommendation](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_GetScalingConfigurationRecommendation.html)API :
```
{
"InferenceRecommendationsJobName": "string",
"RecommendationId": "string", // One of RecommendationId or EndpointName is shown
"EndpointName": "string",
"TargetUtilizationPercentage": Integer,
"ScalingPolicyObjective": {
"MinInvocationsPerMinute": Integer,
"MaxInvocationsPerMinute": Integer
},
"Metric": {
"ModelLatency": Integer,
"InvocationsPerInstance": Integer
},
"DynamicScalingConfiguration": {
"MinCapacity": number,
"MaxCapacity": number,
"ScaleInCooldown": number,
"ScaleOutCooldown": number,
"ScalingPolicies": [
{
"TargetTracking": {
"MetricSpecification": {
"Predefined" {
"PredefinedMetricType": "string"
},
"Customized": {
"MetricName": "string",
"Namespace": "string",
"Statistic": "string"
}
},
"TargetValue": Double
}
}
]
}
}
```
`InferenceRecommendationsJobName`, `RecommendationID` ou `EndpointName`, `TargetCpuUtilizationPerCore` et les champs d’objet `ScalingPolicyObjective` sont copiés à partir de votre demande initiale.
L’objet `Metric` répertorie les métriques qui ont été comparées dans votre tâche de recommandation d’inférence, ainsi qu’un calcul des valeurs pour chaque métrique lorsque l’utilisation de l’instance serait identique à la valeur `TargetCpuUtilizationPerCore`. Cela est utile pour anticiper les métriques de performance de votre point de terminaison lors de sa mise à l’échelle horizontale et de sa montée en puissance conformément à la politique de mise à l’échelle automatique recommandée. Par exemple, déterminez si le taux d’utilisation de votre instance était de 50 % dans votre tâche de recommandation d’inférence alors que votre valeur `InvocationsPerInstance` était à l’origine `4`. Si vous spécifiez la valeur `TargetCpuUtilizationPerCore` sur 100 % dans votre demande de recommandation de mise à l’échelle automatique, la valeur de métrique `InvocationsPerInstance` renvoyée dans la réponse est `2`, car vous avez prévu d’allouer deux fois plus d’utilisation des instances.
L'`DynamicScalingConfiguration`objet renvoie les valeurs que vous devez spécifier [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html#autoscaling-PutScalingPolicy-request-TargetTrackingScalingPolicyConfiguration)lorsque vous appelez l'[PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)API. Cela inclut les valeurs de capacité minimale et maximale recommandées, les temps de stabilisation de réduction horizontale et d’augmentation horizontale, ainsi que l’objet `ScalingPolicies`, qui contient la `TargetValue` recommandée que vous devez spécifier pour chaque métrique.
# Exécuter un test de charge personnalisé
Les tests de charge Amazon SageMaker Inference Recommender permettent d'effectuer des tests de performance approfondis en fonction des exigences de production en matière de latence et de débit, des modèles de trafic personnalisés et des points de terminaison sans serveur ou des instances en temps réel (jusqu'à 10) que vous sélectionnez.
Les sections suivantes montrent comment créer, décrire et arrêter un test de charge par programmation à l'aide du AWS SDK pour Python (Boto3) et AWS CLI, ou de manière interactive à l'aide d'Amazon SageMaker Studio Classic ou de la SageMaker console AI.
## Création d’une tâche de test de charge
Créez un test de charge par programmation à l'aide de AWS SDK pour Python (Boto3), avec ou de manière interactive à l' AWS CLI aide de Studio Classic ou de la SageMaker console AI. Comme pour les recommandations d'inférence d'Inference Recommender, spécifiez un nom de tâche pour votre test de charge, un ARN de rôle AWS IAM, une configuration d'entrée et l'ARN de votre package de modèles à partir du moment où vous avez enregistré votre modèle dans le registre des modèles. Les tests de charge nécessitent que vous spécifiiez également un modèle de trafic et des conditions d’arrêt.
------
#### [ AWS SDK pour Python (Boto3) ]
Utilisez l’API `CreateInferenceRecommendationsJob` pour créer un test de charge d’Inference Recommender. Spécifiez `Advanced` pour `JobType` et fournissez les éléments suivants :
+ Un nom de tâche pour votre test de charge (`JobName`). Le nom du poste doit être unique dans votre AWS région et dans votre AWS compte.
+ L’Amazon Resource Name (ARN) d’un rôle IAM qui permet à Inference Recommender d’effectuer des tâches en votre nom. Définissez-le pour le champ `RoleArn`.
+ Un dictionnaire de configuration des points de terminaison (`InputConfig`) dans lequel spécifiez les éléments suivants :
+ Pour `TrafficPattern`, spécifiez le modèle de trafic par phases ou escaliers. Avec le modèle de trafic par phases, les nouveaux utilisateurs apparaissent chaque minute au rythme que vous spécifiez. Avec le modèle de trafic par escaliers, les nouveaux utilisateurs apparaissent à intervalles réguliers (ou par *étapes*) au rythme que vous spécifiez. Sélectionnez l’une des méthodes suivantes :
+ Pour `TrafficType`, spécifiez `PHASES`. Ensuite, pour le tableau `Phases`, spécifiez le `InitialNumberOfUsers` (le nombre d’utilisateurs simultanés avec lesquels commencer, avec un minimum de 1 et un maximum de 3), `SpawnRate` (le nombre d’utilisateurs à faire apparaître en une minute pour une phase spécifique du test de charge, avec un minimum de 0 et un maximum de 3) et `DurationInSeconds` (la durée de la phase de trafic, avec un minimum de 120 et un maximum de 3 600).
+ Pour `TrafficType`, spécifiez `STAIRS`. Ensuite, pour le tableau `Stairs`, spécifiez la `DurationInSeconds` (la durée de la phase de trafic, avec un minimum de 120 et un maximum de 3 600), `NumberOfSteps` (le nombre d’intervalles utilisés pendant la phase) et `UsersPerStep` (le nombre d’utilisateurs ajoutés pendant chaque intervalle). Notez que la longueur de chaque étape est la valeur de `DurationInSeconds / NumberOfSteps`. Par exemple, si votre `DurationInSeconds` est `600` et que vous spécifiez `5` étapes, chaque étape dure 120 secondes.
**Note**
Un utilisateur est défini comme un acteur généré par le système qui s’exécute en boucle et appelle des demandes vers un point de terminaison dans le cadre d’Inference Recommender. Pour un XGBoost conteneur classique exécuté sur une `ml.c5.large` instance, les points de terminaison peuvent atteindre 30 000 appels par minute (500 tps) avec seulement 15 à 20 utilisateurs.
+ Pour `ResourceLimit`, spécifiez `MaxNumberOfTests` (le nombre maximum de tests de charge d’analyse comparative pour une tâche Inference Recommender, avec un minimum de 1 et un maximum de 10) et `MaxParallelOfTests` (le nombre maximum de tests de charge d’analyse comparative parallèle pour une tâche Inference Recommender, avec un minimum de 1 et un maximum de 10).
+ Pour `EndpointConfigurations`, vous pouvez spécifier l’un des éléments suivants :
+ Pour le champ `InstanceType`, spécifiez le type d’instance sur lequel vous souhaitez exécuter vos tests de charge.
+ La `ServerlessConfig`, dans laquelle vous spécifiez vos valeurs idéales pour `MaxConcurrency` et `MemorySizeInMB` pour un point de terminaison sans serveur. Pour plus d’informations, consultez la [documentation Inférence sans serveur](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
+ Un dictionnaire des conditions d’arrêt (`StoppingConditions`), dans lequel, si l’une des conditions est remplie, la tâche Inference Recommender s’arrête. Pour cet exemple, spécifiez les champs suivants dans le dictionnaire :
+ Pour `MaxInvocations`, spécifiez le nombre maximum de demandes par minute attendues pour le point de terminaison, avec un minimum de 1 et un maximum de 30 000.
+ Pour `ModelLatencyThresholds`, spécifiez `Percentile` (le seuil percentile de latence du modèle) et `ValueInMilliseconds` (la valeur du percentile de latence du modèle en millisecondes).
+ (Facultatif) Pour `FlatInvocations`, vous pouvez spécifier si vous souhaitez poursuivre le test de charge lorsque le taux de TPS (invocations par minute) s’aplatit. Un taux de TPS aplati signifie généralement que le point de terminaison a atteint sa capacité maximale. Toutefois, vous souhaiterez peut-être continuer à surveiller le point de terminaison dans des conditions de pleine capacité. Pour continuer le test de charge lorsque cela se produit, spécifiez cette valeur comme `Continue`. Sinon, la valeur par défaut est `Stop`.
```
# Create a low-level SageMaker service client.
import boto3
aws_region=
sagemaker_client=boto3.client('sagemaker', region=aws_region)
# Provide a name to your recommendation based on load testing
load_test_job_name=""
# Provide the name of the sagemaker instance type
instance_type=""
# Provide the IAM Role that gives SageMaker permission to access AWS services
role_arn='arn:aws:iam:::role/*'
# Provide your model package ARN that was created when you registered your
# model with Model Registry
model_package_arn='arn:aws:sagemaker:::role/*'
sagemaker_client.create_inference_recommendations_job(
JobName=load_test_job_name,
JobType="Advanced",
RoleArn=role_arn,
InputConfig={
'ModelPackageVersionArn': model_package_arn,
"JobDurationInSeconds": 7200,
'TrafficPattern' : {
# Replace PHASES with STAIRS to use the stairs traffic pattern
'TrafficType': 'PHASES',
'Phases': [
{
'InitialNumberOfUsers': 1,
'SpawnRate': 1,
'DurationInSeconds': 120
},
{
'InitialNumberOfUsers': 1,
'SpawnRate': 1,
'DurationInSeconds': 120
}
]
# Uncomment this section and comment out the Phases object above to use the stairs traffic pattern
# 'Stairs' : {
# 'DurationInSeconds': 240,
# 'NumberOfSteps': 2,
# 'UsersPerStep': 2
# }
},
'ResourceLimit': {
'MaxNumberOfTests': 10,
'MaxParallelOfTests': 3
},
"EndpointConfigurations" : [{
'InstanceType': 'ml.c5.xlarge'
},
{
'InstanceType': 'ml.m5.xlarge'
},
{
'InstanceType': 'ml.r5.xlarge'
}]
# Uncomment the ServerlessConfig and comment out the InstanceType field if you want recommendations for a serverless endpoint
# "ServerlessConfig": {
# "MaxConcurrency": value,
# "MemorySizeInMB": value
# }
},
StoppingConditions={
'MaxInvocations': 1000,
'ModelLatencyThresholds':[{
'Percentile': 'P95',
'ValueInMilliseconds': 100
}],
# Change 'Stop' to 'Continue' to let the load test continue if invocations flatten
'FlatInvocations': 'Stop'
}
)
```
Consultez le [guide de référence des SageMaker API Amazon](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html) pour obtenir la liste complète des arguments facultatifs et obligatoires auxquels vous pouvez passer`CreateInferenceRecommendationsJob`.
------
#### [ AWS CLI ]
Utilisez l’API `create-inference-recommendations-job` pour créer un test de charge d’Inference Recommender. Spécifiez `Advanced` pour `JobType` et fournissez les éléments suivants :
+ Un nom de tâche pour votre test de charge (`job-name`). Le nom du poste doit être unique dans votre AWS région et dans votre AWS compte.
+ L’Amazon Resource Name (ARN) d’un rôle IAM qui permet à Inference Recommender d’effectuer des tâches en votre nom. Définissez-le pour le champ `role-arn`.
+ Un dictionnaire de configuration des points de terminaison (`input-config`) dans lequel spécifiez les éléments suivants :
+ Pour `TrafficPattern`, spécifiez le modèle de trafic par phases ou escaliers. Avec le modèle de trafic par phases, les nouveaux utilisateurs apparaissent chaque minute au rythme que vous spécifiez. Avec le modèle de trafic par escaliers, les nouveaux utilisateurs apparaissent à intervalles réguliers (ou par *étapes*) au rythme que vous spécifiez. Sélectionnez l’une des méthodes suivantes :
+ Pour `TrafficType`, spécifiez `PHASES`. Ensuite, pour le tableau `Phases`, spécifiez le `InitialNumberOfUsers` (le nombre d’utilisateurs simultanés avec lesquels commencer, avec un minimum de 1 et un maximum de 3), `SpawnRate` (le nombre d’utilisateurs à faire apparaître en une minute pour une phase spécifique du test de charge, avec un minimum de 0 et un maximum de 3) et `DurationInSeconds` (la durée de la phase de trafic, avec un minimum de 120 et un maximum de 3 600).
+ Pour `TrafficType`, spécifiez `STAIRS`. Ensuite, pour le tableau `Stairs`, spécifiez la `DurationInSeconds` (la durée de la phase de trafic, avec un minimum de 120 et un maximum de 3 600), `NumberOfSteps` (le nombre d’intervalles utilisés pendant la phase) et `UsersPerStep` (le nombre d’utilisateurs ajoutés pendant chaque intervalle). Notez que la longueur de chaque étape est la valeur de `DurationInSeconds / NumberOfSteps`. Par exemple, si votre `DurationInSeconds` est `600` et que vous spécifiez `5` étapes, chaque étape dure 120 secondes.
**Note**
Un utilisateur est défini comme un acteur généré par le système qui s’exécute en boucle et appelle des demandes vers un point de terminaison dans le cadre d’Inference Recommender. Pour un XGBoost conteneur classique exécuté sur une `ml.c5.large` instance, les points de terminaison peuvent atteindre 30 000 appels par minute (500 tps) avec seulement 15 à 20 utilisateurs.
+ Pour `ResourceLimit`, spécifiez `MaxNumberOfTests` (le nombre maximum de tests de charge d’analyse comparative pour une tâche Inference Recommender, avec un minimum de 1 et un maximum de 10) et `MaxParallelOfTests` (le nombre maximum de tests de charge d’analyse comparative parallèle pour une tâche Inference Recommender, avec un minimum de 1 et un maximum de 10).
+ Pour `EndpointConfigurations`, vous pouvez spécifier l’un des éléments suivants :
+ Pour le champ `InstanceType`, spécifiez le type d’instance sur lequel vous souhaitez exécuter vos tests de charge.
+ La `ServerlessConfig`, dans laquelle vous spécifiez vos valeurs idéales pour `MaxConcurrency` et `MemorySizeInMB` pour un point de terminaison sans serveur.
+ Un dictionnaire des conditions d’arrêt (`stopping-conditions`), dans lequel, si l’une des conditions est remplie, la tâche Inference Recommender s’arrête. Pour cet exemple, spécifiez les champs suivants dans le dictionnaire :
+ Pour `MaxInvocations`, spécifiez le nombre maximum de demandes par minute attendues pour le point de terminaison, avec un minimum de 1 et un maximum de 30 000.
+ Pour `ModelLatencyThresholds`, spécifiez `Percentile` (le seuil percentile de latence du modèle) et `ValueInMilliseconds` (la valeur du percentile de latence du modèle en millisecondes).
+ (Facultatif) Pour `FlatInvocations`, vous pouvez spécifier si vous souhaitez poursuivre le test de charge lorsque le taux de TPS (invocations par minute) s’aplatit. Un taux de TPS aplati signifie généralement que le point de terminaison a atteint sa capacité maximale. Toutefois, vous souhaiterez peut-être continuer à surveiller le point de terminaison dans des conditions de pleine capacité. Pour continuer le test de charge lorsque cela se produit, spécifiez cette valeur comme `Continue`. Sinon, la valeur par défaut est `Stop`.
```
aws sagemaker create-inference-recommendations-job\
--region \
--job-name \
--job-type ADVANCED\
--role-arn arn:aws:iam:::role/*\
--input-config \"{
\"ModelPackageVersionArn\": \"arn:aws:sagemaker:::role/*\",
\"JobDurationInSeconds\": 7200,
\"TrafficPattern\" : {
# Replace PHASES with STAIRS to use the stairs traffic pattern
\"TrafficType\": \"PHASES\",
\"Phases\": [
{
\"InitialNumberOfUsers\": 1,
\"SpawnRate\": 60,
\"DurationInSeconds\": 300
}
]
# Uncomment this section and comment out the Phases object above to use the stairs traffic pattern
# 'Stairs' : {
# 'DurationInSeconds': 240,
# 'NumberOfSteps': 2,
# 'UsersPerStep': 2
# }
},
\"ResourceLimit\": {
\"MaxNumberOfTests\": 10,
\"MaxParallelOfTests\": 3
},
\"EndpointConfigurations\" : [
{
\"InstanceType\": \"ml.c5.xlarge\"
},
{
\"InstanceType\": \"ml.m5.xlarge\"
},
{
\"InstanceType\": \"ml.r5.xlarge\"
}
# Use the ServerlessConfig and leave out the InstanceType fields if you want recommendations for a serverless endpoint
# \"ServerlessConfig\": {
# \"MaxConcurrency\": value,
# \"MemorySizeInMB\": value
# }
]
}\"
--stopping-conditions \"{
\"MaxInvocations\": 1000,
\"ModelLatencyThresholds\":[
{
\"Percentile\": \"P95\",
\"ValueInMilliseconds\": 100
}
],
# Change 'Stop' to 'Continue' to let the load test continue if invocations flatten
\"FlatInvocations\": \"Stop\"
}\"
```
------
#### [ Amazon SageMaker Studio Classic ]
Créez un test de charge avec Studio Classic.
1. Dans votre application Studio Classic, choisissez l’icône d’accueil (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/studio/icons/house.png)).
1. Dans la barre latérale gauche de Studio Classic, sélectionnez **Déploiements**.
1. Sélectionnez **Inference Recommender** dans la liste déroulante.
1. Choisissez **Créer une tâche Inference Recommender**. Un nouvel onglet intitulé **Créer une tâche Inference Recommender** s’ouvre.
1. Sélectionnez le nom de votre groupe de modèles dans le champ **Groupe de modèles**. La liste comprend tous les groupes de modèles enregistrés dans le registre de modèles de votre compte, y compris les modèles enregistrés en dehors de Studio Classic.
1. Sélectionnez une version de modèle dans le champ déroulant **Version de modèle**.
1. Sélectionnez **Continuer**.
1. Fournissez un nom pour la tâche dans le champ **Nom**.
1. (Facultatif) Fournissez une description de votre tâche dans le champ **Description**.
1. Choisissez un rôle IAM qui accorde à Inference Recommender l'autorisation d'accéder aux services. AWS Vous pouvez créer un rôle et attacher la politique gérée IAM `AmazonSageMakerFullAccess` pour y parvenir, ou vous pouvez laisser Studio Classic créer un rôle pour vous.
1. Sélectionnez **Conditions d’arrêt** pour développer les champs de saisie disponibles. Fournissez un jeu de conditions pour arrêter une recommandation de déploiement.
1. Spécifiez le nombre maximal de demandes par minute attendues pour le point de terminaison dans le champ **Nombre d’appels max. par minute**.
1. Spécifiez le seuil de latence du modèle en microsecondes dans le champ **Seuil de latence du modèle**. Le champ **Seuil de latence du modèle** décrit l’intervalle de temps nécessaire à un modèle pour répondre, tel qu’il est vu dans Inference Recommender. L’intervalle comprend le temps de communication local nécessaire pour envoyer la demande et récupérer la réponse du conteneur modèle et le temps nécessaire pour terminer l’inférence dans le conteneur.
1. Sélectionnez **Modèle de trafic** pour développer les champs de saisie disponibles.
1. Définissez le nombre initial d’utilisateurs virtuels en spécifiant un nombre entier dans le champ **Nombre initial d’utilisateurs**.
1. Fournissez un nombre entier pour le champ **Taux de génération**. Le taux d’apparition définit le nombre d’utilisateurs créés par seconde.
1. Définissez la durée de la phase en secondes en spécifiant un nombre entier dans le champ **Durée**.
1. (Facultatif) Ajoutez des modèles de trafic supplémentaires. Pour ce faire, sélectionnez **Ajouter**.
1. Sélectionnez le paramètre **Supplémentaire** pour afficher le champ **Durée maximale du test**. Spécifiez (en secondes) la durée maximale qu’un test peut prendre pendant une tâche. Les nouvelles tâches ne sont pas planifiées après la durée définie. Cela permet de garantir que les tâches en cours ne sont pas arrêtés et que vous ne visualisez que les tâches terminées.
1. Sélectionnez **Continuer**.
1. Sélectionnez **Instances sélectionnées**.
1. Dans le champ **Instances pour analyse comparative**, sélectionnez **Ajouter des instances à tester**. Sélectionnez jusqu’à 10 instances pour Inference Recommender à utiliser pour les tests de charge.
1. Sélectionnez **Paramètres supplémentaires**.
1. Fournissez un nombre entier qui définit une limite supérieure du nombre de tests qu’une tâche peut effectuer pour le champ **Nombre max. de tests**. Notez que chaque configuration de point de terminaison entraîne un nouveau test de charge.
1. Indiquez un nombre entier pour le champ de test **Max. parallèle**. Ce paramètre définit une limite supérieure du nombre de tests de charge pouvant s’exécuter en parallèle.
1. Sélectionnez **Soumettre**.
Le test de charge peut durer jusqu’à 2 heures.
**Avertissement**
Ne fermez pas cet onglet. Si vous fermez cet onglet, vous annulez la tâche de test de charge d’Inference Recommender.
------
#### [ SageMaker AI console ]
Créez un test de charge personnalisé via la console SageMaker AI en procédant comme suit :
1. Accédez à la console SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Dans le panneau de navigation de gauche, choisissez **Inférence**, puis **Inference Recommender**.
1. Sur la page **Tâches Inference Recommender**, choisissez **Créer une tâche**.
1. Pour **Étape 1 : Configuration du modèle**, procédez comme suit :
1. Pour **Type de tâche**, choisissez **Tâche Recommender avancée**.
1. Si vous utilisez un modèle enregistré dans le registre des modèles d' SageMaker IA, activez le bouton **Choisir un modèle dans le registre des modèles** et procédez comme suit :
1. Dans la liste déroulante des **groupes de modèles**, choisissez le groupe de modèles dans le registre des modèles SageMaker AI où se trouve votre modèle.
1. Dans la liste déroulante **Version du modèle**, choisissez la version souhaitée de votre modèle.
1. Si vous utilisez un modèle que vous avez créé dans SageMaker AI, désactivez le bouton **Choisir un modèle dans le registre des modèles** et procédez comme suit :
1. Dans le champ **Nom du modèle**, entrez le nom de votre modèle d' SageMaker IA.
1. Pour **le rôle IAM**, vous pouvez sélectionner un rôle AWS IAM existant disposant des autorisations nécessaires pour créer une tâche de recommandation d'instance. Sinon, si vous n'avez pas de rôle existant, vous pouvez choisir **Créer un nouveau rôle** pour ouvrir la fenêtre contextuelle de création de rôle, et SageMaker AI ajoute les autorisations nécessaires au nouveau rôle que vous créez.
1. Pour **Compartiment S3 destiné à l’analyse comparative des données utiles**, entrez le chemin Amazon S3 vers votre archive d’exemples de données utiles, qui doit contenir des exemples de fichiers de données utiles qu’Inference Recommender utilise pour analyser votre modèle sur différents types d’instances.
1. Pour **Type de contenu de la charge utile**, entrez les types MIME pour votre exemple de données de charge utile.
1. Pour **Modèle de trafic**, configurez les phases du test de charge en procédant comme suit :
1. Pour **Nombre initial d’utilisateurs**, spécifiez le nombre d’utilisateurs simultanés avec lesquels vous souhaitez commencer (avec un minimum de 1 et un maximum de 3).
1. Pour **Taux d’apparition**, spécifiez le nombre d’utilisateurs à faire apparaître en une minute pour la phase (avec un minimum de 0 et un maximum de 3).
1. Pour **Durée (secondes)**, spécifiez la durée de la phase de trafic en secondes (avec un minimum de 120 et un maximum de 3 600).
1. (Facultatif) Si vous avez désactivé le bouton **Choisir un modèle dans le registre des modèles et que** vous avez spécifié un modèle d' SageMaker IA, procédez comme suit pour la **configuration du conteneur** :
1. Dans la liste déroulante **Domaine**, sélectionnez le domaine de machine learning du modèle, tel que la vision par ordinateur, le traitement du langage naturel ou le machine learning.
1. **Dans la liste déroulante Framework**, sélectionnez le framework de votre conteneur, tel que TensorFlow ou XGBoost.
1. Pour **Version de framework**, entrez la version de framework de votre image de conteneur.
1. Dans la liste déroulante **Nom du modèle le plus proche**, sélectionnez le modèle préentraîné qui correspond le plus souvent au vôtre.
1. Dans la liste déroulante **Tâche**, sélectionnez la tâche de machine learning exécutée par le modèle, telle que la classification d’images ou la régression.
1. (Facultatif) Pour la **compilation de modèles à l'aide de SageMaker Neo**, vous pouvez configurer la tâche de recommandation pour un modèle que vous avez compilé à l'aide de SageMaker Neo. Pour **Configuration d’entrée de données**, entrez la forme de données d’entrée correcte pour votre modèle dans un format similaire à `{'input':[1,1024,1024,3]}`.
1. Choisissez **Suivant**.
1. Pour **Étape 2 : Instances et paramètres d'environnement**, procédez comme suit :
1. Pour **Sélectionner des instances à des fins de comparaison**, vous pouvez sélectionner jusqu’à 8 types d’instances que vous souhaitez comparer.
1. (Facultatif) Pour **Plages de paramètres d’environnement**, vous pouvez spécifier des paramètres d’environnement qui permettent d’optimiser votre modèle. Spécifiez les paramètres sous forme de paires **Clé** et **Valeur**.
1. Choisissez **Suivant**.
1. Pour **Étape 3 : Paramètres de tâche**, procédez comme suit :
1. (Facultatif) Dans le champ **Nom de la tâche**, entrez le nom de la tâche de recommandation de votre instance. Lorsque vous créez la tâche, SageMaker AI ajoute un horodatage à la fin de ce nom.
1. (Facultatif) Dans le champ **Description de la tâche**, entrez une brève description de la tâche.
1. (Facultatif) Dans la liste déroulante des **clés de chiffrement**, choisissez une AWS KMS clé par son nom ou entrez son ARN pour chiffrer vos données.
1. (Facultatif) Pour **Nombre maximal de tests**, entrez le nombre de tests que vous souhaitez exécuter pendant la tâche de recommandation.
1. (Facultatif) Pour **Nombre maximal de tests parallèles**, entrez le nombre maximal de tests parallèles que vous souhaitez exécuter pendant la tâche de recommandation.
1. Pour **Durée (s) maximale (s) de test**, entrez le nombre maximal de secondes pendant lequel vous souhaitez que chaque test s’exécute.
1. Pour **Invocations par minute**, entrez le nombre maximal de demandes par minute que le point de terminaison peut atteindre avant d’arrêter la tâche de recommandation. Une fois cette limite atteinte, l' SageMaker IA met fin au travail.
1. Pour **Seuil de latence du modèle P99 (ms)**, entrez le percentile de latence du modèle en millisecondes.
1. Choisissez **Suivant**.
1. Pour **Étape 4 : Vérification de la tâche**, passez en revue vos configurations, puis choisissez **Soumettre**.
------
## Obtention de vos résultats de test de charge
Vous pouvez collecter des métriques par programmation pour tous les tests de charge une fois que ceux-ci sont effectués avec AWS SDK pour Python (Boto3) Studio Classic ou la console SageMaker AI. AWS CLI
------
#### [ AWS SDK pour Python (Boto3) ]
Collectez des métriques avec l’API `DescribeInferenceRecommendationsJob`. Spécifiez le nom de la tâche du test de charge pour le champ `JobName` :
```
load_test_response = sagemaker_client.describe_inference_recommendations_job(
JobName=load_test_job_name
)
```
Imprimez l’objet de réponse.
```
load_test_response['Status']
```
Cela renvoie une réponse JSON semblable à l'exemple suivant. Notez que cet exemple montre les types d'instances recommandés pour l'inférence en temps réel (pour un exemple illustrant les recommandations d'inférence sans serveur, consultez l'exemple suivant celui-ci).
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Advanced',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 19, 38, 30, 957000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 19, 46, 31, 399000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 7200,
'TrafficPattern': {
'TrafficType': 'PHASES'
},
'ResourceLimit': {
'MaxNumberOfTests': 100,
'MaxParallelOfTests': 100
},
'EndpointConfigurations': [{
'InstanceType': 'ml.c5d.xlarge'
}]
},
'StoppingConditions': {
'MaxInvocations': 1000,
'ModelLatencyThresholds': [{
'Percentile': 'P95',
'ValueInMilliseconds': 100}
]},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.6899999976158142,
'CostPerInference': 1.0332434612791985e-05,
'MaximumInvocations': 1113,
'ModelLatency': 100000
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.xlarge',
'InitialInstanceCount': 3
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1199',
'date': 'Tue, 26 Oct 2021 19:57:42 GMT'
},
'RetryAttempts': 0}
}
```
Les premières lignes fournissent des informations sur la tâche de test de charge elle-même. Celles-ci incluent le nom de la tâche, l’ARN du rôle, l’heure de création et de suppression.
Le dictionnaire `InferenceRecommendations` contient une liste de recommandations d’inférences Inference Recommender.
Le dictionnaire `EndpointConfiguration` imbriqué contient la recommandation du type d'instance (`InstanceType`) ainsi que le nom du point de terminaison et de la variante (un modèle d'apprentissage AWS automatique déployé) utilisés lors de la tâche de recommandation. Vous pouvez utiliser le nom du point de terminaison et de la variante pour la surveillance dans Amazon CloudWatch Events. Pour plus d’informations, consultez [Métriques Amazon SageMaker AI sur Amazon CloudWatch](monitoring-cloudwatch.md).
Le dictionnaire `EndpointConfiguration` imbriqué contient également la recommandation du nombre d’instances (`InitialInstanceCount`). Il s’agit du nombre d’instances que vous devez provisionner dans le point de terminaison pour répondre aux `MaxInvocations` spécifiées dans `StoppingConditions`. Par exemple, si `InstanceType` est `ml.m5.large` et `InitialInstanceCount` est `2`, vous devez provisionner 2 instances `ml.m5.large` pour votre point de terminaison afin qu’il puisse gérer le TPS spécifié dans la condition d’arrêt `MaxInvocations`.
Le dictionnaire `Metrics` imbriqué contient des informations sur le coût horaire estimé (`CostPerHour`) pour votre point de terminaison en temps réel en dollars américains, le coût estimé par inférence (`CostPerInference`) pour votre point de terminaison en temps réel, le nombre maximum de `InvokeEndpoint` demandes envoyées au point de terminaison et la latence du modèle (`ModelLatency`), qui est l'intervalle de temps (en microsecondes) nécessaire à votre modèle pour répondre à l'IA. SageMaker La latence du modèle inclut le temps de communication local pris pour envoyer la requête et pour récupérer la réponse du conteneur d’un modèle et le temps nécessaire pour terminer l’inférence dans le conteneur.
L’exemple suivant montre la partie `InferenceRecommendations` de la réponse pour une tâche de test de charge configurée pour renvoyer des recommandations d’inférence sans serveur :
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
Vous pouvez interpréter les recommandations pour l’inférence sans serveur de la même manière que les résultats pour l’inférence en temps réel, à l’exception de `ServerlessConfig`, qui vous indique les valeurs spécifiées pour `MaxConcurrency` et `MemorySizeInMB` lors de la configuration du test de charge. Les recommandations sans serveur mesurent également la métrique `ModelSetupTime`, qui mesure (en microsecondes) le temps nécessaire au lancement des ressources de calcul sur un point de terminaison sans serveur. Pour plus d'informations sur la configuration des points de terminaison sans serveur, consultez la [documentation Inférence sans serveur](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
------
#### [ AWS CLI ]
Collectez des métriques avec l'API `describe-inference-recommendations-job`. Spécifiez le nom de la tâche du test de charge pour l’indicateur `job-name` :
```
aws sagemaker describe-inference-recommendations-job --job-name
```
Cela renvoie une réponse semblable à l’exemple suivant. Notez que cet exemple montre les types d’instances recommandés pour l’inférence en temps réel (pour un exemple illustrant les recommandations d’inférence sans serveur, consultez l’exemple suivant celui-ci).
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Advanced',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 19, 38, 30, 957000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 19, 46, 31, 399000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 7200,
'TrafficPattern': {
'TrafficType': 'PHASES'
},
'ResourceLimit': {
'MaxNumberOfTests': 100,
'MaxParallelOfTests': 100
},
'EndpointConfigurations': [{
'InstanceType': 'ml.c5d.xlarge'
}]
},
'StoppingConditions': {
'MaxInvocations': 1000,
'ModelLatencyThresholds': [{
'Percentile': 'P95',
'ValueInMilliseconds': 100
}]
},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.6899999976158142,
'CostPerInference': 1.0332434612791985e-05,
'MaximumInvocations': 1113,
'ModelLatency': 100000
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.xlarge',
'InitialInstanceCount': 3
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1199',
'date': 'Tue, 26 Oct 2021 19:57:42 GMT'
},
'RetryAttempts': 0
}
}
```
Les premières lignes fournissent des informations sur la tâche de test de charge elle-même. Celles-ci incluent le nom de la tâche, l’ARN du rôle, l’heure de création et de suppression.
Le dictionnaire `InferenceRecommendations` contient une liste de recommandations d’inférences Inference Recommender.
Le dictionnaire `EndpointConfiguration` imbriqué contient la recommandation du type d'instance (`InstanceType`) ainsi que le nom du point de terminaison et de la variante (un modèle d'apprentissage AWS automatique déployé) utilisés lors de la tâche de recommandation. Vous pouvez utiliser le nom du point de terminaison et de la variante pour la surveillance dans Amazon CloudWatch Events. Pour plus d’informations, consultez [Métriques Amazon SageMaker AI sur Amazon CloudWatch](monitoring-cloudwatch.md).
Le dictionnaire `Metrics` imbriqué contient des informations sur le coût horaire estimé (`CostPerHour`) pour votre point de terminaison en temps réel en dollars américains, le coût estimé par inférence (`CostPerInference`) pour votre point de terminaison en temps réel, le nombre maximum de `InvokeEndpoint` demandes envoyées au point de terminaison et la latence du modèle (`ModelLatency`), qui est l'intervalle de temps (en microsecondes) nécessaire à votre modèle pour répondre à l'IA. SageMaker La latence du modèle inclut le temps de communication local pris pour envoyer la requête et pour récupérer la réponse du conteneur d’un modèle et le temps nécessaire pour terminer l’inférence dans le conteneur.
L’exemple suivant montre la partie `InferenceRecommendations` de la réponse pour une tâche de test de charge configurée pour renvoyer des recommandations d’inférence sans serveur :
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
Vous pouvez interpréter les recommandations pour l'inférence sans serveur de la même manière que les résultats pour l'inférence en temps réel, à l'exception de `ServerlessConfig`, qui vous indique les valeurs spécifiées pour `MaxConcurrency` et `MemorySizeInMB` lors de la configuration du test de charge. Les recommandations sans serveur mesurent également la métrique `ModelSetupTime`, qui mesure (en microsecondes) le temps nécessaire au lancement des ressources informatiques sur un point de terminaison sans serveur. Pour plus d’informations sur la configuration des points de terminaison sans serveur, consultez la [documentation Inférence sans serveur](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html).
------
#### [ Amazon SageMaker Studio Classic ]
Les recommandations sont renseignées dans un nouvel onglet appelé **Recommandations d’inférence** dans Studio Classic. L’affichage des résultats peut prendre jusqu’à 2 heures. Cet onglet contient les colonnes **Résultats** et **Détails**.
La colonne **Détails** fournit des informations sur la tâche de test de charge, telles que le nom donné à la tâche de test de charge, la date de création de la tâche (**Heure de création**), etc. Elle fournit également des informations sur les **Paramètres**, telles que le nombre maximal d’invocations qui se sont produits par minute et des informations sur les Amazon Resource Names utilisés.
La colonne **Résultats** fournit des fenêtres d'**objectifs de déploiement** et de **recommandations d'SageMaker IA** dans lesquelles vous pouvez ajuster l'ordre dans lequel les résultats sont affichés en fonction de l'importance du déploiement. Il existe trois menus déroulants que vous pouvez utiliser pour fournir le niveau d’importance du **Coût**, de la **Latence** et du **Débit** pour votre cas d’utilisation. Pour chaque objectif (coût, latence et débit), vous pouvez définir le niveau d’importance : **Importance la plus faible**, **Importance faible**, **Importance modérée**, **Importance élevée** ou **Importance la plus élevée**.
En fonction de l'importance que vous avez sélectionnée pour chaque objectif, Inference Recommender affiche sa principale recommandation dans le champ de **SageMakerrecommandation** situé à droite du panneau, ainsi que le coût horaire estimé et la demande d'inférence. Il fournit également des informations sur la latence attendue du modèle, le nombre maximal d’invocations et le nombre d’instances.
En plus de la recommandation principale affichée, vous pouvez également voir les mêmes informations affichées pour toutes les instances testées par l’outil de recommandation d’inférence dans la section **Toutes les exécutions**.
------
#### [ SageMaker AI console ]
Vous pouvez consulter les résultats de vos tâches de test de charge personnalisées dans la console SageMaker AI en procédant comme suit :
1. Accédez à la console SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Dans le panneau de navigation de gauche, choisissez **Inférence**, puis **Inference Recommender**.
1. Sur la page **Tâches Inference Recommender**, choisissez le nom de votre tâche de recommandation d’inférence.
Sur la page de détails de votre tâche, vous pouvez consulter les **recommandations d'inférence**, qui sont les types d'instances recommandés par l' SageMaker IA pour votre modèle, comme indiqué dans la capture d'écran suivante.
![\[Capture d'écran de la liste des recommandations d'inférence sur la page des détails de la tâche dans la console SageMaker AI.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inf-rec-instant-recs.png)
Dans cette section, vous pouvez comparer les types d’instances en fonction de différents facteurs tels que la **Latence du modèle**, le **Coût horaire**, le **Coût par inférence** et les **Invocations par minute**.
Sur cette page, vous pouvez également afficher les configurations que vous avez spécifiées pour votre tâche. Dans la section **Monitor**, vous pouvez consulter les CloudWatch métriques Amazon enregistrées pour chaque type d'instance. Pour en savoir plus sur l'interprétation de ces métriques, consultez [Interprétation des résultats](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-interpret-results.html).
------
# Arrêt de votre test de charge
Vous souhaiterez peut-être arrêter une tâche en cours d’exécution si vous l’avez démarrée par erreur ou si vous n’avez plus besoin de l’exécuter. Arrêtez vos tâches de test de charge par programmation à l'aide de l'`StopInferenceRecommendationsJob`API, de Studio Classic ou de la console SageMaker AI.
------
#### [ AWS SDK pour Python (Boto3) ]
Spécifiez le nom de la tâche du test de charge pour le champ `JobName` :
```
sagemaker_client.stop_inference_recommendations_job(
JobName=''
)
```
------
#### [ AWS CLI ]
Spécifiez le nom de la tâche du test de charge pour l'indicateur `job-name` :
```
aws sagemaker stop-inference-recommendations-job --job-name
```
------
#### [ Amazon SageMaker Studio Classic ]
Fermez l’onglet dans lequel vous avez lancé votre tâche de chargement personnalisé pour arrêter votre test de charge d’Inference Recommender.
------
#### [ SageMaker AI console ]
Pour arrêter votre tâche de test de charge via la console SageMaker AI, procédez comme suit :
1. Accédez à la console SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Dans le panneau de navigation de gauche, choisissez **Inférence**, puis **Inference Recommender**.
1. Sur la page **Tâches Inference Recommender**, sélectionnez votre tâche de test de charge.
1. Choisissez **Arrêter la tâche**.
1. Dans la boîte de dialogue qui s’affiche, choisissez **Confirmer**.
Après avoir arrêté votre tâche, le **Statut** de la tâche devrait passer à **Arrêt en cours**.
------
# Résolution des erreurs Inference Recommender
Cette section contient des informations sur la façon de comprendre et d’éviter les erreurs courantes, les messages d’erreur qu’elles génèrent, ainsi que des conseils sur la manière de résoudre ces erreurs.
## Comment résoudre les problèmes
Vous pouvez tenter de résoudre l’erreur en suivant les étapes suivantes :
+ Vérifiez si vous avez couvert toutes les conditions préalables pour utiliser Inference Recommender. Consultez les [prérequis](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-prerequisites.html).
+ Vérifiez que vous êtes en mesure de déployer votre modèle depuis le registre de modèles vers un point de terminaison et qu’il peut traiter vos données utiles sans erreur. Consultez [Déploiement d’un modèle dans le registre](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry-deploy.html).
+ Lorsque vous lancez une tâche de recommandation d'inférence, vous devriez voir les points de terminaison créés dans la console et vous pouvez consulter les journaux. CloudWatch
## Erreurs courantes
Consultez le tableau suivant pour connaître les erreurs Inference Recommender courantes et leurs solutions.
| Erreur | Solution |
| --- | --- |
| Spécifiez `Domain` dans le package de modèle version 1. `Domain` est un paramètre obligatoire pour la tâche. | Assurez-vous de fournir le domaine ML ou `OTHER` s’il est inconnu. |
| L’ARN du rôle fourni ne peut pas être assumé et une erreur `AWSSecurityTokenServiceException` se produit. | Assurez-vous que le rôle d’exécution fourni possède les autorisations nécessaires spécifiées dans les prérequis. |
| Spécifiez `Framework` dans le package de modèle version 1. `Framework` est un paramètre obligatoire pour la tâche. | Assurez-vous de fournir le cadre ML ou `OTHER` s’il est inconnu. |
| Il y a 0 utilisateur à la fin de la phase précédente et 1 utilisateur initial de la phase actuelle. | Les utilisateurs font ici référence aux utilisateurs virtuels ou aux fils de discussion utilisés pour envoyer des demandes. Chaque phase commence avec les utilisateurs A et se termine avec les utilisateurs B, de sorte que B > A. Entre les phases séquentielles, x\$11 et x\$12, nous exigeons que abs(x\$12.A - x\$11.B) <= 3 et >= 0. |
| La durée totale du trafic (transversal) ne doit pas dépasser la durée de la tâche. | La durée totale de toutes vos phases ne peut pas dépasser la durée de la tâche. |
| Le type d’instance extensible ml.t2.medium n’est pas autorisé. | Inference Recommender ne prend pas en charge les tests de charge sur la famille d’instances t2, car les instances extensibles ne fournissent pas de performances constantes. |
| ResourceLimitExceeded lors de l' CreateEndpointopération d'appel | Vous avez dépassé la limite de ressources de l' SageMaker IA. Par exemple, Inference Recommender peut ne pas être en mesure de provisionner des points de terminaison à des fins d’analyse comparative si le compte a atteint le quota de points de terminaison. Pour plus d'informations sur les limites et les quotas d' SageMaker IA, consultez [Amazon SageMaker AI Endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html). |
| ModelError lors de l' InvokeEndpoint opération d'appel | Une erreur de modèle peut se produire pour les raisons suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/inference-recommender-troubleshooting.html) |
| PayloadError lors de l' InvokeEndpoint opération d'appel | Une erreur de charge utile peut se produire pour les raisons suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/inference-recommender-troubleshooting.html) |
## Vérifiez CloudWatch
Lorsque vous lancez une tâche Inference Recommender, vous devriez voir des points de terminaison créés dans la console. Sélectionnez l'un des points de terminaison et consultez les CloudWatch journaux pour détecter toute erreur 4xx/5xx. Si votre tâche Inference Recommender est réussie, vous pourrez voir les noms des points de terminaison dans les résultats. Même si votre tâche de recommandation d'inférence échoue, vous pouvez toujours consulter les CloudWatch journaux des points de terminaison supprimés en suivant les étapes ci-dessous :
1. Ouvrez la CloudWatch console Amazon à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Sélectionnez la région dans laquelle vous avez créé la tâche Inference Recommender dans la liste déroulante **Région** située en haut à droite.
1. Dans le volet de navigation de CloudWatch, choisissez **Logs**, puis sélectionnez **Log groups**.
1. Recherchez le groupe de journaux nommé `/aws/sagemaker/Endpoints/sm-epc-*`. Sélectionnez le groupe de journaux en fonction de votre dernière tâche Inference Recommender.
Vous pouvez également résoudre les problèmes liés à votre tâche en consultant les journaux d'Inference CloudWatch Recommender. Les journaux Inference Recommender, publiés dans le groupe de `/aws/sagemaker/InferenceRecommendationsJobs` CloudWatch journaux, fournissent une vue d'ensemble de la progression de la tâche dans le flux de `/execution` journaux. Vous trouverez des informations détaillées sur chacune des configurations de point de terminaison testées dans le flux de journaux `/Endpoint/`.
**Vue d’ensemble des flux de journaux d’Inference Recommender**
+ `/execution` contient des informations générales sur les tâches, telles que les configurations de point de terminaison planifiées pour l’analyse comparative, la raison pour laquelle la tâche de compilation a été ignorée et la raison de l’échec de la validation.
+ `/Endpoint/` contient des informations telles que la progression de la création de ressources, la configuration du test, la raison de l’arrêt du test de chargement et le statut du nettoyage des ressources.
+ `/CompilationJob/` contient des informations sur les tâches de compilation créées par Inference Recommender, telles que la configuration et le statut des tâches de compilation.
**Création d’une alarme pour les messages d’erreur d’Inference Recommender**
Inference Recommender génère des instructions de journal pour les erreurs qui peuvent être utiles lors du dépannage. À l'aide d'un groupe de CloudWatch journaux et d'un filtre métrique, vous pouvez rechercher des termes et des modèles dans ces données de journal au fur et à mesure de leur envoi CloudWatch. Vous pouvez ensuite créer une CloudWatch alarme basée sur le filtre métrique du groupe de logs. Pour plus d'informations, voir [Création d'une CloudWatch alarme basée sur un filtre métrique de groupe de logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Create_alarm_log_group_metric_filter.html).
## Vérifier les comparaisons
Lorsque vous lancez une tâche Inference Recommender, Inference Recommender crée plusieurs comparaisons pour évaluer les performances de votre modèle sur différents types d’instances. Vous pouvez utiliser l'[ListInferenceRecommendationsJobSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListInferenceRecommendationsJobSteps.html)API pour consulter les détails de tous les benchmarks. Si une comparaison a échoué, vous pouvez voir les raisons de l’échec dans les résultats.
Pour utiliser l'[ListInferenceRecommendationsJobSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListInferenceRecommendationsJobSteps.html)API, entrez les valeurs suivantes :
+ Pour `JobName`, spécifiez le nom de la tâche Inference Recommender.
+ Pour `StepType`, utilisez `BENCHMARK` pour renvoyer des détails sur les comparaisons de la tâche.
+ Pour `Status`, utilisez `FAILED` pour renvoyer des détails sur les comparaisons ayant échoué uniquement. Pour obtenir la liste des autres types de statut, consultez le `Status` champ de l'[ListInferenceRecommendationsJobSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListInferenceRecommendationsJobSteps.html)API.
```
# Create a low-level SageMaker service client.
import boto3
aws_region = ''
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Provide the job name for the SageMaker Inference Recommender job
job_name = ''
# Filter for benchmarks
step_type = 'BENCHMARK'
# Filter for benchmarks that have a FAILED status
status = 'FAILED'
response = sagemaker_client.list_inference_recommendations_job_steps(
JobName = job_name,
StepType = step_type,
Status = status
)
```
Vous pouvez imprimer l’objet de réponse pour afficher les résultats. L’exemple de code précédent a stocké la réponse dans une variable appelée `response` :
```
print(response)
```
# Inférence en temps réel
L'inférence en temps réel est idéale pour les charges de travail d'inférence où vous avez des exigences en temps réel, interactives et à faible latence. Vous pouvez déployer votre modèle sur des services d'hébergement d' SageMaker IA et obtenir un point de terminaison pouvant être utilisé à des fins d'inférence. Ces points de terminaison sont entièrement gérés et prennent en charge la scalabilité automatique (voir [Mise à l'échelle automatique des modèles Amazon SageMaker AI](endpoint-auto-scaling.md)).
**Topics**
+ [Déploiement de modèles pour l’inférence en temps réel](realtime-endpoints-deploy-models.md)
+ [Invocation de modèles pour une inférence en temps réel](realtime-endpoints-test-endpoints.md)
+ [Points de terminaison](realtime-endpoints-manage.md)
+ [Options d’hébergement](realtime-endpoints-options.md)
+ [Mise à l'échelle automatique des modèles Amazon SageMaker AI](endpoint-auto-scaling.md)
+ [Volumes de stockage d’instances](host-instance-storage.md)
+ [Validation de modèles en production](model-validation.md)
+ [Explicabilité en ligne avec Clarify SageMaker](clarify-online-explainability.md)
+ [Peaufinage des modèles avec les composants d’inférence des adaptateurs](realtime-endpoints-adapt.md)
# Déploiement de modèles pour l’inférence en temps réel
**Important**
Les politiques IAM personnalisées qui permettent à Amazon SageMaker Studio ou Amazon SageMaker Studio Classic de créer des SageMaker ressources Amazon doivent également accorder des autorisations pour ajouter des balises à ces ressources. L’autorisation d’ajouter des balises aux ressources est requise, car Studio et Studio Classic balisent automatiquement toutes les ressources qu’ils créent. Si une politique IAM autorise Studio et Studio Classic à créer des ressources mais n'autorise pas le balisage, des erreurs « AccessDenied » peuvent se produire lors de la tentative de création de ressources. Pour de plus amples informations, veuillez consulter [Fournir des autorisations pour le balisage des ressources d' SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS politiques gérées pour Amazon SageMaker AI](security-iam-awsmanpol.md)qui donnent des autorisations pour créer des SageMaker ressources incluent déjà des autorisations pour ajouter des balises lors de la création de ces ressources.
Il existe plusieurs options pour déployer un modèle à l'aide des services d'hébergement SageMaker AI. Vous pouvez déployer un modèle de manière interactive avec SageMaker Studio. Vous pouvez également déployer un modèle par programmation à l'aide d'un AWS SDK, tel que le SDK Python ou le SDK pour SageMaker Python (Boto3). Vous pouvez également déployer à l'aide du AWS CLI.
## Avant de commencer
Avant de déployer un modèle d' SageMaker IA, repérez et notez les points suivants :
+ L' Région AWS endroit où se trouve votre compartiment Amazon S3
+ Le chemin d’accès d’URI Amazon S3 où sont stockés les artefacts du modèle
+ Le rôle de l'IAM pour l'IA SageMaker
+ Le chemin de registre d'URI Docker Amazon ECR pour l'image personnalisée contenant le code d'inférence, ou le framework et la version d'une image Docker intégrée prise en charge et par AWS
Pour obtenir la liste des réseaux Services AWS disponibles dans chacun d'entre eux Région AWS, voir [Cartes des régions et réseaux périphériques](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Pour plus d’informations sur la création d’un rôle IAM, consultez [Création de rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html).
**Important**
Le compartiment Amazon S3 où les artefacts de modèle sont stockés doit se trouver dans la même Région AWS que le modèle qui vous êtes en train de créer.
## Utilisation partagée des ressources avec plusieurs modèles
Vous pouvez déployer un ou plusieurs modèles sur un terminal avec Amazon SageMaker AI. Lorsque plusieurs modèles partagent un point de terminaison, ils utilisent conjointement les ressources qui y sont hébergées, telles que les instances de calcul ML et CPUs les accélérateurs. Le moyen le plus flexible de déployer plusieurs modèles sur un point de terminaison consiste à définir chaque modèle en tant que *composant d’inférence*.
### Composants Inférence
Un composant d'inférence est un objet d'hébergement SageMaker AI que vous pouvez utiliser pour déployer un modèle sur un point de terminaison. Dans les paramètres du composant d’inférence, vous spécifiez le modèle, le point de terminaison et la manière dont le modèle utilise les ressources hébergées par le point de terminaison. Pour spécifier le modèle, vous pouvez spécifier un objet du modèle SageMaker AI, ou vous pouvez directement spécifier les artefacts et l'image du modèle.
Dans les paramètres, vous pouvez optimiser l’utilisation des ressources en personnalisant la manière dont les cœurs de processeur, les accélérateurs et la mémoire requis sont alloués au modèle. Vous pouvez déployer plusieurs composants d’inférence sur un point de terminaison, chaque composant d’inférence contenant un modèle et les besoins d’utilisation des ressources pour ce modèle.
Après avoir déployé un composant d'inférence, vous pouvez appeler directement le modèle associé lorsque vous utilisez l' InvokeEndpoint action dans l' SageMaker API.
Les composants d’inférence offrent les avantages suivants :
**Flexibilité**
Le composant d’inférence dissocie les détails de l’hébergement du modèle du point de terminaison lui-même. Cela offre plus de flexibilité et de contrôle sur la manière dont les modèles sont hébergés et servis avec un point de terminaison. Vous pouvez héberger plusieurs modèles sur la même infrastructure et vous pouvez ajouter ou supprimer des modèles d’un point de terminaison selon les besoins. Vous pouvez mettre à jour chaque modèle de manière indépendante.
**Capacité de mise à l’échelle**
Vous pouvez spécifier le nombre de copies de chaque modèle à héberger et vous pouvez définir un nombre minimum de copies pour garantir que le modèle charge la quantité requise pour répondre aux demandes. Vous pouvez réduire verticalement n’importe quelle copie de composant d’inférence jusqu’à zéro, ce qui libère de l’espace pour qu’une autre copie puisse augmenter verticalement.
SageMaker L'IA emballe vos modèles sous forme de composants d'inférence lorsque vous les déployez en utilisant :
+ SageMaker Studio classique.
+ Le SDK SageMaker Python pour déployer un objet Model (dans lequel vous définissez le type de point de terminaison sur`EndpointType.INFERENCE_COMPONENT_BASED`).
+ AWS SDK pour Python (Boto3) pour définir les `InferenceComponent` objets que vous déployez sur un point de terminaison.
## Déployez des modèles avec SageMaker Studio
Procédez comme suit pour créer et déployer votre modèle de manière interactive via SageMaker Studio. Pour plus d’informations sur Studio, consultez la documentation [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html). Pour plus d'informations sur les différents scénarios de déploiement, consultez le blog [Package et déployez LLMs facilement des modèles de ML classiques avec Amazon SageMaker AI — Partie 2](https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-2-interactive-user-experiences-in-sagemaker-studio/).
### Préparation de vos artefacts et de vos autorisations
Complétez cette section avant de créer un modèle dans SageMaker Studio.
Deux options s’offrent à vous pour importer vos artefacts et créer un modèle dans Studio :
1. Vous pouvez apporter une archive `tar.gz` prépackagée, qui doit inclure les artefacts de votre modèle, tout code d’inférence personnalisé et toutes les dépendances répertoriées dans un fichier `requirements.txt`.
1. SageMaker L'IA peut emballer vos artefacts pour vous. Vous n'avez qu'à importer les artefacts de votre modèle brut et toutes les dépendances dans un `requirements.txt` fichier, et l' SageMaker IA peut vous fournir le code d'inférence par défaut (ou vous pouvez remplacer le code par défaut par votre propre code d'inférence personnalisé). SageMaker L'IA prend en charge cette option pour les frameworks suivants : PyTorch, XGBoost.
En plus d'apporter votre modèle, votre rôle Gestion des identités et des accès AWS (IAM) et un conteneur Docker (ou le framework et la version souhaités pour lesquels SageMaker AI dispose d'un conteneur prédéfini), vous devez également accorder des autorisations pour créer et déployer des modèles via SageMaker AI Studio.
La [AmazonSageMakerFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonSageMakerFullAccess.html)politique doit être attachée à votre rôle IAM afin de pouvoir accéder à l' SageMaker IA et aux autres services pertinents. Pour connaître les prix des types d'instances dans Studio, vous devez également joindre la [AWS PriceListServiceFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSPriceListServiceFullAccess.html)politique (ou, si vous ne souhaitez pas joindre la politique dans son intégralité, plus précisément l'`pricing:GetProducts`action).
Si vous choisissez de charger les artefacts de votre modèle lors de la création d’un modèle (ou de charger un exemple de fichier de données utiles pour les recommandations d’inférence), vous devez créer un compartiment Amazon S3. Le nom du compartiment doit être préfixé par le mot `SageMaker AI`. Les capitalisations alternatives de l' SageMaker IA sont également acceptables : `Sagemaker` ou. `sagemaker`
Nous vous recommandons d’utiliser la convention de dénomination des compartiments `sagemaker-{Region}-{accountID}`. Ce compartiment est utilisé pour stocker les artefacts que vous chargez.
Après avoir créé le compartiment, attachez-lui la politique CORS (cross-origin resource sharing, partage des ressources entre origines multiples) suivante :
```
[
{
"AllowedHeaders": ["*"],
"ExposeHeaders": ["Etag"],
"AllowedMethods": ["PUT", "POST"],
"AllowedOrigins": ['https://*.sagemaker.aws'],
}
]
```
Vous pouvez attacher une politique CORS à un compartiment Amazon S3 à l’aide de l’une des méthodes suivantes :
+ Via la page [Modifier le partage des ressources cross-origin (CORS)](https://s3.console.aws.amazon.com/s3/bucket/bucket-name/property/cors/edit) de la console Amazon S3
+ Utilisation de l'API Amazon S3 [PutBucketCors](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketCors.html)
+ À l'aide de la put-bucket-cors AWS CLI commande :
```
aws s3api put-bucket-cors --bucket="..." --cors-configuration="..."
```
### Création d’un modèle déployable
Au cours de cette étape, vous créez une version déployable de votre modèle dans SageMaker AI en fournissant vos artefacts ainsi que des spécifications supplémentaires, telles que le conteneur et le framework souhaités, tout code d'inférence personnalisé et les paramètres réseau.
Créez un modèle déployable dans SageMaker Studio en procédant comme suit :
1. Ouvrez l'application SageMaker Studio.
1. Dans le volet de navigation de gauche, choisissez **Modèles**.
1. Choisissez l’onglet **Modèles déployables**.
1. Sur la page **Modèles déployables**, choisissez **Créer**.
1. Sur la page **Créer un modèle déployable**, dans le champ **Nom du modèle**, saisissez un nom pour le modèle.
Vous trouverez plusieurs autres sections à remplir sur la page **Créer un modèle déployable**.
La section **Définition de conteneur** ressemble à la capture d’écran suivante :
![\[Capture d’écran de la section de Définition de conteneur pour créer un modèle dans Studio.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inference/studio-container-definition.png)
**Dans la section **Définition de conteneur**, procédez comme suit :**
1. Pour **le type de conteneur**, sélectionnez **Conteneur préconstruit** si vous souhaitez utiliser un conteneur géré par l' SageMaker IA, ou sélectionnez **Apportez votre propre conteneur** si vous avez votre propre conteneur.
1. Si vous avez sélectionné **Conteneur préconçu**, sélectionnez le **Framework de conteneur**, la **Version du framework** et le **Type de matériel** que vous souhaitez utiliser.
1. Si vous avez sélectionné **Apporter votre propre conteneur**, saisissez un chemin d’accès Amazon ECR pour le **Chemin d’accès ECR vers l’image du conteneur**.
Ensuite, remplissez la section **Artefacts**, qui ressemble à la capture d’écran suivante :
![\[Capture d’écran de la section Artefacts pour créer un modèle dans Studio.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inference/studio-artifacts-section.png)
**Pour la section **Artefacts**, procédez comme suit :**
1. **Si vous utilisez l'un des frameworks pris en charge par l' SageMaker IA pour empaqueter des artefacts de modèles (PyTorch ou XGBoost), vous pouvez choisir l'option **Télécharger des artefacts pour les artefacts**.** Avec cette option, vous pouvez simplement spécifier les artefacts de votre modèle brut, tout code d'inférence personnalisé dont vous disposez et votre fichier requirements.txt, et l' SageMaker IA se charge de l'empaquetage de l'archive pour vous. Procédez comme suit :
1. Pour **Artefacts**, sélectionnez **Charger les artefacts** pour continuer à fournir vos fichiers. Sinon, si vous avez déjà une archive `tar.gz` contenant vos fichiers de modèle, votre code d’inférence et votre fichier `requirements.txt`, sélectionnez **URI S3 d’entrée vers les artefacts prépackagés**.
1. Si vous avez choisi de télécharger vos artefacts, alors pour le **compartiment S3**, entrez le chemin Amazon S3 vers un compartiment dans lequel vous souhaitez que l' SageMaker IA stocke vos artefacts après les avoir emballés pour vous. Ensuite, procédez comme suit.
1. Pour **Charger les artefacts de modèle**, chargez vos fichiers de modèle.
1. Pour le **code d'inférence**, sélectionnez **Utiliser le code d'inférence par défaut** si vous souhaitez utiliser le code par défaut fourni par l' SageMaker IA pour servir l'inférence. Sinon, sélectionnez **Charger un code d’inférence personnalisé** pour utiliser votre propre code d’inférence.
1. Pour **Charger requirements.txt**, chargez un fichier texte répertoriant les dépendances que vous souhaitez installer lors de l’exécution.
1. Si vous n'utilisez pas de framework compatible avec l' SageMaker IA pour empaqueter les artefacts du modèle, Studio vous propose l'option **Artefacts préemballés**, et vous devez fournir tous vos artefacts déjà empaquetés sous forme d'`tar.gz`archive. Procédez comme suit :
1. Pour **Artefacts prépackagés**, sélectionnez **URI S3 d’entrée pour les artefacts de modèle prépackagés** si votre archive `tar.gz` a déjà été chargée sur Amazon S3. Sélectionnez **Télécharger des artefacts de modèles préemballés** si vous souhaitez télécharger directement vos archives vers SageMaker AI.
1. Si vous avez sélectionné **URI S3 d’entrée pour les artefacts de modèle prépackagés**, saisissez le chemin Amazon S3 vers votre archive pour **URI S3**. Sinon, sélectionnez et chargez l’archive à partir de votre machine locale.
La section suivante est **Sécurité**, qui ressemble à la capture d’écran suivante :
![\[Capture d’écran de la section Sécurité pour créer un modèle dans Studio.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inference/studio-security-section.png)
**Pour la section **Sécurité**, procédez comme suit :**
1. Pour **Rôle IAM**, saisissez l’ARN pour un rôle IAM.
1. (Facultatif) Pour **Cloud privé virtuel (VPC)**, vous pouvez sélectionner un VPC Amazon pour stocker votre configuration et vos artefacts de modèle.
1. (Facultatif) Activez le bouton **Isolement de réseau** si vous souhaitez restreindre l’accès Internet de votre conteneur.
Enfin, vous pouvez éventuellement remplir la section **Options avancées**, qui ressemble à la capture d’écran suivante :
![\[Capture d’écran de la section Options avancées pour créer un modèle dans Studio.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inference/studio-advanced-options.png)
**(Facultatif) Pour la section **Options avancées**, procédez comme suit :**
1. Activez le bouton **Recommandations d'instance personnalisées** si vous souhaitez exécuter une tâche Amazon SageMaker Inference Recommender sur votre modèle après sa création. Inference Recommender est une fonctionnalité qui vous fournit des types d’instance recommandés pour optimiser les performances et les coûts d’inférence. Vous pouvez consulter ces recommandations d’instances lorsque vous préparez le déploiement de votre modèle.
1. Pour **Ajouter des variables d’environnement**, saisissez une variable d’environnement pour votre conteneur sous forme de paires clé-valeur.
1. Pour **Balises**, saisissez toutes les balises sous forme de paires clé-valeur.
1. Après avoir terminé la configuration de votre modèle et de votre conteneur, sélectionnez **Créer un modèle déployable**.
Vous devriez maintenant disposer dans SageMaker Studio d'un modèle prêt à être déployé.
### Déployer votre modèle
Enfin, vous déployez le modèle que vous avez configuré à l’étape précédente sur un point de terminaison HTTPS. Vous pouvez déployer un modèle unique ou plusieurs modèles sur le point de terminaison.
**Compatibilité entre le modèle et le point de terminaison**
Avant de pouvoir déployer un modèle sur un point de terminaison, le modèle et le point de terminaison doivent être compatibles en ayant les mêmes valeurs pour les paramètres suivants :
Le rôle IAM
Le VPC Amazon, y compris ses sous-réseaux et groupes de sécurité
L’isolement du réseau (activé ou désactivé)
Studio vous empêche de déployer des modèles sur des points de terminaison incompatibles de la manière suivante :
Si vous tentez de déployer un modèle sur un nouveau point de terminaison, l' SageMaker IA configure le point de terminaison avec des paramètres initiaux compatibles. Si vous interrompez la compatibilité en modifiant ces paramètres, Studio affiche une alerte et empêche votre déploiement.
Si vous tentez de déployer sur un point de terminaison existant et que celui-ci est incompatible, Studio affiche une alerte et empêche votre déploiement.
Si vous tentez d’ajouter plusieurs modèles à un déploiement, Studio vous empêche de déployer des modèles incompatibles entre eux.
Lorsque Studio affiche l’alerte concernant l’incompatibilité du modèle et du point de terminaison, vous pouvez choisir **Afficher les détails** de l’alerte pour voir quels paramètres sont incompatibles.
Pour déployer un modèle, vous pouvez notamment procéder comme suit dans Studio :
1. Ouvrez l'application SageMaker Studio.
1. Dans le volet de navigation de gauche, choisissez **Modèles**.
1. Sur la page **Modèles**, sélectionnez un ou plusieurs modèles dans la liste des modèles d' SageMaker IA.
1. Choisissez **Déployer**.
1. Pour **Nom du point de terminaison**, ouvrez le menu déroulant. Vous pouvez sélectionner un point de terminaison existant ou créer un nouveau point de terminaison sur lequel vous déployez le modèle.
1. Pour **Type d’instance**, sélectionnez le type d’instance à utiliser pour le point de terminaison. Si vous avez déjà exécuté une tâche Inference Recommender pour le modèle, les types d’instance que vous recommandez apparaissent dans la liste sous le titre **Recommandé**. Sinon, vous verrez quelques **Instances potentielles** susceptibles de convenir à votre modèle.
**Compatibilité des types d'instance pour JumpStart**
Si vous déployez un JumpStart modèle, Studio affiche uniquement les types d'instances pris en charge par le modèle.
1. Dans **Nombre d’instances initial**, saisissez le nombre initial d’instances que vous souhaitez provisionner pour votre point de terminaison.
1. Pour **Nombre maximal d’instances**, spécifiez le nombre maximum d’instances que le point de terminaison peut mettre en service lorsqu’il augmente verticalement pour faire face à une augmentation du trafic.
1. Si le modèle que vous déployez est l'un des modèles les plus utilisés JumpStart LLMs depuis le hub de modèles, l'option **Autres configurations** apparaît après les champs de type d'instance et de nombre d'instances.
Pour les plus populaires JumpStart LLMs, AWS propose des types d'instances pré-comparés afin d'optimiser les coûts ou les performances. Ces données peuvent vous aider à choisir le type d’instance à utiliser pour déployer votre LLM. Choisissez **Autres configurations** pour ouvrir une boîte de dialogue contenant les données préévaluées. Le panneau ressemble à la capture d’écran suivante :
![\[Capture d’écran de la boîte Autres configurations\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inference/studio-jumpstart-alternate-configurations.png)
Dans la boîte **Autres configurations**, procédez comme suit :
1. Sélectionnez un type d’instance. Vous pouvez choisir **Coût par heure** ou **Meilleures performances** pour voir les types d’instance qui optimisent le coût ou les performances pour le modèle spécifié. Vous pouvez également sélectionner **Autres instances prises en charge** pour voir la liste des autres types d'instances compatibles avec le JumpStart modèle. Notez que la sélection d’un type d’instance ici remplace toute sélection d’instance précédente spécifiée à l’étape 6.
1. (Facultatif) Activez le bouton **Personnaliser la configuration sélectionnée** pour spécifier le **Nombre maximum de jetons** (le nombre maximum de jetons que vous souhaitez autoriser, qui est la somme de vos jetons d’entrée et de la sortie générée par le modèle), la **Longueur maximale du jeton d’entrée** (le nombre maximum de jetons que vous souhaitez autoriser pour l’entrée de chaque demande) et le **Nombre maximal de requêtes simultanées** (le nombre maximum de requêtes que le modèle peut traiter à la fois).
1. Choisissez **Sélectionner** pour confirmer le type d’instance et les paramètres de configuration.
1. Le champ **Modèle** doit déjà être renseigné avec le nom du ou des modèles que vous déployez. Vous pouvez choisir **Ajouter un modèle** pour ajouter d’autres modèles au déploiement. Pour chaque modèle ajouté, renseignez les champs suivants :
1. Dans **Nombre de cœurs de l’UC**, saisissez les cœurs de processeur que vous souhaitez consacrer à l’utilisation du modèle.
1. Pour **Nombre minimum de copies**, saisissez le nombre minimum de copies de modèle que vous souhaitez héberger sur le point de terminaison à un moment donné.
1. Pour **Mémoire minimale de l’UC (Mo)**, saisissez la quantité minimale de mémoire (en Mo) requise par le modèle.
1. Pour **Mémoire maximale de l’UC (Mo)**, saisissez la quantité maximale de mémoire (en Mo) que vous souhaitez autoriser le modèle à utiliser.
1. (Facultatif) Pour **Options avancées**, procédez comme suit :
1. Pour le **rôle IAM**, utilisez le rôle d'exécution SageMaker AI IAM par défaut ou spécifiez votre propre rôle doté des autorisations dont vous avez besoin. Notez que ce rôle IAM doit être identique à celui que vous avez spécifié lors de la création du modèle déployable.
1. Pour **Cloud privé virtuel (VPC)**, vous pouvez spécifier le VPC dans lequel vous souhaitez héberger votre point de terminaison.
1. Pour la **clé KMS de chiffrement**, sélectionnez une AWS KMS clé pour chiffrer les données sur le volume de stockage attaché à l'instance de calcul ML qui héberge le point de terminaison.
1. Activez le bouton **Activer l’isolement du réseau** pour restreindre l’accès Internet de votre conteneur.
1. Pour **Configuration du délai d’attente**, saisissez des valeurs dans les champs **Expiration de téléchargement des données du modèle (secondes)** et **Expiration de surveillance de l’état du démarrage du conteneur (secondes)**. Ces valeurs déterminent le temps maximal accordé par l' SageMaker IA pour télécharger le modèle dans le conteneur et démarrer le conteneur, respectivement.
1. Pour **Balises**, saisissez toutes les balises sous forme de paires clé-valeur.
**Note**
SageMaker L'IA configure le rôle IAM, le VPC et les paramètres d'isolation du réseau avec des valeurs initiales compatibles avec le modèle que vous déployez. Si vous interrompez la compatibilité en modifiant ces paramètres, Studio affiche une alerte et empêche votre déploiement.
Une fois vos options configurées, la page doit ressembler à la capture d’écran suivante.
![\[Capture d’écran de la page Déploiement du modèle dans Studio.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inference/studio-deploy-realtime-model-2.png)
Après avoir configuré votre déploiement, choisissez **Déployer** pour créer le point de terminaison et déployer votre modèle.
## Déployez des modèles avec Python SDKs
À l'aide du SDK SageMaker Python, vous pouvez créer votre modèle de deux manières. La première consiste à créer un objet modèle à partir de la classe `Model` ou `ModelBuilder`. Si vous utilisez la classe `Model` pour créer votre objet `Model`, vous devez spécifier le package de modèle ou le code d’inférence (en fonction de votre modèle de serveur), les scripts pour gérer la sérialisation et la désérialisation des données entre le client et le serveur, ainsi que toutes les dépendances à charger sur Amazon S3 à des fins de consommation. La deuxième méthode de création de votre modèle consiste à utiliser un `ModelBuilder` pour lequel vous fournissez des artefacts ou un code d’inférence. `ModelBuilder` capture automatiquement vos dépendances, en déduit les fonctions de sérialisation et de désérialisation nécessaires et empaquète vos dépendances pour créer votre objet `Model`. Pour plus d’informations sur `ModelBuilder`, consultez [Créez un modèle dans Amazon SageMaker AI avec ModelBuilder](how-it-works-modelbuilder-creation.md).
La section suivante décrit les deux méthodes permettant de créer votre modèle et de déployer votre objet modèle.
### Configuration
Les exemples suivants préparent le processus de déploiement du modèle. Ils importent les bibliothèques nécessaires et définissent l’URL S3 qui localise les artefacts du modèle.
------
#### [ SageMaker Python SDK ]
**Example instructions d’importation**
L'exemple suivant importe des modules depuis le SDK SageMaker Python, le SDK pour Python (Boto3) et la bibliothèque standard Python. Ces modules fournissent des méthodes utiles qui vous aident à déployer des modèles et ils sont utilisés dans les exemples suivants.
```
import boto3
from datetime import datetime
from sagemaker.compute_resource_requirements.resource_requirements import ResourceRequirements
from sagemaker.predictor import Predictor
from sagemaker.enums import EndpointType
from sagemaker.model import Model
from sagemaker.session import Session
```
------
#### [ boto3 inference components ]
**Example instructions d’importation**
L’exemple suivant importe des modules à partir du kit SDK pour Python (Boto3) et de la bibliothèque standard Python. Ces modules fournissent des méthodes utiles qui vous aident à déployer des modèles et ils sont utilisés dans les exemples suivants.
```
import boto3
import botocore
import sys
import time
```
------
#### [ boto3 models (without inference components) ]
**Example instructions d’importation**
L’exemple suivant importe des modules à partir du kit SDK pour Python (Boto3) et de la bibliothèque standard Python. Ces modules fournissent des méthodes utiles qui vous aident à déployer des modèles et ils sont utilisés dans les exemples suivants.
```
import boto3
import botocore
import datetime
from time import gmtime, strftime
```
------
**Example URL de l’artefact de modèle**
Le code suivant permet de créer un exemple d’URL Amazon S3. L’URL localise les artefacts de modèle pour un modèle préentraîné dans un compartiment Amazon S3.
```
# Create a variable w/ the model S3 URL
# The name of your S3 bucket:
s3_bucket = "amzn-s3-demo-bucket"
# The directory within your S3 bucket your model is stored in:
bucket_prefix = "sagemaker/model/path"
# The file name of your model artifact:
model_filename = "my-model-artifact.tar.gz"
# Relative S3 path:
model_s3_key = f"{bucket_prefix}/"+model_filename
# Combine bucket name, model file name, and relate S3 path to create S3 model URL:
model_url = f"s3://{s3_bucket}/{model_s3_key}"
```
L’URL Amazon S3 complète est stockée dans la variable `model_url`, qui est utilisée dans les exemples suivants.
### Présentation de
Il existe plusieurs manières de déployer des modèles avec le SDK SageMaker Python ou le SDK pour Python (Boto3). Les sections suivantes résument les étapes que vous devez suivre pour différentes approches possibles. Ces étapes sont illustrées par les exemples suivants.
------
#### [ SageMaker Python SDK ]
À l'aide du SDK SageMaker Python, vous pouvez créer votre modèle de l'une des manières suivantes :
+ **Créer un objet modèle à partir de la classe `Model`** : vous devez spécifier le package du modèle ou le code d’inférence (en fonction de votre modèle de serveur), les scripts pour gérer la sérialisation et la désérialisation des données entre le client et le serveur, ainsi que toutes les dépendances à télécharger sur Amazon S3 à des fins de consommation.
+ **Créer un objet modèle à partir de la classe `ModelBuilder`** : vous fournissez des artefacts de modèle ou du code d’inférence et `ModelBuilder` capture automatiquement vos dépendances, en déduit les fonctions de sérialisation et de désérialisation nécessaires, et empaquète vos dépendances pour créer votre objet `Model`.
Pour plus d’informations sur `ModelBuilder`, consultez [Créez un modèle dans Amazon SageMaker AI avec ModelBuilder](how-it-works-modelbuilder-creation.md). Vous pouvez également consulter le blog [Package et déployer des modèles de ML classiques et LLMs facilement avec SageMaker AI — Partie 1](https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-1-pysdk-improvements/) pour plus d'informations.
Les exemples suivants décrivent les deux méthodes de création de votre modèle et de déploiement de votre objet modèle. Pour déployer un modèle de ces manières, procédez comme suit :
1. Définissez les ressources du point de terminaison à allouer au modèle avec un objet `ResourceRequirements`.
1. Créez un objet modèle à partir des classes `Model` ou `ModelBuilder`. L’objet `ResourceRequirements` est spécifié dans les paramètres du modèle.
1. Déployez le modèle sur un point de terminaison en utilisant la méthode `deploy` de l’objet `Model`.
------
#### [ boto3 inference components ]
Les exemples suivants montrent comment attribuer un modèle à un composant d’inférence, puis déployer le composant d’inférence sur un point de terminaison. Pour déployer un modèle de cette manière, procédez comme suit :
1. (Facultatif) Créez un objet de modèle d' SageMaker IA à l'aide de la [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html)méthode.
1. Spécifiez les paramètres de votre point de terminaison en créant un objet de configuration du point de terminaison. Pour en créer un, vous devez utiliser la méthode [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config).
1. Créez votre point de terminaison à l’aide de la méthode [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) et, dans votre demande, indiquez la configuration du point de terminaison que vous avez créée.
1. Créez un composant d’inférence à l’aide de la méthode `create_inference_component`. Dans les paramètres, vous pouvez spécifier un modèle en effectuant l’une des actions suivantes :
+ Spécification d'un objet de modèle d' SageMaker IA
+ Spécification de l’URI de l’image du modèle et de l’URL S3
Vous allouez également des ressources de point de terminaison au modèle. En créant le composant d’inférence, vous déployez le modèle sur le point de terminaison. Vous pouvez déployer plusieurs modèles sur un point de terminaison en créant plusieurs composants d’inférence, un pour chaque modèle.
------
#### [ boto3 models (without inference components) ]
Les exemples suivants montrent comment créer un objet de modèle, puis déployer le modèle sur un point de terminaison. Pour déployer un modèle de cette manière, procédez comme suit :
1. Créez un modèle d' SageMaker IA à l'aide de la [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html)méthode.
1. Spécifiez les paramètres de votre point de terminaison en créant un objet de configuration du point de terminaison. Pour en créer un, vous devez utiliser la méthode [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config). Dans la configuration du point de terminaison, vous attribuez l’objet modèle à une variante de production.
1. Créez votre point de terminaison à l’aide de la méthode [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html). Dans votre demande, indiquez la configuration du point de terminaison que vous avez créée.
Lorsque vous créez le point de terminaison, l' SageMaker IA provisionne les ressources du point de terminaison et déploie le modèle sur le point de terminaison.
------
### Configurer
Les exemples suivants configurent les ressources dont vous avez besoin pour déployer un modèle sur un point de terminaison.
------
#### [ SageMaker Python SDK ]
L’exemple suivant affecte des ressources de point de terminaison à un modèle avec un objet `ResourceRequirements`. Ces ressources incluent les cœurs d’UC, les accélérateurs et la mémoire. L’exemple crée ensuite un objet modèle à partir de la classe `Model`. Vous pouvez également créer un objet modèle en instanciant la [ModelBuilder](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-modelbuilder-creation.html)classe et en l'exécutant. `build` Cette méthode est également illustrée dans l'exemple. `ModelBuilder`fournit une interface unifiée pour l'empaquetage des modèles et, dans ce cas, prépare un modèle pour un déploiement de modèles à grande échelle. L’exemple utilise `ModelBuilder` pour construire un modèle Hugging Face. (Vous pouvez également transmettre un JumpStart modèle). Une fois le modèle créé, vous pouvez spécifier les besoins en ressources dans l’objet modèle. Dans l’étape suivante, vous allez utiliser cet objet pour déployer le modèle sur un point de terminaison.
```
resources = ResourceRequirements(
requests = {
"num_cpus": 2, # Number of CPU cores required:
"num_accelerators": 1, # Number of accelerators required
"memory": 8192, # Minimum memory required in Mb (required)
"copies": 1,
},
limits = {},
)
now = datetime.now()
dt_string = now.strftime("%d-%m-%Y-%H-%M-%S")
model_name = "my-sm-model"+dt_string
# build your model with Model class
model = Model(
name = "model-name",
image_uri = "image-uri",
model_data = model_url,
role = "arn:aws:iam::111122223333:role/service-role/role-name",
resources = resources,
predictor_cls = Predictor,
)
# Alternate mechanism using ModelBuilder
# uncomment the following section to use ModelBuilder
/*
model_builder = ModelBuilder(
model="", # like "meta-llama/Llama-2-7b-hf"
schema_builder=SchemaBuilder(sample_input,sample_output),
env_vars={ "HUGGING_FACE_HUB_TOKEN": "}" }
)
# build your Model object
model = model_builder.build()
# create a unique name from string 'mb-inference-component'
model.model_name = unique_name_from_base("mb-inference-component")
# assign resources to your model
model.resources = resources
*/
```
------
#### [ boto3 inference components ]
L’exemple suivant configure un point de terminaison avec la méthode `create_endpoint_config`. Vous attribuez cette configuration à un point de terminaison lorsque vous le créez. Dans la configuration, vous définissez une ou plusieurs variantes de production. Pour chaque variante, vous pouvez choisir le type d'instance que vous souhaitez qu'Amazon SageMaker AI fournisse, et vous pouvez activer le dimensionnement des instances gérées.
```
endpoint_config_name = "endpoint-config-name"
endpoint_name = "endpoint-name"
inference_component_name = "inference-component-name"
variant_name = "variant-name"
sagemaker_client.create_endpoint_config(
EndpointConfigName = endpoint_config_name,
ExecutionRoleArn = "arn:aws:iam::111122223333:role/service-role/role-name",
ProductionVariants = [
{
"VariantName": variant_name,
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1,
"ManagedInstanceScaling": {
"Status": "ENABLED",
"MinInstanceCount": 1,
"MaxInstanceCount": 2,
},
}
],
)
```
------
#### [ boto3 models (without inference components) ]
**Example définition du modèle**
L'exemple suivant définit un modèle d' SageMaker IA avec la `create_model` méthode dans le AWS SDK pour Python (Boto3).
```
model_name = "model-name"
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = "arn:aws:iam::111122223333:role/service-role/role-name",
PrimaryContainer = {
"Image": "image-uri",
"ModelDataUrl": model_url,
}
)
```
Cet exemple spécifie les éléments suivants :
+ `ModelName` : nom de votre modèle (dans cet exemple, il est stocké sous la forme d’une variable de chaîne appelée `model_name`).
+ `ExecutionRoleArn`: le nom de ressource Amazon (ARN) du rôle IAM qu'Amazon SageMaker AI peut assumer pour accéder aux artefacts du modèle et aux images Docker à des fins de déploiement sur des instances de calcul ML ou pour des tâches de transformation par lots.
+ `PrimaryContainer` : l’emplacement de l’image Docker principale contenant le code d’inférence, les artefacts associés et les cartes d’environnement personnalisées que le code d’inférence utilise lorsque le modèle est déployé pour les prédictions.
**Example configuration du point de terminaison ;**
L’exemple suivant configure un point de terminaison avec la méthode `create_endpoint_config`. Amazon SageMaker AI utilise cette configuration pour déployer des modèles. Dans la configuration, vous identifiez un ou plusieurs modèles, créés avec la `create_model` méthode, pour déployer les ressources que vous souhaitez qu'Amazon SageMaker AI fournisse.
```
endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName = "endpoint-config-name",
# List of ProductionVariant objects, one for each model that you want to host at this endpoint:
ProductionVariants = [
{
"VariantName": "variant-name", # The name of the production variant.
"ModelName": model_name,
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
]
)
```
Cet exemple indique les clés suivantes pour le champ `ProductionVariants` :
+ `VariantName` : nom de la variante de production.
+ `ModelName` : nom du modèle que vous voulez héberger. Il s’agit du nom que vous avez spécifié lors de la création du modèle.
+ `InstanceType` : type d’instance de calcul. Consultez le `InstanceType` champ dans [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html) et la section [Tarification de l'SageMaker IA](https://aws.amazon.com/sagemaker/pricing/) pour obtenir la liste des types d'instances de calcul pris en charge et les tarifs de chaque type d'instance.
------
### Déploiement
Les exemples suivants déploient un modèle sur un point de terminaison.
------
#### [ SageMaker Python SDK ]
L’exemple suivant déploie le modèle sur un point de terminaison HTTPS en temps réel avec la méthode `deploy` de l’objet modèle. Si vous spécifiez une valeur pour l’argument `resources` à la fois pour la création et le déploiement du modèle, les ressources que vous spécifiez pour le déploiement sont prioritaires.
```
predictor = model.deploy(
initial_instance_count = 1,
instance_type = "ml.p4d.24xlarge",
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
resources = resources,
)
```
Pour le champ `instance_type`, l’exemple indique le nom du type d’instance Amazon EC2 pour le modèle. Pour le champ `initial_instance_count`, il indique le nombre initial d’instances sur lesquelles exécuter le point de terminaison.
L’exemple de code suivant illustre un autre cas où vous déployez un modèle sur un point de terminaison, puis un autre modèle sur le même point de terminaison. Dans ce cas, vous devez fournir le même nom de point de terminaison aux méthodes `deploy` des deux modèles.
```
# Deploy the model to inference-component-based endpoint
falcon_predictor = falcon_model.deploy(
initial_instance_count = 1,
instance_type = "ml.p4d.24xlarge",
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
endpoint_name = ""
resources = resources,
)
# Deploy another model to the same inference-component-based endpoint
llama2_predictor = llama2_model.deploy( # resources already set inside llama2_model
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
endpoint_name = "" # same endpoint name as for falcon model
)
```
------
#### [ boto3 inference components ]
Une fois que vous avez une configuration de point de terminaison, utilisez la méthode [create\$1point](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) pour créer votre point de terminaison. Le nom du point de terminaison doit être unique au sein de votre AWS compte. Région AWS
L’exemple suivant crée un point de terminaison à l’aide de la configuration du point de terminaison spécifiée dans la requête. Amazon SageMaker AI utilise le point de terminaison pour provisionner les ressources.
```
sagemaker_client.create_endpoint(
EndpointName = endpoint_name,
EndpointConfigName = endpoint_config_name,
)
```
Une fois que vous avez créé un point de terminaison, vous pouvez y déployer un ou plusieurs modèles en créant des composants d’inférence. L’exemple suivant en crée un à l’aide de la méthode `create_inference_component`.
```
sagemaker_client.create_inference_component(
InferenceComponentName = inference_component_name,
EndpointName = endpoint_name,
VariantName = variant_name,
Specification = {
"Container": {
"Image": "image-uri",
"ArtifactUrl": model_url,
},
"ComputeResourceRequirements": {
"NumberOfCpuCoresRequired": 1,
"MinMemoryRequiredInMb": 1024
}
},
RuntimeConfig = {"CopyCount": 2}
)
```
------
#### [ boto3 models (without inference components) ]
**Example déploiement**
Fournissez la configuration du point de terminaison à SageMaker AI. Le service lance les instances de calcul ML et déploie le ou les modèles tel que spécifié dans la configuration.
Une fois que vous avez votre modèle et votre configuration du point de terminaison, utilisez la méthode [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) pour créer votre point de terminaison. Le nom du point de terminaison doit être unique au sein de votre AWS compte. Région AWS
L’exemple suivant crée un point de terminaison à l’aide de la configuration du point de terminaison spécifiée dans la requête. Amazon SageMaker AI utilise le point de terminaison pour provisionner des ressources et déployer des modèles.
```
create_endpoint_response = sagemaker_client.create_endpoint(
# The endpoint name must be unique within an AWS Region in your AWS account:
EndpointName = "endpoint-name"
# The name of the endpoint configuration associated with this endpoint:
EndpointConfigName = "endpoint-config-name")
```
------
## Déployez des modèles avec le AWS CLI
Vous pouvez déployer un modèle sur un point de terminaison à l'aide du AWS CLI.
### Présentation de
Lorsque vous déployez un modèle avec le AWS CLI, vous pouvez le déployer avec ou sans composant d'inférence. Les sections suivantes résument les commandes que vous exécutez pour les deux approches. Ces commandes sont illustrées par les exemples suivants.
------
#### [ With inference components ]
Pour déployer un modèle avec un composant d’inférence, procédez comme suit :
1. (Facultatif) Créez un modèle à l’aide de la commande [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html).
1. Spécifiez les paramètres de votre point de terminaison en créant une configuration du point de terminaison. Pour en créer une, vous devez exécuter la commande [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html).
1. Créez votre point de terminaison à l’aide de la commande [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html). Dans le corps de commande, spécifiez la configuration du point de terminaison que vous avez créée.
1. Créez un composant d’inférence à l’aide de la commande `create-inference-component`. Dans les paramètres, vous pouvez spécifier un modèle en effectuant l’une des actions suivantes :
+ Spécification d'un objet de modèle d' SageMaker IA
+ Spécification de l’URI de l’image du modèle et de l’URL S3
Vous allouez également des ressources de point de terminaison au modèle. En créant le composant d’inférence, vous déployez le modèle sur le point de terminaison. Vous pouvez déployer plusieurs modèles sur un point de terminaison en créant plusieurs composants d’inférence, un pour chaque modèle.
------
#### [ Without inference components ]
Pour déployer un modèle sans utiliser de composant d’inférence, procédez comme suit :
1. Créez un modèle d' SageMaker IA à l'aide de la [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html)commande.
1. Spécifiez les paramètres de votre point de terminaison en créant un objet de configuration du point de terminaison. Vous utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html) pour en créer un. Dans la configuration du point de terminaison, vous attribuez l’objet modèle à une variante de production.
1. Créez votre point de terminaison à l’aide de la commande [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html). Dans le corps de commande, spécifiez la configuration du point de terminaison que vous avez créée.
Lorsque vous créez le point de terminaison, l' SageMaker IA provisionne les ressources du point de terminaison et déploie le modèle sur le point de terminaison.
------
### Configurer
Les exemples suivants configurent les ressources dont vous avez besoin pour déployer un modèle sur un point de terminaison.
------
#### [ With inference components ]
**Example create-endpoint-config commande**
L'exemple suivant crée une configuration de point de terminaison avec la [create-endpoint-config](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html)commande.
```
aws sagemaker create-endpoint-config \
--endpoint-config-name endpoint-config-name \
--execution-role-arn arn:aws:iam::111122223333:role/service-role/role-name\
--production-variants file://production-variants.json
```
Dans cet exemple, le fichier `production-variants.json` définit une variante de production avec le code JSON suivant :
```
[
{
"VariantName": "variant-name",
"ModelName": "model-name",
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1
}
]
```
Si la commande aboutit, elle AWS CLI répond avec l'ARN de la ressource que vous avez créée.
```
{
"EndpointConfigArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint-config/endpoint-config-name"
}
```
------
#### [ Without inference components ]
**Example commande create-model**
L’exemple suivant crée un modèle à l’aide de la commande [create-model](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html).
```
aws sagemaker create-model \
--model-name model-name \
--execution-role-arn arn:aws:iam::111122223333:role/service-role/role-name \
--primary-container "{ \"Image\": \"image-uri\", \"ModelDataUrl\": \"model-s3-url\"}"
```
Si la commande aboutit, elle AWS CLI répond avec l'ARN de la ressource que vous avez créée.
```
{
"ModelArn": "arn:aws:sagemaker:us-west-2:111122223333:model/model-name"
}
```
**Example create-endpoint-config commande**
L'exemple suivant crée une configuration de point de terminaison avec la [create-endpoint-config](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html)commande.
```
aws sagemaker create-endpoint-config \
--endpoint-config-name endpoint-config-name \
--production-variants file://production-variants.json
```
Dans cet exemple, le fichier `production-variants.json` définit une variante de production avec le code JSON suivant :
```
[
{
"VariantName": "variant-name",
"ModelName": "model-name",
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1
}
]
```
Si la commande aboutit, elle AWS CLI répond avec l'ARN de la ressource que vous avez créée.
```
{
"EndpointConfigArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint-config/endpoint-config-name"
}
```
------
### Déploiement
Les exemples suivants déploient un modèle sur un point de terminaison.
------
#### [ With inference components ]
**Example commande create-endpoint**
L’exemple suivant d’utilisation permet de créer un point de terminaison avec la commande [create-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html).
```
aws sagemaker create-endpoint \
--endpoint-name endpoint-name \
--endpoint-config-name endpoint-config-name
```
Si la commande aboutit, elle AWS CLI répond avec l'ARN de la ressource que vous avez créée.
```
{
"EndpointArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint/endpoint-name"
}
```
**Example create-inference-component commande**
L'exemple suivant crée un composant d'inférence avec la create-inference-component commande.
```
aws sagemaker create-inference-component \
--inference-component-name inference-component-name \
--endpoint-name endpoint-name \
--variant-name variant-name \
--specification file://specification.json \
--runtime-config "{\"CopyCount\": 2}"
```
Dans cet exemple, le fichier `specification.json` définit le conteneur et les ressources de calcul avec le JSON suivant :
```
{
"Container": {
"Image": "image-uri",
"ArtifactUrl": "model-s3-url"
},
"ComputeResourceRequirements": {
"NumberOfCpuCoresRequired": 1,
"MinMemoryRequiredInMb": 1024
}
}
```
Si la commande aboutit, elle AWS CLI répond avec l'ARN de la ressource que vous avez créée.
```
{
"InferenceComponentArn": "arn:aws:sagemaker:us-west-2:111122223333:inference-component/inference-component-name"
}
```
------
#### [ Without inference components ]
**Example commande create-endpoint**
L’exemple suivant d’utilisation permet de créer un point de terminaison avec la commande [create-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html).
```
aws sagemaker create-endpoint \
--endpoint-name endpoint-name \
--endpoint-config-name endpoint-config-name
```
Si la commande aboutit, elle AWS CLI répond avec l'ARN de la ressource que vous avez créée.
```
{
"EndpointArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint/endpoint-name"
}
```
------
# Invocation de modèles pour une inférence en temps réel
Après avoir utilisé Amazon SageMaker AI pour déployer un modèle sur un point de terminaison, vous pouvez interagir avec le modèle en lui envoyant des demandes d'inférence. Pour envoyer une demande d’inférence à un modèle, vous invoquez le point de terminaison qui l’héberge. Vous pouvez appeler vos points de terminaison à l'aide d'Amazon SageMaker Studio, du AWS SDKs, ou du AWS CLI.
## Invoquez votre modèle à l'aide d'Amazon SageMaker Studio
Après avoir déployé votre modèle sur un point de terminaison, vous pouvez consulter le point de terminaison via Amazon SageMaker Studio et tester votre point de terminaison en envoyant des demandes d'inférence uniques.
**Note**
SageMaker L'IA ne prend en charge les tests de terminaux dans Studio que pour les points de terminaison en temps réel.
**Pour envoyer une demande d’inférence de test à votre point de terminaison**
1. Lancez Amazon SageMaker Studio.
1. Dans le panneau de navigation de gauche, sélectionnez **Déploiements**.
1. Dans le menu déroulant, sélectionnez **Endpoints** (Points de terminaison).
1. Recherchez votre point de terminaison par son nom, puis choisissez-le dans le tableau. Les noms de point de terminaison répertoriés dans le panneau **Points de terminaison** sont définis lorsque vous déployez un modèle. L’espace de travail Studio ouvre la page **Point de terminaison** dans un nouvel onglet.
1. Sélectionnez l’onglet **Tester l’inférence**.
1. Dans **Options de test**, sélectionnez l’une des options suivantes :
1. Sélectionnez **Tester l’exemple de demande** pour envoyer immédiatement une demande à votre point de terminaison. Utilisez l’**éditeur JSON** pour fournir des exemples de données au format JSON, puis choisissez **Envoyer la demande** pour envoyer la demande à votre point de terminaison. Après l’envoi de votre demande, Studio affiche le résultat de l’inférence dans une carte à droite de l’éditeur JSON.
1. Sélectionnez **Utiliser un exemple de code du kit SDK Python** pour afficher le code permettant d’envoyer une demande au point de terminaison. Copiez ensuite l’exemple de code depuis la section **Exemple de demande d’inférence** et exécutez le code depuis votre environnement de test.
Le haut de la carte affiche le type de demande qui a été envoyée au point de terminaison (seul JSON est accepté). La carte affiche les champs suivants :
+ **Statut** : affiche l’un des types de statut suivants :
+ `Success` : la demande a réussi.
+ `Failed` : la demande a échoué. Une réponse apparaît sous **Motif de l’échec**.
+ `Pending` : une icône circulaire et en rotation apparaît pendant que la demande d’inférence est en attente.
+ **Longueur d’exécution** : durée de l’invocation (heure de fin moins l’heure de début) en millisecondes.
+ **Durée de la demande** : nombre de minutes qui se sont écoulées depuis l’envoi de la demande.
+ **Durée du résultat** : nombre de minutes qui se sont écoulées depuis le renvoi du résultat.
## Invoquez votre modèle à l'aide du AWS SDK pour Python (Boto3)
Si vous souhaitez invoquer un point de terminaison modèle dans le code de votre application, vous pouvez utiliser l'un des AWS SDKs, notamment le AWS SDK pour Python (Boto3). Pour invoquer votre point de terminaison à l’aide de ce kit SDK, vous devez utiliser l’une des méthodes Python suivantes :
+ `invoke_endpoint` : envoie une demande d’inférence à un point de terminaison du modèle et renvoie la réponse générée par le modèle.
Cette méthode renvoie les données utiles d’inférence sous la forme d’une réponse une fois que le modèle a fini de la générer. Pour plus d’informations, consultez [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html) dans la *Référence des API du kit AWS SDK pour Python (Boto)*.
+ `invoke_endpoint_with_response_stream` : envoie une demande d’inférence à un point de terminaison du modèle et diffuse la réponse de manière incrémentielle pendant que le modèle la génère.
Avec cette méthode, votre application reçoit des parties de la réponse dès qu’elles sont disponibles. Pour plus d’informations, consultez [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html) dans la *Référence des API du kit AWS SDK pour Python (Boto)*.
Utilisez cette méthode uniquement pour invoquer des modèles qui prennent en charge le streaming d’inférence.
Avant de pouvoir utiliser ces méthodes dans le code de votre application, vous devez initialiser un client SageMaker AI Runtime et spécifier le nom de votre point de terminaison. L’exemple suivant configure le client et le point de terminaison pour les autres exemples suivants :
```
import boto3
sagemaker_runtime = boto3.client(
"sagemaker-runtime", region_name='aws_region')
endpoint_name='endpoint-name'
```
### Invocation pour obtenir une réponse d’inférence
L’exemple suivant utilise la méthode `invoke_endpoint` pour invoquer un point de terminaison avec le kit AWS SDK pour Python (Boto3) :
```
# Gets inference from the model hosted at the specified endpoint:
response = sagemaker_runtime.invoke_endpoint(
EndpointName=endpoint_name,
Body=bytes('{"features": ["This is great!"]}', 'utf-8')
)
# Decodes and prints the response body:
print(response['Body'].read().decode('utf-8'))
```
Cet exemple fournit des données d'entrée dans le `Body` champ pour que l' SageMaker IA les transmette au modèle. Ces données doivent être dans le même format que celui utilisé pour l’entraînement. L’exemple assigne la réponse à la variable `response`.
La variable `response` permet d’accéder au statut HTTP, au nom du modèle déployé et à d’autres champs. L’extrait de code suivant imprime le code de statut HTTP :
```
print(response["HTTPStatusCode"])
```
### Invoquer pour diffuser une réponse d’inférence
Si vous avez déployé un modèle qui prend en charge le streaming d’inférence, vous pouvez invoquer le modèle pour recevoir ses données utiles d’inférence sous forme de flux de parties. Le modèle fournit ces pièces progressivement au fur et à mesure qu’il les génère. Lorsqu’une application reçoit un flux d’inférence, elle n’a pas besoin d’attendre que le modèle génère la totalité des données utiles de réponse. Au lieu de cela, l’application reçoit immédiatement des parties de la réponse dès qu’elles sont disponibles.
En consommant un flux d’inférence dans votre application, vous pouvez créer des interactions dans lesquelles vos utilisateurs perçoivent l’inférence comme étant rapide, car ils obtiennent immédiatement la première partie. Vous pouvez mettre en œuvre le streaming pour prendre en charge des expériences interactives rapides, telles que les chatbots, les assistants virtuels et les générateurs de musique. Par exemple, vous pouvez créer un chatbot qui affiche progressivement le texte généré par un grand modèle de langage (LLM).
Pour obtenir un flux d’inférence, vous pouvez utiliser la méthode `invoke_endpoint_with_response_stream`. Dans le corps de la réponse, le kit SDK fournit un objet `EventStream`, qui donne l’inférence sous la forme d’une série d’objets `PayloadPart`.
**Example Flux d’inférence**
L’exemple suivant est un flux d’objets `PayloadPart` :
```
{'PayloadPart': {'Bytes': b'{"outputs": [" a"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" challenging"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" problem"]}\n'}}
. . .
```
Dans chaque partie des données utiles, le champ `Bytes` fournit une partie de la réponse d’inférence du modèle. Cette partie peut être n’importe quel type de contenu généré par un modèle, tel que du texte, des images ou des données audio. Dans cet exemple, les parties sont des objets JSON contenant du texte généré à partir d’un LLM.
En général, la partie de la charge utile contient un fragment discret de données du modèle. Dans cet exemple, les fragments discrets sont des objets JSON entiers. Parfois, la réponse de streaming divise les fragments sur plusieurs parties de la charge utile, ou elle combine plusieurs fragments en une seule partie de charge utile. L’exemple suivant montre un fragment de données au format JSON divisé en deux parties de données utiles :
```
{'PayloadPart': {'Bytes': b'{"outputs": '}}
{'PayloadPart': {'Bytes': b'[" problem"]}\n'}}
```
Lorsque vous écrivez du code d’application qui traite un flux d’inférence, incluez une logique qui gère ces divisions et combinaisons de données occasionnelles. Une stratégie consisterait à écrire du code qui concatène le contenu d’`Bytes` pendant que votre application reçoit les parties des données utiles. En concaténant les données JSON d’exemple ici, vous combineriez les données dans un corps JSON délimité par de nouvelles lignes. Ensuite, votre code pourrait traiter le flux en analysant l’ensemble de l’objet JSON sur chaque ligne.
L’exemple suivant montre le JSON délimité par de nouvelles lignes que vous créeriez lorsque vous concaténez le contenu de l’exemple d’`Bytes` :
```
{"outputs": [" a"]}
{"outputs": [" challenging"]}
{"outputs": [" problem"]}
. . .
```
**Example Code pour traiter un flux d’inférence**
L’exemple de classe Python suivant, `SmrInferenceStream`, montre comment traiter un flux d’inférence qui envoie des données texte au format JSON :
```
import io
import json
# Example class that processes an inference stream:
class SmrInferenceStream:
def __init__(self, sagemaker_runtime, endpoint_name):
self.sagemaker_runtime = sagemaker_runtime
self.endpoint_name = endpoint_name
# A buffered I/O stream to combine the payload parts:
self.buff = io.BytesIO()
self.read_pos = 0
def stream_inference(self, request_body):
# Gets a streaming inference response
# from the specified model endpoint:
response = self.sagemaker_runtime\
.invoke_endpoint_with_response_stream(
EndpointName=self.endpoint_name,
Body=json.dumps(request_body),
ContentType="application/json"
)
# Gets the EventStream object returned by the SDK:
event_stream = response['Body']
for event in event_stream:
# Passes the contents of each payload part
# to be concatenated:
self._write(event['PayloadPart']['Bytes'])
# Iterates over lines to parse whole JSON objects:
for line in self._readlines():
resp = json.loads(line)
part = resp.get("outputs")[0]
# Returns parts incrementally:
yield part
# Writes to the buffer to concatenate the contents of the parts:
def _write(self, content):
self.buff.seek(0, io.SEEK_END)
self.buff.write(content)
# The JSON objects in buffer end with '\n'.
# This method reads lines to yield a series of JSON objects:
def _readlines(self):
self.buff.seek(self.read_pos)
for line in self.buff.readlines():
self.read_pos += len(line)
yield line[:-1]
```
Cet exemple traite le flux d’inférence en procédant comme suit :
+ Initialise un client SageMaker AI Runtime et définit le nom d'un point de terminaison modèle. Avant de pouvoir obtenir un flux d’inférence, le modèle que le point de terminaison héberge doit prendre en charge le streaming d’inférence.
+ Dans l’exemple de méthode `stream_inference`, il reçoit le corps d’une demande et le transmet à la méthode `invoke_endpoint_with_response_stream` du kit SDK.
+ Il itère sur chaque événement de l’objet `EventStream` renvoyé par le kit SDK.
+ À partir de chaque événement, il obtient le contenu de l’objet `Bytes` dans l’objet `PayloadPart`.
+ Dans l’exemple de méthode `_write`, il écrit dans un tampon pour concaténer le contenu des objets `Bytes`. Le contenu combiné forme un corps JSON délimité par de nouvelles lignes.
+ Il utilise l’exemple de méthode `_readlines` pour obtenir une série itérable d’objets JSON.
+ Dans chaque objet JSON, il obtient une partie de l’inférence.
+ Avec l’expression `yield`, il renvoie les pièces de manière incrémentielle.
L’exemple suivant crée et utilise un objet `SmrInferenceStream` :
```
request_body = {"inputs": ["Large model inference is"],
"parameters": {"max_new_tokens": 100,
"enable_sampling": "true"}}
smr_inference_stream = SmrInferenceStream(
sagemaker_runtime, endpoint_name)
stream = smr_inference_stream.stream_inference(request_body)
for part in stream:
print(part, end='')
```
Cet exemple transmet un corps de demande à la méthode `stream_inference`. Il itère la réponse pour imprimer chaque élément renvoyé par le flux d’inférence.
L’exemple suppose que le modèle au point de terminaison spécifié est un LLM qui génère du texte. Le résultat de cet exemple est un corps de texte généré qui s’imprime de manière incrémentielle :
```
a challenging problem in machine learning. The goal is to . . .
```
## Invoquez votre modèle à l'aide du AWS CLI
Vous pouvez appeler le point de terminaison de votre modèle en exécutant des commandes avec le AWS Command Line Interface (AWS CLI). L’ AWS CLI prend en charge les demandes d’inférence standard avec la commande `invoke-endpoint` et prend en charge les demandes d’inférence asynchrones avec la commande `invoke-endpoint-async`.
**Note**
Le AWS CLI ne prend pas en charge les demandes d'inférence en streaming.
L’exemple suivant utilise la commande `invoke-endpoint` pour envoyer une demande d’inférence à un point de terminaison du modèle :
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name endpoint_name \
--body fileb://$file_name \
output_file.txt
```
Pour le paramètre `--endpoint-name`, indiquez le nom de point de terminaison que vous avez spécifié lors de sa création. Pour le `--body` paramètre, fournissez les données d'entrée que l' SageMaker IA doit transmettre au modèle. Les données doivent être dans le même format que celui utilisé pour l’entraînement. Cet exemple montre comment envoyer des données binaires à votre point de terminaison.
Pour plus d'informations sur les circonstances dans lesquelles utiliser le `file://` over `fileb://` lors du transfert du contenu d'un fichier à un paramètre du AWS CLI, consultez la section [Meilleures pratiques relatives aux paramètres de fichiers locaux](https://aws.amazon.com/blogs/developer/best-practices-for-local-file-parameters/).
Pour plus d’informations et pour voir les paramètres supplémentaires que vous pouvez transmettre, consultez [https://docs.aws.amazon.com/cli/latest/reference/sagemaker-runtime/invoke-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker-runtime/invoke-endpoint.html) dans la *Référence des commandes de l’AWS CLI *.
Si la commande `invoke-endpoint` réussit, elle renvoie une réponse telle que la suivante :
```
{
"ContentType": "; charset=utf-8",
"InvokedProductionVariant": ""
}
```
Si la commande échoue, vérifiez si le format des données utiles d’entrée est correct.
Affichez la sortie de l’invocation en vérifiant le fichier de sortie du fichier (`output_file.txt` dans cet exemple).
```
more output_file.txt
```
## Appelez votre modèle à l'aide du AWS SDK pour Python
### Invoquer pour diffuser de manière bidirectionnelle une demande et une réponse d'inférence
Si vous souhaitez invoquer un point de terminaison modèle dans le code de votre application pour prendre en charge le streaming bidirectionnel, vous pouvez utiliser le [nouveau SDK expérimental pour Python](https://github.com/awslabs/aws-sdk-python) qui prend en charge la fonctionnalité de streaming bidirectionnel avec prise en charge HTTP/2. Ce SDK permet une communication bidirectionnelle en temps réel entre votre application cliente et le SageMaker point de terminaison, ce qui vous permet d'envoyer des demandes d'inférence de manière incrémentielle tout en recevant simultanément des réponses en streaming au fur et à mesure que le modèle les génère. Cela est particulièrement utile pour les applications interactives où le client et le serveur doivent échanger des données en continu via une connexion permanente.
**Note**
Le nouveau SDK expérimental est différent du SDK Boto3 standard et prend en charge les connexions bidirectionnelles persistantes pour l'échange de données. Lors de l'utilisation du SDK Python expérimental, nous vous conseillons vivement d'épingler strictement une version du SDK pour tous les cas d'utilisation non expérimentaux.
Pour appeler votre point de terminaison avec le streaming bidirectionnel, utilisez la `invoke_endpoint_with_bidirectional_stream` méthode. Cette méthode établit une connexion permanente qui vous permet de diffuser plusieurs segments de charge utile vers votre modèle tout en recevant des réponses en temps réel lorsque le modèle traite les données. La connexion reste ouverte jusqu'à ce que vous fermiez explicitement le flux d'entrée ou que le terminal ferme la connexion, ce qui permet une durée de connexion maximale de 30 minutes.
### Conditions préalables
Avant de pouvoir utiliser le streaming bidirectionnel dans le code de votre application, vous devez :
1. Installez le SDK expérimental SageMaker Runtime HTTP/2
1. Configuration des AWS informations d'identification pour votre client SageMaker Runtime
1. Déployez un modèle qui prend en charge le streaming bidirectionnel vers un terminal SageMaker
### Configuration du client de streaming bidirectionnel
L'exemple suivant montre comment initialiser les composants requis pour le streaming bidirectionnel :
```
from sagemaker_runtime_http2.client import SageMakerRuntimeHTTP2Client
from sagemaker_runtime_http2.config import Config, HTTPAuthSchemeResolver
from smithy_aws_core.identity import EnvironmentCredentialsResolver
from smithy_aws_core.auth.sigv4 import SigV4AuthScheme
# Configuration
AWS_REGION = "us-west-2"
BIDI_ENDPOINT = f"https://runtime.sagemaker.{AWS_REGION}.amazonaws.com:8443"
ENDPOINT_NAME = "your-endpoint-name"
# Initialize the client configuration
config = Config(
endpoint_uri=BIDI_ENDPOINT,
region=AWS_REGION,
aws_credentials_identity_resolver=EnvironmentCredentialsResolver(),
auth_scheme_resolver=HTTPAuthSchemeResolver(),
auth_schemes={"aws.auth#sigv4": SigV4AuthScheme(service="sagemaker")}
)
# Create the SageMaker Runtime HTTP/2 client
client = SageMakerRuntimeHTTP2Client(config=config)
```
### Client de streaming bidirectionnel complet
L'exemple suivant montre comment créer un client de streaming bidirectionnel qui envoie plusieurs charges utiles de texte à un SageMaker point de terminaison et traite les réponses en temps réel :
```
import asyncio
import logging
from sagemaker_runtime_http2.client import SageMakerRuntimeHTTP2Client
from sagemaker_runtime_http2.config import Config, HTTPAuthSchemeResolver
from sagemaker_runtime_http2.models import (
InvokeEndpointWithBidirectionalStreamInput,
RequestStreamEventPayloadPart,
RequestPayloadPart
)
from smithy_aws_core.identity import EnvironmentCredentialsResolver
from smithy_aws_core.auth.sigv4 import SigV4AuthScheme
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class SageMakerBidirectionalClient:
def __init__(self, endpoint_name, region="us-west-2"):
self.endpoint_name = endpoint_name
self.region = region
self.client = None
self.stream = None
self.response_task = None
self.is_active = False
def _initialize_client(self):
bidi_endpoint = f"runtime.sagemaker.{self.region}.amazonaws.com:8443"
config = Config(
endpoint_uri=bidi_endpoint,
region=self.region,
aws_credentials_identity_resolver=EnvironmentCredentialsResolver(),
auth_scheme_resolver=HTTPAuthSchemeResolver(),
auth_schemes={"aws.auth#sigv4": SigV4AuthScheme(service="sagemaker")}
)
self.client = SageMakerRuntimeHTTP2Client(config=config)
async def start_session(self):
"""Establish a bidirectional streaming connection with the endpoint."""
if not self.client:
self._initialize_client()
logger.info(f"Starting session with endpoint: {self.endpoint_name}")
self.stream = await self.client.invoke_endpoint_with_bidirectional_stream(
InvokeEndpointWithBidirectionalStreamInput(endpoint_name=self.endpoint_name)
)
self.is_active = True
# Start processing responses concurrently
self.response_task = asyncio.create_task(self._process_responses())
async def send_message(self, message):
"""Send a single message to the endpoint."""
if not self.is_active:
raise RuntimeError("Session not active. Call start_session() first.")
logger.info(f"Sending message: {message}")
payload = RequestPayloadPart(bytes_=message.encode('utf-8'))
event = RequestStreamEventPayloadPart(value=payload)
await self.stream.input_stream.send(event)
async def send_multiple_messages(self, messages, delay=1.0):
"""Send multiple messages with a delay between each."""
for message in messages:
await self.send_message(message)
await asyncio.sleep(delay)
async def end_session(self):
"""Close the bidirectional streaming connection."""
if not self.is_active:
return
await self.stream.input_stream.close()
self.is_active = False
logger.info("Stream closed")
# Cancel the response processing task
if self.response_task and not self.response_task.done():
self.response_task.cancel()
async def _process_responses(self):
"""Process incoming responses from the endpoint."""
try:
output = await self.stream.await_output()
output_stream = output[1]
while self.is_active:
result = await output_stream.receive()
if result is None:
logger.info("No more responses")
break
if result.value and result.value.bytes_:
response_data = result.value.bytes_.decode('utf-8')
logger.info(f"Received: {response_data}")
except Exception as e:
logger.error(f"Error processing responses: {e}")
# Example usage
async def run_bidirectional_client():
client = SageMakerBidirectionalClient(endpoint_name="your-endpoint-name")
try:
# Start the session
await client.start_session()
# Send multiple messages
messages = [
"I need help with",
"my account balance",
"I can help with that",
"and recent charges"
]
await client.send_multiple_messages(messages)
# Wait for responses to be processed
await asyncio.sleep(2)
# End the session
await client.end_session()
logger.info("Session ended successfully")
except Exception as e:
logger.error(f"Client error: {e}")
await client.end_session()
if __name__ == "__main__":
asyncio.run(run_bidirectional_client())
```
Le client initialise le client SageMaker Runtime HTTP/2 avec l'URI du point de terminaison régional sur le port 8443, qui est requis pour les connexions de streaming bidirectionnelles. La `session()` méthode start\$1 appelle `invoke_endpoint_with_bidirectional_stream()` pour établir la connexion persistante et crée une tâche asynchrone pour traiter les réponses entrantes simultanément.
La `send_event()` méthode enveloppe les données de charge utile dans les objets de demande appropriés et les envoie via le flux d'entrée, tandis que la `_process_responses()` méthode écoute et traite en permanence les réponses du point de terminaison au fur et à mesure qu'elles arrivent. Cette approche bidirectionnelle permet une interaction en temps réel où l'envoi de demandes et la réception de réponses se font simultanément via la même connexion.
# Points de terminaison
Après avoir déployé votre modèle sur un point de terminaison, vous souhaiterez peut-être afficher et gérer le point de terminaison. Avec SageMaker AI, vous pouvez consulter l’état et les détails de votre point de terminaison, consulter les journaux et métriques pour surveiller les performances de votre point de terminaison, mettre à jour les modèles déployés sur votre point de terminaison, etc.
Les sections suivantes montrent comment vous pouvez gérer les points de terminaison dans Amazon SageMaker Studio ou dans la AWS Management Console.
La page suivante explique comment afficher et modifier vos points de terminaison de manière interactive à l’aide de la console Amazon SageMaker AI ou de SageMaker Studio.
**Topics**
+ [Affichage des détails sur les points de terminaison dans SageMaker Studio](manage-endpoints-studio.md)
+ [Affichage des détails de votre point de terminaison dans la console SageMaker AI](manage-endpoints-console.md)
# Affichage des détails sur les points de terminaison dans SageMaker Studio
Dans Amazon SageMaker Studio, vous pouvez afficher et gérer vos points de terminaison de l’hébergement SageMaker AI. Pour en savoir plus sur Studio, consultez [Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html).
Pour trouver la liste de vos points de terminaison dans SageMaker Studio, procédez comme suit :
1. Ouvrez l’application Studio.
1. Dans le panneau de navigation de gauche, sélectionnez **Déploiements**.
1. Dans le menu déroulant, sélectionnez **Points de terminaison**.
La page **Points de terminaison** s’ouvre et répertorie tous vos points de terminaison de l’hébergement SageMaker AI. Sur cette page, vous pouvez voir les points de terminaison et leur **statut**. Vous pouvez également créer un nouveau point de terminaison, modifier un point de terminaison existant ou supprimer un point de terminaison.
Pour voir les détails d’un point de terminaison spécifique, choisissez-en un dans la liste. Sur la page de détails du point de terminaison, vous obtenez une vue d’ensemble similaire à la capture d’écran suivante.
![\[Capture d’écran de la page principale d’un point de terminaison présentant un résumé des détails du point de terminaison dans Studio.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inference/studio-endpoint-details-page.png)
La page des détails sur chaque point de terminaison contient les onglets d’informations suivants :
# Afficher les variantes (ou les modèles)
L’onglet **Variantes** (également appelé onglet **Modèles** si plusieurs modèles sont déployés sur votre point de terminaison) affiche la liste des [variantes de modèles](https://docs.aws.amazon.com/sagemaker/latest/dg/model-ab-testing.html) ou des modèles actuellement déployés sur votre point de terminaison. La capture d’écran suivante vous montre à quoi ressemble l’aperçu et la section **Modèles** pour un point de terminaison avec plusieurs modèles déployés.
![\[Capture d’écran de la page principale d’un point de terminaison montrant plusieurs modèles déployés.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inference/studio-goldfinch-multi-model-endpoint.png)
Vous pouvez ajouter ou modifier les paramètres pour chaque variante ou modèle. Vous pouvez également sélectionner une variante et activer une politique d’autoscaling par défaut, que vous pourrez modifier ultérieurement dans l’onglet **Autoscaling**.
# Afficher les paramètres
Dans l’onglet **Paramètres**, vous pouvez afficher le rôle IAM AWS associé au point de terminaison, la clé AWS KMS utilisée pour le chiffrement (le cas échéant), le nom de votre VPC et les paramètres d’isolement réseau.
# Tester l’inférence
Dans l’onglet **Tester l’inférence**, vous pouvez envoyer une demande d’inférence de test à un modèle déployé. Cela est utile si vous souhaitez vérifier que votre point de terminaison répond aux demandes comme prévu.
Pour tester l’inférence, procédez comme suit :
1. Dans l’onglet **Tester l’inférence** du modèle, choisissez l’une des options suivantes :
1. Sélectionnez **Entrer le corps de la requête** si vous souhaitez tester le point de terminaison et recevoir une réponse via l’interface Studio.
1. Sélectionnez **Copier un exemple de code (Python)** si vous souhaitez copier un exemple AWS SDK pour Python (Boto3) que vous pouvez utiliser pour invoquer votre point de terminaison depuis un environnement local et recevoir une réponse par programmation.
1. Dans **Modèle**, sélectionnez le modèle que vous voulez tester sur le point de terminaison.
1. Si vous avez choisi la méthode de test de l’interface Studio, vous pouvez également choisir le **type de contenu** souhaité pour la réponse dans la liste déroulante.
Après avoir configuré votre requête, vous pouvez choisir **Envoyer la requête** (pour recevoir une réponse via l’interface Studio) ou **Copier** pour copier l’exemple Python.
Si vous recevez une réponse via l’interface de Studio, elle ressemblera à la capture d’écran suivante.
![\[Capture d’écran d’une demande d’inférence de test réussie sur un point de terminaison dans Studio.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inference/endpoint-test-inference.png)
# Scalabilité automatique
Dans l’onglet **Autoscaling**, vous pouvez consulter toutes les politiques d’autoscaling configurées pour les modèles hébergés sur votre point de terminaison. La capture d’écran suivante montre l’onglet **Autoscaling**.
![\[Capture d’écran de l’onglet Autoscaling, montrant une politique active.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/inference/studio-endpoint-autoscaling.png)
Vous pouvez choisir **Modifier l’autoscaling** pour modifier l’une des politiques et activer ou désactiver la politique d’autoscaling par défaut.
Pour en savoir plus sur l’autoscaling pour les points de terminaison en temps réel, consultez [Mise à l’échelle automatique des modèles Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html). Si vous ne savez pas comment configurer une politique d’autoscaling pour votre point de terminaison, vous pouvez utiliser une [tâche de recommandations d’autoscaling d’Inference Recommender](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-autoscaling.html) pour obtenir des recommandations pour une politique d’autoscaling.
# Affichage des détails de votre point de terminaison dans la console SageMaker AI
Pour afficher vos points de terminaison dans la console SageMaker AI, procédez comme suit :
1. Accédez à la console SageMaker AI à l’adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Dans le panneau de navigation de gauche, sélectionnez **Inférence**.
1. Choisissez **Points de terminaison** dans la liste déroulante.
1. Sur la page **Points de terminaison**, choisissez votre point de terminaison.
La page détaillée du point de terminaison devrait s’ouvrir pour afficher un résumé de votre point de terminaison et des métriques collectées pour celui-ci.
Les sections suivantes décrivent les onglets sur la page des détails des points de terminaison.
# Surveillance des points de terminaison
Après avoir créé un point de terminaison d’hébergement SageMaker AI, vous pouvez surveiller votre point de terminaison à l’aide d’Amazon CloudWatch, qui collecte et traite les données brutes pour les transformer en métriques lisibles en quasi temps réel. Ces métriques vous permettent d’accéder aux informations d’historique et d’obtenir un meilleur point de vue sur les performances de votre point de terminaison. Pour plus d’informations, consultez le *[Guide de l’utilisateur Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)*.
Dans l’onglet **Surveillance** de la page détaillée du point de terminaison, vous pouvez consulter les données des métriques CloudWatch collectées depuis votre point de terminaison.
L’onglet **Surveillance** comprend les sections suivantes :
+ **Métriques opérationnelles** : consultez les métriques qui suivent l’utilisation des ressources de votre point de terminaison, telles que Utilisation de la CPU et Utilisation de la mémoire.
+ **Métriques d’invocation** : consultez les métriques qui suivent le nombre, l’état de santé et le statut des demandes `InvokeEndpoint` arrivant sur votre point de terminaison, telles que Erreurs du modèle d’invocation et Latence du modèle.
+ **Métriques de santé** : consultez les métriques qui suivent l’état de santé général de votre point de terminaison, telles que Échecs d’invocation et Échecs de notification.
Pour une description détaillée de chaque métrique, consultez [Surveillance de SageMaker AI avec CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html).
La capture d’écran suivante illustre la section **Métriques opérationnelles** pour un point de terminaison sans serveur.
![\[Capture d’écran des graphiques de métriques dans la section Métriques opérationnelles de la page détaillée du point de terminaison.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/hosting-operational-metrics.png)
Vous pouvez ajuster les paramètres **Période** et **Statistique** que vous souhaitez suivre pour les métriques d’une section donnée, ainsi que la durée pendant laquelle vous souhaitez consulter les données de métriques. Vous pouvez également ajouter et retirer des widgets de métrique de la vue pour chaque section en choisissant **Ajouter un gadget**. Dans la boîte de dialogue **Ajouter un gadget**, vous pouvez sélectionner et désélectionner les métriques que vous souhaitez voir.
Les métriques disponibles peuvent dépendre de votre type de point de terminaison. Par exemple, les points de terminaison sans serveur ont certaines métriques qui ne sont pas disponibles pour les points de terminaison en temps réel. Pour obtenir des informations plus spécifiques sur les métriques par type de point de terminaison, consultez les pages suivantes :
+ [Surveillance d’un point de terminaison sans serveur](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints-monitoring.html)
+ [Surveillance d’un point de terminaison asynchrone](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-monitor.html)
+ [Métriques CW pour les déploiements de points de terminaison multimodèles](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoint-cloudwatch-metrics.html)
+ [Journaux et métriques des pipelines d’inférence](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipeline-logs-metrics.html)
# Paramètres
Vous pouvez cliquer sur l’onglet **Paramètres** pour afficher des informations supplémentaires sur votre point de terminaison, telles que les paramètres de capture de données, la configuration du point de terminaison et les balises.
# Création et affichage d’alarmes
À partir de l’onglet **Alarmes** de la page détaillée de votre point de terminaison, vous pouvez afficher et créer des alarmes de métrique de seuil statique simples, dans lesquelles vous spécifiez une valeur de seuil pour une métrique. Si la métrique dépasse la valeur de seuil, l’alarme passe à l’état `ALARM`. Pour plus d’informations relatives à la configuration des alarmes CloudWatch, consultez [Utilisation des alarmes Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html).
Dans la section **Résumé du point de terminaison**, vous pouvez consulter le champ **Alarmes**, qui indique le nombre d’alarmes actuellement actives sur votre point de terminaison.
Pour voir quelles alarmes sont à l’état `ALARM`, cliquez sur l’onglet **Alarmes**. L’onglet **Alarmes** affiche la liste complète des alarmes de votre point de terminaison, ainsi que des détails sur leur statut et leurs conditions. La capture d’écran suivante illustre la liste des alarmes de cette section qui ont été configurées pour un point de terminaison.
![\[Capture d’écran de l’onglet Alarmes sur la page détaillée du point de terminaison, qui affiche la liste des alarmes CloudWatch.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/hosting-alarms-tab.png)
Le statut d’une alarme peut être `In alarm`, `OK` ou `Insufficient data` si les données de métrique collectées ne sont pas suffisantes.
Pour créer une alarme pour votre point de terminaison, procédez comme suit :
1. Dans l’onglet **Alarmes**, choisissez **Créer une alarme**.
1. La page **Créer une alarme** s’ouvre. Pour **Nom de l’alarme**, saisissez un nom pour l’alarme.
1. (Facultatif) Entrez une description de l’alarme.
1. Pour **Métrique**, choisissez la métrique CloudWatch qui sera suivie par l’alarme.
1. Pour **Nom de la variante**, choisissez la variante du modèle de point de terminaison que vous souhaitez surveiller.
1. Pour **Statistique**, choisissez l’une des statistiques disponibles pour la métrique que vous avez sélectionnée.
1. Pour **Période**, choisissez la période à utiliser pour calculer chaque valeur statistique. Par exemple, si vous choisissez la statistique Moyenne et une période de 5 minutes, chaque point de données surveillé par l’alarme est la moyenne des points de données de la métrique à intervalles de 5 minutes.
1. Pour **Périodes d’évaluation**, entrez le nombre de points de données que vous souhaitez que l’alarme prenne en compte lorsqu’elle détermine si elle doit passer ou non à l’état d’alarme.
1. Pour **Condition**, choisissez la condition que vous souhaitez utiliser pour votre seuil d’alarme.
1. Pour **Valeur du seuil**, entrez la valeur souhaitée pour votre seuil.
1. (Facultatif) Pour **Notification**, vous pouvez choisir **Ajouter une notification** pour créer ou spécifier une rubrique Amazon SNS qui reçoit une notification lorsque l’état de votre alarme change.
1. Sélectionnez **Créer une alerte**.
Après avoir créé votre alarme, vous pouvez revenir à l’onglet **Alarmes** pour voir son statut à tout moment. Dans cette section, vous pouvez également sélectionner l’alarme et la **modifier** ou la **supprimer**.
# 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**.
------
# Mise à l'échelle automatique des modèles Amazon SageMaker AI
Amazon SageMaker AI prend en charge le dimensionnement automatique (mise à l'échelle automatique) pour vos modèles hébergés. L’*autoscaling* ajuste dynamiquement le nombre d’instances allouées pour un modèle en réponse à des modifications de la charge de travail. Lorsque la charge de travail augmente, l’autoscaling met en ligne plus d’instances. Lorsque la charge de travail diminue, l’autoscaling supprime les instances inutiles pour que vous n’ayez pas à payer les instances allouées que vous n’utilisez pas.
**Topics**
+ [Présentation des politiques d’autoscaling](endpoint-auto-scaling-policy.md)
+ [Conditions préalables à l’autoscaling](endpoint-auto-scaling-prerequisites.md)
+ [Configuration de l’autoscaling d’un modèle avec la console](endpoint-auto-scaling-add-console.md)
+ [Enregistrement d’un modèle](endpoint-auto-scaling-add-policy.md)
+ [Définition d’une stratégie de mise à l’échelle](endpoint-auto-scaling-add-code-define.md)
+ [Application d’une stratégie de mise à l’échelle](endpoint-auto-scaling-add-code-apply.md)
+ [Instructions pour modifier une stratégie de mise à l’échelle](endpoint-auto-scaling-edit.md)
+ [Désactivation temporaire des stratégies de mise à l’échelle](endpoint-auto-scaling-suspend-scaling-activities.md)
+ [Suppression d’une stratégie de mise à l’échelle](endpoint-auto-scaling-delete.md)
+ [Vérification de l’état d’une activité de mise à l’échelle en décrivant les activités de mise à l’échelle](endpoint-scaling-query-history.md)
+ [Mise à l’échelle d’un point de terminaison à zéro instance](endpoint-auto-scaling-zero-instances.md)
+ [Test de charge de votre configuration d’autoscaling](endpoint-scaling-loadtest.md)
+ [CloudFormation À utiliser pour créer une politique de dimensionnement](endpoint-scaling-cloudformation.md)
+ [Mise à jour des points de terminaison qui utilisent l’autoscaling](endpoint-scaling-update.md)
+ [Suppression de points de terminaison configurés pour l’autoscaling](endpoint-delete-with-scaling.md)
# Présentation des politiques d’autoscaling
Pour utiliser l’autoscaling, vous définissez une politique de mise à l’échelle automatique qui ajoute et supprime le nombre d’instances pour votre variante de production en réponse aux charges de travail réelles.
Pour procéder à une mise à l’échelle automatique en fonction de l’évolution de la charge de travail, vous avez deux options : le suivi de cible et les politiques de mise à l’échelle par étapes.
Dans la plupart des cas, nous vous recommandons d’utiliser des politiques de mise à l’échelle du suivi de la cible. Avec le suivi des cibles, vous choisissez une CloudWatch métrique Amazon et une valeur cible. Auto Scaling crée et gère les CloudWatch alarmes relatives à la politique de dimensionnement et calcule l'ajustement de mise à l'échelle en fonction de la métrique et de la valeur cible. La stratégie ajoute et supprime le nombre d’instances comme requis pour maintenir la métrique à la valeur cible spécifiée ou à une valeur proche. Par exemple, une stratégie de dimensionnement qui utilise la métrique `InvocationsPerInstance` prédéfinie avec une valeur cible égale à 70 peut maintenir `InvocationsPerInstance` à la valeur 70 ou à une valeur proche. Pour plus d’informations, consultez [Stratégies de mise à l’échelle du suivi des cibles](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) dans le *Guide de l’utilisateur Application Auto Scaling*.
Vous pouvez utiliser la mise à l’échelle par étapes lorsque vous avez besoin d’une configuration avancée, par exemple en spécifiant le nombre d’instances à déployer dans diverses conditions. Par exemple, vous devez utiliser la mise à l’échelle par étapes si vous souhaitez permettre à un point de terminaison d’augmenter horizontalement à partir de zéro instance active. Pour une présentation des stratégies de mise à l’échelle par étapes et de leur fonctionnement, consultez [Stratégies de mise à l’échelle par étapes](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html) dans le *Guide de l’utilisateur Application Auto Scaling*.
Pour créer une stratégie de mise à l’échelle de suivi des cibles, vous devez spécifier les éléments suivants :
+ **Métrique** : CloudWatch métrique à suivre, telle que le nombre moyen d'appels par instance.
+ **Valeur cible** : la valeur cible de la métrique, telle que 70 invocations par instance et par minute.
Vous pouvez créer des stratégies de suivi des objectifs de la mise à l’échelle avec des métriques prédéfinies ou des métriques personnalisées. Une métrique prédéfinie est définie dans une énumération afin que vous puissiez la spécifier par son nom dans le code ou l'utiliser dans la console SageMaker AI. Vous pouvez également utiliser l’ AWS CLI ou l’API Application Auto Scaling pour appliquer une stratégie de mise à l’échelle avec suivi de cible basée sur une métrique personnalisée ou prédéfinie.
Notez que les activités de mise à l’échelle sont effectuées avec des temps de stabilisation entre elles afin d’éviter des fluctuations rapides de capacité. Vous pouvez éventuellement configurer les temps de stabilisation de votre stratégie de mise à l’échelle.
Pour plus d’informations sur les concepts clés d’autoscaling, consultez la section suivante.
## Mise à l’échelle basée sur une planification
Vous pouvez également créer des actions planifiées pour effectuer des activités de mise à l’échelle à des heures spécifiques. Vous pouvez créer des actions planifiées pour une mise à l’échelle unique ou selon une planification récurrente. Après l’exécution d’une action planifiée, votre politique de mise à l’échelle peut continuer à prendre des décisions sur l’opportunité de procéder à une mise à l’échelle dynamique au fil des modifications de la charge de travail. Le dimensionnement planifié ne peut être géré qu'à partir de l'API Application Auto Scaling AWS CLI ou de l'API Application Auto Scaling. Pour plus d’informations, voir [Mise à l’échelle planifiée](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html) dans le *Guide de l’utilisateur Application Auto Scaling.*.
## Limites de mise à l’échelle minimale et maximale
Lorsque vous configurez l’autoscaling, vous devez spécifier vos limites de mise à l’échelle avant de créer une politique de mise à l’échelle. Vous définissez des limites séparément pour les valeurs minimale et maximale.
La valeur minimale doit être au moins égale à 1, et égale ou inférieure à la valeur spécifiée pour la valeur maximale.
La valeur maximale doit être égale ou supérieure à la valeur spécifiée pour la valeur minimale. SageMaker AI Auto Scaling n'impose pas de limite pour cette valeur.
Pour déterminer les limites de mise à l’échelle dont vous avez besoin pour un trafic classique, testez votre configuration d’autoscaling avec le débit attendu de trafic pour votre modèle.
Si le trafic d'une variante devient nul, l' SageMaker IA s'adapte automatiquement au nombre minimum d'instances spécifié. Dans ce cas, SageMaker l'IA émet des métriques d'une valeur nulle.
Il existe trois options pour définir la capacité minimale et la capacité maximale :
1. Utilisez la console pour mettre à jour les paramètres **Nombre minimal d’instance** et **Nombre maximal d’instances**.
1. Utilisez les options AWS CLI et incluez les `--max-capacity` options `--min-capacity` et lors de l'exécution de la [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)commande.
1. Appelez l'[RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html)API et spécifiez les `MaxCapacity` paramètres `MinCapacity` et.
**Astuce**
Vous pouvez augmenter horizontalement manuellement en augmentant la valeur minimale ou réduire horizontalement manuellement en diminuant la valeur maximale.
## Temps de stabilisation
Un *temps de stabilisation* permet de se protéger contre le surdimensionnement lorsque votre modèle est en cours de réduction horizontale (réduction de la capacité) ou d’augmentation horizontale (augmentation de la capacité). Pour ce faire, il ralentit les activités de mise à l’échelle ultérieures jusqu’à l’expiration de la période. Il bloque spécifiquement la suppression des instances pour les demandes de réduction horizontale et limite la création d’instances pour les demandes d’augmentation horizontale. Pour plus d’informations, consultez [Définir les temps de stabilisation](https://docs.aws.amazon.com/autoscaling/application/userguide/target-tracking-scaling-policy-overview.html#target-tracking-cooldown) dans le *Guide de l’utilisateur Application Auto Scaling*.
Vous configurez le temps de stabilisation dans votre stratégie de mise à l’échelle.
Si vous ne spécifiez pas un temps de stabilisation de réduction ou d’augmentation horizontale, votre stratégie de mise à l’échelle utilise la valeur par défaut, qui est de 300 secondes pour chaque.
Si les instances sont ajoutées ou supprimées trop rapidement lorsque vous testez votre configuration de mise à l’échelle, envisagez d’augmenter la valeur. Vous pouvez voir ce comportement si le trafic vers votre modèle présente un grand nombre de pics, ou si vous avez plusieurs stratégies de mise à l’échelle définies pour une variante.
Si les instances ne sont pas ajoutées assez rapidement pour répondre à une augmentation du trafic, envisagez de diminuer la valeur.
## Ressources connexes
Pour plus d’informations sur la configuration de l’autoscaling, consultez les ressources suivantes :
+ Section [application-autoscaling](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling) du document *Référence des commandes AWS CLI *
+ [Référence de l’API Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/APIReference/)
+ [Guide de l’utilisateur Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/)
**Note**
SageMaker L'IA a récemment introduit de nouvelles fonctionnalités d'inférence basées sur des points de terminaison d'inférence en temps réel. Vous créez un point de terminaison SageMaker AI avec une configuration de point de terminaison qui définit le type d'instance et le nombre d'instances initial pour le point de terminaison. Créez ensuite un composant d'inférence, qui est un objet d'hébergement d' SageMaker IA que vous pouvez utiliser pour déployer un modèle sur un point de terminaison. Pour plus d'informations sur la mise à l'échelle des composants d'inférence, voir L'[SageMaker IA ajoute de nouvelles fonctionnalités d'inférence pour aider à réduire les coûts de déploiement et la latence des modèles de base](https://aws.amazon.com/blogs/aws/amazon-sagemaker-adds-new-inference-capabilities-to-help-reduce-foundation-model-deployment-costs-and-latency/) [et à réduire les coûts de déploiement des modèles de 50 % en moyenne en utilisant les dernières fonctionnalités de l' SageMaker IA](https://aws.amazon.com/blogs/machine-learning/reduce-model-deployment-costs-by-50-on-average-using-sagemakers-latest-features/) sur le AWS blog.
# Conditions préalables à l’autoscaling
Avant de pouvoir utiliser la mise à l'échelle automatique, vous devez déjà avoir créé un point de terminaison du modèle Amazon SageMaker AI. Vous pouvez avoir plusieurs versions de modèle pour le même point de terminaison. Chaque modèle est appelé [variante de production (modèle)](model-ab-testing.md). Pour plus d’informations sur le déploiement d’un point de terminaison de modèle, consultez [Déployer le modèle sur les services d'hébergement SageMaker AI](ex1-model-deployment.md#ex1-deploy-model).
Pour activer le dimensionnement automatique d'un modèle, vous pouvez utiliser la console SageMaker AI, le AWS Command Line Interface (AWS CLI) ou un AWS SDK via l'API Application Auto Scaling.
+ Si c’est la première fois que vous configurez l’autoscaling d’un modèle, nous vous recommandons [Configuration de l’autoscaling d’un modèle avec la console](endpoint-auto-scaling-add-console.md).
+ Lorsque vous utilisez l'API Application Auto Scaling AWS CLI ou l'API Application Auto Scaling, le flux consiste à enregistrer le modèle en tant que cible évolutive, à définir la politique de dimensionnement, puis à l'appliquer. Sur la console SageMaker AI, sous **Inference** dans le volet de navigation, sélectionnez **Endpoints**. Recherchez le nom du point de terminaison de votre modèle, puis choisissez-le pour trouver le nom de la variante. Vous devez spécifier à la fois le nom du point de terminaison et le nom de la variante pour activer l’autoscaling d’un modèle.
Le dimensionnement automatique est rendu possible par la combinaison d'Amazon SageMaker AI, d'Amazon CloudWatch et d'Application Auto Scaling APIs. Pour plus d’informations sur les autorisations minimales requises, consultez les [Exemples de stratégies Application Auto Scaling basées sur une identité](https://docs.aws.amazon.com/autoscaling/application/userguide/security_iam_id-based-policy-examples.html) dans le *Guide de l’utilisateur Application Auto Scaling*.
La politique IAM `SagemakerFullAccessPolicy` possède toutes les autorisations IAM requises pour effectuer l’autoscaling. Pour plus d'informations sur les autorisations SageMaker AI IAM, consultez[Comment utiliser les rôles d'exécution de l' SageMaker IA](sagemaker-roles.md).
Si vous gérez votre propre stratégie d’autorisation, vous devez inclure les autorisations suivantes :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:DescribeEndpoint",
"sagemaker:DescribeEndpointConfig",
"sagemaker:UpdateEndpointWeightsAndCapacities"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"application-autoscaling:*"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/sagemaker.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_SageMakerEndpoint",
"Condition": {
"StringLike": { "iam:AWSServiceName": "sagemaker.application-autoscaling.amazonaws.com" }
}
},
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricAlarm",
"cloudwatch:DescribeAlarms",
"cloudwatch:DeleteAlarms"
],
"Resource": "*"
}
]
}
```
------
## Rôle lié à un service
Auto Scaling utilise le rôle lié à un service `AWSServiceRoleForApplicationAutoScaling_SageMakerEndpoint`. Le rôle lié à un service donne à Application Auto Scaling l’autorisation de décrire les alarmes de vos stratégies, de surveiller les niveaux de capacité actuels et de mettre à l’échelle la ressource cible. Ce rôle est créé automatiquement pour vous. Pour que la création automatique de rôle réussisse, vous devez avoir l’autorisation pour l’action `iam:CreateServiceLinkedRole`. Pour plus d’informations, consultez [Rôles liés à un service](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html) dans le *Guide de l’utilisateur Application Auto Scaling*.
# Configuration de l’autoscaling d’un modèle avec la console
**Pour configurer l’autoscaling d’un modèle (console)**
1. Ouvrez la console Amazon SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Dans le volet de navigation, choisissez **Inférence**, puis **Points de terminaison**.
1. Choisissez votre point de terminaison, puis pour les **Paramètres d’exécution du point de terminaison**, choisissez la variante.
1. Choisissez **Configurer Auto Scaling**.
1. Sur la page **Configurer la mise à l’échelle automatique d’une variante**, pour **Mise à l’échelle automatique d’une variante**, procédez comme suit :
1. Pour **Nombre minimal d’instances**, saisissez le nombre minimal d’instances que la stratégie de mise à l’échelle doit gérer. Au moins 1 instance est requise.
1. Pour **Nombre maximal d’instances**, saisissez le nombre maximal d’instances que la stratégie de mise à l’échelle doit gérer.
1. Pour **Stratégie de mise à l’échelle intégrée**, procédez comme suit :
1. Pour la **Métrique cible**, `SageMakerVariantInvocationsPerInstance` est automatiquement sélectionné pour la métrique et ne peut pas être modifié.
1. Pour la **Valeur cible**, saisissez le nombre moyen d’invocations par instance et par minute pour le modèle. Pour déterminer cette valeur, suivez les instructions proposées dans [Test de charge](endpoint-scaling-loadtest.md).
1. (Facultatif) Pour **Réduire le temps de stabilisation (secondes)** et **Augmenter le temps de stabilisation (secondes)**, entrez le nombre de secondes pour chaque temps de stabilisation.
1. (Facultatif) Sélectionnez **Désactiver la diminution en charge** si vous ne souhaitez pas que l’autoscaling résilie les instances lorsque le trafic diminue.
1. Choisissez **Enregistrer**.
Cette procédure enregistre un modèle en tant que cible évolutive avec Application Auto Scaling. Lorsque vous enregistrez un modèle, Application Auto Scaling effectue les contrôles de validation pour garantir que :
+ Le modèle existe
+ Les autorisations sont suffisantes
+ Vous n’enregistrez pas une variante avec une instance qui est une instance à performances extensibles comme T2
**Note**
SageMaker L'IA ne prend pas en charge la mise à l'échelle automatique pour les instances instables telles que T2, car elles permettent déjà d'augmenter la capacité dans le cadre de charges de travail accrues. Pour plus d’informations sur les instances à performances extensibles, consultez [Types d’instances Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
# Enregistrement d’un modèle
Avant d’ajouter une stratégie de mise à l’échelle à votre modèle, vous devez d’abord enregistrer votre modèle pour l’autoscaling et définir les limites de mise à l’échelle du modèle.
Les procédures suivantes expliquent comment enregistrer un modèle (variante de production) pour le dimensionnement automatique à l'aide de l'API AWS Command Line Interface (AWS CLI) ou Application Auto Scaling.
**Topics**
+ [Enregistrement d’un modèle (AWS CLI)](#endpoint-auto-scaling-add-cli)
+ [Enregistrement d’un modèle (API Application Auto Scaling)](#endpoint-auto-scaling-add-api)
## Enregistrement d’un modèle (AWS CLI)
Pour enregistrer votre variante de production, utilisez la [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)commande avec les paramètres suivants :
+ `--service-namespace`-Définissez cette valeur sur `sagemaker`.
+ `--resource-id`- L’identifiant de la ressource pour le modèle (plus précisément, la variante de production). Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante de production. Par exemple, `endpoint/my-endpoint/variant/my-variant`.
+ `--scalable-dimension`-Définissez cette valeur sur `sagemaker:variant:DesiredInstanceCount`.
+ `--min-capacity` : nombre minimal d’instances. Cette valeur doit être au moins égale à 1 et être inférieure ou égale à celle spécifiée pour `max-capacity`.
+ `--max-capacity` : nombre maximal d’instances. Cette valeur doit être au moins égale à 1 et être supérieure ou égale à celle spécifiée pour `min-capacity`.
**Example**
L’exemple suivant montre comment enregistrer une variante nommée `my-variant`, exécutée sur le point de terminaison `my-endpoint`, qui peut être mise à l’échelle de façon dynamique pour avoir de 1 à 8 instances.
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--min-capacity 1 \
--max-capacity 8
```
## Enregistrement d’un modèle (API Application Auto Scaling)
Pour enregistrer votre modèle avec Application Auto Scaling, utilisez l'opération d'API Application Auto Scaling [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html) avec les paramètres suivants :
+ `ServiceNamespace`-Définissez cette valeur sur `sagemaker`.
+ `ResourceID`- L’identifiant de la ressource pour la variante de production. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple `endpoint/my-endpoint/variant/my-variant`.
+ `ScalableDimension`-Définissez cette valeur sur `sagemaker:variant:DesiredInstanceCount`.
+ `MinCapacity` : nombre minimal d’instances. Cette valeur doit être au moins égale à 1 et être inférieure ou égale à celle spécifiée pour `MaxCapacity`.
+ `MaxCapacity` : nombre maximal d’instances. Cette valeur doit être au moins égale à 1 et être supérieure ou égale à celle spécifiée pour `MinCapacity`.
**Example**
L’exemple suivant montre comment enregistrer une variante de point de terminaison nommée `my-variant`, exécutée sur le point de terminaison `my-endpoint`, qui peut être mise à l’échelle de façon dynamique pour avoir de 1 à 8 instances.
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.RegisterScalableTarget
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"MinCapacity": 1,
"MaxCapacity": 8
}
```
# Définition d’une stratégie de mise à l’échelle
Avant d’ajouter une stratégie de mise à l’échelle à votre modèle, enregistrez votre configuration de stratégie sous forme de bloc JSON dans un fichier texte. Vous utilisez ce fichier texte lorsque vous appelez l'API AWS Command Line Interface (AWS CLI) ou Application Auto Scaling. Vous pouvez optimiser la mise à l'échelle en choisissant une CloudWatch métrique appropriée. Toutefois, avant d’utiliser une métrique personnalisée en production, vous devez tester l’autoscaling avec votre métrique personnalisée.
**Topics**
+ [Spécifiez une métrique prédéfinie (CloudWatch métrique : InvocationsPerInstance)](#endpoint-auto-scaling-add-code-predefined)
+ [Spécifiez une métrique prédéfinie à haute résolution (CloudWatch métriques : ConcurrentRequestsPerModel et ConcurrentRequestsPerCopy)](#endpoint-auto-scaling-add-code-high-res)
+ [Définissez une métrique personnalisée (CloudWatch métrique : CPUUtilization)](#endpoint-auto-scaling-add-code-custom)
+ [Définissez une métrique personnalisée (CloudWatch métrique : ExplanationsPerInstance)](#endpoint-auto-scaling-online-explainability)
+ [Spécification des temps de stabilisation](#endpoint-auto-scaling-add-code-cooldown)
Cette section présente des exemples de configurations de stratégie pour les stratégies de mise à l’échelle du suivi des cibles.
## Spécifiez une métrique prédéfinie (CloudWatch métrique : InvocationsPerInstance)
**Example**
Voici un exemple de configuration de stratégie de suivi des cibles pour une variante qui conserve la moyenne des invocations par instance à 70. Enregistrez cette configuration dans un fichier nommé `config.json`.
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
}
}
```
Pour plus d'informations, reportez-vous [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)à la section *Application Auto Scaling API Reference*.
## Spécifiez une métrique prédéfinie à haute résolution (CloudWatch métriques : ConcurrentRequestsPerModel et ConcurrentRequestsPerCopy)
Avec les CloudWatch mesures haute résolution suivantes, vous pouvez définir des politiques de dimensionnement pour le volume de demandes simultanées que reçoivent vos modèles :
**ConcurrentRequestsPerModel**
Nombre de demandes simultanées reçues par un conteneur de modèle.
**ConcurrentRequestsPerCopy**
Nombre de demandes simultanées reçues par un composant d’inférence.
Ces métriques permettent de suivre le nombre de demandes simultanées traitées par vos conteneurs de modèles, y compris les demandes placées en file d’attente à l’intérieur des conteneurs. Pour les modèles qui envoient leur réponse d’inférence sous forme de flux de jetons, ces métriques suivent chaque demande jusqu’à ce que le modèle envoie le dernier jeton correspondant à la demande.
En tant que métriques à haute résolution, elles émettent des données plus fréquemment que CloudWatch les métriques standard. Les métriques standard, telles que la métrique `InvocationsPerInstance`, émettent des données une fois par minute. Cependant, ces mesures à haute résolution émettent des données toutes les 10 secondes. Par conséquent, à mesure que le trafic simultané vers vos modèles augmente, votre stratégie réagit en augmentant horizontalement beaucoup plus rapidement qu’elle ne le ferait pour les métriques standard. Toutefois, à mesure que le trafic vers vos modèles diminue, votre stratégie réduit horizontalement à la même vitesse que pour les métriques standard.
Voici un exemple de configuration de stratégie de suivi des cibles qui ajoute des instances si le nombre de demandes simultanées par modèle est supérieur à 5. Enregistrez cette configuration dans un fichier nommé `config.json`.
```
{
"TargetValue": 5.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantConcurrentRequestsPerModelHighResolution"
}
}
```
Si vous utilisez des composants d’inférence pour déployer plusieurs modèles sur le même point de terminaison, vous pouvez créer une stratégie équivalente. Dans ce cas, définissez `PredefinedMetricType` sur `SageMakerInferenceComponentConcurrentRequestsPerCopyHighResolution`.
Pour plus d'informations, reportez-vous [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)à la section *Application Auto Scaling API Reference*.
## Définissez une métrique personnalisée (CloudWatch métrique : CPUUtilization)
Pour créer une stratégie de mise à l’échelle du suivi des cibles avec une métrique personnalisée, spécifiez son nom, son espace de noms, son unité, sa statistique et zéro ou plusieurs dimensions. Une dimension se compose d’un nom de dimension et d’une valeur de dimension. Vous pouvez utiliser n’importe quelle métrique de variante de production qui évolue proportionnellement à la capacité.
**Example**
L’exemple de configuration suivant illustre une stratégie de mise à l’échelle du suivi des cibles avec une métrique personnalisée. La stratégie met à l’échelle la variante en fonction d’une utilisation moyenne de l’UC de 50 % sur toutes les instances. Enregistrez cette configuration dans un fichier nommé `config.json`.
```
{
"TargetValue": 50.0,
"CustomizedMetricSpecification":
{
"MetricName": "CPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "VariantName","Value": "my-variant"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
Pour plus d'informations, reportez-vous [CustomizedMetricSpecification](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_CustomizedMetricSpecification.html)à la section *Application Auto Scaling API Reference*.
## Définissez une métrique personnalisée (CloudWatch métrique : ExplanationsPerInstance)
Lorsque l’explicabilité en ligne est activée sur un point de terminaison, une métrique `ExplanationsPerInstance` est émise et affiche le nombre moyen d’enregistrements expliqués par minute, par instance, pour une variante. L’utilisation des ressources des enregistrements d’explicabilité peut être différente de celle des enregistrements de prédiction. Nous vous recommandons vivement d’utiliser cette métrique pour la mise à l’échelle du suivi des cibles des points de terminaison avec l’explicabilité en ligne activée.
Vous pouvez créer plusieurs stratégies de suivi des cibles pour une cible évolutive. Envisagez d’ajouter la stratégie `InvocationsPerInstance` à partir de la section [Spécifiez une métrique prédéfinie (CloudWatch métrique : InvocationsPerInstance)](#endpoint-auto-scaling-add-code-predefined) (en plus de la stratégie `ExplanationsPerInstance`). Si la plupart des invocations ne renvoient pas d’explication en raison de la valeur de seuil définie dans le paramètre `EnableExplanations`, le point de terminaison peut choisir la stratégie `InvocationsPerInstance`. S’il existe un grand nombre d’explications, le point de terminaison peut utiliser la politique `ExplanationsPerInstance`.
**Example**
L’exemple de configuration suivant illustre une stratégie de mise à l’échelle du suivi des cibles avec une métrique personnalisée. La mise à l’échelle de la stratégie ajuste le nombre d’instances de variantes afin que chaque instance possède une métrique `ExplanationsPerInstance` de 20. Enregistrez cette configuration dans un fichier nommé `config.json`.
```
{
"TargetValue": 20.0,
"CustomizedMetricSpecification":
{
"MetricName": "ExplanationsPerInstance",
"Namespace": "AWS/SageMaker",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "VariantName","Value": "my-variant"}
],
"Statistic": "Sum"
}
}
```
Pour plus d'informations, reportez-vous [CustomizedMetricSpecification](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_CustomizedMetricSpecification.html)à la section *Application Auto Scaling API Reference*.
## Spécification des temps de stabilisation
Vous pouvez éventuellement définir des temps de stabilisation dans votre stratégie de mise à l’échelle du suivi des cibles en spécifiant les paramètres `ScaleOutCooldown` et `ScaleInCooldown`.
**Example**
Voici un exemple de configuration de stratégie de suivi des cibles pour une variante qui conserve la moyenne des invocations par instance à 70. La configuration de la stratégie indique un temps de stabilisation de réduction horizontale de 10 minutes (600 secondes) et un temps de stabilisation d’augmentation horizontale de 5 minutes (300 secondes). Enregistrez cette configuration dans un fichier nommé `config.json`.
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"ScaleInCooldown": 600,
"ScaleOutCooldown": 300
}
```
Pour plus d'informations, reportez-vous [TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)à la section *Application Auto Scaling API Reference*.
# Application d’une stratégie de mise à l’échelle
Après avoir enregistré votre modèle et défini une stratégie de mise à l’échelle, appliquez cette stratégie au modèle enregistré. Cette section explique comment appliquer une stratégie de mise à l’échelle à l’aide de l’ AWS Command Line Interface (AWS CLI) ou de l’API Application Auto Scaling.
**Topics**
+ [Application d’une stratégie de mise à l’échelle avec suivi de cible (AWS CLI)](#endpoint-auto-scaling-add-code-apply-cli)
+ [Application d’une stratégie de mise à l’échelle (API Application Auto Scaling)](#endpoint-auto-scaling-add-code-apply-api)
## Application d’une stratégie de mise à l’échelle avec suivi de cible (AWS CLI)
Pour appliquer une politique de dimensionnement à votre modèle, utilisez la [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html) AWS CLI commande avec les paramètres suivants :
+ `--policy-name`Nom de la stratégie de mise à l'échelle.
+ `--policy-type`-Définissez cette valeur sur `TargetTrackingScaling`.
+ `--resource-id`- L’identifiant de la ressource pour la variante. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple, `endpoint/my-endpoint/variant/my-variant`.
+ `--service-namespace`-Définissez cette valeur sur `sagemaker`.
+ `--scalable-dimension`-Définissez cette valeur sur `sagemaker:variant:DesiredInstanceCount`.
+ `--target-tracking-scaling-policy-configuration` : la configuration de la stratégie de mise à l’échelle du suivi des cibles à utiliser pour le modèle.
**Example**
L’exemple suivant applique une stratégie de mise à l’échelle du suivi des cibles nommée `my-scaling-policy` à une variante nommée `my-variant`, exécutée sur le point de terminaison `my-endpoint`. Pour l’option `--target-tracking-scaling-policy-configuration`, spécifiez le fichier `config.json` que vous avez créé précédemment.
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type TargetTrackingScaling \
--resource-id endpoint/my-endpoint/variant/my-variant \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--target-tracking-scaling-policy-configuration file://config.json
```
## Application d’une stratégie de mise à l’échelle (API Application Auto Scaling)
Pour appliquer une stratégie de mise à l'échelle à une variante à l'aide de l'API Application Auto Scaling, utilisez l'opération d'API Application Auto Scaling [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html) avec les paramètres suivants :
+ `PolicyName`- Le nom de la stratégie de mise à l'échelle.
+ `ServiceNamespace`-Définissez cette valeur sur `sagemaker`.
+ `ResourceID`- L’identifiant de la ressource pour la variante. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple, `endpoint/my-endpoint/variant/my-variant`.
+ `ScalableDimension`-Définissez cette valeur sur `sagemaker:variant:DesiredInstanceCount`.
+ `PolicyType`-Définissez cette valeur sur `TargetTrackingScaling`.
+ `TargetTrackingScalingPolicyConfiguration` : la configuration de la politique de mise à l’échelle avec suivi des cibles à utiliser pour la variante.
**Example**
L’exemple suivant applique une stratégie de mise à l’échelle du suivi des cibles nommée `my-scaling-policy` à une variante nommée `my-variant`, exécutée sur le point de terminaison `my-endpoint`. La configuration de la stratégie maintient le nombre moyen d’invocations par instance à 70.
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "my-scaling-policy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration": {
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
}
}
}
```
# Instructions pour modifier une stratégie de mise à l’échelle
Après avoir créé une stratégie de mise à l’échelle, vous pouvez mettre à jour n’importe lequel de ses paramètres, à l’exception du nom.
Pour modifier une politique de dimensionnement du suivi des cibles à l'aide du AWS Management Console, utilisez la même procédure que celle que vous avez utilisée[Configuration de l’autoscaling d’un modèle avec la console](endpoint-auto-scaling-add-console.md).
Vous pouvez utiliser l'API Application Auto Scaling AWS CLI ou l'API Application Auto Scaling pour modifier une politique de dimensionnement de la même manière que vous créez une nouvelle politique de dimensionnement. Pour de plus amples informations, veuillez consulter [Application d’une stratégie de mise à l’échelle](endpoint-auto-scaling-add-code-apply.md).
# Désactivation temporaire des stratégies de mise à l’échelle
Après avoir configuré l’autoscaling, vous disposez des options suivantes si vous devez enquêter sur un problème sans interférer avec les stratégies de mise à l’échelle (mise à l’échelle dynamique) :
+ Suspendez temporairement puis reprenez les activités de dimensionnement en appelant la commande [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)CLI ou l'action d'[RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html)API, en spécifiant une valeur booléenne pour les deux et`DynamicScalingInSuspended`. `DynamicScalingOutSuspended`
**Example**
L’exemple suivant montre comment suspendre les stratégies de mise à l’échelle pour une variante nommée `my-variant`, exécutée sur le point de terminaison `my-endpoint`.
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--suspended-state '{"DynamicScalingInSuspended":true,"DynamicScalingOutSuspended":true}'
```
+ Empêchez les stratégies spécifiques de mise à l’échelle du suivi des cibles de procéder à une réduction horizontale de votre variante en désactivant la partie de réduction horizontale de la stratégie. Cette méthode empêche la stratégie de mise à l’échelle de supprimer des instances, tout en autorisant leur création si nécessaire.
Désactivez temporairement puis activez les activités d'extension en modifiant la politique à l'aide de la commande [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)CLI ou de l'action [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html)API, en spécifiant une valeur booléenne pour. `DisableScaleIn`
**Example**
Voici un exemple de configuration du suivi des cibles pour une stratégie de mise à l’échelle qui effectuera une augmentation horizontale, mais pas de réduction horizontale.
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"DisableScaleIn": true
}
```
# Suppression d’une stratégie de mise à l’échelle
Si vous n’avez plus besoin d’une stratégie de mise à l’échelle, vous pouvez la supprimer à tout moment.
**Topics**
+ [Suppression de toutes les stratégies de mise à l’échelle et désinscription du modèle (console)](#endpoint-auto-scaling-delete-console)
+ [Supprimer une politique de dimensionnement (AWS CLI ou une API Application Auto Scaling)](#endpoint-auto-scaling-delete-code)
## Suppression de toutes les stratégies de mise à l’échelle et désinscription du modèle (console)
**Pour supprimer toutes les stratégies de mise à l’échelle et désinscrire la variante en tant que cible évolutive**
1. Ouvrez la console Amazon SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Dans le volet de navigation, choisissez **Points de terminaison**.
1. Choisissez votre point de terminaison, puis pour les **Paramètres d’exécution du point de terminaison**, choisissez la variante.
1. Choisissez **Configurer Auto Scaling**.
1. Choisissez **Annuler l’enregistrement de la scalabilité automatique**.
## Supprimer une politique de dimensionnement (AWS CLI ou une API Application Auto Scaling)
Vous pouvez utiliser l'API Application Auto Scaling AWS CLI ou l'API Application Auto Scaling pour supprimer une politique de dimensionnement d'une variante.
### Suppression d’une stratégie de mise à l’échelle (interface AWS CLI)
Pour supprimer une politique de dimensionnement d'une variante, utilisez la [delete-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/delete-scaling-policy.html)commande avec les paramètres suivants :
+ `--policy-name`- Le nom de la stratégie de mise à l'échelle.
+ `--resource-id`- L'identifiant de la ressource pour la variante. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple, `endpoint/my-endpoint/variant/my-variant`.
+ `--service-namespace`-Définissez cette valeur sur `sagemaker`.
+ `--scalable-dimension`-Définissez cette valeur sur `sagemaker:variant:DesiredInstanceCount`.
**Example**
L’exemple suivant supprime une stratégie de mise à l’échelle du suivi des cibles nommée `my-scaling-policy` de la variante nommée `my-variant`, exécutée sur le point de terminaison `my-endpoint`.
```
aws application-autoscaling delete-scaling-policy \
--policy-name my-scaling-policy \
--resource-id endpoint/my-endpoint/variant/my-variant \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredInstanceCount
```
### Suppression d'une stratégie de mise à l'échelle (API Application Auto Scaling)
Pour supprimer une stratégie de mise à l'échelle de votre variante, utilisez l'opération d'API Application Auto Scaling [DeleteScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeleteScalingPolicy.html) avec les paramètres suivants :
+ `PolicyName`- Le nom de la stratégie de mise à l'échelle.
+ `ServiceNamespace`-Définissez cette valeur sur `sagemaker`.
+ `ResourceID`- L’identifiant de la ressource pour la variante. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple, `endpoint/my-endpoint/variant/my-variant`.
+ `ScalableDimension`-Définissez cette valeur sur `sagemaker:variant:DesiredInstanceCount`.
**Example**
L’exemple suivant supprime une stratégie de mise à l’échelle du suivi des cibles nommée `my-scaling-policy` de la variante nommée `my-variant`, exécutée sur le point de terminaison `my-endpoint`.
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeleteScalingPolicy
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "my-scaling-policy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount"
}
```
# Vérification de l’état d’une activité de mise à l’échelle en décrivant les activités de mise à l’échelle
Vous pouvez vérifier l’état d’une activité de mise à l’échelle pour votre point de terminaison mis à l’échelle automatiquement en décrivant les activités de mise à l’échelle. Application Auto Scaling fournit des détails sur les activités de mise à l’échelle dans l’espace de noms spécifié des six semaines précédentes. Pour plus d’informations, consultez [Activités de mise à l’échelle pour Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-scaling-activities.html) dans le *Guide de l’utilisateur Application Auto Scaling*.
Pour vérifier l'état d'une activité de dimensionnement, utilisez la [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)commande. Vous ne pouvez pas vérifier l’état d’une activité de mise à l’échelle à l’aide de la console.
**Topics**
+ [Description des activités de mise à l’échelle (AWS CLI)](#endpoint-how-to)
+ [Identification des activités de mise à l’échelle bloquée à partir des quotas d’instance (AWS CLI)](#endpoint-identify-blocked-autoscaling)
## Description des activités de mise à l’échelle (AWS CLI)
Pour décrire les activités de dimensionnement pour toutes les ressources d' SageMaker IA enregistrées auprès d'Application Auto Scaling, utilisez la [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)commande en spécifiant `sagemaker` l'`--service-namespace`option.
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker
```
Pour décrire les activités de mise à l’échelle pour une ressource spécifique, incluez l’option `--resource-id`.
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant
```
L’exemple suivant illustre la sortie produite lorsque vous exécutez cette commande.
```
{
"ActivityId": "activity-id",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"Description": "string",
"Cause": "string",
"StartTime": timestamp,
"EndTime": timestamp,
"StatusCode": "string",
"StatusMessage": "string"
}
```
## Identification des activités de mise à l’échelle bloquée à partir des quotas d’instance (AWS CLI)
Lorsque vous augmentez horizontalement (ajoutez d’autres instances), vous pouvez atteindre votre quota d’instances au niveau du compte. Vous pouvez utiliser la [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)commande pour vérifier si vous avez atteint votre quota d'instance. Si vous dépassez votre quota, l’autoscaling est bloqué.
Pour vérifier si vous avez atteint votre quota d'instance, utilisez la [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html)commande et spécifiez l'ID de ressource pour l'`--resource-id`option.
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant
```
Dans la syntaxe de retour, cochez les cases [StatusCode](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_ScalingActivity.html#autoscaling-Type-ScalingActivity-StatusCode) et [StatusMessage](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_ScalingActivity.html#autoscaling-Type-ScalingActivity-StatusMessage), ainsi que leurs valeurs associées.`StatusCode`renvoie `Failed`. `StatusMessage` contient un message indiquant que le quota de service au niveau du compte a été atteint. Ce message devrait ressembler à l’exemple suivant :
```
{
"ActivityId": "activity-id",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"Description": "string",
"Cause": "minimum capacity was set to 110",
"StartTime": timestamp,
"EndTime": timestamp,
"StatusCode": "Failed",
"StatusMessage": "Failed to set desired instance count to 110. Reason: The
account-level service limit 'ml.xx.xxxxxx for endpoint usage' is 1000
Instances, with current utilization of 997 Instances and a request delta
of 20 Instances. Please contact AWS support to request an increase for this
limit. (Service: AmazonSageMaker; Status Code: 400;
Error Code: ResourceLimitExceeded; Request ID: request-id)."
}
```
# Mise à l’échelle d’un point de terminaison à zéro instance
Lorsque vous configurez l’autoscaling pour un point de terminaison, vous pouvez autoriser le processus de réduction horizontale à réduire le nombre d’instances en service à zéro. Ce faisant, vous réduisez les coûts pendant les périodes où votre point de terminaison ne traite pas les demandes d’inférence et ne nécessite donc aucune instance active.
Cependant, après la réduction horizontale à zéro instance, votre point de terminaison ne peut répondre à aucune demande d’inférence entrante tant qu’il n’a pas provisionné au moins une instance. Pour automatiser le processus de provisionnement, vous créez une stratégie de mise à l’échelle par étapes avec Application Auto Scaling. Ensuite, vous assignez la politique à une CloudWatch alarme Amazon.
Une fois que vous avez configuré la stratégie de mise à l’échelle par étapes et l’alarme, votre point de terminaison provisionne automatiquement une instance peu après avoir reçu une demande d’inférence à laquelle il ne peut pas répondre. Sachez que le processus de provisionnement prend généralement plusieurs minutes. Pendant ce temps, toute tentative d’invoquer le point de terminaison produira une erreur.
Les procédures suivantes expliquent comment configurer l’autoscaling pour un point de terminaison afin qu’il puisse réduire horizontalement vers et augmenter horizontalement à partir de zéro instance. Les procédures utilisent des commandes avec l’ AWS CLI.
**Avant de commencer**
Avant que votre point de terminaison puisse réduire horizontalement vers et augmenter horizontalement à partir de zéro instance, il doit répondre aux exigences suivantes :
+ Il est en service.
+ Il héberge un ou plusieurs composants d’inférence. Un point de terminaison peut être mis à l’échelle vers ou à partir de zéro instance uniquement s’il héberge des composants d’inférence.
Pour plus d'informations sur l'hébergement de composants d'inférence sur les points de terminaison SageMaker AI, consultez. [Déploiement de modèles pour l’inférence en temps réel](realtime-endpoints-deploy-models.md)
+ Dans la configuration du point de terminaison, pour l’objet `ManagedInstanceScaling` de variante de production, vous avez défini le paramètre `MinInstanceCount` sur `0`.
Pour obtenir des informations de référence sur ce paramètre, consultez [ProductionVariantManagedInstanceScaling](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariantManagedInstanceScaling.html).
**Pour permettre à un point de terminaison de réduire horizontalement vers zéro instance (AWS CLI)**
Pour chaque composant d’inférence hébergé par le point de terminaison, procédez comme suit :
1. Inscription du composant d’inférence en tant que cible évolutive. Lorsque vous l’enregistrez, définissez la capacité minimale sur `0`, comme indiqué dans la commande suivante :
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id inference-component/inference-component-name \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--min-capacity 0 \
--max-capacity n
```
Dans cet exemple, remplacez-le *inference-component-name* par le nom de votre composant d'inférence. Remplacez *n* par le nombre maximum de copies de composants d'inférence à provisionner lors de la mise à l'échelle.
Pour plus d'informations sur cette commande et chacun de ses paramètres, consultez [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)la *référence des AWS CLI commandes*.
1. Appliquez une stratégie du suivi des cibles au composant d’inférence, comme illustré par la commande suivante :
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type TargetTrackingScaling \
--resource-id inference-component/inference-component-name \
--service-namespace sagemaker \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--target-tracking-scaling-policy-configuration file://config.json
```
Dans cet exemple, remplacez-le *inference-component-name* par le nom de votre composant d'inférence.
Dans l’exemple, le fichier `config.json` contient une configuration de stratégie du suivi des cibles, telle que la suivante :
```
{
"PredefinedMetricSpecification": {
"PredefinedMetricType": "SageMakerInferenceComponentInvocationsPerCopy"
},
"TargetValue": 1,
"ScaleInCooldown": 300,
"ScaleOutCooldown": 300
}
```
Pour plus d’exemples de configurations de stratégie de suivi, consultez [Définition d’une stratégie de mise à l’échelle](endpoint-auto-scaling-add-code-define.md).
Pour plus d'informations sur cette commande et chacun de ses paramètres, consultez [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)la *référence des AWS CLI commandes*.
**Pour permettre à un point de terminaison d’augmenter horizontalement à partir de zéro instance (AWS CLI)**
Pour chaque composant d’inférence hébergé par le point de terminaison, procédez comme suit :
1. Appliquez une stratégie de mise à l’échelle par étapes au composant d’inférence, comme illustré par la commande suivante :
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type StepScaling \
--resource-id inference-component/inference-component-name \
--service-namespace sagemaker \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--step-scaling-policy-configuration file://config.json
```
Dans cet exemple, remplacez-le *my-scaling-policy* par un nom unique pour votre politique. *inference-component-name*Remplacez-le par le nom de votre composant d'inférence.
Dans l’exemple, le fichier `config.json` contient une configuration de stratégie de mise à l’échelle par étapes, telle que la suivante :
```
{
"AdjustmentType": "ChangeInCapacity",
"MetricAggregationType": "Maximum",
"Cooldown": 60,
"StepAdjustments":
[
{
"MetricIntervalLowerBound": 0,
"ScalingAdjustment": 1
}
]
}
```
Lorsque la politique de dimensionnement de cette étape est déclenchée, l' SageMaker IA fournit les instances nécessaires pour prendre en charge les copies des composants d'inférence.
Après avoir créé la stratégie de mise à l’échelle par étapes, notez son Amazon Resource Name (ARN). Vous aurez besoin de l'ARN de l' CloudWatch alarme à l'étape suivante.
Pour plus d’informations sur les stratégies de mise à l’échelle par étapes, consultez [Stratégies de mise à l’échelle par étapes](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html) dans le *Guide de l’utilisateur Application Auto Scaling*.
1. Créez une CloudWatch alarme et attribuez-lui la politique de dimensionnement des étapes, comme illustré dans l'exemple suivant :
```
aws cloudwatch put-metric-alarm \
--alarm-actions step-scaling-policy-arn \
--alarm-description "Alarm when SM IC endpoint invoked that has 0 instances." \
--alarm-name ic-step-scaling-alarm \
--comparison-operator GreaterThanThreshold \
--datapoints-to-alarm 1 \
--dimensions "Name=InferenceComponentName,Value=inference-component-name" \
--evaluation-periods 1 \
--metric-name NoCapacityInvocationFailures \
--namespace AWS/SageMaker \
--period 60 \
--statistic Sum \
--threshold 1
```
Dans cet exemple, remplacez-le *step-scaling-policy-arn* par l'ARN de votre politique d'échelonnement des étapes. *ic-step-scaling-alarm*Remplacez-le par le nom de votre choix. *inference-component-name*Remplacez-le par le nom de votre composant d'inférence.
Cet exemple définit le `--metric-name` paramètre sur`NoCapacityInvocationFailures`. SageMaker L'IA émet cette métrique lorsqu'un point de terminaison reçoit une demande d'inférence, mais que le point de terminaison ne dispose d'aucune instance active pour traiter la demande. Lorsque cet événement se produit, l’alarme déclenche la stratégie de mise à l’échelle par étapes de l’étape précédente.
Pour plus d'informations sur cette commande et chacun de ses paramètres, consultez [put-metric-alarm](https://docs.aws.amazon.com/cli/latest/reference/cloudwatch/put-metric-alarm.html)la *référence des AWS CLI commandes*.
# Test de charge de votre configuration d’autoscaling
Effectuez les tests de charge pour choisir une configuration de mise à l’échelle qui fonctionne comme vous le voulez.
Les consignes suivantes pour le test de charge supposent que vous utilisez une stratégie de mise à l’échelle qui utilise la métrique cible prédéfinie `SageMakerVariantInvocationsPerInstance`.
**Topics**
+ [Détermination des caractéristiques de performance](#endpoint-scaling-loadtest-variant)
+ [Calcul de la charge cible](#endpoint-scaling-loadtest-calc)
## Détermination des caractéristiques de performance
Effectuez un test de charge pour trouver le pic des `InvocationsPerInstance` que la variante de production de votre modèle peut gérer, et la latence des demandes lorsque la simultanéité augmente.
Cette valeur dépend du type d’instance choisi, des données utiles que les clients de votre modèle envoient généralement et des performances de toutes les dépendances externes de votre modèle.
**Pour déterminer le pic requests-per-second (RPS) que la variante de production de votre modèle peut gérer et la latence des demandes**
1. Configurez un point de terminaison avec votre modèle à l’aide d’une seule instance. Pour plus d’informations sur la configuration d’un point de terminaison, consultez [Déployer le modèle sur les services d'hébergement SageMaker AI](ex1-model-deployment.md#ex1-deploy-model).
1. Utilisez un outil de test de charge pour générer un nombre croissant de requêtes parallèles, et surveiller les demandes par seconde et le modèle de latence dans la sortie de l’outil de test de charge.
**Note**
Vous pouvez également surveiller requests-per-minute au lieu du RPS. Dans ce cas, ne multipliez pas par 60 dans l’équation pour calculer `SageMakerVariantInvocationsPerInstance` comme ci-dessous.
Lorsque la latence du modèle augmente ou que la proportion de transactions réussies diminue, il s’agit du pic des demandes par seconde que votre modèle peut traiter.
## Calcul de la charge cible
Une fois que vous avez trouvé les caractéristiques de performance de la variante, vous pouvez déterminer le RPS maximal autorisé à être envoyé à une instance. Le seuil utilisé pour le dimensionnement doit être inférieur à la valeur maximale. Utilisez l’équation suivante en combinaison avec un test de charge pour déterminer la valeur appropriée pour la métrique cible `SageMakerVariantInvocationsPerInstance` de votre configuration de mise à l’échelle.
```
SageMakerVariantInvocationsPerInstance = (MAX_RPS * SAFETY_FACTOR) * 60
```
Où `MAX_RPS` est le RPS maximal que vous avez déterminé précédemment et `SAFETY_FACTOR` le facteur de sécurité que vous avez choisi pour vous assurer que vos clients ne dépassent pas le RPS maximal. Multipliez par 60 pour convertir le RPS en un CloudWatch indicateur par minute utilisé par l' SageMaker IA pour implémenter la mise à l'échelle automatique (vous n'avez pas besoin de le faire si vous avez mesuré requests-per-minute au lieu de requests-per-second). invocations-per-minute
**Note**
SageMaker AI vous recommande de commencer les tests avec une valeur `SAFETY_FACTOR` de 0,5. Testez votre configuration de mise à l’échelle pour vous assurer qu’elle fonctionne de la façon escomptée avec votre modèle pour augmenter et diminuer le trafic client sur votre point de terminaison.
# CloudFormation À utiliser pour créer une politique de dimensionnement
L’exemple suivant montre comment configurer l’autoscaling du modèle sur un point de terminaison à l’aide de CloudFormation.
```
Endpoint:
Type: "AWS::SageMaker::Endpoint"
Properties:
EndpointName: yourEndpointName
EndpointConfigName: yourEndpointConfigName
ScalingTarget:
Type: "AWS::ApplicationAutoScaling::ScalableTarget"
Properties:
MaxCapacity: 10
MinCapacity: 2
ResourceId: endpoint/my-endpoint/variant/my-variant
RoleARN: arn
ScalableDimension: sagemaker:variant:DesiredInstanceCount
ServiceNamespace: sagemaker
ScalingPolicy:
Type: "AWS::ApplicationAutoScaling::ScalingPolicy"
Properties:
PolicyName: my-scaling-policy
PolicyType: TargetTrackingScaling
ScalingTargetId:
Ref: ScalingTarget
TargetTrackingScalingPolicyConfiguration:
TargetValue: 70.0
ScaleInCooldown: 600
ScaleOutCooldown: 30
PredefinedMetricSpecification:
PredefinedMetricType: SageMakerVariantInvocationsPerInstance
```
Pour plus d’informations, consultez [Création de ressources Application Auto Scaling avec AWS CloudFormation](https://docs.aws.amazon.com/autoscaling/application/userguide/creating-resources-with-cloudformation.html) dans le *Guide de l’utilisateur d’Application Auto Scaling*.
# Mise à jour des points de terminaison qui utilisent l’autoscaling
Lorsque vous mettez à jour un point de terminaison, Application Auto Scaling vérifie si l’un des modèles de ce point de terminaison est une cible d’autoscaling. Si la mise à jour modifie le type d’instance d’un modèle qui est une cible de l’autoscaling, la mise à jour échoue.
Dans le AWS Management Console, vous voyez un avertissement indiquant que vous devez désenregistrer le modèle de la mise à l'échelle automatique avant de pouvoir le mettre à jour. Si vous essayez de mettre à jour le point de terminaison en appelant l'API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html), l'appel échoue. Avant de mettre à jour le point de terminaison, supprimez toutes les politiques de dimensionnement configurées pour celui-ci et annulez l'enregistrement de la variante en tant que cible évolutive en appelant l'action API [DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html)Application Auto Scaling. Une fois que vous avez mis à jour le point de terminaison, vous pouvez enregistrer la variante mise à jour en tant que cible évolutive et attacher une stratégie de mise à l’échelle.
Il y a une exception. Si vous modifiez le modèle d'une variante configurée pour le dimensionnement automatique, Amazon SageMaker AI Auto Scaling autorise la mise à jour. Cela est dû au fait que la modification du modèle n’affecte pas généralement suffisamment les performances pour modifier la mise à l’échelle. Si vous mettez à jour un modèle pour une variante configurée pour l’autoscaling, vérifiez que la modification du modèle n’a pas d’incidence significative sur les performances et le comportement de mise à l’échelle.
Lorsque vous mettez à jour les points de terminaison SageMaker AI auxquels la mise à l'échelle automatique est appliquée, procédez comme suit :
**Pour mettre à jour un point de terminaison auquel l’autoscaling est appliqué**
1. Désenregistrez le point de terminaison en tant que cible évolutive en appelant. [DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html)
1. Étant donné que l’autoscaling est bloqué pendant l’opération de mise à jour (ou si vous avez désactivé l’autoscaling à l’étape précédente), vous pouvez prendre la précaution supplémentaire d’augmenter le nombre d’instances de votre point de terminaison pendant la mise à jour. Pour cela, mettez à jour le nombre d'instances pour les variantes de production hébergées sur le point de terminaison en appelant [UpdateEndpointWeightsAndCapacities](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html).
1. Appelez [ DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) de façon répétée jusqu'à ce que la valeur du champ `EndpointStatus` de la réponse soit `InService`.
1. Appelez [ DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) pour obtenir les valeurs de la configuration du point de terminaison actuel.
1. Créez une configuration de point de terminaison en appelant [ CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html). Pour les variantes de production où vous souhaitez conserver le nombre ou la pondération d'instance existant(e), utilisez le même nom de variante que celui de la réponse de l'appel à [ DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) à l'étape précédente. Pour toutes les autres valeurs, utilisez les valeurs que vous avez obtenues comme réponse lorsque vous avez appelé [ DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) lors de l'étape précédente.
1. Mettez à jour le point de terminaison en appelant [ UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html). Spécifiez la configuration du point de terminaison que vous avez créée à l’étape précédente comme champ `EndpointConfig`. Si vous souhaitez conserver les propriétés de variante telles que le nombre d’instances ou la pondération, définissez la valeur du paramètre `RetainAllVariantProperties` sur `True`. Ce paramètre spécifie que les variantes de production portant le même nom seront mises à jour avec le nombre `DesiredInstanceCount` le plus récent de la réponse de l’appel à `DescribeEndpoint`, quelles que soient les valeurs du champ `InitialInstanceCount` dans le nouveau `EndpointConfig`.
1. (Facultatif) Réactivez le dimensionnement automatique en appelant [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html)et [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html).
**Note**
Les étapes 1 et 7 sont obligatoires uniquement si vous mettez à jour un point de terminaison avec les modifications suivantes :
Modification du type d’instance d’une variante de production dont l’autoscaling est configuré
Suppression d’une variante de production dont l’autoscaling est configuré.
# Suppression de points de terminaison configurés pour l’autoscaling
Si vous supprimez un point de terminaison, Application Auto Scaling vérifie si l’un des modèles sur ce point de terminaison est une cible d’autoscaling. Si c’est le cas et que vous avez l’autorisation d’annuler l’inscription du modèle, Application Auto Scaling annule l’inscription des modèles en tant que cibles évolutives, sans vous en informer. Si vous utilisez une politique d'autorisation personnalisée qui n'autorise pas l'[DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html)action, vous devez demander l'accès à cette action avant de supprimer le point de terminaison.
**Note**
En tant qu’utilisateur IAM, vous n’avez peut-être pas l’autorisation suffisante pour supprimer un point de terminaison si un autre utilisateur a configuré l’autoscaling pour une variante sur ce point de terminaison.
# Volumes de stockage d’instances
Lorsque vous créez un point de terminaison, Amazon SageMaker AI attache aux instances Amazon EC2 un volume de stockage Amazon Elastic Block Store (Amazon EBS) qui héberge le point de terminaison. La taille du volume de stockage est évolutive et les options de stockage se divisent en deux catégories : le stockage sur SSD et le stockage sur disque dur.
Pour plus d’informations sur les stockages et les fonctions Amazon EBS, consultez les pages suivantes.
+ [Fonctionnalités Amazon EBS](https://aws.amazon.com/ebs/features/)
+ [Guide de l'utilisateur Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html)
Pour obtenir la liste complète des volumes de stockage de l’instance hôte, consultez [Tableau des volumes de stockage de l’instance hôte](https://aws.amazon.com/releasenotes/host-instance-storage-volumes-table/)
**Note**
Amazon SageMaker AI attache aux instances Amazon EC2 un volume de stockage Amazon Elastic Block Store (Amazon EBS) uniquement lorsque vous créez des types de points de terminaison [Inférence asynchrone](async-inference.md) ou [Inférence en temps réel](realtime-endpoints.md). Pour plus d'informations sur la personnalisation du volume de stockage Amazon EBS, consultez [Paramètres de point de terminaison SageMaker AI pour l’inférence de modèles de grande taille](large-model-inference-hosting.md).
# Validation de modèles en production
SageMaker AI vous permet de tester plusieurs modèles ou versions de modèle avec le même point de terminaison à l’aide de variantes. Une variante se compose d’une instance de ML et des composants de service spécifiés dans un modèle SageMaker AI. Vous pouvez avoir plusieurs variantes derrière un point de terminaison. Chaque variante peut avoir un type d’instance différent ou un modèle SageMaker AI qui peut être mis à l’échelle automatiquement indépendamment des autres. Les modèles des variantes peuvent être entraînés à l'aide de différents jeux de données, de différents algorithmes, de différents cadres de ML ou d'une combinaison de ces éléments. Toutes les variantes derrière un point de terminaison partagent le même code d'inférence. SageMaker AI prend en charge deux types de variantes : les variantes de production et les variantes shadow.
Si plusieurs variantes de production sont associées à un point de terminaison, vous pouvez attribuer une partie de vos demandes d'inférence à chaque variante. Chaque demande est acheminée vers une seule variante de production. La variante de production vers laquelle la demande a été acheminée fournit la réponse à l'appelant. Vous pouvez comparer les performances des variantes de production entre elles..
Vous pouvez également avoir une variante shadow correspondant à une variante de production derrière un point de terminaison. Une partie des demandes d'inférence destinées à la variante de production est répliquée vers la variante shadow. Les réponses de la variante shadow sont journalisées à des fins de comparaison et ne sont pas renvoyées à l'appelant. Cela vous permet de tester les performances de la variante shadow sans exposer l'appelant à la réponse produite par la variante shadow.
**Topics**
+ [Test de modèles avec des variantes de production](model-ab-testing.md)
+ [Test de modèles avec des variantes shadow](model-shadow-deployment.md)
# Test de modèles avec des variantes de production
Dans les flux de travail ML de production, les scientifiques des données et les ingénieurs tentent souvent d'améliorer leurs performances de différentes manières, par exemple [Réglage automatique du modèle grâce à l' SageMaker IA](automatic-model-tuning.md), l'entraînement sur des données supplémentaires ou plus récentes, et une meilleure sélection des fonctions avec des instances et des conteneurs en service améliorés et mis à jour. Vous pouvez utiliser des variantes de production pour comparer vos modèles, instances et conteneurs, et choisir le candidat le plus performant pour répondre aux demandes d'inférence.
Avec les points de terminaison multivariants SageMaker AI, vous pouvez répartir les demandes d'invocation des points de terminaison entre plusieurs variantes de production en fournissant la distribution du trafic pour chaque variante, ou vous pouvez invoquer une variante spécifique directement pour chaque demande. Dans cette rubrique, nous examinons les deux méthodes de test des modèles ML.
**Topics**
+ [Test des modèles en spécifiant la répartition du trafic](#model-testing-traffic-distribution)
+ [Test des modèles en appelant des variantes spécifiques](#model-testing-target-variant)
+ [Exemple de A/B test de modèle](#model-ab-test-example)
## Test des modèles en spécifiant la répartition du trafic
Pour tester plusieurs modèles en répartissant le trafic entre eux, spécifiez le pourcentage du trafic qui est acheminé vers chaque modèle en spécifiant la pondération de chaque variante de production dans la configuration du point de terminaison. Pour plus d'informations, consultez [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html). Le diagramme suivant montre de façon détaillée comment cela fonctionne.
![\[Exemple montrant comment InvokeEndpoint fonctionne la distribution du trafic entre les modèles à l'aide de l' SageMaker IA.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model-traffic-distribution.png)
## Test des modèles en appelant des variantes spécifiques
Pour tester plusieurs modèles en invoquant des modèles spécifiques pour chaque demande, spécifiez la version spécifique du modèle que vous souhaitez invoquer en fournissant une valeur pour le `TargetVariant` paramètre lors de l'appel [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html). SageMaker L'IA garantit que la demande est traitée par la variante de production que vous spécifiez. Si vous avez déjà fourni la répartition du trafic et que vous spécifiez une valeur pour le paramètre `TargetVariant`, le routage ciblé remplace la répartition aléatoire du trafic. Le diagramme suivant montre de façon détaillée comment cela fonctionne.
![\[Exemple montrant comment InvokeEndpoint fonctionne l'invocation de modèles spécifiques pour chaque demande en utilisant l' SageMaker IA.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model-target-variant.png)
## Exemple de A/B test de modèle
La réalisation de A/B tests entre un nouveau modèle et un ancien modèle avec du trafic de production peut constituer une étape finale efficace du processus de validation d'un nouveau modèle. Lors A/B des tests, vous testez différentes variantes de vos modèles et comparez les performances de chaque variante. Si la version la plus récente du modèle offre de meilleures performances que la version précédente existante, remplacez l'ancienne version du modèle par la nouvelle version en production.
L'exemple suivant montre comment effectuer des tests de A/B modèles. Pour obtenir un exemple de bloc-notes implémentant cet exemple, consultez [A/B Testing ML models in production](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_endpoints/a_b_testing/a_b_testing.html).
### Étape 1 : Créer et déployer des modèles
Tout d'abord, nous définissons l'emplacement de nos modèles dans Amazon S3. Ces emplacements sont utilisés lorsque nous déployons nos modèles dans les étapes suivantes :
```
model_url = f"s3://{path_to_model_1}"
model_url2 = f"s3://{path_to_model_2}"
```
Ensuite, nous créons les objets du modèle avec les données d'image et de modèle. Ces objets de modèle sont utilisés pour déployer des variantes de production sur un point de terminaison. Les modèles sont développés en entraînant des modèles ML sur différents ensembles de données, différents algorithmes ou frameworks ML et différents hyperparamètres :
```
from sagemaker.amazon.amazon_estimator import get_image_uri
model_name = f"DEMO-xgb-churn-pred-{datetime.now():%Y-%m-%d-%H-%M-%S}"
model_name2 = f"DEMO-xgb-churn-pred2-{datetime.now():%Y-%m-%d-%H-%M-%S}"
image_uri = get_image_uri(boto3.Session().region_name, 'xgboost', '0.90-1')
image_uri2 = get_image_uri(boto3.Session().region_name, 'xgboost', '0.90-2')
sm_session.create_model(
name=model_name,
role=role,
container_defs={
'Image': image_uri,
'ModelDataUrl': model_url
}
)
sm_session.create_model(
name=model_name2,
role=role,
container_defs={
'Image': image_uri2,
'ModelDataUrl': model_url2
}
)
```
Nous créons maintenant deux variantes de production, chacune ayant ses propres exigences en matière de modèle et de ressources (type d'instance et nombre d'instances). Cela vous permet également de tester des modèles sur différents types d'instance.
Nous avons défini l'élément initial\$1weight sur 1 pour les deux variantes. Cela signifie que 50 % des demandes vont à `Variant1`, et les 50 % restants à `Variant2`. La somme des pondérations des deux variantes est de 2 et chaque variante a une pondération affectée de 1. Cela signifie que chaque variante reçoit 1/2 (ou 50 %) du trafic total.
```
from sagemaker.session import production_variant
variant1 = production_variant(
model_name=model_name,
instance_type="ml.m5.xlarge",
initial_instance_count=1,
variant_name='Variant1',
initial_weight=1,
)
variant2 = production_variant(
model_name=model_name2,
instance_type="ml.m5.xlarge",
initial_instance_count=1,
variant_name='Variant2',
initial_weight=1,
)
```
Nous sommes enfin prêts à déployer ces variantes de production sur un terminal d' SageMaker intelligence artificielle.
```
endpoint_name = f"DEMO-xgb-churn-pred-{datetime.now():%Y-%m-%d-%H-%M-%S}"
print(f"EndpointName={endpoint_name}")
sm_session.endpoint_from_production_variants(
name=endpoint_name,
production_variants=[variant1, variant2]
)
```
### Étape 2 : Appeler les modèles déployés
Maintenant, nous envoyons des demandes à ce point de terminaison pour obtenir des inférences en temps réel. Nous utilisons à la fois la répartition du trafic et le ciblage direct.
Tout d'abord, nous utilisons la répartition du trafic que nous avons configurée à l'étape précédente. Chaque réponse d'inférence contient le nom de la variante de production qui traite la demande, cela nous permettant de voir que le trafic vers les deux variantes de production est à peu près égal.
```
# get a subset of test data for a quick test
!tail -120 test_data/test-dataset-input-cols.csv > test_data/test_sample_tail_input_cols.csv
print(f"Sending test traffic to the endpoint {endpoint_name}. \nPlease wait...")
with open('test_data/test_sample_tail_input_cols.csv', 'r') as f:
for row in f:
print(".", end="", flush=True)
payload = row.rstrip('\n')
sm_runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType="text/csv",
Body=payload
)
time.sleep(0.5)
print("Done!")
```
SageMaker L'IA émet des métriques telles que `Latency` et `Invocations` pour chaque variante sur Amazon CloudWatch. Pour une liste complète des métriques émises par SageMaker l'IA, voir[Métriques Amazon SageMaker AI sur Amazon CloudWatch](monitoring-cloudwatch.md). Faisons une requête CloudWatch pour obtenir le nombre d'appels par variante, afin de montrer comment les appels sont répartis par défaut entre les variantes :
![\[Exemple de CloudWatch nombre d'appels par variante.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model-variant-invocations.png)
Appelons maintenant une version spécifique du modèle en spécifiant `Variant1` comme `TargetVariant` dans l'appel à `invoke_endpoint`.
```
print(f"Sending test traffic to the endpoint {endpoint_name}. \nPlease wait...")
with open('test_data/test_sample_tail_input_cols.csv', 'r') as f:
for row in f:
print(".", end="", flush=True)
payload = row.rstrip('\n')
sm_runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType="text/csv",
Body=payload,
TargetVariant="Variant1"
)
time.sleep(0.5)
```
Pour confirmer que toutes les nouvelles invocations ont été traitées par`Variant1`, nous pouvons demander le nombre CloudWatch d'invocations par variante. Nous voyons que pour les appels les plus récents (dernier horodatage), toutes les demandes ont été traitées par `Variant1`, comme nous l'avions spécifié. Aucune invocation n'a été faite pour `Variant2`.
![\[Exemple de CloudWatch nombre d'appels pour chaque variante.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model-invocations-target1.png)
### Étape 3 : Évaluer la performance du modèle
Pour voir quelle version du modèle fonctionne le mieux, évaluons l'exactitude, la précision, le rappel, le score F1 et le récepteur fonctionnant charactersistic/Area sous la courbe pour chaque variante. Tout d'abord, examinons ces métriques pour `Variant1` :
![\[Exemple de courbe de caractéristiques de fonctionnement du récepteur pour Variant1.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model-curve.png)
Regardons maintenant les métriques pour `Variant2` :
![\[Exemple de courbe de caractéristiques de fonctionnement du récepteur pour Variant2.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model2-curve.png)
Pour la plupart de nos métriques définies, `Variant2` fonctionne mieux, donc c'est la variante que nous voulons utiliser en production.
### Étape 4 : Augmenter le trafic vers le meilleur modèle
Maintenant que nous avons déterminé que `Variant2` fonctionnait mieux que `Variant1`, nous allons déplaçons plus de trafic vers elle. Nous pouvons continuer à l'utiliser `TargetVariant` pour invoquer une variante de modèle spécifique, mais une approche plus simple consiste à mettre à jour les poids attribués à chaque variante en appelant [UpdateEndpointWeightsAndCapacities](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html). Cela permet de modifier la répartition du trafic en direction de vos variantes de production sans nécessiter de mises à jour de votre point de terminaison. Rappelez-vous qu'à la section de configuration, nous avons défini les pondérations de variante afin de fractionner le trafic dans des proportions de 50/50. Les CloudWatch statistiques du nombre total d'appels pour chaque variante ci-dessous nous montrent les modèles d'invocation pour chaque variante :
![\[Exemples de CloudWatch mesures pour le nombre total d'appels pour chaque variante.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model-invocations-even-dist.png)
Nous transférons maintenant 75 % du trafic `Variant2` en attribuant de nouvelles pondérations à chaque variante utilisée. `UpdateEndpointWeightsAndCapacities` SageMaker L'IA envoie désormais 75 % des demandes d'inférence à `Variant2` et 25 % des demandes restantes à`Variant1`.
```
sm.update_endpoint_weights_and_capacities(
EndpointName=endpoint_name,
DesiredWeightsAndCapacities=[
{
"DesiredWeight": 25,
"VariantName": variant1["VariantName"]
},
{
"DesiredWeight": 75,
"VariantName": variant2["VariantName"]
}
]
)
```
Les CloudWatch statistiques relatives au nombre total d'appels pour chaque variante nous indiquent que le nombre d'appels est plus élevé pour : `Variant2` `Variant1`
![\[Exemples de CloudWatch mesures pour le nombre total d'appels pour chaque variante.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model-invocations-75-25.png)
Nous pouvons continuer à surveiller nos métriques et, lorsque nous sommes satisfaits des performances d'une variante, nous pouvons acheminer 100 % du trafic vers cette dernière. Nous utilisons [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html) pour mettre à jour les affectations de trafic pour les variantes. Le poids pour `Variant1` est défini sur 0 et le poids pour `Variant2` est défini sur 1. SageMaker L'IA envoie désormais 100 % de toutes les demandes d'inférence à`Variant2`.
```
sm.update_endpoint_weights_and_capacities(
EndpointName=endpoint_name,
DesiredWeightsAndCapacities=[
{
"DesiredWeight": 0,
"VariantName": variant1["VariantName"]
},
{
"DesiredWeight": 1,
"VariantName": variant2["VariantName"]
}
]
)
```
Les CloudWatch mesures relatives au nombre total d'appels pour chaque variante indiquent que toutes les demandes d'inférence sont traitées par `Variant2` et qu'aucune demande d'inférence n'est traitée par. `Variant1`
![\[Exemples de CloudWatch mesures pour le nombre total d'appels pour chaque variante.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/model-invocations-best-model.png)
Vous pouvez maintenant mettre à jour votre point de terminaison en toute sécurité et supprimer `Variant1` de votre point de terminaison. Vous pouvez également continuer à tester de nouveaux modèles en production en ajoutant de nouvelles variantes à votre point de terminaison et en suivant les étapes 2 à 4.
# Test de modèles avec des variantes shadow
Vous pouvez utiliser des déploiements SageMaker AI Model Shadow pour créer des variantes shadow de longue durée afin de valider tout nouveau composant candidat de votre pile de serveurs de modèles avant de le lancer en production. Le diagramme suivant montre de façon détaillée comment les variantes shadow fonctionnent.
![\[Détails d'une variante shadow.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/juxtaposer/shadow-variant.png)
## Déployer des variantes shadow
L'exemple de code suivant montre comment vous pouvez déployer par programmation des variantes shadow. Remplacez *user placeholder text* dans l'exemple par vos propres informations.
1. Créez deux modèles SageMaker AI : l’un pour votre variante de production et l’autre pour votre variante shadow.
```
import boto3
from sagemaker import get_execution_role, Session
aws_region = "aws-region"
boto_session = boto3.Session(region_name=aws_region)
sagemaker_client = boto_session.client("sagemaker")
role = get_execution_role()
bucket = Session(boto_session).default_bucket()
model_name1 = "name-of-your-first-model"
model_name2 = "name-of-your-second-model"
sagemaker_client.create_model(
ModelName = model_name1,
ExecutionRoleArn = role,
Containers=[
{
"Image": "ecr-image-uri-for-first-model",
"ModelDataUrl": "s3-location-of-trained-first-model"
}
]
)
sagemaker_client.create_model(
ModelName = model_name2,
ExecutionRoleArn = role,
Containers=[
{
"Image": "ecr-image-uri-for-second-model",
"ModelDataUrl": "s3-location-of-trained-second-model"
}
]
)
```
1. Créez une configuration de point de terminaison. Spécifiez à la fois vos variantes de production et shadow dans la configuration.
```
endpoint_config_name = name-of-your-endpoint-config
create_endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[
{
"VariantName": name-of-your-production-variant,
"ModelName": model_name1,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
"InitialVariantWeight": 1,
}
],
ShadowProductionVariants=[
{
"VariantName": name-of-your-shadow-variant,
"ModelName": model_name2,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
"InitialVariantWeight": 1,
}
]
)
```
1. Créez un point de terminaison .
```
create_endpoint_response = sm.create_endpoint(
EndpointName=name-of-your-endpoint,
EndpointConfigName=endpoint_config_name,
)
```
# Explicabilité en ligne avec Clarify SageMaker
Ce guide explique comment configurer l'explicabilité en ligne avec SageMaker Clarify. Avec les points de terminaison [d'inférence en temps réel](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html) de l' SageMaker IA, vous pouvez analyser l'explicabilité en temps réel et en continu. La fonction d'explicabilité en ligne s'inscrit dans la partie **Déploiement vers la production** du flux de travail [Amazon SageMaker AI Machine Learning](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-mlconcepts.html).
## Comment fonctionne l'explicabilité en ligne Clarify
Le graphique suivant décrit l'architecture d' SageMaker intelligence artificielle permettant d'héberger un point de terminaison qui répond aux demandes d'explicabilité. Il décrit les interactions entre un point de terminaison, le conteneur du modèle et l'explicateur SageMaker Clarify.
![\[SageMaker Architecture d'IA montrant l'hébergement d'un point de terminaison qui répond à des demandes d'explicabilité à la demande.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/clarify/DeveloperGuideArchitecture.png)
Voici comment fonctionne l'explicabilité en ligne Clarify. L'application envoie une `InvokeEndpoint` demande de type REST au service SageMaker AI Runtime. Le service achemine cette demande vers un point de terminaison d' SageMaker IA pour obtenir des prédictions et des explications. Le service reçoit ensuite la réponse du point de terminaison. Enfin, le service renvoie la réponse à l'application.
Pour augmenter la disponibilité des terminaux, l' SageMaker IA tente automatiquement de distribuer les instances des points de terminaison dans plusieurs zones de disponibilité, en fonction du nombre d'instances indiqué dans la configuration des points de terminaison. Sur une instance de point de terminaison, lors d'une nouvelle demande d'explicabilité, l'explicateur SageMaker Clarify appelle le conteneur du modèle pour les prédictions. Ensuite, il calcule et renvoie les attributions de fonctionnalités.
Voici les quatre étapes pour créer un point de terminaison qui utilise l'explicabilité en ligne de SageMaker Clarify :
1. [Vérifiez si votre modèle d' SageMaker IA préentraîné est compatible avec l'explicabilité en ligne en suivant les étapes de pré-vérification.](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-online-explainability-precheck.html)
1. [Créez une configuration de point de terminaison avec la configuration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) SageMaker explicative Clarify à l'aide de l'`CreateEndpointConfig`API.
1. [Créez un point de terminaison](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) et fournissez la configuration du point de terminaison à l' SageMaker IA à l'aide de l'`CreateEndpoint`API. Le service lance l'instance de calcul de machine learning et déploie le modèle tel que spécifié dans la configuration.
1. [Appelez le point de terminaison](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) : une fois le point de terminaison en service, appelez l'API SageMaker AI Runtime `InvokeEndpoint` pour envoyer des demandes au point de terminaison. Le point de terminaison renvoie ensuite des explications et des prédictions.
# Vérification préalable du conteneur de modèle
Cette section vous explique comment vérifier au préalable la compatibilité des entrées et des sorties du conteneur de modèle avant de configurer un point de terminaison. La fiche SageMaker explicative Clarify est **indépendante du modèle, mais** elle comporte des exigences relatives à l'entrée et à la sortie du conteneur du modèle.
**Note**
Vous pouvez gagner en efficacité en configurant votre conteneur afin qu'il prenne en charge les demandes par lots, qui prennent en charge au moins deux enregistrements dans une même demande. Par exemple, un enregistrement unique est une seule ligne de données CSV ou une seule ligne de données JSON Lines. SageMaker Clarify tentera d'abord d'envoyer un mini-lot d'enregistrements au conteneur modèle avant de revenir aux demandes d'enregistrement unique.
## Entrée du conteneur de modèle
------
#### [ CSV ]
Le conteneur de modèle prend en charge la saisie au format CSV avec un type MIME : `text/csv`. Le tableau suivant présente des exemples d'entrées prises en charge par SageMaker Clarify.
| Entrée du conteneur de modèle (représentation sous forme de chaîne) | Commentaires |
| --- | --- |
| '1,2,3,4' | Enregistrement unique qui utilise quatre fonctionnalités numériques. |
| '1,2,3,4\$1n5,6,7,8' | Deux enregistrements, séparés par un saut de ligne '\$1n'. |
| ’"This is a good product",5’ | Enregistrement unique qui contient une fonctionnalité textuelle et une fonctionnalité numérique. |
| ‘"This is a good product",5\$1n"Bad shopping experience",1' | Deux enregistrements. |
------
#### [ JSON Lines ]
SageMaker AI prend également en charge la saisie [au format dense JSON Lines](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-jsonlines) avec le type MIME :`application/jsonlines`, comme indiqué dans le tableau suivant.
| Entrée du conteneur de modèle | Commentaires |
| --- | --- |
| '\$1"data":\$1"features":[1,2,3,4]\$1\$1' | Enregistrement unique ; une liste de fonctionnalités peut être extraite par JMESPath expression`data.features`. |
| ’\$1"data":\$1"features":[1,2,3,4]\$1\$1\$1n\$1"data":\$1"features":[5,6,7,8]\$1\$1’ | Deux enregistrements. |
| ’\$1"features":["This is a good product",5]\$1’ | Enregistrement unique ; une liste de fonctionnalités peut être extraite par JMESPath expression`features`. |
| ’\$1"features":["This is a good product",5]\$1\$1n\$1"features":["Bad shopping experience",1]\$1’ | Deux enregistrements. |
------
## Sortie du conteneur de modèle
La sortie de votre conteneur de modèle doit être au format CSV ou au format dense JSON Lines. De plus, le conteneur du modèle doit inclure les probabilités des enregistrements d'entrée, que SageMaker Clarify utilise pour calculer les attributions de fonctionnalités.
Les exemples de données suivants concernent les sorties du conteneur de modèle au **format CSV**.
------
#### [ Probability only ]
Pour les problèmes de régression et de classification binaire, le conteneur de modèle génère une valeur de probabilité (score) unique de l'étiquette prédite. Ces probabilités peuvent être extraites à l'aide de l'index de colonne 0. Pour les problèmes impliquant plusieurs classes, le conteneur de modèle génère une liste de probabilités (scores). Pour les problèmes impliquant plusieurs classes, si aucun index n'est fourni, toutes les valeurs sont extraites.
| Entrée du conteneur de modèle | Sortie du conteneur de modèle (représentation sous forme de chaîne) |
| --- | --- |
| Enregistrement unique | '0.6' |
| Deux enregistrements (résultats sur une ligne) | '0.6,0.3' |
| Deux enregistrements (résultats sur deux lignes) | '0.6\$1n0.3' |
| Enregistrement unique d'un modèle multi-classes (trois classes) | '0.1,0.6,0.3' |
| Deux enregistrements d'un modèle multi-classes (trois classes) | '0.1,0.6,0.3\$1n0.2,0.5,0.3' |
------
#### [ Predicted label and probabilities ]
Le conteneur de modèle génère l'étiquette prédite suivie de sa probabilité au format **CSV**. Ces probabilités peuvent être extraites à l'aide de l'index `1`.
| Entrée du conteneur de modèle | Sortie du conteneur de modèle |
| --- | --- |
| Enregistrement unique | '1,0.6' |
| Deux enregistrements | '1,0.6\$1n0,0.3' |
------
#### [ Predicted labels header and probabilities ]
Un conteneur de modèle multi-classes entraîné par Autopilot peut être configuré pour générer la **représentation sous forme de chaîne** de la liste des étiquettes prédites et des probabilités au format **CSV**. Dans l'exemple suivant, les probabilités peuvent être extraites par l'index `1`. Les en-têtes d'étiquette peuvent être extraits par l'index `1` et les en-têtes d'étiquette peuvent être extraits à l'aide de l'index `0`.
| Entrée du conteneur de modèle | Sortie du conteneur de modèle |
| --- | --- |
| Enregistrement unique | '"[\$1'cat\$1',\$1'dog\$1',\$1'fish\$1']","[0.1,0.6,0.3]"' |
| Deux enregistrements | '"[\$1'cat\$1',\$1'dog\$1',\$1'fish\$1']","[0.1,0.6,0.3]"\$1n"[\$1'cat\$1',\$1'dog\$1',\$1'fish\$1']","[0.2,0.5,0.3]"' |
------
Les exemples de données suivants concernent les sorties de conteneur de modèle au format **JSON Lines**.
------
#### [ Probability only ]
Dans cet exemple, le conteneur de modèle génère la probabilité qui peut être extraite par l'expression [https://jmespath.org/](https://jmespath.org/) `score` au format **JSON Lines**.
| Entrée du conteneur de modèle | Sortie du conteneur de modèle |
| --- | --- |
| Enregistrement unique | '\$1"score":0.6\$1' |
| Deux enregistrements | '\$1"score":0.6\$1\$1n\$1"score":0.3\$1' |
------
#### [ Predicted label and probabilities ]
Dans cet exemple, un conteneur de modèle multi-classes génère une liste d'en-têtes d'étiquettes ainsi qu'une liste de probabilités au format **JSON Lines**. Les probabilités peuvent être extraites par l'expression `JMESPath` `probability` et les en-têtes d'étiquette peuvent être extraits par l'expression `JMESPath` `predicted labels`.
| Entrée du conteneur de modèle | Sortie du conteneur de modèle |
| --- | --- |
| Enregistrement unique | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1' |
| Deux enregistrements | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1\$1n\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]\$1' |
------
#### [ Predicted labels header and probabilities ]
Dans cet exemple, un conteneur de modèle multi-classes génère une liste d'en-têtes d'étiquettes et de probabilités au format **JSON Lines**. Les probabilités peuvent être extraites par l'expression `JMESPath` `probability` et les en-têtes d'étiquette peuvent être extraits par l'expression `JMESPath` `predicted labels`.
| Entrée du conteneur de modèle | Sortie du conteneur de modèle |
| --- | --- |
| Enregistrement unique | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1' |
| Deux enregistrements | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1\$1n\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]\$1' |
------
## Validation d'un conteneur de modèle
Nous vous recommandons de déployer votre modèle sur un point de terminaison d'inférence en temps réel basé sur l' SageMaker IA et d'envoyer des demandes à ce point de terminaison. Examinez manuellement les demandes (entrées du conteneur de modèle) et les réponses (sorties du conteneur de modèle) pour vous assurer qu'elles sont conformes aux exigences des sections **Entrée du conteneur de modèle** et **Sortie du conteneur de modèle**. Si votre conteneur de modèle prend en charge les demandes par lots, vous pouvez commencer par une seule demande d’enregistrement, puis essayer avec deux enregistrements ou plus.
Les commandes suivantes montrent comment demander une réponse à l’aide de l’ AWS CLI. AWS CLI Il est préinstallé dans les instances SageMaker Studio Classic et SageMaker Notebook. Si vous devez l'installer AWS CLI, suivez ce [guide d'installation](https://aws.amazon.com/cli/).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
Les paramètres sont définis, comme suit :
+ `$ENDPOINT NAME` : nom du point de terminaison.
+ `$CONTENT_TYPE` : type MIME de la demande (entrée du conteneur de modèle).
+ `$ACCEPT_TYPE` : type MIME de la réponse (sortie du conteneur de modèle).
+ `$REQUEST_DATA` : chaîne de données utiles demandée.
+ `$CLI_BINARY_FORMAT` : format du paramètre de l'interface de ligne de commande (CLI). Pour AWS CLI la version 1, ce paramètre doit rester vide. Pour la version 2, ce paramètre doit être défini sur `--cli-binary-format raw-in-base64-out`.
**Note**
AWS CLI [v2 transmet les paramètres binaires sous forme de chaînes codées en base64 par défaut.](https://docs.aws.amazon.com/cli/latest/userguide/cliv2-migration.html#cliv2-migration-binaryparam)
Les exemples suivants utilisent la version AWS CLI 1 :
------
#### [ Request and response in CSV format ]
+ La demande se compose d'un seul enregistrement et la réponse est sa valeur de probabilité.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
Sortie :
`0.6`
+ La demande se compose de deux enregistrements, la réponse inclut leurs probabilités et le modèle sépare les probabilités par une virgule. L'expression `$'content'` contenue dans le `--body` indique à la commande d'interpréter `\n` dans le contenu comme un saut de ligne.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Sortie :
`0.6,0.3`
+ La demande se compose de deux enregistrements, la réponse inclut leurs probabilités et le modèle sépare les probabilités par un saut de ligne.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Sortie :
`0.6`
`0.3`
+ La demande se compose d'un seul enregistrement et la réponse est constituée de valeurs de probabilité (modèle multi-classes, trois classes).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
Sortie :
`0.1,0.6,0.3`
+ La demande se compose de deux enregistrements et la réponse comprend leurs valeurs de probabilité (modèle multi-classes, trois classes).
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Sortie :
`0.1,0.6,0.3`
`0.2,0.5,0.3`
+ La demande se compose de deux enregistrements, et la réponse comprend l'étiquette prédite et la probabilité.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-2 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Sortie :
`1,0.6`
`0,0.3`
+ La demande se compose de deux enregistrements, et la réponse comprend les en-têtes d'étiquette et les probabilités.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-3 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Sortie :
`"['cat','dog','fish']","[0.1,0.6,0.3]"`
`"['cat','dog','fish']","[0.2,0.5,0.3]"`
------
#### [ Request and response in JSON Lines format ]
+ La demande se compose d'un seul enregistrement et la réponse est sa valeur de probabilité.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines \
--content-type application/jsonlines \
--accept application/jsonlines \
--body '{"features":["This is a good product",5]}' \
/dev/stderr 1>/dev/null
```
Sortie :
`{"score":0.6}`
+ La demande contient deux enregistrements, et la réponse comprend l'étiquette prédite et la probabilité.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-2 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
Sortie :
`{"predicted_label":1,"probability":0.6}`
`{"predicted_label":0,"probability":0.3}`
+ La demande contient deux enregistrements, et la réponse comprend les en-têtes d'étiquette et les probabilités.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-3 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"data":{"features":[1,2,3,4]}}\n{"data":{"features":[5,6,7,8]}}' \
/dev/stderr 1>/dev/null
```
Sortie :
`{"predicted_labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]}`
`{"predicted_labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]}`
------
#### [ Request and response in different formats ]
+ La demande est au format CSV et la réponse au format JSON Lines :
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Sortie :
`{"probability":0.6}`
`{"probability":0.3}`
+ La demande est au format JSON Lines et la réponse au format CSV :
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-in-csv-out \
--content-type application/jsonlines \
--accept text/csv \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
Sortie :
`0.6`
`0.3`
------
Une fois les validations terminées, [supprimez](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-delete-resources.html) le point de terminaison de test.
# Configuration et création d'un point de terminaison
Créez une configuration de point de terminaison adaptée à votre modèle et utilisez cette configuration pour créer le point de terminaison. Vous pouvez utiliser le conteneur du modèle validé lors de l'[étape de pré-vérification](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-online-explainability-precheck.html) pour créer un point de terminaison et activer la fonctionnalité d'explicabilité en ligne SageMaker Clarify.
Utilisez l'`sagemaker_client`objet pour créer un point de terminaison à l'aide de l'[CreateEndpointConfig](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API. Définissez le membre`ClarifyExplainerConfig` dans le paramètre `ExplainerConfig` comme suit :
```
sagemaker_client.create_endpoint_config(
EndpointConfigName='name-of-your-endpoint-config',
ExplainerConfig={
'ClarifyExplainerConfig': {
'EnableExplanations': '`true`',
'InferenceConfig': {
...
},
'ShapConfig': {
...
}
},
},
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': 'name-of-your-model',
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}]
...
)
sagemaker_client.create_endpoint(
EndpointName='name-of-your-endpoint',
EndpointConfigName='name-of-your-endpoint-config'
)
```
Le premier appel à l'objet `sagemaker_client` crée une configuration de point de terminaison avec la fonction d'explicabilité activée. Le second appel utilise la configuration du point de terminaison pour lancer le point de terminaison.
**Note**
Vous pouvez également héberger plusieurs modèles dans un seul conteneur derrière un point de [terminaison multimodèle d'inférence en temps réel basé sur l'SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) et configurer l'explicabilité en ligne avec Clarify. SageMaker
# L'expression `EnableExplanations`
Le paramètre `EnableExplanations` est une chaîne d'expression booléenne [https://jmespath.org/](https://jmespath.org/). Il est évalué pour **chaque enregistrement** de la demande d'explicabilité. Si ce paramètre est évalué comme étant **vrai**, l'enregistrement est expliqué. Si ce paramètre est évalué comme étant **faux**, aucune explication n'est générée.
SageMaker Clarify désérialise la sortie du conteneur du modèle pour chaque enregistrement dans une structure de données compatible JSON, puis utilise le `EnableExplanations` paramètre pour évaluer les données.
**Remarques**
Il existe deux options pour les enregistrements en fonction du format de sortie du conteneur de modèle.
Si la sortie du conteneur de modèle est au format CSV, un enregistrement est chargé sous forme de tableau JSON.
Si la sortie du conteneur de modèle est au format JSON Lines, un enregistrement est chargé sous forme d'objet JSON.
Le `EnableExplanations` paramètre est une JMESPath expression qui peut être transmise pendant les `CreateEndpointConfig` opérations `InvokeEndpoint` ou. Si l' JMESPath expression que vous avez fournie n'est pas valide, la création du point de terminaison échouera. Si l'expression est valide, mais que le résultat de l'évaluation de l'expression est inattendu, le point de terminaison est créé avec succès, mais une erreur est générée lorsque le point de terminaison est appelé. Testez votre expression `EnableExplanations` à l'aide de l'API `InvokeEndpoint`, puis appliquez-la à la configuration du point de terminaison.
Voici quelques exemples d'expressions `EnableExplanations` valides. Dans les exemples, une JMESPath expression entoure un littéral à l'aide de caractères antirétrospectifs. Par exemple, ``true`` signifie vrai.
| Expression (représentation sous forme de chaîne) | Sortie du conteneur de modèle (représentation sous forme de chaîne) | Résultat de l'évaluation (booléen) | Signification |
| --- | --- | --- | --- |
| '`true`' | (N/A) | True | Active l'explicabilité en ligne de manière inconditionnelle. |
| '`false`' | (N/A) | False | Désactive l'explicabilité en ligne de manière inconditionnelle. |
| '[1]>`0.5`' | '1,0.6' | True | Pour chaque enregistrement, le conteneur de modèle affiche son étiquette prédite et sa probabilité. Explique un enregistrement si sa probabilité (à l'indice 1) est supérieure à 0,5. |
| 'probability>`0.5`' | '\$1"predicted\$1label":1,"probability":0.6\$1' | True | Pour chaque enregistrement, le conteneur de modèle génère des données JSON. Explique un enregistrement si sa probabilité est supérieure à 0,5. |
| '\$1contains(probabilities[:-1], max(probabilities))' | '\$1"probabilities": [0.4, 0.1, 0.4], "labels":["cat","dog","fish"]\$1' | False | Pour un modèle multi-classes : explique un enregistrement si son étiquette prédite (la classe ayant la valeur de probabilité maximale) est la dernière classe. Littéralement, l'expression signifie que la valeur de probabilité maximale ne figure pas dans la liste des probabilités à l'exception de la dernière. |
# Jeu de données synthétique
SageMaker Clarify utilise l'algorithme Kernel SHAP. À partir d'un enregistrement (également appelé échantillon ou instance) et de la configuration SHAP, l'explicateur génère d'abord un ensemble de données synthétique. SageMaker Clarify interroge ensuite le conteneur du modèle pour obtenir les prédictions de l'ensemble de données, puis calcule et renvoie les attributions des entités. La taille du jeu de données synthétique affecte le temps d'exécution de l'outil d'explication Clarify. Les grands jeux de données synthétiques mettent plus de temps à obtenir les prédictions du modèle que les plus petits.
La taille du jeu de données synthétique est déterminée par la formule suivante :
```
Synthetic dataset size = SHAP baseline size * n_samples
```
La taille de référence SHAP est égale au nombre d'enregistrements contenus dans les données de référence SHAP. Ces informations sont extraites de `ShapBaselineConfig`.
La taille de `n_samples` est définie par le paramètre `NumberOfSamples` dans la configuration de l'outil d'explication et par le nombre de fonctionnalités. Si le nombre de fonctionnalités est égal à `n_features`, alors `n_samples` est calculé de la manière suivante :
```
n_samples = MIN(NumberOfSamples, 2^n_features - 2)
```
L'exemple suivant illustre `n_samples` si `NumberOfSamples` n'est pas fourni.
```
n_samples = MIN(2*n_features + 2^11, 2^n_features - 2)
```
Par exemple, un enregistrement tabulaire comportant 10 fonctionnalités a une taille de référence SHAP de 1. Si `NumberOfSamples` n'est pas fourni, le jeu de données synthétique contient 1 022 enregistrements. Si l'enregistrement comporte 20 fonctionnalités, le jeu de données synthétique contient 2 088 enregistrements.
Pour les problèmes de NLP, `n_features` est égal au nombre de fonctionnalités non textuelles auquel est ajouté le nombre d'unités de texte.
**Note**
L'API `InvokeEndpoint` comporte un délai d'expiration de la demande. Si le jeu de données synthétique est trop volumineux, il se peut que l'outil d'explication ne soit pas en mesure de terminer le calcul avant la fin de ce délai. Si nécessaire, utilisez les informations précédentes pour comprendre et réduire la taille de la référence SHAP et `NumberOfSamples`. Si votre conteneur de modèle est configuré pour traiter les demandes par lots, vous pouvez également ajuster la valeur de `MaxRecordCount`.
# Appel du point de terminaison
Une fois le point de terminaison en cours d'exécution, utilisez l'[InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)API SageMaker AI Runtime du service SageMaker AI Runtime pour envoyer des demandes au point de terminaison ou l'invoquer. En réponse, les demandes sont traitées comme des demandes d'explicabilité par l'explicateur SageMaker Clarify.
**Note**
Pour appeler un point de terminaison, choisissez l'une des options suivantes :
Pour obtenir des instructions sur l'utilisation de Boto3 ou sur l'appel AWS CLI d'un point de terminaison, consultez. [Invocation de modèles pour une inférence en temps réel](realtime-endpoints-test-endpoints.md)
Pour utiliser le SageMaker SDK pour Python afin d'invoquer un point de terminaison, consultez l'API [Predictor](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html).
## Demande
L'API `InvokeEndpoint` possède un paramètre `EnableExplanations` facultatif, qui est mappé à l'en-tête HTTP `X-Amzn-SageMaker-Enable-Explanations`. Si ce paramètre est fourni, il remplace le paramètre `EnableExplanations` de `ClarifyExplainerConfig`.
**Note**
Les paramètres requis de l'API `InvokeEndpoint` sont `ContentType` et `Accept`. Les formats pris en charge incluent le type MIME `text/csv` et `application/jsonlines`.
Utilisez `sagemaker_runtime_client` pour envoyer une demande au point de terminaison, de la manière suivante :
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName='name-of-your-endpoint',
EnableExplanations='`true`',
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4', # single record (of four numerical features)
)
```
Pour les points de terminaison multimodèles, transmettez un paramètre `TargetModel` supplémentaire dans l’exemple de demande précédent pour spécifier le modèle à cibler au niveau du point de terminaison. Le point de terminaison multimodèle charge dynamiquement les modèles cibles selon les besoins. Pour plus d’informations à propos de l’utilisation des points de terminaison multimodèles, consultez [Points de terminaison multimodèles](multi-model-endpoints.md). Consultez le carnet d'exemples [SageMaker Clarify Online Explainability on Multi-Model Endpoint Sample Notebook](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/tabular_multi_model_endpoint/multi_model_xgboost_with_online_explainability.ipynb) pour un exemple de configuration et d'appel de plusieurs modèles cibles à partir d'un seul point de terminaison.
## Réponse
Si le point de terminaison est créé avec `ExplainerConfig`, alors un nouveau schéma de réponse est utilisé. Ce nouveau schéma est différent d'un point de terminaison qui ne possède pas le paramètre `ExplainerConfig` fourni, et n'est pas compatible avec ce type de point de terminaison.
Le type MIME de la réponse est `application/json`, et la charge utile de la réponse peut être décodée à partir d'octets UTF-8 vers un objet JSON. Voici les membres de cet objet JSON :
+ `version` : version du schéma de réponse au format chaîne. Par exemple, `1.0`.
+ `predictions` : les prédictions émises par la demande sont les suivantes :
+ `content_type` : type MIME des prédictions, faisant référence au `ContentType` de la réponse du conteneur de modèle.
+ `data` : chaîne des données de prédictions fournie en tant que charge utile de la réponse du conteneur de modèle pour la demande.
+ `label_headers` : en-têtes d'étiquette du paramètre `LabelHeaders`. Ces en-têtes sont fournis dans la configuration de l'outil d'explication ou dans la sortie du conteneur de modèle.
+ `explanations` : explications fournies dans la charge utile de la demande. Si aucun enregistrement n'est expliqué, ce membre renvoie l'objet vide `{}`.
+
+ `kernel_shap` : clé faisant référence à un tableau d'explications Kernel SHAP pour chaque enregistrement de la demande. Si un enregistrement n'est pas expliqué, l'explication correspondante est `null`.
L'élément `kernel_shap` contient les membres suivants :
+ `feature_header` : nom d'en-tête des fonctionnalités fournies par le paramètre `FeatureHeaders` dans la configuration de l'outil d'explication `ExplainerConfig`.
+ `feature_type` : type de fonctionnalité déduit par l'outil d'explication ou fourni dans le paramètre `FeatureTypes` de `ExplainerConfig`. Cet élément n'est disponible que pour les problèmes d'explicabilité du NLP.
+ `attributions` : tableau d'objets d'attribution. Les fonctionnalités de texte peuvent avoir plusieurs objets d'attribution, chacun pour une unité. L'objet d'attribution contient les membres suivants :
+ `attribution` : liste de valeurs de probabilité, données pour chaque classe.
+ `description` : description des unités de texte, disponible uniquement pour les problèmes d'explicabilité du NLP.
+ `partial_text` : partie du texte expliquée par l'outil d'explication.
+ `start_idx` : index de base zéro permettant d'identifier l'emplacement dans le tableau du début du fragment de texte partiel.
# Exemples de code : kit SDK pour Python
Cette section fournit un exemple de code permettant de créer et d'invoquer un point de terminaison utilisant l'explicabilité en ligne SageMaker Clarify. Ces exemples de code utilisent le [kit SDK AWS pour Python.](https://aws.amazon.com/sdk-for-python/)
## Données tabulaires
L'exemple suivant utilise des données tabulaires et un modèle d' SageMaker IA appelé`model_name`. Dans cet exemple, le conteneur de modèle accepte les données au format CSV et chaque enregistrement comporte quatre caractéristiques numériques. Dans cette configuration minimale, **conçue uniquement à des fins de démonstration**, les données de base SHAP sont définies sur zéro. Consultez [Bases de référence SHAP pour l’explicabilité](clarify-feature-attribute-shap-baselines.md) afin de découvrir comment choisir des valeurs plus appropriées pour `ShapBaseline`.
Configurez le point de terminaison comme suit :
```
endpoint_config_name = 'tabular_explainer_endpoint_config'
response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': model_name,
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}],
ExplainerConfig={
'ClarifyExplainerConfig': {
'ShapConfig': {
'ShapBaselineConfig': {
'ShapBaseline': '0,0,0,0',
},
},
},
},
)
```
Utilisez la configuration du point de terminaison pour créer un point de terminaison, comme suit :
```
endpoint_name = 'tabular_explainer_endpoint'
response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
```
Utilisez l'API `DescribeEndpoint` pour inspecter la progression de la création d'un point de terminaison, comme suit :
```
response = sagemaker_client.describe_endpoint(
EndpointName=endpoint_name,
)
response['EndpointStatus']
```
Une fois que le statut du point de terminaison est InService « », invoquez le point de terminaison avec un enregistrement de test, comme suit :
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4',
)
```
**Note**
Dans l'exemple de code précédent, pour les points de terminaison multimodèles, transmettez un paramètre `TargetModel` supplémentaire dans la demande pour spécifier le modèle à cibler au niveau du point de terminaison.
Supposons que le code d'état de la réponse est 200 (aucune erreur) et chargez le corps de la réponse comme suit :
```
import codecs
import json
json.load(codecs.getreader('utf-8')(response['Body']))
```
L'action par défaut pour le point de terminaison consiste à expliquer l'enregistrement. Voici un exemple de sortie dans l'objet JSON renvoyé.
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv; charset=utf-8",
"data": "0.0006380207487381"
},
"explanations": {
"kernel_shap": [
[
{
"attributions": [
{
"attribution": [-0.00433456]
}
]
},
{
"attributions": [
{
"attribution": [-0.005369821]
}
]
},
{
"attributions": [
{
"attribution": [0.007917749]
}
]
},
{
"attributions": [
{
"attribution": [-0.00261214]
}
]
}
]
]
}
}
```
Utilisez le paramètre `EnableExplanations` pour activer les explications à la demande, comme suit :
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4',
EnableExplanations='[0]>`0.8`',
)
```
**Note**
Dans l'exemple de code précédent, pour les points de terminaison multimodèles, transmettez un paramètre `TargetModel` supplémentaire dans la demande pour spécifier le modèle à cibler au niveau du point de terminaison.
Dans cet exemple, la valeur de prédiction est inférieure à la valeur de seuil de `0.8`. L'enregistrement n'est donc pas expliqué :
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv; charset=utf-8",
"data": "0.6380207487381995"
},
"explanations": {}
}
```
Utilisez des outils de visualisation pour vous aider à interpréter les explications renvoyées. L'image suivante montre comment les graphiques SHAP peuvent être utilisés pour comprendre comment chaque fonctionnalité contribue à la prédiction. La valeur de base du diagramme, également appelée « valeur attendue », est la moyenne des prédictions du jeu de données d'entraînement. Les fonctionnalités qui poussent la valeur attendue vers le haut sont rouges, tandis que les fonctionnalités qui poussent la valeur attendue vers le bas sont bleues. Consultez la [disposition de la force additive SHAP](https://shap.readthedocs.io/en/latest/generated/shap.plots.force.html) pour plus d'informations.
![\[Exemple de diagramme SHAP pouvant être utilisé pour comprendre comment chaque caractéristique contribue à la prédiction.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/clarify/force-plot.png)
Consultez l'[exemple complet de bloc-notes pour les données tabulaires](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/tabular/tabular_online_explainability_with_sagemaker_clarify.ipynb).
## Données de texte
Cette section fournit un exemple de code permettant de créer et d'appeler un point de terminaison d'explicabilité en ligne pour les données texte. L'exemple de code utilise le kit SDK pour Python
L'exemple suivant utilise des données de texte et un modèle d' SageMaker IA appelé`model_name`. Dans cet exemple, le conteneur de modèle accepte les données au format CSV et chaque enregistrement est une chaîne unique.
```
endpoint_config_name = 'text_explainer_endpoint_config'
response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': model_name,
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}],
ExplainerConfig={
'ClarifyExplainerConfig': {
'InferenceConfig': {
'FeatureTypes': ['text'],
'MaxRecordCount': 100,
},
'ShapConfig': {
'ShapBaselineConfig': {
'ShapBaseline': '""',
},
'TextConfig': {
'Granularity': 'token',
'Language': 'en',
},
'NumberOfSamples': 100,
},
},
},
)
```
+ `ShapBaseline` : jeton spécial réservé au traitement du langage naturel (NLP).
+ `FeatureTypes` : identifie la fonctionnalité sous forme de texte. Si ce paramètre n'est pas fourni, l'outil d'explication tente de déduire le type de fonctionnalité.
+ `TextConfig` : spécifie l'unité de granularité et la langue pour l'analyse des fonctionnalités textuelles. Dans cet exemple, la langue est l'anglais et la valeur `token` pour la granularité signifie un mot dans un texte en anglais.
+ `NumberOfSamples` : limite permettant de définir les limites supérieures de la taille du jeu de données synthétique.
+ `MaxRecordCount` : nombre maximal d'enregistrements dans une demande que le conteneur de modèle peut gérer. Ce paramètre est défini pour stabiliser les performances.
Utilisez la configuration du point de terminaison pour créer le point de terminaison, comme suit :
```
endpoint_name = 'text_explainer_endpoint'
response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
```
Une fois que l'état du point de terminaison est `InService`, appelez le point de terminaison. L'exemple de code suivant utilise un enregistrement de test comme suit :
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='"This is a good product"',
)
```
Si la demande aboutit, le corps de la réponse renvoie un objet JSON valide similaire à l'objet suivant :
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv",
"data": "0.9766594\n"
},
"explanations": {
"kernel_shap": [
[
{
"attributions": [
{
"attribution": [
-0.007270948666666712
],
"description": {
"partial_text": "This",
"start_idx": 0
}
},
{
"attribution": [
-0.018199033666666628
],
"description": {
"partial_text": "is",
"start_idx": 5
}
},
{
"attribution": [
0.01970993241666666
],
"description": {
"partial_text": "a",
"start_idx": 8
}
},
{
"attribution": [
0.1253469515833334
],
"description": {
"partial_text": "good",
"start_idx": 10
}
},
{
"attribution": [
0.03291143366666657
],
"description": {
"partial_text": "product",
"start_idx": 15
}
}
],
"feature_type": "text"
}
]
]
}
}
```
Utilisez des outils de visualisation pour vous aider à interpréter les attributions de texte renvoyées. L'image suivante montre comment l'utilitaire de visualisation captum peut être utilisé pour comprendre de quelle manière chaque terme contribue à la prédiction. Plus la saturation des couleurs est élevée, plus l'importance accordée au mot est élevée. Dans cet exemple, une couleur rouge vif très saturée indique une forte contribution négative. Une couleur verte très saturée indique une forte contribution positive. La couleur blanche indique que le mot a une contribution neutre. Consultez la bibliothèque [captum](https://github.com/pytorch/captum) pour plus d'informations sur l'analyse et le rendu des attributions.
![\[L'utilitaire de visualisation captum est utilisé pour comprendre comment chaque terme contribue à la prédiction.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/clarify/word-importance.png)
Consultez l'[exemple complet de bloc-notes pour les données texte](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/natural_language_processing/nlp_online_explainability_with_sagemaker_clarify.ipynb).
# Guide de dépannage
Si vous rencontrez des erreurs lors de l'utilisation de l'explicabilité en ligne de SageMaker Clarify, consultez les rubriques de cette section.
**`InvokeEndpoint`L'API échoue avec l'erreur « :Read ReadTimeoutError timeout on endpoint... »**
Cette erreur signifie que la demande n'a pas pu être traitée dans le délai de 60 secondes défini par le [délai d'expiration de la demande](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html).
Pour réduire la latence des demandes, procédez comme suit :
+ Ajustez les performances du modèle lors de l'inférence. Par exemple, SageMaker AI [Neo](https://aws.amazon.com/sagemaker/neo/) peut optimiser les modèles à des fins d'inférence.
+ Autorisez le conteneur de modèle à gérer les demandes par lots.
+ Utilisez une valeur `MaxRecordCount` plus grande pour réduire le nombre d'appels de l'outil d'explication vers le conteneur de modèle. Cela permet de réduire la latence et la surcharge du réseau.
+ Utilisez un type d'instance auquel un plus grand nombre de ressources sont allouées. Vous pouvez également attribuer d'autres instances au point de terminaison pour aider à équilibrer la charge.
+ Réduisez le nombre d'enregistrements au sein d'une même demande `InvokeEndpoint`.
+ Réduisez le nombre d'enregistrements dans les données de base.
+ Utilisez une valeur `NumberOfSamples` plus petite pour réduire la taille du jeu de données synthétique. Pour plus d’informations sur la façon dont le nombre d’échantillon affecte un jeu de données synthétique, consultez [Jeu de données synthétique](clarify-online-explainability-create-endpoint-synthetic.md).
# Peaufinage des modèles avec les composants d’inférence des adaptateurs
Avec Amazon SageMaker AI, vous pouvez héberger des modèles de base préentraînés sans avoir à créer vos propres modèles à partir de zéro. Toutefois, pour adapter un modèle de fondation à usage général aux besoins uniques de votre activité, vous devez en créer une version peaufinée. LoRA (Low-Rank Adaptation) est une technique de peaufinage peu coûteuse. Le principe qui sous-tend la LoRA est que seule une petite partie d’un grand modèle de fondation nécessite une mise à jour pour l’adapter à de nouvelles tâches ou à de nouveaux domaines. Un adaptateur LoRA augmente l’inférence à partir d’un modèle de fondation avec seulement quelques couches d’adaptateurs supplémentaires.
*Si vous hébergez votre modèle de base à l'aide d'un composant d'inférence SageMaker AI, vous pouvez affiner ce modèle de base à l'aide d'adaptateurs LoRa en créant des composants d'inférence d'adaptateurs.* Lorsque vous créez un composant d’inférence d’adaptateur, vous spécifiez les éléments suivants :
+ Le *composant d’inférence de base* qui doit contenir le composant d’inférence de l’adaptateur. Le composant d’inférence de base contient le modèle de fondation que vous souhaitez adapter. Le composant d’inférence d’adaptateur utilise les ressources de calcul que vous avez attribuées au composant d’inférence de base.
+ L’emplacement où vous avez stocké l’adaptateur LoRA dans Amazon S3.
Une fois que vous avez créé le composant d’inférence d’adaptateur, vous pouvez l’invoquer directement. Lorsque vous le faites, l' SageMaker IA combine l'adaptateur avec le modèle de base pour augmenter la réponse générée.
**Avant de commencer**
Avant de pouvoir créer un composant d’inférence d’adaptateur, vous devez respecter les exigences suivantes :
+ Vous disposez d’un composant d’inférence de base contenant le modèle de fondation à adapter. Vous avez déployé ce composant d'inférence sur un point de terminaison d' SageMaker IA.
Pour plus d’informations sur le déploiement de composants d’inférence vers des points de terminaison, consultez [Déploiement de modèles pour l’inférence en temps réel](realtime-endpoints-deploy-models.md).
+ Vous disposez d’un modèle d’adaptateur LoRA et vous avez stocké les artefacts de modèle sous la forme d’un fichier `tar.gz` dans Amazon S3. Vous spécifiez l’URI S3 des artefacts lorsque vous créez le composant d’inférence d’adaptateur.
Les exemples suivants utilisent le kit SDK pour Python (Boto3) pour créer et invoquer un composant d’inférence d’adaptateur.
**Example Appel `create_inference_component` pour créer un composant d’inférence d’adaptateur**
L’exemple suivant crée un composant d’inférence d’adaptateur et l’attribue à un composant d’inférence de base :
```
sm_client.create_inference_component(
InferenceComponentName = adapter_ic_name,
EndpointName = endpoint_name,
Specification={
"BaseInferenceComponentName": base_inference_component_name,
"Container": {
"ArtifactUrl": adapter_s3_uri
},
},
)
```
Lorsque vous utilisez cet exemple dans votre propre code, remplacez les valeurs des espaces réservés comme suit :
+ *adapter\$1ic\$1name*— Nom unique pour le composant d'inférence de votre adaptateur.
+ *endpoint\$1name*— Nom du point de terminaison qui héberge le composant d'inférence de base.
+ *base\$1inference\$1component\$1name*— Nom du composant d'inférence de base qui contient le modèle de base à adapter.
+ *adapter\$1s3\$1uri*— L'URI S3 qui localise le `tar.gz` fichier contenant les artefacts de votre adaptateur LoRa.
Vous créez un composant d’inférence d’adaptateur avec un code similaire au code d’un composant d’inférence normal. L’une des différences est que, pour le paramètre `Specification`, vous omettez la clé `ComputeResourceRequirements`. Lorsque vous invoquez un composant d’inférence d’adaptateur, il est chargé par le composant d’inférence de base. Le composant d’inférence d’adaptateur utilise les ressources de calcul du composant d’inférence de base.
Pour plus d’informations sur la création et le déploiement de composants d’inférence avec le kit SDK pour Python (Boto3), consultez [Déployez des modèles avec Python SDKs](realtime-endpoints-deploy-models.md#deploy-models-python).
Après avoir créé un composant d’inférence d’adaptateur, vous l’invoquez en spécifiant son nom dans une demande `invoke_endpoint`.
**Example Appel `invoke_endpoint` pour invoquer un composant d’inférence d’adaptateur**
L’exemple suivant invoque un composant d’inférence d’adaptateur :
```
response = sm_rt_client.invoke_endpoint(
EndpointName = endpoint_name,
InferenceComponentName = adapter_ic_name,
Body = json.dumps(
{
"inputs": prompt,
"parameters": {"max_new_tokens": 100, "temperature":0.9}
}
),
ContentType = "application/json",
)
adapter_reponse = response["Body"].read().decode("utf8")["generated_text"]
```
Lorsque vous utilisez cet exemple dans votre propre code, remplacez les valeurs des espaces réservés comme suit :
+ *endpoint\$1name*— Nom du point de terminaison qui héberge les composants d'inférence de base et d'adaptateur.
+ *adapter\$1ic\$1name*— Nom du composant d'inférence de l'adaptateur.
+ *prompt*— L'invite à envoyer la demande d'inférence.
Pour plus d’informations sur l’invocation de composants d’inférence avec le kit SDK pour Python (Boto3), consultez [Invocation de modèles pour une inférence en temps réel](realtime-endpoints-test-endpoints.md).
# Déployez des modèles avec Amazon SageMaker Serverless Inference
Amazon SageMaker Serverless Inference est une option d'inférence spécialement conçue qui vous permet de déployer et de faire évoluer des modèles de machine learning sans configurer ni gérer aucune infrastructure sous-jacente. L’inférence sans serveur à la demande est idéale pour les charges de travail qui ont des périodes d’inactivité entre les pics de trafic et peuvent tolérer des démarrages à froid. Les points de terminaison sans serveur lancent automatiquement les ressources de calcul et les mettent à l’échelle en fonction du trafic, éliminant ainsi le besoin de choisir des types d’instances ou de gérer des politiques de mise à l’échelle. Cela supprime les tâches les plus complexes et lourdes de la sélection et de la gestion des serveurs. L’inférence sans serveur s’intègre à AWS Lambda pour vous offrir une haute disponibilité, une tolérance aux pannes intégrée et une mise à l’échelle automatique. Avec un pay-per-use modèle, l'inférence sans serveur est une option rentable si vous êtes confronté à un schéma de trafic peu fréquent ou imprévisible. Pendant les périodes où il n’y a pas de demandes, l’inférence sans serveur réduit votre point de terminaison à 0, vous aidant à minimiser vos coûts. Pour plus d'informations sur la tarification de l'inférence sans serveur à la demande, consultez [Amazon SageMaker ](https://aws.amazon.com/sagemaker/pricing/) Pricing.
(Facultatif) Vous pouvez également utiliser la simultanéité provisionnée avec l’inférence sans serveur. L’inférence sans serveur avec la simultanéité provisionnée est une option rentable lorsque vous êtes confronté à des pics de trafic prévisibles. La concurrence provisionnée vous permet de déployer des modèles sur des terminaux sans serveur avec des performances prévisibles et une évolutivité élevée tout en préservant la chaleur de vos terminaux. SageMaker L'IA garantit que, pour le nombre de simultanéité provisionnée que vous allouez, les ressources de calcul sont initialisées et prêtes à réagir en quelques millisecondes. Pour l’inférence sans serveur avec la simultanéité provisionnée, vous payez en fonction de la capacité de calcul utilisée pour traiter les demandes d’inférence, facturée à la milliseconde et de la quantité de données traitées. Vous payez également pour l’utilisation de la simultanéité provisionnée, en fonction de la mémoire configurée, de la durée allouée et du niveau de simultanéité activé. [Pour plus d'informations sur la tarification de l'inférence sans serveur avec concurrence provisionnée, consultez Amazon Pricing. SageMaker ](https://aws.amazon.com/sagemaker/pricing/)
[Vous pouvez intégrer l'inférence sans serveur à vos MLOps pipelines pour rationaliser votre flux de travail ML, et vous pouvez utiliser un point de terminaison sans serveur pour héberger un modèle enregistré auprès de Model Registry.](model-registry.md)
L'inférence sans serveur est généralement disponible dans 21 AWS régions : États-Unis Est (Virginie du Nord), États-Unis Est (Ohio), États-Unis Ouest (Californie du Nord), États-Unis Ouest (Oregon), Afrique (Le Cap), Asie-Pacifique (Hong Kong), Asie-Pacifique (Mumbai), Asie-Pacifique (Tokyo), Asie-Pacifique (Séoul), Asie-Pacifique (Osaka), Asie-Pacifique (Singapour), Asie-Pacifique (Sydney), Canada (Centre), Europe (Francfort), Europe (Irlande), Europe (Londres), Europe (Paris), Europe (Stockholm), Europe (Milan), Moyen-Orient (Bahreïn), Amérique du Sud (São Paulo). Pour plus d'informations sur la disponibilité régionale d'Amazon SageMaker AI, consultez la [liste des services AWS régionaux](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).
## Comment ça marche
Le diagramme suivant montre le flux de travail d’une inférence sans serveur à la demande et les avantages de l’utilisation d’un point de terminaison sans serveur.
![\[Schéma illustrant le flux de travail d’inférence sans serveur.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/serverless-endpoints-how-it-works.png)
Lorsque vous créez un point de terminaison sans serveur à la demande, l' SageMaker IA approvisionne et gère les ressources de calcul pour vous. Vous pouvez ensuite envoyer des demandes d'inférence au point de terminaison et recevoir les prédictions du modèle en réponse. SageMaker L'IA augmente ou diminue les ressources de calcul selon les besoins pour gérer le trafic de vos demandes, et vous ne payez que pour ce que vous utilisez.
Pour la simultanéité provisionnée, l’inférence sans serveur s’intègre également à Application Auto Scaling, afin que vous puissiez gérer la simultanéité provisionnée en fonction d’une métrique cible ou d’un calendrier. Pour de plus amples informations, veuillez consulter [Mise à l’échelle automatique de la simultanéité provisionnée pour un point de terminaison sans serveur](serverless-endpoints-autoscale.md).
Les sections suivantes fournissent des détails supplémentaires sur Serverless Inference et son fonctionnement.
**Topics**
+ [Prise en charge du conteneur](#serverless-endpoints-how-it-works-containers)
+ [Taille de la mémoire](#serverless-endpoints-how-it-works-memory)
+ [Appels simultanés](#serverless-endpoints-how-it-works-concurrency)
+ [Réduction des démarrages à froid](#serverless-endpoints-how-it-works-cold-starts)
+ [Exclusions de fonctions](#serverless-endpoints-how-it-works-exclusions)
### Prise en charge du conteneur
Pour votre conteneur de terminaux, vous pouvez choisir un conteneur SageMaker fourni par l'IA ou apporter le vôtre. SageMaker L'IA fournit des conteneurs pour ses algorithmes intégrés et des images Docker prédéfinies pour certains des frameworks d'apprentissage automatique les plus courants, tels qu'Apache MXNet, TensorFlow PyTorch, et Chainer. Pour obtenir la liste des SageMaker images disponibles, consultez [Available Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Si vous apportez votre propre conteneur, vous devez le modifier pour qu'il fonctionne avec l' SageMaker IA. Pour plus d’informations sur l’ajout de votre propre conteneur, consultez [Adaptez votre propre conteneur d'inférence pour Amazon AI SageMaker](adapt-inference-container.md).
La taille maximale de l’image de conteneur que vous pouvez utiliser est de 10 Go. Pour les points de terminaison sans serveur, nous vous recommandons de créer un seul employé dans le conteneur et de ne charger qu’une seule copie du modèle. Notez que cela ne ressemble pas aux points de terminaison en temps réel, où certains conteneurs d' SageMaker IA peuvent créer un worker pour chaque vCPU afin de traiter les demandes d'inférence et de charger le modèle dans chaque vCPU.
Si vous disposez déjà d’un conteneur pour un point de terminaison en temps réel, vous pouvez utiliser le même conteneur pour votre point de terminaison sans serveur, bien que certaines fonctionnalités soient exclues. Pour en savoir plus sur les fonctionnalités de conteneur qui ne sont pas prises en charge dans l’inférence sans serveur, consultez [Exclusions de fonctions](#serverless-endpoints-how-it-works-exclusions). Si vous choisissez d'utiliser le même conteneur, SageMaker AI séquestre (conserve) une copie de l'image de votre conteneur jusqu'à ce que vous supprimiez tous les points de terminaison qui utilisent l'image. SageMaker L'IA chiffre l'image copiée au repos à l'aide d'une clé détenue par l' SageMaker IA AWS KMS .
### Taille de la mémoire
Votre point de terminaison sans serveur a une taille de mémoire RAM minimale de 1 024 Mo (1 Go), et la taille maximale que vous pouvez choisir est de 6 144 Mo (6 Go). Voici les tailles de mémoire parmi lesquelles vous pouvez choisir : 1 024 Mo, 2 048 Mo, 3 072 Mo, 4 096 Mo, 5 120 Mo ou 6 144 Mo. Serverless Inference attribue automatiquement des ressources de calcul proportionnelles à la mémoire que vous sélectionnez. Si vous choisissez une taille de mémoire plus grande, votre conteneur a accès à plus de CPUs v. Choisissez la taille de la mémoire de votre terminal en fonction de la taille de votre modèle. En règle générale, la taille de la mémoire doit être au moins aussi grande que celle de votre modèle. Vous devrez peut-être effectuer un benchmarking afin de choisir la bonne sélection de mémoire pour votre modèle en fonction de votre latence SLAs. Pour un guide étape par étape sur le benchmarking, consultez [Présentation du kit d'analyse comparative d'Amazon SageMaker Serverless Inference](https://aws.amazon.com/blogs/machine-learning/introducing-the-amazon-sagemaker-serverless-inference-benchmarking-toolkit/). Les augmentations de taille de mémoire ont des prix différents ; consultez la [page de tarification d'Amazon SageMaker AI](https://aws.amazon.com/sagemaker/pricing/) pour plus d'informations.
Quelle que soit la taille de mémoire que vous choisissez, votre point de terminaison sans serveur dispose de 5 Go de stockage de disque éphémère disponible. Pour obtenir de l’aide sur les problèmes d’autorisations de conteneur lors de l’utilisation du stockage, consultez [Résolution des problèmes](serverless-endpoints-troubleshooting.md).
### Appels simultanés
L’inférence sans serveur à la demande gère les politiques de mise à l’échelle et les quotas prédéfinis pour la capacité de votre point de terminaison. Les points de terminaison sans serveur ont un quota pour le nombre d’appels simultanés pouvant être traités en même temps. Si le point de terminaison est appelé avant la fin du traitement de la première demande, il traite la deuxième demande simultanément.
La simultanéité totale que vous pouvez partager entre tous les points de terminaison sans serveur dans votre compte dépend de votre région :
+ Pour les régions USA Est (Ohio), USA Est (Virginie du Nord), USA Ouest (Oregon), Asie-Pacifique (Singapour), Asie-Pacifique (Sydney), Asie-Pacifique (Tokyo), Europe (Francfort) et Europe (Irlande), la simultanéité totale que vous pouvez partager entre tous les points de terminaison sans serveur par région dans votre compte est de 1 000.
+ Pour les régions USA Ouest (Californie du Nord), Afrique (Le Cap), Asie-Pacifique (Hong Kong), Asie-Pacifique (Mumbai), Asie-Pacifique (Osaka), Asie-Pacifique (Séoul), Canada (Centre), Europe (Londres), Europe (Milan), Europe (Paris), Europe (Stockholm), Moyen-Orient (Bahreïn) et Amérique du Sud (São Paulo), la simultanéité totale par région dans votre compte est de 500.
Vous pouvez définir la simultanéité maximale à 200 pour un seul point de terminaison, et le nombre total de points de terminaison sans serveur que vous pouvez héberger dans une région est de 50. La simultanéité maximale pour un point de terminaison individuel empêche celui-ci de prendre tous les appels autorisés pour votre compte, et tous les appels de point de terminaison au-delà du maximum sont limités.
**Note**
La simultanéité provisionnée que vous attribuez à un point de terminaison sans serveur doit toujours être inférieure ou égale à la simultanéité maximale que vous avez attribuée à ce point de terminaison.
Pour savoir comment définir la simultanéité maximale pour votre point de terminaison, consultez [Créer une configuration de point de terminaison](serverless-endpoints-create-config.md). Pour plus d'informations sur les quotas et les limites, consultez la section [Points de terminaison et quotas Amazon SageMaker AI](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html) dans le *Références générales AWS*. Pour demander une augmentation de la limite de service, contactez le [support AWS](https://console.aws.amazon.com/support). Pour obtenir des instructions sur la façon de demander une augmentation de la limite de service, consultez [Régions et quotas pris en charge](regions-quotas.md).
### Réduction des démarrages à froid
Si votre point de terminaison d’inférence sans serveur à la demande ne reçoit pas de trafic pendant un certain temps, puis reçoit soudainement de nouvelles demandes, il pourrait lui falloir un certain temps pour lancer les ressources de calcul afin de traiter les demandes. C’est ce qu’on appelle un *démarrage à froid*. Étant donné que les points de terminaison sans serveur fournissent des ressources de calcul à la demande, votre point de terminaison peut connaître des démarrages à froid. Un démarrage à froid peut également avoir lieu si vos demandes simultanées dépassent le taux d’utilisation actuel des demandes simultanées. La durée de démarrage à froid dépend de la taille de votre modèle, du temps qu’il faut pour télécharger votre modèle et de l’heure de démarrage de votre conteneur.
Pour surveiller la durée de votre temps de démarrage à froid, vous pouvez utiliser la CloudWatch métrique Amazon `OverheadLatency` pour surveiller votre point de terminaison sans serveur. Cette métrique suit le temps nécessaire pour lancer de nouvelles ressources de calcul pour votre point de terminaison. Pour en savoir plus sur l'utilisation CloudWatch des métriques avec les points de terminaison sans serveur, consultez. [Alarmes et journaux pour le suivi des métriques provenant des points de terminaison sans serveur](serverless-endpoints-monitoring.md)
Vous pouvez minimiser les démarrages à froid en utilisant la simultanéité provisionnée. SageMaker L'IA garde le terminal au chaud et le rend prêt à réagir en quelques millisecondes, pour le nombre de simultanéité provisionnée que vous avez alloué.
### Exclusions de fonctions
Certaines fonctionnalités actuellement disponibles pour l'inférence en temps réel par SageMaker IA ne sont pas prises en charge pour l'inférence sans serveur, notamment les packages de modèles AWS Marketplace GPUs, les registres Docker privés, les points de terminaison multimodèles, la configuration VPC, l'isolation du réseau, la capture de données, les variantes de production multiples, Model Monitor et les pipelines d'inférence.
Vous ne pouvez pas convertir votre point de terminaison en temps réel basé sur une instance en un point de terminaison sans serveur. Si vous essayez de mettre à jour votre point de terminaison en temps réel sans serveur, vous recevez un message `ValidationError`. Vous pouvez convertir un point de terminaison sans serveur en temps réel, mais une fois la mise à jour effectuée, vous ne pouvez pas le restaurer en mode sans serveur.
## Prise en main
Vous pouvez créer, mettre à jour, décrire et supprimer un point de terminaison sans serveur à l'aide de la console SageMaker AI AWS SDKs, du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-serverless-inference) et du. AWS CLI Vous pouvez appeler votre point de terminaison à l' AWS SDKsaide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-serverless-inference) et du AWS CLI. Pour les points de terminaison sans serveur avec la simultanéité provisionnée, vous pouvez utiliser Application Auto Scaling afin de mettre à l’échelle automatiquement la simultanéité provisionnée en fonction d’une métrique cible ou d’un calendrier. Pour plus d’informations sur la configuration et l’utilisation d’un point de terminaison sans serveur, référez-vous au guide [Opérations de point de terminaison sans serveur](serverless-endpoints-create-invoke-update-delete.md). Pour plus d’informations sur l’autoscaling des points de terminaison sans serveur avec la simultanéité provisionnée, consultez [Mise à l’échelle automatique de la simultanéité provisionnée pour un point de terminaison sans serveur](serverless-endpoints-autoscale.md).
**Note**
Application Auto Scaling pour l’inférence sans serveur avec la simultanéité provisionnée n’est actuellement pas prise en charge sur AWS CloudFormation.
### Exemples de blocs-notes et de blogs
Pour des exemples de blocs-notes Jupyter illustrant des flux de travail de point de terminaison end-to-end sans serveur, consultez les exemples de blocs-notes d'[inférence sans serveur](https://github.com/aws/amazon-sagemaker-examples/tree/master/serverless-inference).
# Opérations de point de terminaison sans serveur
Contrairement aux autres points de terminaison en temps réel basés sur l' SageMaker IA, Serverless Inference gère les ressources de calcul pour vous, réduisant ainsi la complexité afin que vous puissiez vous concentrer sur votre modèle de machine learning plutôt que sur la gestion de l'infrastructure. Le guide suivant met en évidence les fonctions clés des points de terminaison sans serveur : comment créer, appeler, mettre à jour, décrire ou supprimer un point de terminaison. Vous pouvez utiliser la console SageMaker AI AWS SDKs, le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-serverless-inference) ou le AWS CLI pour gérer vos points de terminaison sans serveur.
**Topics**
+ [Remplir les conditions préalables](serverless-endpoints-prerequisites.md)
+ [Création de point de terminaison sans serveur](serverless-endpoints-create.md)
+ [Appeler un point de terminaison sans serveur](serverless-endpoints-invoke.md)
+ [Mettre à jour un point de terminaison sans serveur](serverless-endpoints-update.md)
+ [Décrire un point de terminaison sans serveur](serverless-endpoints-describe.md)
+ [Supprimer un point de terminaison sans serveur](serverless-endpoints-delete.md)
# Remplir les conditions préalables
La rubrique suivante décrit les conditions préalables que vous devez remplir avant de créer un point de terminaison sans serveur. Ces conditions préalables incluent le stockage correct des artefacts de votre modèle, la configuration d'un AWS IAM avec les autorisations appropriées et la sélection d'une image de conteneur.
**Pour remplir les conditions préalables**
1. **Créez un AWS compte.** Vous avez d'abord besoin d'un AWS compte et d'un utilisateur Gestion des identités et des accès AWS administrateur. Pour obtenir des instructions sur la création d'un AWS compte, voir [Comment créer et activer un nouveau AWS compte ?](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) . Pour obtenir des instructions sur la façon de sécuriser votre compte avec un utilisateur administrateur IAM, consultez [Création de votre premier utilisateur administrateur et groupe IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) dans le *Guide de l’utilisateur IAM*.
1. **Créez un compartiment Amazon S3.** Vous utilisez un compartiment Amazon S3 pour stocker vos artefacts de modèle. Pour savoir comment créer un compartiment, consultez [Créer votre premier compartiment S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html) dans le *Guide de l’utilisateur Amazon S3*.
1. **Chargez vos artefacts de modèles dans votre compartiment S3.** Pour obtenir des instructions sur la façon de charger votre modèle dans votre compartiment, consultez [Charger un objet dans votre compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) dans le *Guide de l’utilisateur Amazon S3*.
1. **Créez un rôle IAM pour Amazon SageMaker AI.** Amazon SageMaker AI a besoin d'accéder au compartiment S3 qui stocke votre modèle. Créez un rôle IAM avec une politique qui donne à l' SageMaker IA un accès en lecture à votre compartiment. La procédure suivante montre comment créer un rôle dans la console, mais vous pouvez également utiliser l'[CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html)API du *guide de l'utilisateur IAM*. Pour plus d’informations sur l’octroi d’autorisations détaillées à votre rôle en fonction de votre cas d’utilisation, consultez [Comment utiliser les rôles d'exécution de l' SageMaker IA](sagemaker-roles.md#sagemaker-roles-createmodel-perms).
1. Connectez-vous à la [console IAM](https://console.aws.amazon.com/iam/).
1. Dans l’onglet de navigation, sélectionnez **Rôles**.
1. Choisissez **Create Role** (Créer un rôle).
1. Pour **Sélectionner le type d'entité de confiance**, choisissez le **AWS service**, puis choisissez **SageMaker AI**.
1. Sélectionnez **Suivant : Autorisations**, puis **Suivant : Balises**.
1. (Facultatif) Ajoutez des balises en tant que paires de valeur clé si vous souhaitez disposer de métadonnées pour le rôle.
1. Choisissez **Suivant : Vérification**.
1. Dans **Nom du rôle**, entrez un nom unique au sein de votre AWS compte pour le nouveau rôle. Vous ne pouvez pas modifier le nom du rôle après avoir créé le rôle.
1. (Facultatif) Dans le champ **Description du rôle**, saisissez la description du nouveau rôle.
1. Choisissez **Créer un rôle**.
1. **Associez des autorisations de compartiment S3 à votre rôle d' SageMaker IA.** Après avoir créé un rôle IAM, associez une politique qui autorise l' SageMaker IA à accéder au compartiment S3 contenant les artefacts de votre modèle.
1. Sous l’onglet de navigation de la console IAM, sélectionnez **Rôles**.
1. Dans la liste des rôles, recherchez le rôle que vous avez créé à l’étape précédente par son nom.
1. Choisissez votre rôle, puis sélectionnez **Attacher des politiques**.
1. Sous **Attacher des autorisations**, sélectionnez **Créer une politique**.
1. Sélectionnez **Créer une politique**, puis l’onglet **JSON**.
1. Ajoutez la déclaration de politique suivante dans l’éditeur JSON. Assurez-vous de remplacer `` par le nom du compartiment S3 qui stocke vos artefacts de modèle. Si vous souhaitez restreindre l’accès à un dossier ou un fichier spécifique dans votre compartiment, vous pouvez également spécifier le chemin du dossier Amazon S3, par exemple, `/`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::/*"
}
]
}
```
------
1. Choisissez **Suivant : Balises**.
1. (Facultatif) Ajoutez des balises dans des paires de valeur clé à la politique.
1. Choisissez **Suivant : Vérification**.
1. Pour **Nom**, attribuez un nom à cette nouvelle politique.
1. (Facultatif) Ajoutez une **Description** de la politique.
1. Choisissez **Create Policy** (Créer une politique).
1. Après avoir créé la politique, revenez à la **section Rôles** de la [console IAM](https://console.aws.amazon.com/iam/) et sélectionnez votre rôle d' SageMaker IA.
1. Choisissez **Attacher des politiques**.
1. Pour **Attacher des autorisations**, recherchez la politique que vous avez créée par son nom. Sélectionnez-la et sélectionnez **Attacher une politique**.
1. **Sélectionnez une image de conteneur Docker prédéfinie ou apportez la vôtre.** Le conteneur que vous choisissez sert à l'inférence sur votre point de terminaison. SageMaker L'IA fournit des conteneurs pour les algorithmes intégrés et des images Docker prédéfinies pour certains des frameworks d'apprentissage automatique les plus courants, tels qu'Apache MXNet, TensorFlow PyTorch, et Chainer. Pour une liste complète des SageMaker images disponibles, consultez [Available Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Si aucun des conteneurs SageMaker AI existants ne répond à vos besoins, vous devrez peut-être créer votre propre conteneur Docker. Pour plus d'informations sur la façon de créer votre image Docker et de la rendre compatible avec l' SageMaker IA, consultez[Conteneurs avec code d’inférence personnalisé](your-algorithms-inference-main.md). Pour utiliser votre conteneur avec un point de terminaison sans serveur, l'image du conteneur doit résider dans un référentiel Amazon ECR au sein du même AWS compte qui crée le point de terminaison.
1. **(Facultatif) Enregistrez votre modèle auprès de Model Registry.** [SageMaker Model Registry](model-registry.md) vous aide à cataloguer et à gérer les versions de vos modèles à utiliser dans les pipelines de ML. Pour plus d’informations sur l’enregistrement d’une version de votre modèle, consultez [Création d’un groupe de modèles](model-registry-model-group.md) et [Enregistrement d’une version de modèle](model-registry-version.md). Pour obtenir un exemple de flux de travail de registre de modèles et d’inférence sans serveur, consultez l’[exemple de bloc-notes](https://github.com/aws/amazon-sagemaker-examples/blob/main/serverless-inference/serverless-model-registry.ipynb) suivant.
1. **(Facultatif) Apportez une AWS KMS clé.** Lorsque vous configurez un point de terminaison sans serveur, vous avez la possibilité de spécifier une clé KMS utilisée par SageMaker AI pour chiffrer votre image Amazon ECR. Notez que la stratégie de clé pour la clé KMS doit accorder l’accès au rôle IAM que vous spécifiez lors de la configuration de votre point de terminaison. Pour en savoir plus sur les clés KMS, consultez le [Guide du développeur AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
# Création de point de terminaison sans serveur
**Important**
Les politiques IAM personnalisées qui permettent à Amazon SageMaker Studio ou Amazon SageMaker Studio Classic de créer des SageMaker ressources Amazon doivent également accorder des autorisations pour ajouter des balises à ces ressources. L’autorisation d’ajouter des balises aux ressources est requise, car Studio et Studio Classic balisent automatiquement toutes les ressources qu’ils créent. Si une politique IAM autorise Studio et Studio Classic à créer des ressources mais n'autorise pas le balisage, des erreurs « AccessDenied » peuvent se produire lors de la tentative de création de ressources. Pour de plus amples informations, veuillez consulter [Fournir des autorisations pour le balisage des ressources d' SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS politiques gérées pour Amazon SageMaker AI](security-iam-awsmanpol.md)qui donnent des autorisations pour créer des SageMaker ressources incluent déjà des autorisations pour ajouter des balises lors de la création de ces ressources.
Pour créer un point de terminaison sans serveur, vous pouvez utiliser la console Amazon SageMaker AI, le APIs, ou le AWS CLI. Vous pouvez créer un point de terminaison sans serveur en utilisant un processus similaire à celui d’un [point de terminaison en temps réel](realtime-endpoints.md).
**Topics**
+ [Création d’un modèle](serverless-endpoints-create-model.md)
+ [Créer une configuration de point de terminaison](serverless-endpoints-create-config.md)
+ [Créer un point de terminaison](serverless-endpoints-create-endpoint.md)
# Création d’un modèle
Pour créer votre modèle, vous devez fournir l’emplacement de vos artefacts de modèle et de l’image de conteneur. Vous pouvez également utiliser une version du modèle depuis [SageMaker Model Registry](model-registry.md). Les exemples présentés dans les sections suivantes vous montrent comment créer un modèle à l'aide de l'[CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API, du Model Registry et de la [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home).
## Pour créer un modèle (à l’aide du registre de modèles)
[Model Registry](model-registry.md) est une fonctionnalité de l' SageMaker IA qui vous aide à cataloguer et à gérer les versions de votre modèle à utiliser dans les pipelines de ML. Pour utiliser Model Registry avec Serverless Inference, vous devez commencer par enregistrer une version de modèle dans un groupe de modèles Model Registry. Pour savoir comment enregistrer un modèle dans Model Registry, suivez les procédures des rubriques [Création d’un groupe de modèles](model-registry-model-group.md) et [Enregistrement d’une version de modèle](model-registry-version.md).
Dans l'exemple suivant, vous devez disposer de l'ARN d'une version de modèle enregistrée et utiliser le [AWS SDK pour Python (Boto3) pour appeler](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) l'API. [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) Pour l'inférence sans serveur, Model Registry n'est actuellement pris en charge que par le AWS SDK pour Python (Boto3). Pour l’exemple, spécifiez les valeurs suivantes :
+ Pour `model_name`, saisissez le nom du modèle.
+ En `sagemaker_role` effet, vous pouvez utiliser le rôle par défaut SageMaker créé par l'IA ou un rôle SageMaker AI IAM personnalisé à l'étape 4 de la section. [Remplir les conditions préalables](serverless-endpoints-prerequisites.md)
+ Pour `ModelPackageName`, spécifiez l’ARN de la version de votre modèle, qui doit être enregistré dans un groupe de modèles dans le registre de modèles.
```
#Setup
import boto3
import sagemaker
region = boto3.Session().region_name
client = boto3.client("sagemaker", region_name=region)
#Role to give SageMaker AI permission to access AWS services.
sagemaker_role = sagemaker.get_execution_role()
#Specify a name for the model
model_name = ""
#Specify a Model Registry model version
container_list = [
{
"ModelPackageName":
}
]
#Create the model
response = client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
container_list
)
```
## Pour créer un modèle (à l’aide de l’API)
L'exemple suivant utilise le [AWS SDK pour Python (Boto3) pour appeler](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) l'API. [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) Indiquez l’une des valeurs suivantes :
+ Car `sagemaker_role,` vous pouvez utiliser le rôle par défaut SageMaker créé par l'IA ou un rôle SageMaker AI IAM personnalisé à l'étape 4 de la section. [Remplir les conditions préalables](serverless-endpoints-prerequisites.md)
+ Pour `model_url`, spécifiez l’URI Amazon S3 pour votre modèle.
+ Pour `container`, récupérez le conteneur que vous souhaitez utiliser par son chemin Amazon ECR. Cet exemple utilise un conteneur SageMaker fourni par l'IA XGBoost . Si vous n'avez pas sélectionné de conteneur d' SageMaker IA ou si vous n'avez pas apporté le vôtre, consultez l'étape 6 de la [Remplir les conditions préalables](serverless-endpoints-prerequisites.md) section pour plus d'informations.
+ Pour `model_name`, saisissez le nom du modèle.
```
#Setup
import boto3
import sagemaker
region = boto3.Session().region_name
client = boto3.client("sagemaker", region_name=region)
#Role to give SageMaker AI permission to access AWS services.
sagemaker_role = sagemaker.get_execution_role()
#Get model from S3
model_url = "s3://amzn-s3-demo-bucket/models/model.tar.gz"
#Get container image (prebuilt example)
from sagemaker import image_uris
container = image_uris.retrieve("xgboost", region, "0.90-1")
#Create model
model_name = ""
response = client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
Containers = [{
"Image": container,
"Mode": "SingleModel",
"ModelDataUrl": model_url,
}]
)
```
## Pour créer un modèle (à l’aide de la console)
1. Connectez-vous à la [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home).
1. Sous l’onglet de navigation, sélectionnez **Inférence**.
1. Ensuite, sélectionnez **Modèles**.
1. Sélectionnez **Créer un modèle**.
1. Dans **Nom du modèle**, entrez un nom pour le modèle unique à votre compte et Région AWS.
1. Pour **le rôle IAM**, sélectionnez un rôle IAM que vous avez déjà créé (voir[Remplir les conditions préalables](serverless-endpoints-prerequisites.md)) ou autorisez SageMaker AI à en créer un pour vous.
1. Dans **Définition de conteneur 1**, pour **Options d’entrée de conteneur**, sélectionnez **Fournir des artefacts de modèle et un emplacement d’entrée**.
1. Pour **Fournir des artefacts de modèle et des options d’image d’inférence**, sélectionnez **Utiliser un seul modèle**.
1. Pour **Emplacement de l’image du code d’inférence**, saisissez un chemin Amazon ECR vers un conteneur. L'image doit être une image de première partie SageMaker fournie par l'IA (par exemple TensorFlow, XGBoost) ou une image résidant dans un référentiel Amazon ECR sur le même compte dans lequel vous créez le point de terminaison. Si vous n’avez pas de conteneur, revenez à l’étape 6 de la section [Remplir les conditions préalables](serverless-endpoints-prerequisites.md) pour plus d’informations.
1. Pour **Emplacement des artefacts de modèle**, saisissez l’URI Amazon S3 de votre modèle de ML. Par exemple, `s3://amzn-s3-demo-bucket/models/model.tar.gz`.
1. (Facultatif) Pour **Balises**, ajoutez des paires de valeur clé afin de créer des métadonnées pour votre modèle.
1. Sélectionnez **Créer un modèle**.
# Créer une configuration de point de terminaison
Après avoir créé un modèle, créez une configuration de point de terminaison. Vous pouvez ensuite déployer votre modèle à l’aide des spécifications de votre configuration de point de terminaison. Dans la configuration, vous spécifiez si vous souhaitez un point de terminaison en temps réel ou sans serveur. Pour créer une configuration de point de terminaison sans serveur, vous pouvez utiliser la [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home), l'[CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API ou le AWS CLI. Les approches relatives à l’API et à la console sont décrites dans les sections suivantes.
## Pour créer une configuration de point de terminaison (à l’aide de l’API)
L'exemple suivant utilise le [AWS SDK pour Python (Boto3) pour appeler](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) l'API. [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) Indiquez l’une des valeurs suivantes :
+ Pour `EndpointConfigName`, choisissez un nom pour la configuration du point de terminaison. Le nom doit être unique dans votre compte dans une région.
+ (Facultatif) Pour`KmsKeyId`, utilisez l'ID de clé, l'ARN de clé, le nom d'alias ou l'ARN d'alias de la AWS KMS clé que vous souhaitez utiliser. SageMaker L'IA utilise cette clé pour chiffrer votre image Amazon ECR.
+ Pour `ModelName`, utilisez le nom du modèle que vous souhaitez déployer. Il doit s’agir du même modèle que celui que vous avez utilisé dans l’étape [Création d’un modèle](serverless-endpoints-create-model.md).
+ Dans `ServerlessConfig` :
+ Définissez `MemorySizeInMB` sur `2048`. Pour cet exemple, nous définissons la taille de la mémoire sur 2 048 Mo, mais vous pouvez choisir l’une des valeurs suivantes pour votre taille de mémoire : 1 024 Mo, 2 048 Mo, 3 072 Mo, 4 096 Mo, 5 120 Mo ou 6 144 Mo.
+ Définissez `MaxConcurrency` sur `20`. Pour cet exemple, nous définissons la concurrence maximale à 20. Le nombre maximal d’appels simultanés que vous pouvez définir pour un point de terminaison sans serveur est de 200 et la valeur minimale que vous pouvez choisir est 1.
+ (Facultatif) Pour utiliser la simultanéité provisionnée, définissez `ProvisionedConcurrency` sur 10. Pour cet exemple, nous définissons la simultanéité provisionnée sur 10. Le nombre de `ProvisionedConcurrency` d’un point de terminaison sans serveur doit être inférieur ou égal au nombre de `MaxConcurrency`. Vous pouvez le laisser vide si vous souhaitez utiliser un point de terminaison d’inférence sans serveur à la demande. Vous pouvez mettre à l’échelle la simultanéité provisionnée de façon dynamique. Pour de plus amples informations, veuillez consulter [Mise à l’échelle automatique de la simultanéité provisionnée pour un point de terminaison sans serveur](serverless-endpoints-autoscale.md).
```
response = client.create_endpoint_config(
EndpointConfigName="",
KmsKeyId="arn:aws:kms:us-east-1:123456789012:key/143ef68f-76fd-45e3-abba-ed28fc8d3d5e",
ProductionVariants=[
{
"ModelName": "",
"VariantName": "AllTraffic",
"ServerlessConfig": {
"MemorySizeInMB": 2048,
"MaxConcurrency": 20,
"ProvisionedConcurrency": 10,
}
}
]
)
```
## Pour créer une configuration de point de terminaison (à l’aide de la console)
1. Connectez-vous à la [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home).
1. Sous l'onglet de navigation, sélectionnez **Inference**.
1. Ensuite, sélectionnez **Configurations de point de terminaison**.
1. Sélectionnez **Créer une configuration de point de terminaison**.
1. Pour **Nom de configuration du point de terminaison**, saisissez un nom unique au sein de votre compte d’une région.
1. Pour **Type de point de terminaison**, sélectionnez **Sans serveur**.
![\[Capture d’écran de l’option de type de point de terminaison dans la console.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/serverless-endpoints-endpoint-config.png)
1. Pour **Variantes de production**, sélectionnez **Ajouter un modèle**.
1. Sous **Ajouter un modèle**, sélectionnez le modèle que vous souhaitez utiliser dans la liste des modèles, puis sélectionnez **Enregistrer**.
1. Après avoir ajouté votre modèle, sous **Actions**, sélectionnez **Modifier**.
1. Pour **Taille de la mémoire**, choisissez la taille de mémoire souhaitée en Go.
![\[Capture d’écran de l’option de taille de mémoire dans la console.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/serverless-endpoints-endpoint-config-2.png)
1. Pour **Simultanéité max.**, saisissez le nombre maximal d’appels simultanés souhaité pour le point de terminaison. La valeur maximale que vous pouvez saisir est 200 et la valeur minimale est 1.
1. (Facultatif) Pour utiliser la simultanéité provisionnée, entrez le nombre souhaité d’invocations simultanées dans le champ **Paramètres de la simultanéité provisionnée**. Le nombre d’invocations simultanées provisionnées doit être inférieur ou égal au nombre d’invocations simultanées maximum.
1. Choisissez **Enregistrer**.
1. (Facultatif) Pour **Balises**, saisissez des paires de valeur clé si vous souhaitez créer des métadonnées pour votre configuration de point de terminaison.
1. Sélectionnez **Créer une configuration de point de terminaison**.
# Créer un point de terminaison
Pour créer un point de terminaison sans serveur, vous pouvez utiliser la [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home), l'[CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)API ou le AWS CLI. Les approches relatives à l’API et à la console sont décrites dans les sections suivantes. Une fois que vous avez créé votre point de terminaison, plusieurs minutes peuvent être nécessaires pour que le point de terminaison devienne disponible.
## Pour créer un point de terminaison (à l’aide de l’API)
L'exemple suivant utilise le [AWS SDK pour Python (Boto3) pour appeler](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) l'API. [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) Indiquez l’une des valeurs suivantes :
+ Pour `EndpointName`, saisissez un nom pour le point de terminaison unique au sein d’une région de votre compte.
+ Pour `EndpointConfigName`, utilisez le nom de la configuration de point de terminaison que vous avez créée dans la section précédente.
```
response = client.create_endpoint(
EndpointName="",
EndpointConfigName=""
)
```
## Pour créer un point de terminaison (à l’aide de la console)
1. Connectez-vous à la [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home).
1. Sous l'onglet de navigation, sélectionnez **Inference**.
1. Ensuite, sélectionnez **Points de terminaison**.
1. Choisissez **Créer un point de terminaison**.
1. Pour **Nom du point de terminaison**, saisissez un nom unique au sein d’une région de votre compte.
1. Pour **Attacher la configuration du point de terminaison**, sélectionnez **Utiliser une configuration de point de terminaison existante**.
1. Pour **Configuration de point de terminaison**, sélectionnez le nom de la configuration de point de terminaison que vous avez créée dans la section précédente, puis **Sélectionner la configuration de point de terminaison**.
1. (Facultatif) Pour **Balises**, saisissez des paires de valeur clé si vous souhaitez créer des métadonnées pour votre point de terminaison.
1. Choisissez **Créer un point de terminaison**.
![\[Capture d’écran de la page de création et de configuration du point de terminaison dans la console.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/serverless-endpoints-create.png)
# Appeler un point de terminaison sans serveur
Pour effectuer une inférence à l’aide d’un point de terminaison sans serveur, vous devez envoyer une demande HTTP au point de terminaison. Vous pouvez utiliser l'[InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)API ou le AWS CLI, qui font une `POST` demande pour appeler votre point de terminaison. La taille maximale de la charge utile de demande et de réponse pour les appels sans serveur est de 4 Mo. Pour les points de terminaison sans serveur :
+ Le modèle doit être téléchargé et le serveur doit répondre avec succès à `/ping` dans les 3 minutes.
+ Le délai d’attente du conteneur pour répondre aux demandes d’inférence à `/invocations` est de 1 minute.
## Pour appeler un point de terminaison
L'exemple suivant utilise le [AWS SDK pour Python (Boto3) pour appeler](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) l'API. [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) Notez que, contrairement aux autres appels d'API présentés dans ce guide, pour`InvokeEndpoint`, vous devez utiliser SageMaker Runtime Runtime en tant que client. Indiquez l’une des valeurs suivantes :
+ Pour `endpoint_name`, utilisez le nom du point de terminaison sans serveur en service que vous souhaitez appeler.
+ Pour `content_type`, spécifiez le type MIME de vos données d’entrée dans le corps de la demande (par exemple, `application/json`).
+ Pour `payload`, utilisez les données utiles de votre demande pour l’inférence. Votre charge utile doit être en octets ou en objet de type fichier.
```
runtime = boto3.client("sagemaker-runtime")
endpoint_name = ""
content_type = ""
payload =
response = runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType=content_type,
Body=payload
)
```
# Mettre à jour un point de terminaison sans serveur
Avant de mettre à jour votre point de terminaison, créez une configuration de point de terminaison ou utilisez une configuration de point de terminaison existante. La configuration du point de terminaison est l’endroit où vous spécifiez les modifications pour votre mise à jour. Vous pouvez ensuite mettre à jour votre point de terminaison avec la [console SageMaker AI](https://console.aws.amazon.com/sagemaker/home), l'[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API ou le AWS CLI. Le processus de mise à jour d’un point de terminaison sans serveur est le même que celui d’un [point de terminaison en temps réel](realtime-endpoints.md). Notez que lors de la mise à jour de votre point de terminaison, vous pouvez rencontrer des démarrages à froid lorsque vous envoyez des demandes au point de terminaison, car l' SageMaker IA doit réinitialiser votre conteneur et votre modèle.
Vous pourriez vouloir mettre à jour un point de terminaison sans serveur à la demande vers un point de terminaison sans serveur avec la simultanéité provisionnée ou ajuster la valeur de la simultanéité provisionnée pour un point de terminaison sans serveur existant avec la simultanéité provisionnée. Dans les deux cas, vous devrez créer une nouvelle configuration de point de terminaison sans serveur avec la valeur souhaitée pour la simultanéité provisionnée et appliquer `UpdateEndpoint` au point de terminaison sans serveur existant. Pour plus d’informations sur la création d’une nouvelle configuration de point de terminaison sans serveur avec la simultanéité provisionnée, consultez [Créer une configuration de point de terminaison](serverless-endpoints-create-config.md).
Si vous souhaitez supprimer la simultanéité provisionnée d’un point de terminaison sans serveur, vous devrez créer une nouvelle configuration de point de terminaison sans spécifier de valeur pour la simultanéité provisionnée, puis appliquer `UpdateEndpoint` au point de terminaison.
**Note**
La mise à jour d’un point de terminaison d’inférence en temps réel vers un point de terminaison sans serveur à la demande ou un point de terminaison sans serveur avec la simultanéité provisionnée n’est actuellement pas prise en charge.
## Mettre à jour le point de terminaison
Après avoir créé une nouvelle configuration de point de terminaison sans serveur, vous pouvez utiliser la console [AWS SDK pour Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)ou la [console SageMaker AI](https://console.aws.amazon.com/sagemaker/) pour mettre à jour un point de terminaison sans serveur existant. Des exemples de mise à jour de votre point de terminaison à l'aide de la console AWS SDK pour Python (Boto3) et de l' SageMaker IA sont présentés dans les sections suivantes.
### Pour mettre à jour le point de terminaison (à l’aide de Boto3)
L’exemple suivant utilise le [AWS SDK pour Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) pour appeler la méthode [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/update_endpoint.html). Spécifiez au moins les paramètres suivants lors de l’appel de la méthode :
+ Pour `EndpointName`, utilisez le nom du point de terminaison que vous mettez à jour.
+ Pour `EndpointConfigName`, utilisez le nom de la configuration de point de terminaison que vous souhaitez utiliser pour la mise à jour.
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
)
```
### Pour mettre à jour le point de terminaison (à l’aide de la console)
1. Connectez-vous à la [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/).
1. Sous l'onglet de navigation, sélectionnez **Inference**.
1. Ensuite, sélectionnez **Points de terminaison**.
1. Dans la liste des points de terminaison, sélectionnez le point de terminaison que vous souhaitez mettre à jour.
1. Choisissez **Modifier** dans la section **Paramètres de configuration du point de terminaison**.
1. Pour **Modifier la configuration du point de terminaison**, sélectionnez **Utiliser une configuration de point de terminaison existante**.
1. Dans la liste des configurations de point de terminaison, sélectionnez celle que vous souhaitez utiliser pour votre mise à jour.
1. Sélectionnez **Sélectionner la configuration du point de terminaison**.
1. Sélectionnez **Mettre à jour le point de terminaison**.
# Décrire un point de terminaison sans serveur
Vous devez peut-être récupérer des informations sur votre point de terminaison, y compris des détails tels que l’ARN du point de terminaison, l’état actuel, la configuration de déploiement et les raisons de l’échec. Vous pouvez trouver des informations sur votre terminal à l'aide de la [console SageMaker AI](https://console.aws.amazon.com/sagemaker/home), de l'[DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API ou du AWS CLI.
## Pour décrire un point de terminaison (à l’aide de l’API)
L'exemple suivant utilise le [AWS SDK pour Python (Boto3) pour appeler](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#id309) l'API. [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) Pour `EndpointName`, utilisez le nom du point de terminaison que vous souhaitez vérifier.
```
response = client.describe_endpoint(
EndpointName="",
)
```
## Pour décrire un point de terminaison (à l’aide de la console)
1. Connectez-vous à la [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home).
1. Sous l'onglet de navigation, sélectionnez **Inference**.
1. Ensuite, sélectionnez **Points de terminaison**.
1. Dans la liste des points de terminaison, sélectionnez le point de terminaison que vous souhaitez vérifier.
La page du point de terminaison contient les informations sur celui-ci.
# Supprimer un point de terminaison sans serveur
Vous pouvez supprimer votre point de terminaison sans serveur à l'aide de la [console SageMaker AI](https://console.aws.amazon.com/sagemaker/home), de l'[DeleteEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html)API ou du AWS CLI. Les exemples suivants vous montrent comment supprimer votre point de terminaison via l'API et la console SageMaker AI.
## Pour supprimer un point de terminaison (à l’aide de l’API)
L'exemple suivant utilise le [AWS SDK pour Python (Boto3) pour appeler](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) l'API. [DeleteEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) Pour `EndpointName`, utilisez le nom du point de terminaison sans serveur que vous souhaitez supprimer.
```
response = client.delete_endpoint(
EndpointName="",
)
```
## Pour supprimer un point de terminaison (à l’aide de la console)
1. Connectez-vous à la [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/home).
1. Sous l'onglet de navigation, sélectionnez **Inference**.
1. Ensuite, sélectionnez **Points de terminaison**.
1. Dans la liste des points de terminaison, sélectionnez le point de terminaison que vous souhaitez supprimer.
1. Sélectionnez la liste déroulante **Actions**, puis choisissez **Supprimer**.
1. Lorsque vous y êtes invité, choisissez **Supprimer**.
Votre point de terminaison devrait maintenant commencer le processus de suppression.
# Alarmes et journaux pour le suivi des métriques provenant des points de terminaison sans serveur
Pour contrôler votre point de terminaison sans serveur, vous pouvez utiliser les alarmes Amazon CloudWatch. CloudWatch est un service qui collecte des métriques en temps réel à partir de vos applications et ressources AWS. Une alarme contrôle les métriques au fur et à mesure qu’elles sont collectées et vous donne la possibilité de préspécifier un seuil et les actions à entreprendre si ce seuil est dépassé. Par exemple, votre alarme CloudWatch peut vous envoyer une notification si votre point de terminaison dépasse un seuil d’erreur. En configurant des alarmes CloudWatch, vous gagnez en visibilité sur les performances et les fonctionnalités de votre point de terminaison. Pour plus d’informations sur les alarmes CloudWatch, consultez [Utilisation d’alarmes Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) dans le *Guide de l’utilisateur Amazon CloudWatch*.
## Surveillance avec CloudWatch
Voici une liste exhaustive des métriques pour les points de terminaison sans serveur. Toute métrique non répertoriée ci-dessous n’est pas publiée pour les points de terminaison sans serveur. Pour en savoir plus sur les métriques suivantes, consultez [Surveillance d’Amazon SageMaker AI avec Amazon CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html).
### Métriques de point de terminaison courantes
Ces métriques CloudWatch sont les mêmes que celles publiées pour les points de terminaison en temps réel.
La métrique `OverheadLatency` suit toute la latence supplémentaire ajoutée par SageMaker AI, y compris le temps de démarrage à froid de lancement de nouvelles ressources de calcul pour votre point de terminaison sans serveur. Comparé aux points de terminaison sans serveur à la demande, la `OverheadLatency` des points de terminaison sans serveur dotés de la simultanéité provisionnée est généralement nettement inférieure.
Les points de terminaison sans serveur peuvent également utiliser les métriques `Invocations4XXErrors`, `Invocations5XXErrors`, `Invocations`, `ModelLatency`, `ModelSetupTime` et `MemoryUtilization`. Pour en savoir plus sur ces mesures, consultez [SageMaker Métriques d'invocation des terminaux AI](monitoring-cloudwatch.md#cloudwatch-metrics-endpoint-invocation).
### Métriques de point de terminaison sans serveur courantes
Ces métriques CloudWatch sont publiées à la fois pour les points de terminaison sans serveur à la demande et pour les points de terminaison sans serveur avec la simultanéité provisionnée.
| Nom de la métrique | Description | Unité/Statistiques |
| --- | --- | --- |
| ServerlessConcurrentExecutionsUtilization | Le nombre d’exécutions simultanées divisé par la simultanéité maximum. | Unités : aucuneStatistiques valides : moyenne, maximum, minimum |
### Métriques d’un point de terminaison sans serveur avec la simultanéité provisionnée
Ces métriques CloudWatch sont publiées pour les points de terminaison sans serveur avec la simultanéité provisionnée.
| Nom de la métrique | Description | Unité/Statistiques |
| --- | --- | --- |
| ServerlessProvisionedConcurrencyExecutions | Le nombre d’exécutions simultanées gérées par le point de terminaison. | Unités : nombreStatistiques valides : moyenne, maximum, minimum |
| ServerlessProvisionedConcurrencyUtilization | Le nombre d’exécutions simultanées divisé par la simultanéité provisionnée allouée. | Unités : aucuneStatistiques valides : moyenne, maximum, minimum |
| ServerlessProvisionedConcurrencyInvocations | Le nombre de demandes InvokeEndpoint traitées par la simultanéité provisionnée. | Unités : nombreStatistiques valides : moyenne, maximum, minimum |
| ServerlessProvisionedConcurrencySpilloverInvocations | Le nombre de demandes InvokeEndpoint non traitées par la simultanéité provisionnée, qui sont gérées par u à la demande. | Unités : nombreStatistiques valides : moyenne, maximum, minimum |
## Journaux
Si vous souhaitez contrôler les journaux de votre point de terminaison pour le débogage ou l’analyse de la progression, vous pouvez utiliser Amazon CloudWatch Logs. Le groupe de journaux fourni par SageMaker AI que vous pouvez utiliser pour les points de terminaison sans serveur est `/aws/sagemaker/Endpoints/[EndpointName]`. Pour plus d’informations sur l’utilisation de CloudWatch Logs dans SageMaker AI, consultez [CloudWatch Journaux pour Amazon SageMaker AI](logging-cloudwatch.md). Pour en savoir plus sur CloudWatch Logs, consultez [Qu’est-ce qu’Amazon CloudWatch Logs ?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) dans le *Guide de l’utilisateur Amazon CloudWatch Logs*.
# Mise à l’échelle automatique de la simultanéité provisionnée pour un point de terminaison sans serveur
Amazon SageMaker AI effectue automatiquement une mise à l’échelle horizontale ou une montée en puissance des points de terminaison sans serveur à la demande. Pour les points de terminaison sans serveur dotés d’une simultanéité provisionnée, vous pouvez utiliser Application Auto Scaling pour augmenter ou réduire la simultanéité provisionnée en fonction de votre profil de trafic, optimisant ainsi les coûts.
Les conditions préalables requises pour automatiquement mettre à l’échelle la simultanéité provisionnée sur les points de terminaison sans serveur sont les suivantes :
+ [Enregistrement d’un modèle](#serverless-endpoints-autoscale-register)
+ [Définition d’une stratégie de mise à l’échelle](#serverless-endpoints-autoscale-define)
+ [Application d’une stratégie de mise à l’échelle](#serverless-endpoints-autoscale-apply)
Avant de pouvoir utiliser la mise à l’échelle automatique, vous devez avoir déjà déployé un modèle vers un point de terminaison sans serveur avec la simultanéité provisionnée. Les modèles déployés sont appelés [variante de production](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html). Consultez [Créer une configuration de point de terminaison](serverless-endpoints-create-config.md) et [Créer un point de terminaison](serverless-endpoints-create-endpoint.md) pour plus d’informations sur le déploiement d’un modèle sur un point de terminaison sans serveur avec la simultanéité provisionnée. Pour spécifier les métriques et les valeurs cibles d’une stratégie de mise à l’échelle, vous devez configurer une stratégie de mise à l’échelle. Pour plus d’informations sur comment définir une stratégie de mise à l’échelle, consultez [Définition d’une stratégie de mise à l’échelle](#serverless-endpoints-autoscale-define). Après avoir enregistré votre modèle et défini une stratégie de mise à l’échelle, appliquez cette stratégie au modèle enregistré. Pour en savoir plus sur comment appliquer la stratégie de mise à l’échelle, consultez [Application d’une stratégie de mise à l’échelle](#serverless-endpoints-autoscale-apply).
Pour plus d’informations sur les autres conditions préalables et les composants utilisés avec l’autoscalling, consultez la section [Conditions préalables à l’autoscaling](endpoint-auto-scaling-prerequisites.md) dans la [documentation sur l’autoscaling SageMaker AI](endpoint-auto-scaling.md).
## Enregistrement d’un modèle
Pour ajouter la mise à l’échelle automatique à un point de terminaison sans serveur avec la simultanéité provisionnée, vous devez d’abord enregistrer votre modèle (variante de production) à l’aide d’AWS CLI ou de l’API Application Auto Scaling.
### Enregistrement d’un modèle (AWS CLI)
Pour enregistrer votre modèle, utilisez la commande `register-scalable-target` d’AWS CLI avec les paramètres suivants :
+ `--service-namespace` : définissez cette valeur sur `sagemaker`.
+ `--resource-id` : l’identifiant de la ressource pour le modèle (plus précisément, la variante de production). Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante de production. Par exemple `endpoint/MyEndpoint/variant/MyVariant`.
+ `--scalable-dimension` : définissez cette valeur sur `sagemaker:variant:DesiredProvisionedConcurrency`.
+ `--min-capacity` : le nombre minimum de simultanéité provisionnée pour le modèle. Définissez `--min-capacity` sur au moins 1. La valeur doit être inférieure ou égale à celle spécifiée pour `--max-capacity`.
+ `--max-capacity` : le nombre maximum de simultanéité provisionnée qui doit être activée via Application Auto Scaling. Définissez `--max-capacity` sur 1 au minimum. Cette valeur doit être supérieure ou égale à la valeur spécifiée pour `--min-capacity`.
L’exemple suivant montre comment enregistrer un modèle nommé `MyVariant` qui est mis à l’échelle de façon dynamique pour avoir une valeur de simultanéité provisionnée de 1 à 10 :
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant \
--min-capacity 1 \
--max-capacity 10
```
### Enregistrement d’un modèle (API Application Auto Scaling)
Pour enregistrer votre modèle, utilisez l’action d’API Application Auto Scaling `RegisterScalableTarget` avec les paramètres suivants :
+ `ServiceNamespace` : définissez cette valeur sur `sagemaker`.
+ `ResourceId` : l’identifiant de la ressource pour le modèle (plus précisément, la variante de production). Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante de production. Par exemple `endpoint/MyEndpoint/variant/MyVariant`.
+ `ScalableDimension` : définissez cette valeur sur `sagemaker:variant:DesiredProvisionedConcurrency`.
+ `MinCapacity` : le nombre minimum de simultanéité provisionnée pour le modèle. Définissez `MinCapacity` sur au moins 1. La valeur doit être inférieure ou égale à celle spécifiée pour `MaxCapacity`.
+ `MaxCapacity` : le nombre maximum de simultanéité provisionnée qui doit être activée via Application Auto Scaling. Définissez `MaxCapacity` sur 1 au minimum. Cette valeur doit être supérieure ou égale à la valeur spécifiée pour `MinCapacity`.
L’exemple suivant montre comment enregistrer un modèle nommé `MyVariant` qui est mis à l’échelle de façon dynamique pour avoir une valeur de simultanéité provisionnée de 1 à 10 :
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.RegisterScalableTarget
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndPoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
"MinCapacity": 1,
"MaxCapacity": 10
}
```
## 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. Définissez la stratégie de mise à l’échelle sous forme de bloc JSON dans un fichier texte. Vous pouvez ensuite utiliser ce fichier texte pour appeler l’AWS CLI ou l’API Application Auto Scaling. Pour définir rapidement la stratégie de mise à l’échelle avec suivi de cible pour un point de terminaison sans serveur, utilisez la métrique `SageMakerVariantProvisionedConcurrencyUtilization` prédéfinie.
```
{
"TargetValue": 0.5,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantProvisionedConcurrencyUtilization"
},
"ScaleOutCooldown": 1,
"ScaleInCooldown": 1
}
```
## Application d’une stratégie de mise à l’échelle
Après avoir enregistré votre modèle, vous pouvez appliquer une stratégie de mise à l’échelle à votre point de terminaison sans serveur avec la simultanéité provisionnée. Consultez [Application d’une stratégie de mise à l’échelle avec suivi de cible](#serverless-endpoints-autoscale-apply-target) pour appliquer une stratégie de mise à l’échelle avec suivi de cible que vous avez définie. Si le flux de trafic vers votre point de terminaison sans serveur suit une routine prévisible, au lieu d’appliquer une stratégie de mise à l’échelle avec suivi de cible, vous souhaiterez peut-être planifier des actions de mise à l’échelle à des moments précis. Pour plus d’informations sur la planification d’actions de mise à l’échelle, consultez [Mise à l’échelle planifiée](#serverless-endpoints-autoscale-apply-scheduled).
### Application d’une stratégie de mise à l’échelle avec suivi de cible
Vous pouvez utiliser la AWS Management Console, l’AWS CLI ou l’API Application Auto Scaling pour appliquer une stratégie de mise à l’échelle avec suivi de cible à votre point de terminaison sans serveur avec la simultanéité provisionnée.
#### Application d’une stratégie de mise à l’échelle avec suivi de cible (AWS CLI)
Pour appliquer une stratégie de mise à l’échelle à votre modèle, utilisez la commande `put-scaling-policy` de l’AWS CLI avec les paramètres suivants :
+ `--policy-name` : nom de la stratégie de mise à l’échelle.
+ `--policy-type` : définissez cette valeur sur `TargetTrackingScaling`.
+ `--resource-id` : identifiant de la ressource pour la variante. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple `endpoint/MyEndpoint/variant/MyVariant`.
+ `--service-namespace` : définissez cette valeur sur `sagemaker`.
+ `--scalable-dimension` : définissez cette valeur sur `sagemaker:variant:DesiredProvisionedConcurrency`.
+ `--target-tracking-scaling-policy-configuration` : la configuration de la stratégie de mise à l’échelle du suivi des cibles à utiliser pour le modèle.
L’exemple suivant montre comment appliquer une stratégie de mise à l’échelle avec suivi de cible nommée `MyScalingPolicy` à une variante nommée `MyVariant`. La configuration de stratégie est enregistrée dans un fichier nommé `scaling-policy.json`.
```
aws application-autoscaling put-scaling-policy \
--policy-name MyScalingPolicy \
--policy-type TargetTrackingScaling \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant \
--target-tracking-scaling-policy-configuration file://[file-localtion]/scaling-policy.json
```
#### Application d’une stratégie de mise à l’échelle avec suivi de cible (API Application Auto Scaling)
Pour appliquer une stratégie de mise à l’échelle à votre modèle, utilisez l’action `PutScalingPolicy` de l’API Application Auto Scaling avec les paramètres suivants :
+ `PolicyName` : nom de la stratégie de mise à l’échelle.
+ `PolicyType` : définissez cette valeur sur `TargetTrackingScaling`.
+ `ResourceId` : identifiant de la ressource pour la variante. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple `endpoint/MyEndpoint/variant/MyVariant`.
+ `ServiceNamespace` : définissez cette valeur sur `sagemaker`.
+ `ScalableDimension` : définissez cette valeur sur `sagemaker:variant:DesiredProvisionedConcurrency`.
+ `TargetTrackingScalingPolicyConfiguration` : la configuration de la stratégie de mise à l’échelle du suivi des cibles à utiliser pour le modèle.
L’exemple suivant montre comment appliquer une stratégie de mise à l’échelle avec suivi de cible nommée `MyScalingPolicy` à une variante nommée `MyVariant`. La configuration de stratégie est enregistrée dans un fichier nommé `scaling-policy.json`.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.PutScalingPolicy
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "MyScalingPolicy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration":
{
"TargetValue": 0.5,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantProvisionedConcurrencyUtilization"
}
}
}
```
#### Application d’une stratégie de mise à l’échelle avec suivi de cible (AWS Management Console)
Pour appliquer une stratégie de mise à l’échelle avec suivi de cible avec la AWS Management Console :
1. Connectez-vous à la [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/).
1. Sous le volet de navigation, sélectionnez **Inference** (Inférence).
1. Choisissez **Points de terminaison** pour afficher la liste de tous vos points de terminaison.
1. Choisissez le point de terminaison auquel vous souhaitez appliquer la stratégie de mise à l’échelle. Une page contenant les paramètres du point de terminaison apparaîtra, avec les modèles (variante de production) répertoriés dans la section **Paramètres d’exécution de point de terminaison**.
1. Sélectionnez la variante de production à laquelle vous souhaitez appliquer la stratégie de mise à l’échelle, puis choisissez **Configurer Auto Scaling**. La boîte de dialogue **Configurer la scalabilité automatique d’une variante** s’affiche.
![\[Capture d’écran de la boîte de dialogue de configuration de la mise à l’échelle automatique d’une variante dans la console.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/serverless-endpoints-variant-autoscaling.png)
1. Entrez les valeurs de simultanéité provisionnée minimale et maximale dans les champs **Simultanéité provisionnée minimale** et **Simultanéité provisionnée maximale** dans la section **Scalabilité automatique d’une variante**. La simultanéité provisionnée minimale doit être inférieure ou égale à la simultanéité provisionnée maximale.
1. Entrez la valeur cible dans le champ **Valeur cible** pour la métrique cible, `SageMakerVariantProvisionedConcurrencyUtilization`.
1. (Facultatif) Entrez les valeurs de stabilisation de la diminution en charge et de la montée en charge (en secondes) dans les champs **Stabilisation de la diminution en charge** et **Stabilisation de la montée en charge** respectivement.
1. (Facultatif) Sélectionnez **Désactiver la diminution en charge** si vous ne souhaitez pas que l’autoscaling supprime l’instance lorsque le trafic diminue.
1. Sélectionnez **Save**.
### Mise à l’échelle planifiée
Si le trafic vers votre point de terminaison sans serveur avec la simultanéité provisionnée suit un schéma de routine, vous souhaiterez peut-être planifier des actions de mise à l’échelle à des moments précis, afin de réduire horizontalement ou d’augmenter horizontalement la simultanéité provisionnée. Vous pouvez utiliser l’AWS CLI ou l’API Application Auto Scaling pour planifier des actions de mise à l’échelle.
#### Mise à l’échelle planifiée (AWS CLI)
Pour appliquer une stratégie de mise à l’échelle à votre modèle, utilisez la commande `put-scheduled-action` de l’AWS CLI avec les paramètres suivants :
+ `--schedule-action-name` : nom de l’action de mise à l’échelle.
+ `--schedule` : expression cron qui spécifie les heures de début et de fin de l’action de mise à l’échelle selon un calendrier récurrent.
+ `--resource-id` : identifiant de la ressource pour la variante. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple `endpoint/MyEndpoint/variant/MyVariant`.
+ `--service-namespace` : définissez cette valeur sur `sagemaker`.
+ `--scalable-dimension` : définissez cette valeur sur `sagemaker:variant:DesiredProvisionedConcurrency`.
+ `--scalable-target-action` : cible de l’action de mise à l’échelle.
L’exemple suivant montre comment ajouter une action de mise à l’échelle nommée `MyScalingAction` vers un modèle nommé `MyVariant` selon un calendrier récurrent. Selon le calendrier spécifié (tous les jours à 12 h 15 UTC), si la simultanéité provisionnée actuelle est inférieure à la valeur spécifiée pour `MinCapacity`. Application Auto Scaling faire monter en puissance la simultanéité provisionnée à la valeur spécifiée par `MinCapacity`.
```
aws application-autoscaling put-scheduled-action \
--scheduled-action-name 'MyScalingAction' \
--schedule 'cron(15 12 * * ? *)' \
--service-namespace sagemaker \
--resource-id endpoint/MyEndpoint/variant/MyVariant \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--scalable-target-action 'MinCapacity=10'
```
#### Mise à l’échelle planifiée (API Application Auto Scaling)
Pour appliquer une stratégie de mise à l’échelle à votre modèle, utilisez l’action `PutScheduledAction` de l’API Application Auto Scaling avec les paramètres suivants :
+ `ScheduleActionName` : nom de l’action de mise à l’échelle.
+ `Schedule` : expression cron qui spécifie les heures de début et de fin de l’action de mise à l’échelle selon un calendrier récurrent.
+ `ResourceId` : identifiant de la ressource pour la variante. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple `endpoint/MyEndpoint/variant/MyVariant`.
+ `ServiceNamespace` : définissez cette valeur sur `sagemaker`.
+ `ScalableDimension` : définissez cette valeur sur `sagemaker:variant:DesiredProvisionedConcurrency`.
+ `ScalableTargetAction` : cible de l’action de mise à l’échelle.
L’exemple suivant montre comment ajouter une action de mise à l’échelle nommée `MyScalingAction` vers un modèle nommé `MyVariant` selon un calendrier récurrent. Selon le calendrier spécifié (tous les jours à 12 h 15 UTC), si la simultanéité provisionnée actuelle est inférieure à la valeur spécifiée pour `MinCapacity`. Application Auto Scaling faire monter en puissance la simultanéité provisionnée à la valeur spécifiée par `MinCapacity`.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.PutScheduledAction
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ScheduledActionName": "MyScalingAction",
"Schedule": "cron(15 12 * * ? *)",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
"ScalableTargetAction": "MinCapacity=10"
}
}
}
```
# Nettoyage
Une fois que vous avez fini d’utiliser l’autoscaling pour votre point de terminaison sans serveur avec la simultanéité provisionnée, vous devez nettoyer les ressources que vous avez créées. Cela implique de supprimer la stratégie de mise à l’échelle et de désenregistrer le modèle d’Application Autoscaling. Le nettoyage vous permet de ne pas encourir de coûts inutiles pour les ressources que vous n’utilisez plus.
## Suppression d’une stratégie de mise à l’échelle
Vous pouvez supprimer une stratégie de mise à l’échelle à partir de la AWS Management Console, de l’AWS CLI ou de l’API Application Auto Scaling. Pour plus d’informations sur la suppression d’une stratégie de mise à l’échelle avec la AWS Management Console, consultez [Suppression d’une stratégie de mise à l’échelle](endpoint-auto-scaling-delete.md) dans la [documentation sur l’autoscaling de SageMaker AI](endpoint-auto-scaling.md).
### Suppression d’une stratégie de mise à l’échelle (interface AWS CLI)
Pour appliquer une stratégie de mise à l’échelle à votre modèle, utilisez la commande `delete-scaling-policy` de l’AWS CLI avec les paramètres suivants :
+ `--policy-name` : nom de la stratégie de mise à l’échelle.
+ `--resource-id` : identifiant de la ressource pour la variante. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple `endpoint/MyEndpoint/variant/MyVariant`.
+ `--service-namespace` : définissez cette valeur sur `sagemaker`.
+ `--scalable-dimension` : définissez cette valeur sur `sagemaker:variant:DesiredProvisionedConcurrency`.
L’exemple suivant supprime une stratégie de mise à l’échelle nommée `MyScalingPolicy` du modèle nommé `MyVariant`.
```
aws application-autoscaling delete-scaling-policy \
--policy-name MyScalingPolicy \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant
```
### Suppression d’une stratégie de mise à l’échelle (API Application Auto Scaling)
Pour supprimer une stratégie de mise à l’échelle de votre modèle, utilisez l’action `DeleteScalingPolicy` de l’API Application Auto Scaling avec les paramètres suivants :
+ `PolicyName` : nom de la stratégie de mise à l’échelle.
+ `ResourceId` : identifiant de la ressource pour la variante. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple `endpoint/MyEndpoint/variant/MyVariant`.
+ `ServiceNamespace` : définissez cette valeur sur `sagemaker`.
+ `ScalableDimension` : définissez cette valeur sur `sagemaker:variant:DesiredProvisionedConcurrency`.
L’exemple suivant utilise l’API Application Auto Scaling pour supprimer une stratégie de mise à l’échelle nommée `MyScalingPolicy` du modèle nommé `MyVariant`.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeleteScalingPolicy
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "MyScalingPolicy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
}
```
## Annulation de l’enregistrement d’un modèle
Vous pouvez annuler l’enregistrement d’un modèle avec la AWS Management Console, l’AWS CLI ou l’API Application Auto Scaling.
### Annulation de l’enregistrement d’un modèle (AWS CLI)
Pour annuler l’enregistrement d’un modèle d’Application Auto Scaling, utilisez la commande `deregister-scalable-target` de l’AWS CLI avec les paramètres suivants :
+ `--resource-id` : identifiant de la ressource pour la variante. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple `endpoint/MyEndpoint/variant/MyVariant`.
+ `--service-namespace` : définissez cette valeur sur `sagemaker`.
+ `--scalable-dimension` : définissez cette valeur sur `sagemaker:variant:DesiredProvisionedConcurrency`.
L’exemple suivant annule l’enregistrement d’un modèle nommé `MyVariant` d’Application Auto Scaling.
```
aws application-autoscaling deregister-scalable-target \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant
```
### Annulation de l’enregistrement d’un modèle (API Application Auto Scaling)
Pour annuler l’enregistrement d’un modèle d’Application Auto Scaling, utilisez l’action d’API Application Auto Scaling `DeregisterScalableTarget` avec les paramètres suivants :
+ `ResourceId` : identifiant de la ressource pour la variante. Pour ce paramètre, le type de ressource est `endpoint` et l’identifiant unique est le nom de la variante. Par exemple `endpoint/MyEndpoint/variant/MyVariant`.
+ `ServiceNamespace` : définissez cette valeur sur `sagemaker`.
+ `ScalableDimension` : définissez cette valeur sur `sagemaker:variant:DesiredProvisionedConcurrency`.
L’exemple suivant utilise l’API Application Auto Scaling pour annuler l’enregistrement d’un modèle nommé `MyVariant` d’Application Auto Scaling.
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeregisterScalableTarget
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
}
```
### Annulation de l’enregistrement d’un modèle (AWS Management Console)
Pour annuler l’enregistrement d’un modèle (variante de production) avec la AWS Management Console :
1. Ouvrez la [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/).
1. Sous le panneau de navigation, choisissez **Inférence**.
1. Choisissez **Points de terminaison** pour afficher la liste de vos points de terminaison.
1. Choisissez le point de terminaison sans serveur hébergeant la variante de production. Une page contenant les paramètres du point de terminaison apparaîtra, avec les variantes de production répertoriées dans la section **Paramètres d’exécution de point de terminaison**.
1. Sélectionnez la variante de production dont vous souhaitez annuler l’enregistrement, puis choisissez **Configurer Auto Scaling**. La boîte de dialogue **Configurer la scalabilité automatique d’une variante** s’affiche.
1. Choisissez **Annuler l’enregistrement de la scalabilité automatique**.
# Résolution des problèmes
**Important**
Les politiques IAM personnalisées qui autorisent Amazon SageMaker Studio ou Amazon SageMaker Studio Classic à créer des ressources Amazon SageMaker doivent également accorder des autorisations pour ajouter des balises à ces ressources. L’autorisation d’ajouter des balises aux ressources est requise, car Studio et Studio Classic balisent automatiquement toutes les ressources qu’ils créent. Si une politique IAM autorise Studio et Studio Classic à créer des ressources mais n’autorise pas le balisage, des erreurs « AccessDenied » peuvent se produire lors de la tentative de création de ressources. Pour plus d’informations, consultez [Fournir des autorisations pour le balisage des ressources d' SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
Les [AWS politiques gérées pour Amazon SageMaker AI](security-iam-awsmanpol.md) qui autorisent la création de ressources SageMaker incluent déjà des autorisations permettant d’ajouter des balises lors de la création de ces ressources.
Si vous rencontrez des problèmes avec Serverless Inference, reportez-vous aux conseils de résolution des problèmes suivants.
## Problèmes de conteneur
Si le conteneur que vous utilisez pour un point de terminaison sans serveur est le même que celui que vous avez utilisé sur un point de terminaison basé sur une instance, votre conteneur pourrait ne pas disposer des autorisations nécessaires pour écrire des fichiers. Plusieurs raisons sont possibles :
+ Votre point de terminaison sans serveur n’est pas créé ou mis à jour en raison d’un échec de la surveillance de l’état du ping.
+ Les journaux Amazon CloudWatch Logs pour le point de terminaison montrent que le conteneur ne parvient pas à écrire dans un fichier ou un répertoire en raison d’une erreur d’autorisations.
Pour résoudre ce problème, vous pouvez essayer d’ajouter des autorisations de lecture, d’écriture et d’exécution pour `other` sur le fichier ou le répertoire, puis de reconstruire le conteneur. Vous pouvez suivre les étapes suivantes pour terminer ce processus :
1. Dans le Dockerfile que vous avez utilisé pour créer votre conteneur, ajoutez la commande suivante : `RUN chmod o+rwX `
1. Recréez le conteneur.
1. Chargez la nouvelle image de conteneur sur Amazon ECR.
1. Essayez à nouveau de créer ou de mettre à jour le point de terminaison sans serveur.
# Inférence asynchrone
Amazon SageMaker Asynchronous Inference est une fonctionnalité de l' SageMaker IA qui met en file d'attente les demandes entrantes et les traite de manière asynchrone. Cette option est idéale pour les demandes avec des charges utiles importantes (allant jusqu'à 1 Go), des temps de traitement longs (allant jusqu'à une heure) et des exigences de latence en temps quasi réel. L'inférence asynchrone vous permet d'économiser sur les coûts en faisant automatiquement passer le nombre d'instances à zéro lorsqu'il n'y a aucune requête à traiter. Ainsi, vous ne payez que lorsque votre point de terminaison traite les requêtes.
## Comment ça marche
La création de points de terminaison d'inférence asynchrone est similaire à la création de points de terminaison d'inférence en temps réel. Vous pouvez utiliser vos modèles d' SageMaker IA existants et il vous suffit de spécifier l'`AsyncInferenceConfig`objet lors de la création de la configuration de votre point de terminaison avec le `EndpointConfig` champ de l'`CreateEndpointConfig`API. Le diagramme suivant illustre l'architecture et le flux de travail de l'inférence asynchrone.
![\[Diagramme d’architecture d’inférence asynchrone illustrant comment un utilisateur invoque un point de terminaison.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/async-architecture.png)
Pour invoquer le point de terminaison, vous devez placer les données utiles de la demande dans Amazon S3. Vous devez également fournir un pointeur vers ces données utiles dans le cadre de la demande `InvokeEndpointAsync`. Lors de l'invocation, l' SageMaker IA met la demande en file d'attente pour traitement et renvoie un identifiant et un emplacement de sortie en réponse. Lors du traitement, l' SageMaker IA place le résultat dans l'emplacement Amazon S3. Vous pouvez choisir de recevoir des notifications de réussite ou d'erreur avec Amazon SNS. Pour plus d’informations sur la configuration des notifications asynchrones, consultez [Vérifier les résultats de la prédiction](async-inference-check-predictions.md).
**Note**
En cas de configuration d'inférence asynchrone (`AsyncInferenceConfig`) dans la configuration des points de terminaison, le point de terminaison ne peut recevoir que des appels asynchrones.
## Comment bénéficier du service ?
Si vous utilisez Amazon SageMaker Asynchronous Inference pour la première fois, nous vous recommandons de procéder comme suit :
+ Lisez [Opérations des points de terminaison asynchrones](async-inference-create-invoke-update-delete.md) pour savoir comment créer, invoquer, mettre à jour et supprimer des points de terminaison asynchrones.
+ [Explorez le [bloc-notes d'exemple d'inférence asynchrone](https://github.com/aws/amazon-sagemaker-examples/blob/main/async-inference/Async-Inference-Walkthrough.ipynb) dans le référentiel aws/. amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples) GitHub
Notez que si votre point de terminaison utilise l'une des fonctions répertoriées sur la page [Exclusions](deployment-guardrails-exclusions.md), vous ne pouvez pas utiliser l'inférence asynchrone.
# Opérations des points de terminaison asynchrones
Ce guide présente les conditions préalables pour créer un point de terminaison asynchrone et explique comment créer, invoquer et supprimer vos points de terminaison asynchrones. Vous pouvez créer, mettre à jour, supprimer et invoquer des points de terminaison asynchrones à l'aide du SDK Amazon Python et AWS SDKs du SDK Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-asynchronous-inference).
**Topics**
+ [Remplir les conditions préalables](async-inference-create-endpoint-prerequisites.md)
+ [Comment créer un point de terminaison d’inférence asynchrone](async-inference-create-endpoint.md)
+ [Appeler un point de terminaison asynchrone](async-inference-invoke-endpoint.md)
+ [Mettre à jour un point de terminaison asynchrone](async-inference-update-endpoint.md)
+ [Supprimer un point de terminaison asynchrone](async-inference-delete-endpoint.md)
# Remplir les conditions préalables
La rubrique suivante décrit les conditions préalables que vous devez remplir avant de créer un point de terminaison asynchrone. Ces conditions préalables incluent le stockage correct des artefacts de votre modèle, la configuration d'un AWS IAM avec les autorisations appropriées et la sélection d'une image de conteneur.
**Pour remplir les conditions préalables**
1. **Créez un rôle IAM pour Amazon SageMaker AI.**
L'inférence asynchrone doit avoir accès à l'URI de votre compartiment Amazon S3. Pour faciliter cela, créez un rôle IAM capable d'exécuter l' SageMaker IA et autorisé à accéder à Amazon S3 et Amazon SNS. Grâce à ce rôle, l' SageMaker IA peut s'exécuter sous votre compte et accéder à votre compartiment Amazon S3 et aux rubriques Amazon SNS.
Vous pouvez créer un rôle IAM à l'aide de la console IAM AWS SDK pour Python (Boto3), ou. AWS CLI Voici un exemple de la création d'un rôle IAM et de l'attachement des politiques nécessaires avec la console IAM.
1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.
1. Dans le panneau de navigation de la console IAM, sélectionnez **Roles** (Rôles), puis **Create role** (Créer un rôle).
1. Pour **Select type of trusted entity (Sélectionner le type d'entité de confiance)**, choisissez **Service AWS **.
1. Choisissez le service que vous voulez autoriser à endosser ce rôle. Dans ce cas, choisissez **SageMaker AI**. Choisissez ensuite **Suivant : Autorisations**.
+ Cela crée automatiquement une politique IAM qui accorde l'accès aux services associés tels qu'Amazon S3, Amazon ECR et CloudWatch Logs.
1. Choisissez **Next: Tags (Suivant : Identifications)**.
1. (Facultatif) Ajoutez des métadonnées au rôle en associant les identifications sous forme de paires clé-valeur. Pour plus d’informations sur l’utilisation de balises dans IAM, consultez [Balisage de ressources IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_tags.html).
1. Choisissez **Suivant : Examiner**.
1. Saisissez un **Role name (Nom de rôle)**.
1. Si possible, saisissez un nom de rôle ou un suffixe de nom de rôle. Les noms de rôles doivent être uniques dans votre AWS compte. Ils ne sont pas distingués au cas par cas. Par exemple, vous ne pouvez pas créer deux rôles nommés `PRODROLE` et `prodrole`. Comme d'autres AWS ressources peuvent faire référence au rôle, vous ne pouvez pas modifier le nom du rôle une fois celui-ci créé.
1. (Facultatif) Dans le champ **Role description (Description du rôle)**, saisissez la description du nouveau rôle.
1. Passez en revue les informations du rôle, puis choisissez **Créer un rôle**.
Notez l'ARN du rôle SageMaker AI. Pour connaître l'ARN du rôle à l'aide de la console, procédez comme suit :
1. Accédez à la console IAM : [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Sélectionnez **Roles (Rôles)**.
1. Recherchez le rôle que vous venez de créer en saisissant son nom dans le champ Recherche.
1. Sélectionnez le rôle.
1. L'ARN du rôle figure en haut de la page **Summary (Récapitulatif)**.
1. **Ajoutez les autorisations Amazon SageMaker AI, Amazon S3 et Amazon SNS à votre rôle IAM.**
Une fois le rôle créé, accordez des autorisations SageMaker AI, Amazon S3 et éventuellement Amazon SNS à votre rôle IAM.
Dans la console IAM, sélectionnez **Roles** (Rôles). Recherchez le rôle que vous avez créé en saisissant son nom dans le champ **Search** (Recherche).
1. Choisissez votre rôle.
1. Ensuite, choisissez **Attach Policies (Attacher des politiques)**.
1. Amazon SageMaker Asynchronous Inference a besoin d'une autorisation pour effectuer les actions suivantes :`"sagemaker:CreateModel"`,`"sagemaker:CreateEndpointConfig"`, `"sagemaker:CreateEndpoint"` et. `"sagemaker:InvokeEndpointAsync"`
Ces actions sont incluses dans la politique `AmazonSageMakerFullAccess`. Ajoutez cette politique à votre rôle IAM. Recherchez `AmazonSageMakerFullAccess` dans le champ **Search (Recherche)**. Sélectionnez `AmazonSageMakerFullAccess`.
1. Choisissez **Attach policy** (Attacher la politique).
1. Ensuite, choisissez **Attach Policies** (Attacher des politiques) pour ajouter des autorisations Amazon S3.
1. Sélectionnez **Create Policy** (Créer une politique).
1. Sélectionnez l'onglet `JSON`.
1. Ajoutez la déclaration de politique suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::bucket_name/*"
}
]
}
```
------
1. Choisissez **Suivant : Balises**.
1. Saisissez un **Policy name** (Nom de politique).
1. Choisissez **Create Policy** (Créer une politique).
1. Répétez les mêmes étapes que celles que vous avez effectuées pour ajouter des autorisations Amazon S3 afin d'ajouter des autorisations Amazon SNS. Pour la déclaration de politique, attachez les éléments suivants :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sns:Publish"
],
"Effect": "Allow",
"Resource": "arn:aws:sns:us-east-1:111122223333:SNS_Topic"
}
]
}
```
------
1. **Chargez vos données d'inférence (par exemple, modèle de machine learning, exemples de données) sur **Amazon S3**.**
1. **Sélectionnez une image d'inférence Docker prédéfinie ou créez votre propre image Docker d'inférence.**
SageMaker L'IA fournit des conteneurs pour ses algorithmes intégrés et des images Docker prédéfinies pour certains des frameworks d'apprentissage automatique les plus courants, tels qu'Apache MXNet, TensorFlow PyTorch, et Chainer. Pour une liste complète des images d' SageMaker IA disponibles, consultez [Available Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Si vous choisissez d'utiliser un conteneur fourni par l' SageMaker IA, vous pouvez augmenter le délai d'expiration du point de terminaison et la taille de la charge utile par rapport à la valeur par défaut en définissant les variables d'environnement dans le conteneur. Pour savoir comment définir les différentes variables d'environnement pour chaque framework, consultez l'étape de création de modèle de la création d'un point de terminaison asynchrone.
Si aucun des conteneurs SageMaker AI existants ne répond à vos besoins et que vous n'avez pas de conteneur existant, vous devrez peut-être créer un nouveau conteneur Docker. Consultez [Conteneurs avec code d’inférence personnalisé](your-algorithms-inference-main.md) pour savoir comment créer votre image Docker.
1. **Créer une rubrique Amazon SNS (facultatif)**
Créez une rubrique Amazon Simple Notification Service (Amazon SNS) qui envoie des notifications concernant les requêtes qui ont terminé le traitement. Amazon SNS est un service de notification destiné aux applications orientées messagerie. Plusieurs abonnés demandent et reçoivent des notifications « push » de messages critiques via un choix de protocoles de transport, y compris HTTP, Amazon SQS et les e-mails. Vous pouvez spécifier des rubriques Amazon SNS lorsque vous créez un objet `EndpointConfig` et spécifiez `AsyncInferenceConfig` à l'aide de l'API `EndpointConfig`.
Suivez ces étapes pour créer une rubrique Amazon SNS et vous y abonner.
1. Créez une rubrique à partir de la console Amazon SNS. Des instructions sont disponibles dans la section [Création d'une rubrique Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html) du *Guide du développeur* *Amazon Simple Notification Service*.
1. Abonnez-vous à la rubrique. Pour obtenir des instructions, consultez [Abonnement à une rubrique Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html) dans le *Guide du développeur* *Amazon Simple Notification Service*.
1. Lorsque vous recevez un e-mail vous invitant à confirmer votre abonnement à la rubrique, confirmez l'abonnement.
1. Notez l’Amazon Resource Name (ARN) de la rubrique. La rubrique Amazon SNS que vous avez créée est une autre ressource de votre AWS compte et elle possède un ARN unique. L'ARN est au format suivant :
```
arn:aws:sns:aws-region:account-id:topic-name
```
Pour plus d’informations sur Amazon SNS, consultez le [Guide du développeur Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html).
# Comment créer un point de terminaison d’inférence asynchrone
Créez un point de terminaison asynchrone de la même manière que vous créeriez un point de terminaison à l'aide des services d'hébergement SageMaker AI :
+ Créez un modèle en SageMaker IA avec`CreateModel`.
+ Créez une configuration de point de terminaison avec `CreateEndpointConfig`.
+ Créez un point de terminaison HTTPS avec `CreateEndpoint`.
Pour créer un point de terminaison, vous devez d'abord créer un modèle avec [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), où vous pointez sur l'artefact du modèle et sur un chemin de registre Docker (Image). Vous créez ensuite une configuration dans [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)laquelle vous spécifiez un ou plusieurs modèles créés à l'aide de l'`CreateModel`API pour le déploiement et les ressources que vous souhaitez que l' SageMaker IA fournisse. Créez un point de terminaison avec [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) à l'aide de la configuration de point de terminaison spécifiée dans la requête. Vous pouvez mettre à jour un point de terminaison asynchrone avec l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html). Envoyez et recevez des requêtes d'inférence à partir du modèle hébergé sur le point de terminaison avec `InvokeEndpointAsync`. Vous pouvez supprimer vos points de terminaison avec 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 une liste complète des SageMaker images disponibles, consultez [Available Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Consultez [Conteneurs avec code d’inférence personnalisé](your-algorithms-inference-main.md) pour savoir comment créer votre image Docker.
**Topics**
+ [Création d'un modèle](async-inference-create-endpoint-create-model.md)
+ [Création d'une configuration de point de terminaison](async-inference-create-endpoint-create-endpoint-config.md)
+ [Créez un point de terminaison](async-inference-create-endpoint-create-endpoint.md)
# Création d'un modèle
L'exemple suivant illustre la création d'un groupe de modèles à l'aide du kit AWS SDK pour Python (Boto3). Les premières lignes définissent :
+ `sagemaker_client`: un objet client SageMaker IA de bas niveau qui facilite l'envoi et la réception de demandes aux AWS services.
+ `sagemaker_role`: variable de chaîne avec le rôle SageMaker AI IAM Amazon Resource Name (ARN).
+ `aws_region`: variable de chaîne avec le nom de votre AWS région.
```
import boto3
# Specify your AWS Region
aws_region=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Role to give SageMaker permission to access AWS services.
sagemaker_role= "arn:aws:iam:::role/*"
```
Ensuite, spécifiez l'emplacement du modèle pré-entraîné stocké dans Amazon S3. Dans cet exemple, nous utilisons un XGBoost modèle préentraîné nommé`demo-xgboost-model.tar.gz`. L'URI Amazon S3 complet est stocké dans une variable de chaîne `model_url` :
```
#Create a variable w/ the model S3 URI
s3_bucket = '' # Provide the name of your S3 bucket
bucket_prefix='saved_models'
model_s3_key = f"{bucket_prefix}/demo-xgboost-model.tar.gz"
#Specify S3 bucket w/ model
model_url = f"s3://{s3_bucket}/{model_s3_key}"
```
Spécifiez un conteneur principal. Pour les conteneurs primaires, vous spécifiez l'image Docker contenant le code d'inférence, les artefacts (des entraînements précédents) et une carte d'environnement personnalisée que le code d'inférence utilise lorsque vous déployez le modèle pour les prédictions.
Dans cet exemple, nous spécifions une image de conteneur d'algorithme XGBoost intégrée :
```
from sagemaker import image_uris
# Specify an AWS container image.
container = image_uris.retrieve(region=aws_region, framework='xgboost', version='0.90-1')
```
Créez un modèle dans Amazon SageMaker AI avec`CreateModel`. Spécifiez les paramètres suivants :
+ `ModelName` : nom de votre modèle (dans cet exemple, il est stocké sous la forme d'une variable de chaîne appelée `model_name`).
+ `ExecutionRoleArn`: le nom de ressource Amazon (ARN) du rôle IAM qu'Amazon SageMaker AI peut assumer pour accéder aux artefacts du modèle et aux images Docker à des fins de déploiement sur des instances de calcul ML ou pour des tâches de transformation par lots.
+ `PrimaryContainer` : l’emplacement de l’image Docker principale contenant le code d’inférence, les artefacts associés et les cartes d’environnement personnalisées que le code d’inférence utilise lorsque le modèle est déployé pour les prédictions.
```
model_name = ''
#Create model
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
'Image': container,
'ModelDataUrl': model_url,
})
```
Consultez la [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)description dans le guide de référence des SageMaker API pour obtenir la liste complète des paramètres de l'API.
Si vous utilisez un conteneur fourni par l' SageMaker IA, vous pouvez augmenter le délai d'expiration du serveur de modèles et la taille de la charge utile des valeurs par défaut aux maximums pris en charge par le framework en définissant des variables d'environnement au cours de cette étape. Il se peut que vous ne puissiez pas tirer parti du délai d'expiration maximal et des tailles de charge utile maximales pris en charge par l'inférence asynchrone si vous ne définissez pas explicitement ces variables. L'exemple suivant montre comment définir les variables d'environnement d'un conteneur d' PyTorch inférence en fonction TorchServe de.
```
model_name = ''
#Create model
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
'Image': container,
'ModelDataUrl': model_url,
'Environment': {
'TS_MAX_REQUEST_SIZE': '100000000',
'TS_MAX_RESPONSE_SIZE': '100000000',
'TS_DEFAULT_RESPONSE_TIMEOUT': '1000'
},
})
```
Une fois que vous avez terminé de créer votre point de terminaison, vous devez vérifier que vous avez correctement défini les variables d'environnement en les imprimant depuis votre script `inference.py`. Le tableau suivant répertorie les variables d'environnement pour plusieurs frameworks, que vous pouvez définir pour modifier les valeurs par défaut.
| Cadre | Variables d’environnement |
| --- | --- |
| PyTorch 1,8 (basé sur TorchServe) | 'TS\$1MAX\$1REQUEST\$1SIZE' : '100000000' 'TS\$1MAX\$1RESPONSE\$1SIZE' : '100000000' 'TS\$1DEFAULT\$1RESPONSE\$1TIMEOUT' : '1000' |
| PyTorch 1.4 (basé sur le MMS) | 'MMS\$1MAX\$1REQUEST\$1SIZE' : '1000000000' 'MMS\$1MAX\$1RESPONSE\$1SIZE' : '1000000000' 'MMS\$1DEFAULT\$1RESPONSE\$1TIMEOUT' : '900' |
| HuggingFace Conteneur d'inférence (basé sur le MMS) | 'MMS\$1MAX\$1REQUEST\$1SIZE' : '2000000000' 'MMS\$1MAX\$1RESPONSE\$1SIZE' : '2000000000' 'MMS\$1DEFAULT\$1RESPONSE\$1TIMEOUT' : '900' |
# Création d'une configuration de point de terminaison
Une fois que vous avez un modèle, créez une configuration de point de terminaison avec [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html). Les services d'hébergement Amazon SageMaker AI utilisent cette configuration pour déployer des modèles. Dans la configuration, vous identifiez un ou plusieurs modèles, créés à l'aide de with [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), pour déployer les ressources que vous souhaitez qu'Amazon SageMaker AI fournisse. Spécifiez l'objet `AsyncInferenceConfig` et fournissez un emplacement Amazon S3 de sortie pour `OutputConfig`. Vous pouvez éventuellement spécifier des rubriques [Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) sur lesquelles envoyer des notifications concernant les résultats de prédiction. Pour plus d’informations sur les rubriques Amazon SNS, consultez [Configuration d’Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-configuring.html).
L'exemple suivant montre comment créer une configuration de point de terminaison à l'aide du kit AWS SDK pour Python (Boto3) :
```
import datetime
from time import gmtime, strftime
# Create an endpoint config name. Here we create one based on the date
# so it we can search endpoints based on creation time.
endpoint_config_name = f"XGBoostEndpointConfig-{strftime('%Y-%m-%d-%H-%M-%S', gmtime())}"
# The name of the model that you want to host. This is the name that you specified when creating the model.
model_name=''
create_endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name, # You will specify this name in a CreateEndpoint request.
# List of ProductionVariant objects, one for each model that you want to host at this endpoint.
ProductionVariants=[
{
"VariantName": "variant1", # The name of the production variant.
"ModelName": model_name,
"InstanceType": "ml.m5.xlarge", # Specify the compute instance type.
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
],
AsyncInferenceConfig={
"OutputConfig": {
# Location to upload response outputs when no location is provided in the request.
"S3OutputPath": f"s3://{s3_bucket}/{bucket_prefix}/output"
# (Optional) specify Amazon SNS topics
"NotificationConfig": {
"SuccessTopic": "arn:aws:sns:aws-region:account-id:topic-name",
"ErrorTopic": "arn:aws:sns:aws-region:account-id:topic-name",
}
},
"ClientConfig": {
# (Optional) Specify the max number of inflight invocations per instance
# If no value is provided, Amazon SageMaker will choose an optimal value for you
"MaxConcurrentInvocationsPerInstance": 4
}
}
)
print(f"Created EndpointConfig: {create_endpoint_config_response['EndpointConfigArn']}")
```
Dans l'exemple susmentionné, vous spécifiez les clés suivantes pour `OutputConfig` pour le champ `AsyncInferenceConfig` :
+ `S3OutputPath` : l'emplacement pour charger les sorties de réponse lorsqu'aucun emplacement n'est fourni dans la requête.
+ `NotificationConfig` : (facultatif) les rubriques SNS qui vous envoient des notifications lorsqu'une requête d'inférence réussit (`SuccessTopic`) ou échoue (`ErrorTopic`).
Vous pouvez également spécifier l'argument facultatif suivant pour `ClientConfig` dans le champ `AsyncInferenceConfig` :
+ `MaxConcurrentInvocationsPerInstance`: (Facultatif) Le nombre maximum de demandes simultanées envoyées par le client SageMaker AI au conteneur modèle.
# Créez un point de terminaison
Une fois que vous avez votre configuration de modèle et de point de terminaison, utilisez l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) pour créer votre point de terminaison. Le nom du point de terminaison doit être unique dans une AWS région de votre AWS compte.
L’exemple suivant crée un point de terminaison à l’aide de la configuration de point de terminaison spécifiée dans la requête. Amazon SageMaker AI utilise le point de terminaison pour provisionner des ressources et déployer des modèles.
```
# The name of the endpoint.The name must be unique within an AWS Region in your AWS account.
endpoint_name = ''
# The name of the endpoint configuration associated with this endpoint.
endpoint_config_name=''
create_endpoint_response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name)
```
Lorsque vous appelez l'`CreateEndpoint`API, Amazon SageMaker Asynchronous Inference envoie une notification de test pour vérifier que vous avez configuré une rubrique Amazon SNS. Amazon SageMaker Asynchronous Inference envoie également des notifications de test après les appels vers et. `UpdateEndpoint` `UpdateEndpointWeightsAndCapacities` Cela permet à SageMaker l'IA de vérifier que vous disposez des autorisations requises. La notification peut simplement être ignorée. La notification de test a la forme suivante :
```
{
"eventVersion":"1.0",
"eventSource":"aws:sagemaker",
"eventName":"TestNotification"
}
```
# Appeler un point de terminaison asynchrone
Obtenez des inférences du modèle hébergé sur votre point de terminaison asynchrone avec `InvokeEndpointAsync`.
**Note**
Si vous ne l'avez pas déjà fait, téléchargez vos données d'inférence (par exemple, modèle de machine learning, exemples de données) sur Amazon S3.
Renseignez les champs suivants dans votre demande :
+ Pour `InputLocation`, spécifiez l'emplacement de vos données d'inférence.
+ Pour `EndpointName`, spécifiez le nom de votre point de terminaison.
+ (Facultatif) Pour `InvocationTimeoutSeconds`, vous pouvez définir le délai d'attente maximal des demandes. Vous pouvez définir cette valeur sur un maximum de 3 600 secondes (une heure) par demande. Si vous ne spécifiez pas ce champ dans votre demande, la demande expire par défaut après 15 minutes.
```
# Create a low-level client representing Amazon SageMaker Runtime
sagemaker_runtime = boto3.client("sagemaker-runtime", region_name=)
# Specify the location of the input. Here, a single SVM sample
input_location = "s3://bucket-name/test_point_0.libsvm"
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name=''
# After you deploy a model into production using SageMaker AI hosting
# services, your client applications use this API to get inferences
# from the model hosted at the specified endpoint.
response = sagemaker_runtime.invoke_endpoint_async(
EndpointName=endpoint_name,
InputLocation=input_location,
InvocationTimeoutSeconds=3600)
```
Vous recevez une réponse sous forme de chaîne JSON avec votre ID de requête et le nom du compartiment Amazon S3 qui aura la réponse à l'appel d'API une fois qu'il aura été traité.
# Mettre à jour un point de terminaison asynchrone
Mettre à jour un point de terminaison asynchrone avec l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html). Lorsque vous mettez à jour un point de terminaison, l' SageMaker IA approvisionne et passe d'abord à la nouvelle configuration de point de terminaison que vous spécifiez avant de supprimer les ressources qui étaient provisionnées dans la configuration de point de terminaison précédente. Ne supprimez pas une `EndpointConfig` avec un point de terminaison qui est en direct ou pendant qu'une opération `UpdateEndpoint` ou `CreateEndpoint` est en cours d'exécution sur le point de terminaison.
```
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name=''
# The name of the endpoint configuration associated with this endpoint.
endpoint_config_name=''
sagemaker_client.update_endpoint(
EndpointConfigName=endpoint_config_name,
EndpointName=endpoint_name
)
```
Lorsqu'Amazon SageMaker AI reçoit la demande, il définit le statut du point de terminaison sur **Updating**. Après avoir mis à jour le point de terminaison asynchrone, il définit le statut sur. **InService** Pour vérifier le statut d'un point de terminaison, utilisez l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html). Pour obtenir la liste complète des paramètres que vous pouvez spécifier lors de la mise à jour d’un point de terminaison, consultez l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html).
# Supprimer un point de terminaison asynchrone
Supprimez un point de terminaison asynchrone de la même manière que vous supprimeriez un point de terminaison hébergé par l' SageMaker IA avec l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html)API. Spécifiez le nom du point de terminaison asynchrone que vous souhaitez supprimer. Lorsque vous supprimez un point de terminaison, l' SageMaker IA libère toutes les ressources déployées lors de sa création. 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.
Supprimez votre modèle d' SageMaker IA à l'aide de l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html)API ou de la console d' SageMaker IA.
------
#### [ Boto3 ]
```
import boto3
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=)
sagemaker_client.delete_endpoint(EndpointName='')
```
------
#### [ SageMaker AI console ]
1. Accédez à la console SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Développez la liste déroulante **Inference** (Inférence).
1. Sélectionnez **Endpoints (Points de terminaison)**.
1. Recherchez le point de terminaison dans la barre de recherche **Search endpoints** (Rechercher des points de terminaison).
1. Sélectionnez votre point de terminaison.
1. Sélectionnez **Delete (Supprimer)**.
------
Outre la suppression du point de terminaison asynchrone, vous souhaiterez peut-être effacer les autres ressources utilisées pour créer le point de terminaison, telles que le référentiel Amazon ECR (si vous avez créé une image d'inférence personnalisée), le modèle d' SageMaker IA et la configuration du point de terminaison asynchrone elle-même.
# Alarmes et journaux pour le suivi des métriques provenant des points de terminaison asynchrones
Vous pouvez surveiller SageMaker AI à l’aide d’Amazon CloudWatch, qui collecte et traite les données brutes pour les transformer en métriques lisibles en quasi temps réel. Avec Amazon CloudWatch, vous pouvez accéder aux informations historiques et acquérir un meilleur point de vue de la façon dont votre service ou application web s'exécute. Pour plus d’informations sur Amazon CloudWatch, consultez [Qu’est-ce que Amazon CloudWatch ?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html).
## Surveillance avec CloudWatch
Voici une liste exhaustive des métriques pour les points de terminaison asynchrones qui figurent dans l'espace de noms `AWS/SageMaker`. Toute métrique n'apparaissant pas n'est pas publiée si le point de terminaison est activé pour l'inférence asynchrone. Ces métriques incluent (sans s'y limiter) :
+ OverheadLatency
+ Invocations
+ InvocationsPerInstance
### Métriques de point de terminaison courantes
Ces métriques sont les mêmes que celles publiées aujourd'hui pour les points de terminaison en temps réel. Pour plus d’informations sur les autres métriques dans Amazon CloudWatch, consultez [Surveiller Amazon SageMaker à l’aide d’Amazon CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html).
| Nom de la métrique | Description | Unité/Statistiques |
| --- | --- | --- |
| `Invocation4XXErrors` | Nombre de demandes dans lesquelles le modèle a retourné un code de réponse HTTP 4xx. Pour chaque réponse 4xx, 1 est envoyé. Dans le cas contraire, la valeur 0 est envoyée. | Unités : aucuneStatistiques valides : Moyenne, somme |
| `Invocation5XXErrors` | Nombre de requêtes InvokeEndpoint dans lesquelles le modèle a renvoyé un code de réponse HTTP 5xx. Pour chaque réponse 5xx, 1 est envoyé. Dans le cas contraire, la valeur 0 est envoyée. | Unités : aucuneStatistiques valides : Moyenne, somme |
| `ModelLatency` | L’intervalle de temps nécessaire à un modèle pour répondre, comme observé depuis SageMaker AI. Cet intervalle inclut le temps de communication local pris pour envoyer la requête et pour récupérer la réponse du conteneur d'un modèle et le temps nécessaire pour terminer l'inférence dans le conteneur. | Unités : microsecondes Statistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage |
### Métriques de point de terminaison d'inférence asynchrone
Ces métriques sont publiées pour les points de terminaison activés pour l'inférence asynchrone. Les métriques suivantes sont publiées avec la dimension `EndpointName` :
| Nom de la métrique | Description | Unité/Statistiques |
| --- | --- | --- |
| `ApproximateBacklogSize` | Nombre d'éléments dans la file d'attente d'un point de terminaison en cours de traitement ou à traiter. | Unités : nombre Statistiques valides : moyenne, maximum, minimum |
| `ApproximateBacklogSizePerInstance` | Nombre d'éléments de la file d'attente divisé par le nombre d'instances derrière un point de terminaison. Cette métrique est principalement utilisée pour configurer la scalabilité automatique des applications pour un point de terminaison asynchrone. | Unités : nombreStatistiques valides : moyenne, maximum, minimum |
| `ApproximateAgeOfOldestRequest` | Âge de la requête la plus ancienne de la file d'attente. | Unités : secondesStatistiques valides : moyenne, maximum, minimum |
| `HasBacklogWithoutCapacity` | La valeur de cette métrique est `1` lorsqu'il y a des demandes dans la file d'attente, mais zéro instance derrière le point de terminaison. La valeur est `0` à tout autre moment. Vous pouvez utiliser cette métrique pour mettre automatiquement à l'échelle votre point de terminaison à partir de zéro instance dès réception d'une nouvelle demande dans la file d'attente. | Unités : nombreStatistiques valides : Moyenne |
Les métriques suivantes sont publiées avec les dimensions `EndpointName` et `VariantName` :
| Nom de la métrique | Description | Unité/Statistiques |
| --- | --- | --- |
| `RequestDownloadFailures` | Lorsqu'un échec d'inférence survient en raison d'un problème lors du téléchargement de la requête depuis Amazon S3. | Unités : nombreStatistiques valides : somme |
| `ResponseUploadFailures` | Lorsqu'un échec d'inférence survient en raison d'un problème lors du chargement de la réponse vers Amazon S3. | Unités : nombreStatistiques valides : somme |
| `NotificationFailures` | Lorsqu'un problème survient pendant la publication de notifications. | Unités : nombreStatistiques valides : somme |
| `RequestDownloadLatency` | Temps total de téléchargement de la charge utile de la requête. | Unités : microsecondesStatistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage |
| `ResponseUploadLatency` | Temps total de chargement de la charge utile de la réponse. | Unités : microsecondes Statistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage |
| `ExpiredRequests` | Nombre de requêtes dans la file d'attente qui échouent en raison de leur durée de vie de requête spécifiée. | Unités : nombreStatistiques valides : somme |
| `InvocationFailures` | Si une invocation échoue pour quelque raison que ce soit. | Unités : nombreStatistiques valides : somme |
| `InvocationsProcesssed` | Nombre d'invocations asynchrones traitées par le point de terminaison. | Unités : nombreStatistiques valides : somme |
| `TimeInBacklog` | Durée totale pendant laquelle la requête a été mise en file d'attente avant d'être traitée. Cela n'inclut pas le temps de traitement réel (c'est-à-dire le temps de téléchargement, le temps de chargement, la latence du modèle). | Unités : millisecondesStatistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage |
| `TotalProcessingTime` | Durée entre l’heure de réception de la demande d’inférence par SageMaker AI et la fin de son traitement. Cela inclut le temps dans le backlog et le temps nécessaire pour charger et envoyer des notifications de réponse, le cas échéant. | Unités : millisecondesStatistiques valides : Moyenne, Somme, Min, Max, Exemple de comptage |
L'inférence asynchrone d'Amazon SageMaker inclut également des métriques au niveau de l'hôte. Pour en savoir plus sur les métriques de niveau hôte, consultez [Tâches SageMaker AI et métriques de point de terminaison](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-jobs).
## Journaux
En plus des [modèles de journaux de conteneur](https://docs.aws.amazon.com/sagemaker/latest/dg/logging-cloudwatch.html) qui sont publiés sur Amazon CloudWatch dans votre compte, vous obtenez également un nouveau journal de plateforme pour le suivi et le débogage des requêtes d'inférence.
Les nouveaux journaux sont publiés sous le groupe de journaux de points de terminaison :
```
/aws/sagemaker/Endpoints/[EndpointName]
```
Le nom de flux de journaux est composé des éléments suivants :
```
[production-variant-name]/[instance-id]/data-log.
```
Les lignes des journaux contiennent l'ID d'inférence de la requête, de sorte que les erreurs peuvent être facilement mappées à une requête particulière.
# Vérifier les résultats de la prédiction
Il existe plusieurs manières de vérifier les résultats des prédictions à partir de votre point de terminaison asynchrone. Voici quelques-unes d'entre elles :
1. Les rubriques Amazon SNS.
1. Vérifier les sorties dans votre compartiment Amazon S3.
## Rubriques Amazon SNS
Amazon SNS est un service de notification destiné aux applications orientées messagerie. Plusieurs abonnés demandent et reçoivent des notifications « push » de messages critiques via un choix de protocoles de transport, y compris HTTP, Amazon SQS et les e-mails. L'inférence asynchrone d'Amazon SageMaker publie des notifications lorsque vous créez un point de terminaison avec [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) et spécifiez une rubrique Amazon SNS.
**Note**
Pour recevoir des notifications Amazon SNS, votre rôle IAM doit avoir des autorisations `sns:Publish`. Pour en savoir plus sur les prérequis pour utiliser l'inférence asynchrone, suivez le [Remplir les conditions préalables](async-inference-create-endpoint-prerequisites.md).
Pour utiliser Amazon SNS afin de vérifier les résultats de prédiction à partir de votre point de terminaison asynchrone, vous devez d'abord créer une rubrique, vous abonner à la rubrique, confirmer votre abonnement à la rubrique et noter l'Amazon Resource Name (ARN) de cette rubrique. Pour obtenir des informations détaillées sur la création, l’abonnement et la recherche de l’Amazon ARN d’une rubrique Amazon SNS, consultez [Configuration d’Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-configuring.html).
Indiquez le ou les ARN de rubrique Amazon SNS dans le champ `AsyncInferenceConfig` lorsque vous créez une configuration de point de terminaison avec `CreateEndpointConfig`. Vous pouvez spécifier à la fois une `ErrorTopic` et une `SuccessTopic` Amazon SNS.
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name=)
sagemaker_client.create_endpoint_config(
EndpointConfigName=, # You specify this name in a CreateEndpoint request.
# List of ProductionVariant objects, one for each model that you want to host at this endpoint.
ProductionVariants=[
{
"VariantName": "variant1", # The name of the production variant.
"ModelName": "model_name",
"InstanceType": "ml.m5.xlarge", # Specify the compute instance type.
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
],
AsyncInferenceConfig={
"OutputConfig": {
# Location to upload response outputs when no location is provided in the request.
"S3OutputPath": "s3:///"
"NotificationConfig": {
"SuccessTopic": "arn:aws:sns:aws-region:account-id:topic-name",
"ErrorTopic": "arn:aws:sns:aws-region:account-id:topic-name",
}
}
}
)
```
Après avoir créé votre point de terminaison et l'avoir appelé, vous recevez une notification de votre rubrique Amazon SNS. Par exemple, si vous vous êtes abonné pour recevoir des notifications par e-mail de votre rubrique, vous recevez une notification par e-mail chaque fois que vous appelez votre point de terminaison. L'exemple suivant illustre le contenu JSON d'une notification par e-mail d'appel réussie.
```
{
"awsRegion":"us-east-1",
"eventTime":"2022-01-25T22:46:00.608Z",
"receivedTime":"2022-01-25T22:46:00.455Z",
"invocationStatus":"Completed",
"requestParameters":{
"contentType":"text/csv",
"endpointName":"",
"inputLocation":"s3:////input-data.csv"
},
"responseParameters":{
"contentType":"text/csv; charset=utf-8",
"outputLocation":"s3:////prediction.out"
},
"inferenceId":"11111111-2222-3333-4444-555555555555",
"eventVersion":"1.0",
"eventSource":"aws:sagemaker",
"eventName":"InferenceResult"
}
```
## Vérifier votre compartiment S3
Lorsque vous invoquez un point de terminaison avec `InvokeEndpointAsync`, il renvoie un objet de réponse. Vous pouvez utiliser l'objet de réponse pour obtenir l'URI Amazon S3 où votre sortie est stockée. Avec l’emplacement de sortie, vous pouvez utiliser une classe de session SageMaker AI du kit SageMaker Python SDK afin de vérifier une sortie par programmation.
Ce qui suit stocke le dictionnaire de sortie de `InvokeEndpointAsync` en tant que réponse nommée comme variable. Avec la variable de réponse, vous obtenez ensuite l'URI de sortie Amazon S3 et le stockez sous forme de variable de chaîne appelée `output_location`.
```
import uuid
import boto3
sagemaker_runtime = boto3.client("sagemaker-runtime", region_name=)
# Specify the S3 URI of the input. Here, a single SVM sample
input_location = "s3://bucket-name/test_point_0.libsvm"
response = sagemaker_runtime.invoke_endpoint_async(
EndpointName='',
InputLocation=input_location,
InferenceId=str(uuid.uuid4()),
ContentType="text/libsvm" #Specify the content type of your data
)
output_location = response['OutputLocation']
print(f"OutputLocation: {output_location}")
```
Pour plus d’informations sur les types de contenu pris en charge, consultez [Formats de données courants pour l’inférence](cdf-inference.md).
Avec l’emplacement de sortie Amazon S3, vous pouvez ensuite utiliser une [classe de session SageMaker AI du kit SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/api/utility/session.html?highlight=session) pour lire dans des fichiers Amazon S3. L'exemple de code suivant montre comment créer une fonction (`get_ouput`) qui tente à plusieurs reprises de lire un fichier à partir de l'emplacement de sortie Amazon S3 :
```
import sagemaker
import urllib, time
from botocore.exceptions import ClientError
sagemaker_session = sagemaker.session.Session()
def get_output(output_location):
output_url = urllib.parse.urlparse(output_location)
bucket = output_url.netloc
key = output_url.path[1:]
while True:
try:
return sagemaker_session.read_s3_file(
bucket=output_url.netloc,
key_prefix=output_url.path[1:])
except ClientError as e:
if e.response['Error']['Code'] == 'NoSuchKey':
print("waiting for output...")
time.sleep(2)
continue
raise
output = get_output(output_location)
print(f"Output: {output}")
```
# Mettre automatiquement à l'échelle un point de terminaison asynchrone
Amazon SageMaker AI prend en charge la mise à l’échelle automatique (autoscaling) de votre point de terminaison asynchrone. La mise à l'échelle automatique ajuste dynamiquement le nombre d'instances allouées pour un modèle en réponse aux modifications de la charge de travail. Contrairement aux autres modèles hébergés pris en charge par Amazon SageMaker AI, avec l’inférence asynchrone, vous pouvez également réduire verticalement vos instances de points de terminaison asynchrones à zéro. Les requêtes reçues lorsqu'il n'y a aucune instance sont mises en file d'attente pour traitement une fois que le point de terminaison augmente.
Pour mettre à l'échelle automatiquement votre point de terminaison asynchrone, vous devez au minimum :
+ Enregistrer un modèle déployé (variante de production).
+ Définir une politique de mise à l'échelle.
+ Appliquer la politique de scalabilité automatique.
Avant de pouvoir utiliser la mise à l’échelle automatique, vous devez avoir déjà déployé un modèle vers un point de terminaison SageMaker AI. Les modèles déployés sont appelés [variante de production](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html). Consultez [Déployer le modèle sur les services d'hébergement SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-model-deployment.html#ex1-deploy-model) pour en savoir plus sur le déploiement d'un modèle sur un point de terminaison. Pour spécifier les métriques et les valeurs cibles d'une politique de mise à l'échelle, configurez une politique de mise à l'échelle. Pour savoir comment définir une politique de mise à l’échelle, consultez [Définition d’une stratégie de mise à l’échelle](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling-add-code-define.html). Après avoir enregistré votre modèle et défini une stratégie de mise à l'échelle, appliquez cette stratégie au modèle enregistré. Pour savoir comment appliquer la politique de mise à l’échelle, consultez [Application d’une stratégie de mise à l’échelle](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling-add-code-apply.html).
Vous pouvez définir une politique de mise à l'échelle supplémentaire et facultative pour augmenter votre point de terminaison à la réception d'une demande, après que ce dernier a été réduit à zéro. Pour plus d'informations, consultez [Facultatif : définition d'une politique de mise à l'échelle pour augmenter à partir de zéro pour les nouvelles demandes](#async-inference-autoscale-scale-up). Si vous ne spécifiez pas cette politique facultative, votre point de terminaison ne démarre la mise à l'échelle à partir de zéro que lorsque le nombre de demandes en attente dépasse la valeur de suivi cible.
Pour plus d’informations sur les autres prérequis et les composants utilisés avec la mise à l’échelle automatique, consultez la section [Prérequis](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling-prerequisites.html) de la documentation SageMaker AI sur la mise à l’échelle automatique.
**Note**
Si vous associez plusieurs politiques de dimensionnement au même groupe de dimensionnement automatique, vous risquez de rencontrer des conflits de dimensionnement. Lorsqu'un conflit se produit, Amazon EC2 Auto Scaling choisit la politique qui fournit la plus grande capacité à la fois de mise à l'échelle horizontale et de mise à l'échelle horizontale. Pour plus d'informations sur ce comportement, consultez [Plusieurs politiques de mise à l'échelle dynamique](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scale-based-on-demand.html#multiple-scaling-policy-resolution) dans la *documentation Amazon EC2 Auto Scaling*.
## 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 dimensionnement, vous configurez une stratégie de dimensionnement avec suivi de cible. Définissez la politique de mise à l'échelle sous forme de bloc JSON dans un fichier texte. Utilisez ce fichier texte pour invoquer l’AWS CLI ou l’API Application Auto Scaling. Pour plus d’informations sur la syntaxe de la configuration d’une politique, consultez [https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html) dans la Référence des API Application Auto Scaling.
Pour les points de terminaison asynchrones, SageMaker AI recommande fortement de créer une configuration de politique pour la mise à l’échelle du suivi de cible d’une variante. Dans cet exemple de configuration, nous utilisons une métrique personnalisée, `CustomizedMetricSpecification`, appelée `ApproximateBacklogSizePerInstance`.
```
TargetTrackingScalingPolicyConfiguration={
'TargetValue': 5.0, # The target value for the metric. Here the metric is: ApproximateBacklogSizePerInstance
'CustomizedMetricSpecification': {
'MetricName': 'ApproximateBacklogSizePerInstance',
'Namespace': 'AWS/SageMaker',
'Dimensions': [
{'Name': 'EndpointName', 'Value': }
],
'Statistic': 'Average',
}
}
```
## Définition d'une politique de mise à l'échelle qui met à l'échelle jusqu'à zéro
La section suivante vous montre comment définir et enregistrer votre variante de point de terminaison avec la scalabilité automatique des applications à l'aide du kit AWS SDK pour Python (Boto3). Après avoir défini un objet client de bas niveau représentant la scalabilité automatique des applications avec Boto3, nous utilisons la méthode [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/application-autoscaling.html#ApplicationAutoScaling.Client.register_scalable_target](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/application-autoscaling.html#ApplicationAutoScaling.Client.register_scalable_target) pour enregistrer la variante de production. Nous défini `MinCapacity` sur 0 car l'inférence asynchrone vous permet d'effectuer une mise à l'échelle automatique à 0 lorsqu'il n'y a aucune requête à traiter.
```
# Common class representing application autoscaling for SageMaker
client = boto3.client('application-autoscaling')
# This is the format in which application autoscaling references the endpoint
resource_id='endpoint/' + + '/variant/' + <'variant1'>
# Define and register your endpoint variant
response = client.register_scalable_target(
ServiceNamespace='sagemaker',
ResourceId=resource_id,
ScalableDimension='sagemaker:variant:DesiredInstanceCount', # The number of EC2 instances for your Amazon SageMaker model endpoint variant.
MinCapacity=0,
MaxCapacity=5
)
```
Pour obtenir une description détaillée de l’API Application Autoscaling, consultez la documentation sur [Application Scaling de Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/application-autoscaling.html#ApplicationAutoScaling.Client.register_scalable_target).
## Facultatif : définition d'une politique de mise à l'échelle pour augmenter à partir de zéro pour les nouvelles demandes
Vous pouvez avoir un cas d'utilisation avec des demandes sporadiques ou des périodes avec un faible nombre de demandes. Si votre point de terminaison a été réduit à zéro instance au cours de ces périodes, votre point de terminaison ne sera pas de nouveau augmenté tant que le nombre de demandes dans la file d'attente ne dépassera pas la cible spécifiée dans votre politique de mise à l'échelle. Cela peut entraîner de longs délais d'attente pour les demandes dans la file d'attente. La section suivante explique comment créer une politique de mise à l'échelle supplémentaire pour augmenter votre point de terminaison à partir de zéro instance après réception de toute nouvelle demande dans la file d'attente. Votre point de terminaison sera en mesure de répondre aux nouvelles demandes plus rapidement au lieu d'attendre que la taille de la file d'attente dépasse la cible.
Pour créer une politique de mise à l'échelle pour votre point de terminaison afin d'augmenter à partir de zéro instance, procédez comme suit :
1. Créez une politique de mise à l'échelle qui définit le comportement souhaité, qui consiste à augmenter la taille de votre point de terminaison lorsqu'il se trouve à zéro instance, mais que des demandes sont en file d'attente. Ce qui suit montre comment définir une politique de mise à l'échelle appelée `HasBacklogWithoutCapacity-ScalingPolicy` à l'aide du kit AWS SDK pour Python (Boto3). Lorsque la file d'attente est supérieure à zéro et que le nombre actuel d'instances pour votre point de terminaison est également nul, la politique augmente la taille de votre point de terminaison. Dans tous les autres cas, la politique n'a aucune incidence sur la mise à l'échelle de votre point de terminaison.
```
response = client.put_scaling_policy(
PolicyName="HasBacklogWithoutCapacity-ScalingPolicy",
ServiceNamespace="sagemaker", # The namespace of the service that provides the resource.
ResourceId=resource_id, # Endpoint name
ScalableDimension="sagemaker:variant:DesiredInstanceCount", # SageMaker supports only Instance Count
PolicyType="StepScaling", # 'StepScaling' or 'TargetTrackingScaling'
StepScalingPolicyConfiguration={
"AdjustmentType": "ChangeInCapacity", # Specifies whether the ScalingAdjustment value in the StepAdjustment property is an absolute number or a percentage of the current capacity.
"MetricAggregationType": "Average", # The aggregation type for the CloudWatch metrics.
"Cooldown": 300, # The amount of time, in seconds, to wait for a previous scaling activity to take effect.
"StepAdjustments": # A set of adjustments that enable you to scale based on the size of the alarm breach.
[
{
"MetricIntervalLowerBound": 0,
"ScalingAdjustment": 1
}
]
},
)
```
1. Créez une alarme CloudWatch à l'aide de la métrique personnalisée `HasBacklogWithoutCapacity`. Lorsqu'elle est déclenchée, l'alarme initie la politique de mise à l'échelle que vous avez définie précédemment. Pour plus d'informations sur la métrique `HasBacklogWithoutCapacity`, consultez [Métriques de point de terminaison d'inférence asynchrone](async-inference-monitor.md#async-inference-monitor-cloudwatch-async).
```
response = cw_client.put_metric_alarm(
AlarmName=step_scaling_policy_alarm_name,
MetricName='HasBacklogWithoutCapacity',
Namespace='AWS/SageMaker',
Statistic='Average',
EvaluationPeriods= 2,
DatapointsToAlarm= 2,
Threshold= 1,
ComparisonOperator='GreaterThanOrEqualToThreshold',
TreatMissingData='missing',
Dimensions=[
{ 'Name':'EndpointName', 'Value':endpoint_name },
],
Period= 60,
AlarmActions=[step_scaling_policy_arn]
)
```
Vous devriez désormais disposer d'une politique de mise à l'échelle et d'une alarme CloudWatch qui augmentent la taille de votre point de terminaison à partir de zéro instance chaque fois que votre file d'attente contient des demandes en attente.
# Résolution des problèmes
Les questions fréquentes (FAQ) suivantes peuvent vous aider à résoudre les problèmes liés à vos points de terminaison d'inférence asynchrone Amazon SageMaker.
## Q : La mise à l'échelle automatique est activée. Comment puis-je trouver le nombre d'instances derrière le point de terminaison à un moment donné ?
Vous pouvez utiliser les méthodes suivantes pour déterminer le nombre d'instances derrière votre point de terminaison :
+ Vous pouvez utiliser l’API [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) SageMaker AI pour décrire le nombre d’instances situées derrière le point de terminaison à tout instant.
+ Vous pouvez obtenir le nombre d'instances en consultant vos métriques Amazon CloudWatch. Consultez les [métriques de vos instances de point de terminaison](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-jobs), telles que `CPUUtilization` ou `MemoryUtilization`, et vérifiez les statistiques relatives au nombre d'échantillons sur une période d'une minute. Ce nombre doit être égal au nombre d'instances actives. La capture d'écran suivante montre la métrique `CPUUtilization` représentée graphiquement dans la console CloudWatch, où la valeur **Statistique** est définie sur `Sample count`, la valeur **Période** est définie sur `1 minute` et le nombre obtenu est 5.
![\[Console CloudWatch représentant graphiquement le nombre d’instances actives pour un point de terminaison.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/cloudwatch-sample-count.png)
## Q : Quelles sont les variables d’environnement réglables courantes pour les conteneurs SageMaker AI ?
Les tableaux suivants présentent les variables d’environnement réglables courantes pour les conteneurs SageMaker AI par type de cadre.
**TensorFlow**
| Variable d'environnement | Description |
| --- | --- |
| `SAGEMAKER_TFS_INSTANCE_COUNT` | Pour les modèles basés sur Tensorflow, le binaire `tensorflow_model_server` est l'élément opérationnel responsable du chargement d'un modèle en mémoire, de l'exécution d'entrées par rapport à un graphe du modèle et de la dérivation des sorties. Généralement, une seule instance de ce binaire est lancée pour servir les modèles dans un point de terminaison. Ce binaire est multithread en interne et génère plusieurs threads pour répondre à une demande d'inférence. Dans certains cas, si vous constatez que le processeur est convenablement utilisé (plus de 30 % d'utilisation) mais que la mémoire est sous-utilisée (moins de 10 % d'utilisation), il peut être utile d'augmenter ce paramètre. L'augmentation du nombre `tensorflow_model_servers` de serveurs disponibles augmente généralement le débit d'un point de terminaison. |
| `SAGEMAKER_TFS_FRACTIONAL_GPU_MEM_MARGIN` | Ce paramètre régit la fraction de la mémoire GPU disponible pour initialiser CUDA/cuDNN et les autres bibliothèques GPU. `0.2` signifie que 20 % de la mémoire GPU disponible est réservée à l'initialisation de CUDA/cuDNN et des autres bibliothèques GPU, et que 80 % de la mémoire GPU disponible est allouée de manière égale entre les processus TF. La mémoire GPU est préallouée sauf si l'option `allow_growth` est activée. |
| `SAGEMAKER_TFS_INTER_OP_PARALLELISM` | Elle est liée à la variable `inter_op_parallelism_threads`. Cette variable détermine le nombre de threads utilisés par les opérations indépendantes sans blocage. `0` signifie que le système choisit un nombre approprié. |
| `SAGEMAKER_TFS_INTRA_OP_PARALLELISM` | Elle est liée à la variable `intra_op_parallelism_threads`. Cela détermine le nombre de threads qui peuvent être utilisés pour certaines opérations telles que la multiplication matricielle et les réductions pour les accélérations. Une valeur de `0` signifie que le système choisit un nombre approprié. |
| `SAGEMAKER_GUNICORN_WORKERS` | Cela régit le nombre de processus d'application de travail que Gunicorn est invité à générer pour traiter les demandes. Cette valeur est utilisée en combinaison avec d'autres paramètres pour dériver un ensemble qui maximise le débit d'inférence. En plus de cela, la variable `SAGEMAKER_GUNICORN_WORKER_CLASS` régit le type des applications de travail engendrées, généralement `async` ou `gevent`. |
| `SAGEMAKER_GUNICORN_WORKER_CLASS` | Cela régit le nombre de processus d'application de travail que Gunicorn est invité à générer pour traiter les demandes. Cette valeur est utilisée en combinaison avec d'autres paramètres pour dériver un ensemble qui maximise le débit d'inférence. En plus de cela, la variable `SAGEMAKER_GUNICORN_WORKER_CLASS` régit le type des applications de travail engendrées, généralement `async` ou `gevent`. |
| `OMP_NUM_THREADS` | Python utilise OpenMP en interne pour implémenter le multithreading au sein des processus. Généralement, des threads équivalents au nombre de cœurs CPU sont générés. Mais lorsqu'il est implémenté en plus du multithreading simultané (SMT), tel que la technologie Hyper-Threading d'Intel, un certain processus peut sursouscrire un cœur en particulier en générant deux fois plus de threads que le nombre réel de cœurs de processeur. Dans certains cas, un binaire Python peut générer jusqu'à quatre fois plus de threads que de cœurs de processeur disponibles. Par conséquent, le paramètre idéal pour ce paramètre, si vous avez sursouscrit des cœurs disponibles à l'aide de threads de travail, est `1`, ou la moitié du nombre de cœurs de processeur d'un processeur avec le SMT activé. |
| `TF_DISABLE_MKL` `TF_DISABLE_POOL_ALLOCATOR` | Dans certains cas, la désactivation de MKL peut accélérer l'inférence si `TF_DISABLE_MKL` et `TF_DISABLE_POOL_ALLOCATOR` sont définies sur `1`. |
**PyTorch**
| Variable d'environnement | Description |
| --- | --- |
| `SAGEMAKER_TS_MAX_BATCH_DELAY` | Il s'agit du délai de traitement par lots maximal que TorchServe attend de recevoir. |
| `SAGEMAKER_TS_BATCH_SIZE` | Si TorchServe ne reçoit pas le nombre de demandes spécifié dans `batch_size` avant la fin du délai imparti, il envoie les demandes reçues au gestionnaire de modèles. |
| `SAGEMAKER_TS_MIN_WORKERS` | Nombre minimal d'applications de travail auquel TorchServe est autorisé à réduire la capacité. |
| `SAGEMAKER_TS_MAX_WORKERS` | Nombre maximal d'applications de travail auquel TorchServe est autorisé à augmenter la capacité. |
| `SAGEMAKER_TS_RESPONSE_TIMEOUT` | Délai après lequel l'inférence expire en l'absence de réponse. |
| `SAGEMAKER_TS_MAX_REQUEST_SIZE` | Taille de charge utile maximale pour TorchServe. |
| `SAGEMAKER_TS_MAX_RESPONSE_SIZE` | Taille de réponse maximale pour TorchServe. |
**Serveur multimodèle (MMS)**
| Variable d'environnement | Description |
| --- | --- |
| `job_queue_size` | Il est utile de régler ce paramètre dans un scénario où le type de la charge utile de demande d'inférence est important et si, en raison de cette taille, la consommation de mémoire de tas de la JVM dans laquelle cette file d'attente est maintenue peut être plus élevée. Dans l'idéal, vous pouvez réduire les besoins en mémoire de tas de la JVM et permettre aux applications de travail Python d'allouer plus de mémoire pour la prise en charge réelle du modèle. La JVM sert uniquement à recevoir les requêtes HTTP, à les mettre en file d'attente et à les distribuer aux applications de travail basées sur Python pour l'inférence. Si vous augmentez la variable `job_queue_size`, vous risquez d'augmenter la consommation de mémoire de tas de la JVM et, finalement, de priver l'hôte de la mémoire qui aurait pu être utilisée par les applications de travail Python. Par conséquent, soyez également prudent lorsque vous réglez ce paramètre. |
| `default_workers_per_model` | Ce paramètre est destiné au service du modèle backend et peut être utile à régler, car il s'agit du composant essentiel du service de modèle global, sur la base duquel Python traite les threads de génération pour chaque modèle. Si ce composant est plus lent (ou s'il n'est pas réglé correctement), le réglage frontal risque de ne pas être efficace. |
## Q : Comment puis-je m'assurer que mon conteneur prend en charge l'inférence asynchrone ?
Vous pouvez utiliser le même conteneur pour l'inférence asynchrone que pour l'inférence en temps réel ou la transformation par lots. Vous devez confirmer que les délais d'expiration et les limites de taille de charge utile sur votre conteneur sont définis pour gérer des charges utiles plus importantes et des délais d'expiration plus longs.
## Q : Quelles sont les limites spécifiques à l'inférence asynchrone et peuvent-elles être ajustées ?
Reportez-vous aux limites suivantes pour l'inférence asynchrone :
+ Limite de taille de charge utile : 1 Go
+ Limite de délai d'expiration : une demande peut prendre jusqu'à 60 minutes.
+ Durée de vie (TTL) des messages en file d'attente : 6 heures
+ Nombre de messages pouvant être placés dans Amazon SQS : illimité. Toutefois, il existe un quota de 120 000 messages en cours pour une file d’attente standard et de 20 000 pour une file d’attente FIFO.
## Q : Quelles métriques sont les meilleures à définir pour la mise à l'échelle automatique dans le cadre d'une inférence asynchrone ? Puis-je avoir plusieurs politiques de mise à l'échelle ?
En général, avec l'inférence asynchrone, vous pouvez monter en puissance en fonction des invocations ou des instances. Pour les métriques d'invocation, il est judicieux de consulter votre métrique `ApproximateBacklogSize`, qui correspond au nombre d'éléments de votre file d'attente qui doivent encore être traités. Vous pouvez utiliser cette métrique ou votre métrique `InvocationsPerInstance` pour comprendre à quel TPS vous êtes peut-être limité. Au niveau de l'instance, vérifiez votre type d'instance et son utilisation du CPU/GPU pour définir à quel moment monter en puissance. Si la capacité d'une instance unique dépasse 60-70 %, cela est souvent bon signe et indique que vous saturez votre matériel.
Nous ne recommandons pas l'utilisation de plusieurs politiques de mise à l'échelle, car cela peut engendrer des conflits et créer de la confusion au niveau du matériel, ce qui peut entraîner des retards lors d'une montée en puissance.
## Q : Pourquoi mon point de terminaison asynchrone résilie une instance en tant que `Unhealthy` et les demandes de mise à jour provenant de la mise à l'échelle automatique échouent ?
Vérifiez si votre conteneur est capable de gérer simultanément des demandes ping et d'invocation. Les demandes d’invocation SageMaker AI prennent environ 3 minutes, et pendant ce temps, plusieurs demandes ping finissent généralement par échouer en raison de l’expiration du délai imparti à SageMaker AI pour détecter votre conteneur comme `Unhealthy`.
## Q : `MaxConcurrentInvocationsPerInstance` peut-il fonctionner pour mon modèle de conteneur BYOC avec les paramètres ningx/gunicorn/flask ?
Oui. `MaxConcurrentInvocationsPerInstance` est une fonctionnalité des points de terminaison asynchrones. Cela ne dépend pas de l'implémentation du conteneur personnalisé. `MaxConcurrentInvocationsPerInstance` contrôle la fréquence à laquelle les demandes d'invocation sont envoyées au conteneur client. Si cette valeur est définie sur `1`, une seule demande est envoyée au conteneur à la fois, quel que soit le nombre d'applications de travail présentes sur le conteneur client.
## Q : Comment puis-je corriger les erreurs de serveur de modèle (500) sur mon point de terminaison asynchrone ?
L'erreur signifie que le conteneur client a renvoyé une erreur. SageMaker AI ne contrôle pas le comportement des conteneurs client. SageMaker AI renvoie simplement la réponse du `ModelContainer` et ne réessaie pas. Si vous le souhaitez, vous pouvez configurer l'invocation pour réessayer en cas d'échec. Nous vous suggérons d'activer la journalisation des conteneurs et de consulter vos journaux de conteneurs pour trouver la cause première de l'erreur 500 dans votre modèle. Vérifiez également les métriques `CPUUtilization` et `MemoryUtilization` correspondantes au point de défaillance. Vous pouvez également configurer [S3FailurePath](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AsyncInferenceOutputConfig.html#sagemaker-Type-AsyncInferenceOutputConfig-S3FailurePath) sur la réponse du modèle dans Amazon SNS dans le cadre des notifications d'erreur asynchrone pour enquêter sur les défaillances.
## Q : Comment puis-je savoir si `MaxConcurrentInvocationsPerInstance=1` prend effet ? Y a-t-il des métriques que je peux vérifier ?
Vous pouvez vérifier la métrique `InvocationsProcesssed`, qui doit correspondre au nombre d'invocations que vous prévoyez de traiter en une minute sur la base d'une simultanéité unique.
## Q : Comment puis-je suivre la réussite et l'échec de mes demandes d'invocation ? Quelles sont les bonnes pratiques ?
La bonne pratique consiste à activer Amazon SNS, qui est un service de notification destiné aux applications orientées messagerie, avec plusieurs abonnés demandant et recevant des notifications « push » de messages à caractère urgent via divers protocoles de transport, dont notamment HTTP, Amazon SQS et la messagerie électronique. L'inférence asynchrone publie des notifications lorsque vous créez un point de terminaison avec `CreateEndpointConfig` et spécifiez une rubrique Amazon SNS.
Pour utiliser Amazon SNS afin de vérifier les résultats de prédiction à partir de votre point de terminaison asynchrone, vous devez d'abord créer une rubrique, vous abonner à la rubrique, confirmer votre abonnement à la rubrique et noter l'Amazon Resource Name (ARN) de cette rubrique. Pour obtenir des informations détaillées sur la création, l'abonnement et la recherche de l'Amazon ARN d'une rubrique Amazon SNS, consultez [Configuration d'Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-configuring.html) dans le *Guide du développeur Amazon SNS*. Pour plus d'informations sur l'utilisation d'Amazon SNS avec l'inférence asynchrone, consultez [Vérification des résultats de prédiction](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-check-predictions.html).
## Q : Puis-je définir une politique de mise à l'échelle pour augmenter le nombre d'instances à partir de zéro après réception d'une nouvelle demande ?
Oui. L'inférence asynchrone fournit un mécanisme permettant de réduire à zéro le nombre d'instances en l'absence de demandes. Si votre point de terminaison a été réduit à zéro instance au cours de ces périodes, votre point de terminaison ne sera pas de nouveau augmenté tant que le nombre de demandes dans la file d'attente ne dépassera pas la cible spécifiée dans votre politique de mise à l'échelle. Cela peut entraîner de longs délais d'attente pour les demandes dans la file d'attente. Dans de tels cas, si vous souhaitez augmenter le nombre d'instances à partir de zéro pour les nouvelles demandes tout en restant sous la cible de file d'attente spécifiée, vous pouvez utiliser une politique de mise à l'échelle supplémentaire appelée `HasBacklogWithoutCapacity`. Pour plus d'informations sur la façon de définir cette politique de mise à l'échelle, consultez [Mise à l'échelle automatique d'un point de terminaison asynchrone](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-autoscale.html#async-inference-autoscale-scale-up).
## Q : Je reçois une erreur indiquant que le type d'instance n'est pas pris en charge pour l'inférence asynchrone. Quels sont les types d'instances pris en charge par l'inférence asynchrone ?
Pour obtenir la liste exhaustive des instances prises en charge par l'inférence asynchrone par région, consultez [Tarification d'Amazon SageMaker](https://aws.amazon.com/sagemaker/pricing/). Vérifiez si l'instance requise est disponible dans votre région avant de continuer.
# Transformation par lots à des fins d'inférence avec Amazon AI SageMaker
Utilisez la transformation par lots lorsque vous avez besoin d'effectuer les opérations suivantes :
+ Prétraiter les jeux de données afin d’éliminer le bruit ou les biais qui nuisent à l’entraînement ou à l’inférence à partir de votre jeu de données
+ Obtenir des inférences à partir de jeux de données volumineux
+ Exécuter l’inférence lorsque vous n’avez pas besoin d’un point de terminaison persistant
+ Associer les enregistrements d’entrée aux inférences pour faciliter l’interprétation des résultats
Pour filtrer des données d'entrée avant de procéder à des inférences ou pour associer des enregistrements d'entrée à des inférences relatives à ces enregistrements, consultez [Association de résultats de prédiction à des enregistrements d'entrée](batch-transform-data-processing.md). Par exemple, vous pouvez filtrer les données d'entrée pour fournir un contexte permettant de créer et d'interpréter les rapports sur les données de sortie.
**Topics**
+ [Utilisation de la transformation par lots pour obtenir des inférences à partir de jeux de données volumineux](#batch-transform-large-datasets)
+ [Accélération d’une tâche de transformation par lots](#batch-transform-reduce-time)
+ [Utilisation de la transformation par lots pour tester des variantes de production](#batch-transform-test-variants)
+ [Exemples de blocs-notes de transformation par lots](#batch-transform-notebooks)
+ [Association de résultats de prédiction à des enregistrements d'entrée](batch-transform-data-processing.md)
+ [Stockage dans une transformation par lots](batch-transform-storage.md)
+ [Résolution des problèmes](batch-transform-errors.md)
## Utilisation de la transformation par lots pour obtenir des inférences à partir de jeux de données volumineux
La transformation par lots gère automatiquement le traitement des jeux de données volumineux dans les limites des paramètres spécifiés. Par exemple, supposons que vous disposez d’un fichier de jeux de données, `input1.csv`, stocké dans un compartiment S3. Le contenu du fichier d'entrée peut ressembler à l'exemple suivant :
```
Record1-Attribute1, Record1-Attribute2, Record1-Attribute3, ..., Record1-AttributeM
Record2-Attribute1, Record2-Attribute2, Record2-Attribute3, ..., Record2-AttributeM
Record3-Attribute1, Record3-Attribute2, Record3-Attribute3, ..., Record3-AttributeM
...
RecordN-Attribute1, RecordN-Attribute2, RecordN-Attribute3, ..., RecordN-AttributeM
```
Lorsqu'une tâche de transformation par lots démarre, l' SageMaker IA démarre des instances de calcul et répartit la charge de travail d'inférence ou de prétraitement entre elles. La transformation par lots partitionne les objets Amazon S3 dans l'entrée par clé et mappe les objets Amazon S3 aux instances. Lorsque vous disposez de plusieurs fichiers, la première instance peut traiter `input1.csv` et la seconde instance peut traiter un autre fichier nommé `input2.csv`. Quand vous disposez d’un fichier d’entrée, mais que vous initialisez plusieurs instances de calcul, une seule d’entre elles traite le fichier d’entrée. Les autres instances restent inactives.
Vous pouvez également fractionner les fichiers d'entrée en mini-lots. Par exemple, vous pouvez créer un mini-lot à partir de `input1.csv` en incluant uniquement deux des fichiers.
```
Record3-Attribute1, Record3-Attribute2, Record3-Attribute3, ..., Record3-AttributeM
Record4-Attribute1, Record4-Attribute2, Record4-Attribute3, ..., Record4-AttributeM
```
**Note**
SageMaker L'IA traite chaque fichier d'entrée séparément. Il ne combine pas les mini-lots de différents fichiers d'entrée pour respecter la limite [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB ).
Pour diviser les fichiers d'entrée en mini-lots lorsque vous créez une tâche de transformation par lots, définissez la valeur du [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType )paramètre sur. `Line` SageMaker AI utilise l'intégralité du fichier d'entrée dans une seule requête lorsque :
+ `SplitType` est défini sur `None`.
+ Il n’est pas possible de fractionner un fichier d’entrée en mini-lots.
. Notez que Batch Transform ne prend pas en charge les entrées au format CSV contenant des caractères de saut de ligne intégrés. Vous pouvez contrôler la taille des mini-lots en utilisant les paramètres `[BatchStrategy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-BatchStrategy)` et `[MaxPayloadInMB](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxPayloadInMB)`. `MaxPayloadInMB` ne doit pas dépasser 100 Mo. Si vous spécifiez le paramètre `[MaxConcurrentTransforms](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxConcurrentTransforms)` facultatif, puis la valeur de `(MaxConcurrentTransforms * MaxPayloadInMB)` ne doit pas non plus dépasser 100 Mo.
Quand la tâche de transformation par lots traite correctement tous les enregistrements d’un fichier d’entrée, elle crée un fichier de sortie. Celui-ci porte le même nom et la même extension de fichier `.out`. Lorsqu'il y a plusieurs fichiers d'entrée, comme `input1.csv` et `input2.csv`, les fichiers de sortie sont nommés `input1.csv.out` et `input2.csv.out`. La tâche de transformation par lots stocke les fichiers de sortie à l'emplacement spécifié dans Amazon S3, par exemple `s3://amzn-s3-demo-bucket/output/`.
Dans un fichier de sortie, les prédictions sont répertoriées dans le même ordre que les enregistrements correspondants dans le fichier d'entrée. Le fichier de sortie `input1.csv.out`, basé sur le fichier d'entrée indiqué précédemment, se présente comme suit.
```
Inference1-Attribute1, Inference1-Attribute2, Inference1-Attribute3, ..., Inference1-AttributeM
Inference2-Attribute1, Inference2-Attribute2, Inference2-Attribute3, ..., Inference2-AttributeM
Inference3-Attribute1, Inference3-Attribute2, Inference3-Attribute3, ..., Inference3-AttributeM
...
InferenceN-Attribute1, InferenceN-Attribute2, InferenceN-Attribute3, ..., InferenceN-AttributeM
```
Si vous définissez [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ) sur `Line`, vous pouvez définir le paramètre [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ) sur `Line` pour concaténer les enregistrements de sortie à l'aide d'un délimiteur de ligne. Cela ne modifie pas le nombre de fichiers de sortie. Le nombre de fichiers de sortie est égal au nombre de fichiers d'entrée, et l'utilisation de `AssembleWith` ne fusionne pas les fichiers. Si vous ne spécifiez pas le paramètre `AssembleWith`, les enregistrements de sortie sont concaténés par défaut dans un format binaire.
Lorsque les données d'entrée sont très volumineuses et sont transmises à l'aide de l'encodage segmenté HTTP, pour diffuser les données vers l'algorithme, définissez [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB) sur `0`. Les algorithmes intégrés d'Amazon SageMaker AI ne prennent pas en charge cette fonctionnalité.
Pour plus d'informations sur l'utilisation de l'API pour créer une tâche de transformation par lots, consultez l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html). Pour plus d’informations sur la relation entre les objets en entrée et en sortie d’une transformation par lots, consultez [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html). Pour obtenir un exemple d’utilisation de la transformation par lots, consultez [(Facultatif) Faire une prédiction avec la transformation par lots](ex1-model-deployment.md#ex1-batch-transform).
## Accélération d’une tâche de transformation par lots
Si vous utilisez l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html), vous pouvez réduire le temps nécessaire à l’exécution des tâches de transformation par lots en utilisant des valeurs optimales pour les paramètres. Cela inclut des paramètres tels que [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB), [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxConcurrentTransforms](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxConcurrentTransforms) ou [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-BatchStrategy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-BatchStrategy). Le rapport qualité-prix idéal pour `MaxConcurrentTransforms` est égal au nombre de travailleurs de calcul dans la tâche de transformation par lots.
Si vous utilisez la console SageMaker AI, spécifiez ces valeurs de paramètres optimales dans la section **Configuration supplémentaire de la page de configuration** de la **tâche de transformation par lots**. SageMaker L'IA trouve automatiquement les paramètres optimaux pour les algorithmes intégrés. Pour les algorithmes personnalisés, indiquez les valeurs suivantes par l'intermédiaire du point de terminaison [execution-parameters](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-batch-code.html#your-algorithms-batch-code-how-containe-serves-requests).
## Utilisation de la transformation par lots pour tester des variantes de production
Pour tester différents modèles ou différentes valeurs d’hyperparamètres, créez une tâche de transformation pour chaque nouvelle variante de modèle et utilisez un jeu de données de validation. Pour chaque tâche de transformation, spécifiez un nom et un emplacement de modèle uniques dans Amazon S3 pour le fichier de sortie. Pour analyser les résultats, utilisez [Journaux et métriques des pipelines d’inférence](inference-pipeline-logs-metrics.md).
## Exemples de blocs-notes de transformation par lots
Pour un exemple de bloc-notes utilisant la transformation par lots, consultez [Batch Transform with PCA and DBSCAN Movie Clusters](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_batch_transform/introduction_to_batch_transform/batch_transform_pca_dbscan_movie_clusters.html). Ce bloc-notes utilise la transformation par lots avec un modèle d’analyse des composants principaux (PCA) pour réduire les données dans une matrice d’évaluation utilisateur-article. Il montre ensuite l’application d’un algorithme de regroupement spatial d’applications basé sur la densité avec bruit (DBSCAN) pour regrouper les films en clusters.
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) Après avoir créé et ouvert une instance de bloc-notes, cliquez sur l'onglet **SageMakerExemples** pour voir la liste de tous les exemples d' SageMaker IA. Vous trouverez des exemples de bloc-notes de modélisation des rubriques qui utilisent les algorithmes NTM dans la section **Advanced functionality (Fonctionnalité avancée)**. Pour ouvrir un bloc-notes, choisissez l’onglet **Use (Utiliser)** correspondant, puis **Create copy (Créer une copie)**.
# Association de résultats de prédiction à des enregistrements d'entrée
Lorsque vous effectuez des prédictions sur un ensemble de données volumineux, vous pouvez exclure les attributs qui ne sont pas nécessaires pour les prédictions. Une fois les prédictions effectuées, vous souhaitez dans la plupart des cas associer certains des attributs exclus avec ces prédictions ou avec d'autres données d'entrée dans votre rapport. En utilisant la transformation par lots pour effectuer ces étapes de traitement des données, vous pouvez souvent éliminer d'autres prétraitement ou post-traitement. Vous pouvez utiliser les fichiers d'entrée au format JSON et CVS uniquement.
**Topics**
+ [Flux de travail pour l'association d'inférences à des enregistrements d'entrée](#batch-transform-data-processing-workflow)
+ [Utilisation du traitement des données dans les tâches de transformation par lots](#batch-transform-data-processing-steps)
+ [JSONPath Opérateurs pris en charge](#data-processing-operators)
+ [Exemples de transformation par lots](#batch-transform-data-processing-examples)
## Flux de travail pour l'association d'inférences à des enregistrements d'entrée
Le schéma suivant illustre le flux de travail pour associer des inférences à des enregistrements d'entrée.
![\[Flux de travail pour associer des inférences à des enregistrements d’entrée.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/batch-transform-data-processing.png)
Pour associer des inférences à des données d'entrée, il y a trois étapes principales :
1. Filtrez les données d'entrée qui ne sont pas nécessaires à l'inférence avant de les transmettre à la tâche de transformation par lots. Utilisez le paramètre [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-InputFilter ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-InputFilter ) pour déterminer les attributs à utiliser en tant qu'entrée pour le modèle.
1. Associez les données d'entrée aux résultats de l'inférence. Utilisez le paramètre [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-JoinSource ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-JoinSource ) pour combiner les données d'entrée avec l'inférence.
1. Filtrez les données associées afin de conserver les entrées nécessaires pour indiquer le contexte de l'interprétation des prédictions dans les rapports. Utilisez [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-OutputFilter ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-OutputFilter ) pour stocker la partie spécifiée du jeu de données associé dans le fichier de sortie.
## Utilisation du traitement des données dans les tâches de transformation par lots
Lors de la création d'une tâche de transformation par lots avec [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html) pour traiter des données :
1. Spécifiez la partie de l'entrée à transmettre au modèle avec le paramètre `InputFilter` dans la structure de données `DataProcessing`.
1. Associez les données d'entrée brutes aux données transformées avec le paramètre `JoinSource`.
1. Indiquez la partie de l'entrée associée et des données transformées issues de la tâche de transformation par lots à inclure dans le fichier de sortie avec le paramètre `OutputFilter`.
1. Choisissez des fichiers au format JSON ou CSV pour l'entrée :
+ Pour les fichiers d'entrée au format JSON ou JSON Lines, SageMaker AI ajoute l'`SageMakerOutput`attribut au fichier d'entrée ou crée un nouveau fichier de sortie JSON avec les `SageMakerInput` attributs et. `SageMakerOutput` Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataProcessing.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataProcessing.html).
+ Pour les fichiers d'entrée au format CSV, les données d'entrée associées sont suivies des données transformées et la sortie est un fichier CSV.
Si vous utilisez un algorithme avec la structure `DataProcessing`, il doit prendre en charge le format que vous avez choisi pour les fichiers d'entrée *et* les fichiers de sortie. Par exemple, avec le champ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html) de l'API `CreateTransformJob`, vous devez configurer les paramètres [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType) et [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-Accept](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-Accept) sur l'une des valeurs suivantes : `text/csv`, `application/json` ou `application/jsonlines`. La syntaxe permettant de spécifier des colonnes dans un fichier CSV est différente de la syntaxe permettant de spécifier des attributs dans un fichier JSON. L'utilisation d'une syntaxe incorrecte provoque une erreur. Pour de plus amples informations, veuillez consulter [Exemples de transformation par lots](#batch-transform-data-processing-examples). Pour plus d'informations sur les formats de fichier d'entrée et de sortie pour les algorithmes intégrés, consultez [Algorithmes intégrés et modèles préentraînés dans Amazon SageMaker](algos.md).
Les délimiteurs d'enregistrement pour l'entrée et la sortie doivent également être cohérents avec l'entrée de fichier que vous avez choisie. Le paramètre [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType) indique le mode de fractionnement des enregistrements dans le jeu de données d'entrée. Le paramètre [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ) indique le mode de reconstitution des enregistrements pour la sortie. Si vous définissez les formats d'entrée et de sortie sur `text/csv`, vous devez également définir les paramètres `SplitType` et `AssembleWith` sur `line`. Si vous définissez les formats d'entrée et de sortie sur `application/jsonlines`, vous pouvez définir les paramètres `SplitType` et `AssembleWith` sur `line`.
Pour les fichiers CSV, vous ne pouvez pas utiliser de caractères de saut de ligne intégrés. Pour les fichiers JSON, le nom d'attribut `SageMakerOutput` est réservé à la sortie. Le fichier d'entrée JSON ne peut pas avoir d'attribut portant ce nom. Si c'est le cas, les données du fichier d'entrée risquent d'être écrasées.
## JSONPath Opérateurs pris en charge
Pour filtrer et joindre les données d'entrée et les inférer, utilisez une JSONPath sous-expression. SageMaker L'IA ne prend en charge qu'un sous-ensemble des JSONPath opérateurs définis. Le tableau suivant répertorie les JSONPath opérateurs pris en charge. Pour les données CSV, chaque ligne est considérée comme un tableau JSON, de sorte que seule la base d'index JSONPaths peut être appliquée`$[0]`, par exemple`$[1:]`. Les données CSV doivent également respecter le [format RFC](https://tools.ietf.org/html/rfc4180).
| JSONPath Opérateur | Description | Exemple |
| --- | --- | --- |
| \$1 | Élément racine d'une requête. Cet opérateur est requis au début de toutes les expressions de chemin d'accès. | \$1 |
| . | Élément enfant à notation point. | `$.id` |
| \$1 | Caractère générique. Utilisez-le pour remplacer un nom d'attribut ou une valeur numérique. | `$.id.*` |
| ['' (,'')] | Élément à notation crochet ou éléments enfants multiples. | `$['id','SageMakerOutput']` |
| [ (,)] | Index ou tableau d'index. Les valeurs d'index négatives sont également prises en charge. Un index `-1` correspond au dernier élément d'un tableau. | `$[1]` , `$[1,3,5]` |
| [:] | Opérateur de découpage de tableau. La méthode array slice() extrait une section d'un tableau et renvoie un nouveau tableau. Si vous omettez**, SageMaker AI utilise le premier élément du tableau. Si vous omettez**, SageMaker AI utilise le dernier élément du tableau. | `$[2:5]`, `$[:5]`, `$[2:]` |
Lorsque vous utilisez la notation entre crochets pour spécifier plusieurs éléments enfants d'un champ donné, l'imbrication supplémentaire d'enfants entre parenthèses n'est pas prise en charge. Par exemple, `$.field1.['child1','child2']` est pris en charge alors qu'`$.field1.['child1','child2.grandchild']` ne l'est pas.
Pour plus d'informations sur JSONPath les opérateurs, reportez-vous à [JsonPath](https://github.com/json-path/JsonPath)la section suivante GitHub.
## Exemples de transformation par lots
Les exemples suivants illustrent les méthodes courantes permettant d'associer des données d'entrée aux résultats de prédiction.
**Topics**
+ [Exemple : Inférences de sortie uniquement](#batch-transform-data-processing-example-default)
+ [Exemple : inférences de sortie avec des données d'entrée](#batch-transform-data-processing-example-all)
+ [Exemple : inférences de sortie avec des données d'entrée et exclusion de la colonne ID de l'entrée (CSV)](#batch-transform-data-processing-example-select-csv)
+ [Exemple : inférences de sortie jointes à une colonne ID et exclusion de la colonne ID de l'entrée (CSV)](#batch-transform-data-processing-example-select-json)
### Exemple : Inférences de sortie uniquement
Par défaut, le paramètre [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-DataProcessing](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-DataProcessing) ne joint pas les résultats d'inférence à l'entrée. Il génère uniquement les résultats de l'inférence.
Si vous souhaitez spécifier explicitement de ne pas associer les résultats aux entrées, utilisez le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) et spécifiez les paramètres suivants dans un appel de transformateur.
```
sm_transformer = sagemaker.transformer.Transformer(…)
sm_transformer.transform(…, input_filter="$", join_source= "None", output_filter="$")
```
Pour générer des inférences à l'aide du AWS SDK pour Python, ajoutez le code suivant à votre CreateTransformJob demande. Le code suivant imite le comportement par défaut.
```
{
"DataProcessing": {
"InputFilter": "$",
"JoinSource": "None",
"OutputFilter": "$"
}
}
```
### Exemple : inférences de sortie avec des données d'entrée
Si vous utilisez le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) pour combiner les données d'entrée avec les inférences du fichier de sortie, spécifiez les `accept` paramètres `assemble_with` et lors de l'initialisation de l'objet transformateur. Lorsque vous utilisez l'appel de transformation, spécifiez `Input` pour le paramètre `join_source` et spécifiez également le paramètres `split_type` et `content_type`. Le paramètre `split_type` doit avoir la même valeur que `assemble_with`, et le paramètre `content_type` doit avoir la même valeur que `accept`. Pour plus d'informations sur les paramètres et leurs valeurs acceptées, consultez la page [Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html#sagemaker.transformer.Transformer) du *SDK Amazon SageMaker AI Python*.
```
sm_transformer = sagemaker.transformer.Transformer(…, assemble_with="Line", accept="text/csv")
sm_transformer.transform(…, join_source="Input", split_type="Line", content_type="text/csv")
```
Si vous utilisez le AWS SDK pour Python (Boto 3), associez toutes les données d'entrée à l'inférence en ajoutant le code suivant à votre demande. [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html) Les valeurs pour `Accept` et `ContentType` doivent correspondre, et les valeurs pour `AssembleWith` et `SplitType` doivent également correspondre.
```
{
"DataProcessing": {
"JoinSource": "Input"
},
"TransformOutput": {
"Accept": "text/csv",
"AssembleWith": "Line"
},
"TransformInput": {
"ContentType": "text/csv",
"SplitType": "Line"
}
}
```
Pour le format JSON ou JSON Lines, les résultats figurent dans la clé `SageMakerOutput` du fichier JSON en entrée. Par exemple, si l'entrée est un fichier JSON qui contient la paire clé-valeur `{"key":1}`, le résultat de la transformation des données peut être `{"label":1}`.
SageMaker L'IA enregistre les deux dans le fichier d'entrée de la `SageMakerInput` clé.
```
{
"key":1,
"SageMakerOutput":{"label":1}
}
```
**Note**
Le résultat associé pour JSON doit être un objet de type paire clé-valeur. Si l'entrée n'est pas un objet de paire clé-valeur, SageMaker AI crée un nouveau fichier JSON. Dans le nouveau fichier JSON, les données d'entrée sont stockées dans la clé `SageMakerInput` et les résultats sont stockés dans la valeur `SageMakerOutput`.
Pour un fichier CSV, si l'enregistrement est `[1,2,3]` et le résultat d'étiquette est `[1]` par exemple, le fichier de sortie contient alors `[1,2,3,1]`.
### Exemple : inférences de sortie avec des données d'entrée et exclusion de la colonne ID de l'entrée (CSV)
Si vous utilisez le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) pour associer vos données d'entrée à la sortie d'inférence tout en excluant une colonne ID de l'entrée du transformateur, spécifiez les mêmes paramètres que ceux de l'exemple précédent ainsi qu'une JSONPath sous-expression pour le `input_filter` dans votre appel de transformateur. Par exemple, si vos données d'entrée incluent cinq colonnes (la première étant la colonne ID), utilisez la demande de transformateur suivante pour sélectionner toutes les colonnes à l'exception de la colonne ID comme fonctions. Le transformateur sort toujours toutes les colonnes d'entrée jointes aux inférences. Pour plus d'informations sur les paramètres et leurs valeurs acceptées, consultez la page [Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html#sagemaker.transformer.Transformer) du *SDK Amazon SageMaker AI Python*.
```
sm_transformer = sagemaker.transformer.Transformer(…, assemble_with="Line", accept="text/csv")
sm_transformer.transform(…, split_type="Line", content_type="text/csv", input_filter="$[1:]", join_source="Input")
```
Si vous utilisez le AWS SDK pour Python (Boto 3), ajoutez le code suivant à votre `[ CreateTransformJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)` demande.
```
{
"DataProcessing": {
"InputFilter": "$[1:]",
"JoinSource": "Input"
},
"TransformOutput": {
"Accept": "text/csv",
"AssembleWith": "Line"
},
"TransformInput": {
"ContentType": "text/csv",
"SplitType": "Line"
}
}
```
Pour spécifier des colonnes dans SageMaker AI, utilisez l'index des éléments du tableau. La première colonne est l'index 0, la deuxième est l'index 1 et la sixième est l'index 5.
Pour exclure la première colonne de l'entrée, définissez `[InputFilter](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-InputFilter )` sur `"$[1:]"`. Les deux points (`:`) indiquent à SageMaker AI d'inclure tous les éléments compris entre deux valeurs, y compris. Par exemple, `$[1:4]` spécifie les colonnes 2 à 5.
Si vous omettez le nombre après les deux points, par exemple, `[5:]`, le sous-ensemble inclut toutes les colonnes, de la sixième à la dernière. Si vous omettez le nombre avant les deux points, par exemple, `[:5]`, le sous-ensemble inclut toutes les colonnes, de la première (index 0) à la sixième.
### Exemple : inférences de sortie jointes à une colonne ID et exclusion de la colonne ID de l'entrée (CSV)
Si vous utilisez le [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable), vous pouvez spécifier la sortie pour joindre uniquement des colonnes d'entrée spécifiques (comme la colonne ID) aux inférences en spécifiant le `output_filter` dans l'appel du transformateur. `output_filter`Utilise une JSONPath sous-expression pour spécifier les colonnes à renvoyer en sortie après avoir joint les données d'entrée aux résultats de l'inférence. La demande suivante montre comment faire des prédictions tout en excluant une colonne ID, puis joindre la colonne ID avec les inférences. Notez que dans l'exemple suivant, la dernière colonne (`-1`) de la sortie contient les inférences. Si vous utilisez des fichiers JSON, SageMaker AI stocke les résultats de l'inférence dans l'attribut`SageMakerOutput`. Pour plus d'informations sur les paramètres et leurs valeurs acceptées, consultez la page [Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html#sagemaker.transformer.Transformer) du *SDK Amazon SageMaker AI Python*.
```
sm_transformer = sagemaker.transformer.Transformer(…, assemble_with="Line", accept="text/csv")
sm_transformer.transform(…, split_type="Line", content_type="text/csv", input_filter="$[1:]", join_source="Input", output_filter="$[0,-1]")
```
Si vous utilisez le AWS SDK pour Python (Boto 3), joignez uniquement la colonne ID avec les inférences en ajoutant le code suivant à votre demande. [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)
```
{
"DataProcessing": {
"InputFilter": "$[1:]",
"JoinSource": "Input",
"OutputFilter": "$[0,-1]"
},
"TransformOutput": {
"Accept": "text/csv",
"AssembleWith": "Line"
},
"TransformInput": {
"ContentType": "text/csv",
"SplitType": "Line"
}
}
```
**Avertissement**
Si vous utilisez un fichier d'entrée au format JSON, le fichier ne peut pas contenir le nom d'attribut `SageMakerOutput`. Le nom d'attribut est réservé aux interférences présentes dans le fichier de sortie. Si votre fichier d'entrée au format JSON contient un attribut portant ce nom, les valeurs du fichier d'entrée peuvent être remplacées par l'inférence.
# Stockage dans une transformation par lots
Lorsque vous exécutez une tâche de transformation par lots, Amazon SageMaker AI associe un volume de stockage Amazon Elastic Block Store aux instances Amazon EC2 qui traitent votre tâche. Le volume stocke votre modèle et la taille du volume de stockage est fixée à 30 Go. Vous avez la possibilité de chiffrer votre modèle au repos dans le volume de stockage.
**Note**
Si vous possédez un modèle de grande taille, vous risquez de rencontrer un `InternalServerError`.
Pour plus d’informations sur le stockage et les fonctions Amazon EBS, consultez les pages suivantes :
+ [Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html) dans le Guide de l’utilisateur Amazon EC2
+ [Volumes Amazon EBS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volumes.html) dans le Guide de l’utilisateur Amazon EC2
**Note**
Les instances G4dn sont équipées de leur propre stockage SSD local. Pour en savoir plus sur les instances G4dn, consultez la page [Instances G4 d'Amazon EC2](https://aws.amazon.com/ec2/instance-types/g4/).
# Résolution des problèmes
Si vous rencontrez des erreurs dans Amazon SageMaker AI Batch Transform, consultez les conseils de dépannage suivants.
## Erreurs de délai d'expiration max.
Si vous obtenez des erreurs de délai d'expiration max. lors de l'exécution de tâches de transformation par lots, essayez ce qui suit :
+ Commencez par l'enregistrement unique `[BatchStrategy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-BatchStrategy)`, une taille de lot égale ou inférieure à la valeur par défaut (6 Mo) que vous spécifiez dans le paramètre `[MaxPayloadInMB](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxPayloadInMB)`, et un petit exemple de jeu de données. Réglez le paramètre de délai d'expiration maximal `[InvocationsTimeoutInSeconds](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelClientConfig.html#sagemaker-Type-ModelClientConfig-InvocationsTimeoutInSeconds)` (qui est d'une heure maximum) jusqu'à ce que vous receviez une réponse d'appel réussie.
+ Une fois que vous avez reçu une réponse d'appel réussie, augmentez la valeur `MaxPayloadInMB` (qui a une valeur maximale de 100 Mo) et les paramètres `InvocationsTimeoutInSeconds` pour déterminer la taille de lot maximale pouvant prendre en charge le délai d'expiration du modèle souhaité. Vous pouvez utiliser l'enregistrement unique ou multiple `BatchStrategy` à cette étape.
**Note**
Le dépassement de la limite `MaxPayloadInMB` provoque une erreur. Cette erreur peut se produire lorsqu'un jeu de données volumineux ne peut pas être fractionné, que le paramètre `SplitType` est défini sur none (aucun) ou que des enregistrements individuels dans le jeu de données dépassent la limite.
+ (Facultatif) Réglez le paramètre `[MaxConcurrentTransforms](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxConcurrentTransforms)`, qui spécifie le nombre maximal de demandes parallèles pouvant être envoyées à chaque instance dans une tâche de transformation par lots. Toutefois, la valeur de `MaxConcurrentTransforms * MaxPayloadInMB` ne doit pas dépasser 100 Mo.
## Sortie incomplète
SageMaker L'IA utilise l'[API Amazon S3 Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/dev/uploadobjusingmpu.html) pour télécharger les résultats d'une tâche de transformation par lots vers Amazon S3. En cas d'erreur, les résultats téléchargés sont supprimés d'Amazon S3. Dans certains cas, par exemple une indisponibilité du réseau, un chargement partitionné incomplet peut être conservé dans Amazon S3. Un téléchargement incomplet peut également se produire si vous avez plusieurs fichiers d'entrée mais que certains fichiers ne peuvent pas être traités par SageMaker AI Batch Transform. Les fichiers d'entrée qui n'ont pas pu être traités n'auront pas de fichiers de sortie correspondants dans Amazon S3.
Pour éviter les frais de stockage, nous vous recommandons d'ajouter la [stratégie de compartiment S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config) aux règles de cycle de vie du compartiment S3. Cette stratégie supprime les chargements partitionnés incomplets qui pourraient être stockés dans le compartiment S3. Pour plus d’informations, consultez [Gestion du cycle de vie des objets](https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lifecycle-mgmt.html).
## La tâche s'affiche sous la forme `failed`
Si une tâche de transformation par lots ne parvient pas à traiter un fichier d'entrée en raison d'un problème lié à l'ensemble de données, SageMaker AI marque la tâche comme`failed`. Si un fichier d'entrée contient un enregistrement incorrect, la tâche de transformation ne crée pas de fichier de sortie pour ce fichier d'entrée, car cela l'empêche de conserver le même ordre dans les données transformées que dans le fichier d'entrée. Lorsque votre ensemble de données comporte plusieurs fichiers d'entrée, une tâche de transformation continue à traiter les fichiers d'entrée même si l'un de ces fichiers ne peut pas être traité. Les fichiers traités génèrent quand même des résultats exploitables.
Si vous utilisez vos propres algorithmes, vous pouvez utiliser un espace réservé au texte, par exemple `ERROR`, lorsque l'algorithme détecte un mauvais enregistrement dans un fichier d'entrée. Par exemple, si le dernier enregistrement d'un ensemble de données est mauvais, l'algorithme place le texte de l'espace réservé pour cet enregistrement dans le fichier de sortie.
# Parallélisme des modèles et inférence de modèles de grande taille
Amazon SageMaker AI inclut des conteneurs de deep learning (DLC) spécialisés, des bibliothèques et des outils pour le parallélisme des modèles et l’inférence de modèles de grande taille (LMI). Dans les sections suivantes, vous trouverez des ressources pour bien démarrer avec l’inférence de modèles de grande taille sur SageMaker AI.
**Topics**
+ [Documentation du conteneur d’inférence de modèles de grande taille (LMI)](large-model-inference-container-docs.md)
+ [Paramètres de point de terminaison SageMaker AI pour l’inférence de modèles de grande taille](large-model-inference-hosting.md)
+ [Déploiement de modèles non compressés](large-model-inference-uncompressed.md)
+ [Déployez de grands modèles à des fins d'inférence avec TorchServe](large-model-inference-tutorials-torchserve.md)
# Documentation du conteneur d’inférence de modèles de grande taille (LMI)
La [documentation du conteneur LMI](https://docs.djl.ai/master/docs/serving/serving/docs/lmi/index.html) est disponible sur le site de documentation de la bibliothèque Deep Java.
La documentation est destinée aux développeurs, aux scientifiques des données et aux ingénieurs en apprentissage automatique qui ont besoin de déployer et d'optimiser de grands modèles de langage (LLMs) sur Amazon SageMaker AI. Il vous aide à utiliser les conteneurs LMI, qui sont des conteneurs Docker spécialisés pour l'inférence LLM, fournis par. AWS Elle fournit une vue d’ensemble, des guides de déploiement, des guides de l’utilisateur pour les bibliothèques d’inférence prises en charge et des didacticiels avancés.
En utilisant la documentation du conteneur LMI, vous pouvez :
+ comprendre les composants et l’architecture des conteneurs LMI ;
+ découvrir comment sélectionner le type d’instance et le système dorsal adaptés à votre cas d’utilisation ;
+ Configuration et déploiement LLMs sur l' SageMaker IA à l'aide de conteneurs LMI
+ optimiser les performances en utilisant des caractéristiques comme la quantification, le parallélisme de tenseur et le traitement par lots continu ;
+ Comparez et ajustez vos points de terminaison d' SageMaker IA pour un débit et une latence optimaux
# Paramètres de point de terminaison SageMaker AI pour l’inférence de modèles de grande taille
Vous pouvez personnaliser les paramètres suivants pour faciliter l’inférence de modèles de grande taille (LMI) à faible latence avec SageMaker AI :
+ **Taille maximale du volume Amazon EBS sur l'instance (`VolumeSizeInGB`)** : si la taille du modèle est supérieure à 30 Go et que vous utilisez une instance sans disque local, vous devez augmenter ce paramètre pour qu'il soit légèrement supérieur à la taille de votre modèle.
+ **Quota d'expiration de surveillance de l'état (`ContainerStartupHealthCheckTimeoutInSeconds`)** : si votre conteneur est correctement configuré et que les journaux CloudWatch indiquent un quota d'expiration pour la surveillance de l'état, vous devez augmenter ce quota afin que le conteneur dispose de suffisamment de temps pour répondre aux surveillances de l'état.
+ **Quota d'expiration de téléchargement de modèle (`ModelDataDownloadTimeoutInSeconds`)** : si la taille de votre modèle est supérieure à 40 Go, vous devez augmenter ce quota afin de disposer de suffisamment de temps pour télécharger le modèle depuis Amazon S3 vers l'instance.
L'extrait de code suivant montre comment configurer par programmation les paramètres susmentionnés. Remplacez le *texte des espaces réservés en italique* dans l'exemple par vos propres informations.
```
import boto3
aws_region = "aws-region"
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name = "endpoint-name"
# Create an endpoint config name.
endpoint_config_name = "endpoint-config-name"
# The name of the model that you want to host.
model_name = "the-name-of-your-model"
instance_type = "instance-type"
sagemaker_client.create_endpoint_config(
EndpointConfigName = endpoint_config_name
ProductionVariants=[
{
"VariantName": "variant1", # The name of the production variant.
"ModelName": model_name,
"InstanceType": instance_type, # Specify the compute instance type.
"InitialInstanceCount": 1, # Number of instances to launch initially.
"VolumeSizeInGB": 256, # Specify the size of the Amazon EBS volume.
"ModelDataDownloadTimeoutInSeconds": 1800, # Specify the model download timeout in seconds.
"ContainerStartupHealthCheckTimeoutInSeconds": 1800, # Specify the health checkup timeout in seconds
},
],
)
sagemaker_client.create_endpoint(EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name)
```
Pour plus d’informations sur les clés `ProductionVariants`, consultez [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html).
Pour des exemples illustrant comment obtenir une inférence à faible latence avec de grands modèles, consultez [Exemples d’inférence d’IA générative sur Amazon SageMaker AI](https://github.com/aws-samples/sagemaker-genai-hosting-examples/tree/main) dans le référentiel GitHub aws-samples.
# Déploiement de modèles non compressés
Lors du déploiement de modèles de machine learning, l'une des options consiste à archiver et à compresser les artefacts du modèle dans un format `tar.gz`. Bien que cette méthode fonctionne bien pour les petits modèles, la compression d'un artefact de modèle de grande taille contenant des centaines de milliards de paramètres, puis sa décompression sur un point de terminaison, peut prendre un temps considérable. Pour l'inférence de modèles de grande taille, nous vous recommandons de déployer un modèle de machine learning non compressé. Ce guide explique comment déployer un modèle de machine learning non compressé.
Pour déployer des modèles de machine learning non compressés, téléchargez tous les artefacts du modèle sur Amazon S3 et organisez-les sous un préfixe Amazon S3 commun. Un préfixe Amazon S3 est une chaîne de caractères située au début du nom d'une clé d'objet Amazon S3, séparée du reste du nom par un délimiteur. Pour plus d'informations sur les préfixes Amazon S3, consultez [Organisation des objets à l'aide de préfixes](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-prefixes.html).
Pour déployer avec SageMaker AI, vous devez utiliser une barre oblique (/) comme délimiteur. Vous devez vous assurer que seuls les artefacts associés à votre modèle de machine learning sont organisés avec le préfixe. Pour les modèles de machine learning dotés d'un seul artefact non compressé, le préfixe sera identique au nom de la clé. Vous pouvez vérifier quels objets sont associés à votre préfixe avec l'AWS CLI :
```
aws s3 ls --recursive s3://bucket/prefix
```
Après avoir chargé les artefacts du modèle sur Amazon S3 et les avoir organisés sous un préfixe commun, vous pouvez spécifier leur emplacement dans le champ [ModelDataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelDataSource.html) lorsque vous invoquez la demande [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html). SageMaker AI téléchargera automatiquement les artefacts du modèle non compressés pour `/opt/ml/model` à des fins d’inférence. Pour plus d’informations sur les règles appliquées par SageMaker AI lors du téléchargement des artefacts, consultez [S3ModelDataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3ModelDataSource.html).
L'extrait de code suivant montre comment invoquer l'API `CreateModel` lors du déploiement d'un modèle non compressé. Remplacez le *texte utilisateur en italique* par vos propres informations.
```
model_name = "model-name"
sagemaker_role = "arn:aws:iam::123456789012:role/SageMakerExecutionRole"
container = "123456789012.dkr.ecr.us-west-2.amazonaws.com/inference-image:latest"
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
"Image": container,
"ModelDataSource": {
"S3DataSource": {
"S3Uri": "s3://amzn-s3-demo-bucket/prefix/to/model/data/",
"S3DataType": "S3Prefix",
"CompressionType": "None",
},
},
},
)
```
L'exemple susmentionné suppose que les artefacts de votre modèle sont organisés sous un préfixe commun. Si, au contraire, votre artefact de modèle est un seul objet Amazon S3 non compressé, changez `"S3Uri"` pour pointer vers l'objet Amazon S3, puis remplacez `"S3DataType"` par `"S3Object"`.
**Note**
Actuellement, vous ne pouvez pas utiliser `ModelDataSource` avec AWS Marketplace, la transformation par lots SageMaker AI, les points de terminaison d’inférence sans serveur SageMaker et les points de terminaison multimodèles SageMaker.
# Déployez de grands modèles à des fins d'inférence avec TorchServe
Ce didacticiel explique comment déployer de grands modèles et utiliser des inférences dans Amazon SageMaker AI avec TorchServe on GPUs. Cet exemple déploie le modèle [OPT-30b](https://huggingface.co/facebook/opt-30b) sur une instance `ml.g5`. Vous pouvez le modifier pour l'adapter à d'autres modèles et types d'instance. Dans les exemples, remplacez `italicized placeholder text` par vos propres informations.
TorchServe est une puissante plateforme ouverte pour l'inférence de modèles distribués à grande échelle. En prenant en charge les bibliothèques populaires telles que PyTorch Pi PPy native et HuggingFace Accelerate, il offre un gestionnaire uniforme APIs qui reste cohérent entre les scénarios d'inférence de grands modèles distribués et de modèles non distribués. DeepSpeed Pour plus d'informations, consultez [TorchServela documentation sur l'inférence de grands modèles](https://pytorch.org/serve/large_model_inference.html#).
## Conteneurs de deep learning avec TorchServe
Pour déployer un modèle de grande taille TorchServe sans SageMaker IA, vous pouvez utiliser l'un des conteneurs d'apprentissage profond pour SageMaker IA (DLCs). Par défaut, TorchServe est installé dans tous AWS PyTorch DLCs. Pendant le chargement du modèle, TorchServe vous pouvez installer des bibliothèques spécialisées adaptées aux grands modèles tels que PiPPy, Deepspeed et Accelerate.
Le tableau suivant répertorie toutes les [SageMaker IA DLCs avec TorchServe](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only).
| Catégorie de DLC | Cadre | Matériel | Exemple d'URL |
| --- | --- | --- | --- |
| [SageMaker Conteneurs AI Framework](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) | PyTorch 2,0.0\$1 | CPU, GPU | 763104351884.dkr.ecr.us-east-1.amazonaws.com/pytorch-inference:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker |
| [SageMaker Conteneurs Graviton AI Framework](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) | PyTorch 2,0.0\$1 | CPU | 763104351884.dkr. ecr.us-east-1.amazonaws.com /:2.0.1-cpu-py310-ubuntu20.04-sagemaker pytorch-inference-graviton |
| [Conteneurs d’inférence StabilityAI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#stabilityai-inference-containers) | PyTorch 2,0.0\$1 | GPU | 763104351884.dkr. ecr.us-east-1.amazonaws.com /:2.0.1-sgm0.1.0-gpu-py310-cu118-ubuntu20.04-sagemaker stabilityai-pytorch-inference |
| [Conteneurs Neuron](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) | PyTorch 1.13.1 | Neuronx | 763104351884.dkr. ecr.us-west-2.amazonaws.com /:1.13.1-neuron-py310-sdk2.12.0-ubuntu20.04 pytorch-inference-neuron |
## Prise en main
Avant de déployer votre modèle, respectez les prérequis. Vous pouvez également configurer les paramètres de votre modèle et personnaliser le code du gestionnaire.
### Conditions préalables
Avant de démarrer, vérifiez que les conditions préalables suivantes sont respectées :
1. Assurez-vous d'avoir accès à un AWS compte. [Configurez votre environnement](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) de manière à ce qu'ils AWS CLI puissent accéder à votre compte via un utilisateur AWS IAM ou un rôle IAM. Nous vous recommandons d'utiliser un rôle IAM. À des fins de test dans votre compte personnel, vous pouvez associer les politiques d'autorisations gérées suivantes au rôle IAM :
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AWSServiceRoleForAmazonEKSNodegroup](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AWSServiceRoleForAmazonEKSNodegroup)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [Amazon S3 FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
Pour plus d’informations sur la façon d’attacher des politiques IAM à un rôle, consultez [Ajout et suppression d’autorisations basées sur l’identité IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) dans le *Guide de l’utilisateur IAM AWS *.
1. Configurez vos dépendances de façon locale, comme indiqué dans les exemples suivants.
1. Installez la version 2 de AWS CLI :
```
# Install the latest AWS CLI v2 if it is not installed
!curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" !unzip awscliv2.zip
#Follow the instructions to install v2 on the terminal
!cat aws/README.md
```
1. Installez SageMaker AI et le client Boto3 :
```
# If already installed, update your client
#%pip install sagemaker pip --upgrade --quiet
!pip install -U sagemaker
!pip install -U boto
!pip install -U botocore
!pip install -U boto3
```
### Configuration des paramètres et des réglages du modèle
TorchServe permet [https://pytorch.org/docs/stable/elastic/run.html](https://pytorch.org/docs/stable/elastic/run.html)de configurer l'environnement distribué pour le traitement parallèle des modèles. TorchServe a la capacité de prendre en charge plusieurs travailleurs pour un modèle de grande taille. TorchServe Utilise par défaut un algorithme circulaire pour l'attribuer GPUs à un travailleur sur un hôte. Dans le cas d'une inférence de modèle à grande échelle, le nombre de travailleurs GPUs affectés à chaque travailleur est automatiquement calculé en fonction du nombre de travailleurs GPUs spécifiés dans le `model_config.yaml` fichier. La variable d'environnement`CUDA_VISIBLE_DEVICES`, qui spécifie le périphérique IDs GPU visible à un moment donné, est définie en fonction de ce nombre.
Par exemple, supposons qu'il y en ait 8 GPUs sur un nœud et qu'un travailleur en ait besoin de 4 GPUs sur un nœud (`nproc_per_node=4`). Dans ce cas, en TorchServe attribue quatre GPUs au premier travailleur (`CUDA_VISIBLE_DEVICES="0,1,2,3"`) et quatre GPUs au second travailleur (`CUDA_VISIBLE_DEVICES="4,5,6,7”`).
Outre ce comportement par défaut, TorchServe offre aux utilisateurs la flexibilité de spécifier GPUs pour un travailleur. Par exemple, si vous définissez la variable `deviceIds: [2,3,4,5]` dans le [fichier YAML de configuration du modèle](https://github.com/pytorch/serve/blob/5ee02e4f050c9b349025d87405b246e970ee710b/model-archiver/README.md?plain=1#L164), et que vous la définissez`nproc_per_node=2`, puis que vous l' TorchServe `CUDA_VISIBLE_DEVICES=”2,3”`assignez au premier et `CUDA_VISIBLE_DEVICES="4,5”` au second programme de travail.
Dans l’exemple `model_config.yaml` suivant, nous configurons les paramètres frontaux et dorsaux pour le modèle [OPT-30b](https://huggingface.co/facebook/opt-30b). Les paramètres frontaux configurés sont `parallelType`, `deviceType`, `deviceIds `et `torchrun`. Pour des informations plus détaillées sur les paramètres frontaux que vous pouvez configurer, consultez la [PyTorch GitHub documentation](https://github.com/pytorch/serve/blob/2bf505bae3046b0f7d0900727ec36e611bb5dca3/docs/configuration.md?plain=1#L267). La configuration dorsale est basée sur une carte YAML qui permet une personnalisation libre. Pour les paramètres du back-end, nous définissons la DeepSpeed configuration et les paramètres supplémentaires utilisés par le code du gestionnaire personnalisé.
```
# TorchServe front-end parameters
minWorkers: 1
maxWorkers: 1
maxBatchDelay: 100
responseTimeout: 1200
parallelType: "tp"
deviceType: "gpu"
# example of user specified GPU deviceIds
deviceIds: [0,1,2,3] # sets CUDA_VISIBLE_DEVICES
torchrun:
nproc-per-node: 4
# TorchServe back-end parameters
deepspeed:
config: ds-config.json
checkpoint: checkpoints.json
handler: # parameters for custom handler code
model_name: "facebook/opt-30b"
model_path: "model/models--facebook--opt-30b/snapshots/ceea0a90ac0f6fae7c2c34bcb40477438c152546"
max_length: 50
max_new_tokens: 10
manual_seed: 40
```
### Personnalisation des gestionnaires
TorchServe propose des [gestionnaires de base et des](https://github.com/pytorch/serve/tree/master/ts/torch_handler/distributed) [utilitaires de gestion pour l'](https://github.com/pytorch/serve/tree/master/ts/handler_utils)inférence de grands modèles conçus à l'aide de bibliothèques populaires. L'exemple suivant montre comment la classe de gestionnaire personnalisée [TransformersSeqClassifierHandler](https://github.com/pytorch/serve/blob/ab69b69a59d6ca6074df7e6d4014f07eb48dedba/examples/large_models/deepspeed/custom_handler.py#L16C7-L16C39)étend [BaseDeepSpeedHandler](https://github.com/pytorch/serve/blob/ab69b69a59d6ca6074df7e6d4014f07eb48dedba/ts/torch_handler/distributed/base_deepspeed_handler.py#L8)et utilise les utilitaires de [gestion](https://github.com/pytorch/serve/blob/master/ts/handler_utils/distributed/deepspeed.py). Pour un exemple de code complet, consultez le [`custom_handler.py`code figurant dans la PyTorch GitHub documentation](https://github.com/pytorch/serve/blob/master/examples/large_models/deepspeed/custom_handler.py).
```
class TransformersSeqClassifierHandler(BaseDeepSpeedHandler, ABC):
"""
Transformers handler class for sequence, token classification and question answering.
"""
def __init__(self):
super(TransformersSeqClassifierHandler, self).__init__()
self.max_length = None
self.max_new_tokens = None
self.tokenizer = None
self.initialized = False
def initialize(self, ctx: Context):
"""In this initialize function, the HF large model is loaded and
partitioned using DeepSpeed.
Args:
ctx (context): It is a JSON Object containing information
pertaining to the model artifacts parameters.
"""
super().initialize(ctx)
model_dir = ctx.system_properties.get("model_dir")
self.max_length = int(ctx.model_yaml_config["handler"]["max_length"])
self.max_new_tokens = int(ctx.model_yaml_config["handler"]["max_new_tokens"])
model_name = ctx.model_yaml_config["handler"]["model_name"]
model_path = ctx.model_yaml_config["handler"]["model_path"]
seed = int(ctx.model_yaml_config["handler"]["manual_seed"])
torch.manual_seed(seed)
logger.info("Model %s loading tokenizer", ctx.model_name)
self.tokenizer = AutoTokenizer.from_pretrained(model_name)
self.tokenizer.pad_token = self.tokenizer.eos_token
config = AutoConfig.from_pretrained(model_name)
with torch.device("meta"):
self.model = AutoModelForCausalLM.from_config(
config, torch_dtype=torch.float16
)
self.model = self.model.eval()
ds_engine = get_ds_engine(self.model, ctx)
self.model = ds_engine.module
logger.info("Model %s loaded successfully", ctx.model_name)
self.initialized = True
def preprocess(self, requests):
"""
Basic text preprocessing, based on the user's choice of application mode.
Args:
requests (list): A list of dictionaries with a "data" or "body" field, each
containing the input text to be processed.
Returns:
tuple: A tuple with two tensors: the batch of input ids and the batch of
attention masks.
"""
def inference(self, input_batch):
"""
Predicts the class (or classes) of the received text using the serialized transformers
checkpoint.
Args:
input_batch (tuple): A tuple with two tensors: the batch of input ids and the batch
of attention masks, as returned by the preprocess function.
Returns:
list: A list of strings with the predicted values for each input text in the batch.
"""
def postprocess(self, inference_output):
"""Post Process Function converts the predicted response into Torchserve readable format.
Args:
inference_output (list): It contains the predicted response of the input text.
Returns:
(list): Returns a list of the Predictions and Explanations.
"""
```
## Préparation des artefacts de votre modèle
Avant de déployer votre modèle sur l' SageMaker IA, vous devez empaqueter les artefacts de votre modèle. Pour les modèles de grande taille, nous vous recommandons d'utiliser l' PyTorch [torch-model-archiver](https://github.com/pytorch/serve/blob/master/model-archiver/README.md)outil avec l'argument`--archive-format no-archive`, qui ignore la compression des artefacts du modèle. L’exemple suivant enregistre tous les artefacts du modèle dans un nouveau dossier nommé `opt/`.
```
torch-model-archiver --model-name opt --version 1.0 --handler custom_handler.py --extra-files ds-config.json -r requirements.txt --config-file opt/model-config.yaml --archive-format no-archive
```
[Une fois le `opt/` dossier créé, téléchargez le modèle OPT-30b dans le dossier à l'aide de l'outil Download\$1model. PyTorch ](https://github.com/pytorch/serve/blob/master/examples/large_models/utils/Download_model.py)
```
cd opt
python path_to/Download_model.py --model_path model --model_name facebook/opt-30b --revision main
```
Enfin, chargez les artefacts du modèle sur un compartiment Amazon S3.
```
aws s3 cp opt {your_s3_bucket}/opt --recursive
```
Vous devriez maintenant avoir des artefacts de modèle stockés dans Amazon S3 prêts à être déployés sur un point de terminaison d' SageMaker IA.
## Déployez le modèle à l'aide du SDK SageMaker Python
Après avoir préparé les artefacts de votre modèle, vous pouvez déployer votre modèle sur un point de terminaison d'hébergement SageMaker AI. Cette section explique comment déployer un grand modèle sur un point de terminaison et effectuer des prédictions de réponse en streaming. Pour plus d’informations sur le streaming des réponses provenant des points de terminaison, consultez [Invoquer des points de terminaison en temps réel](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-test-endpoints.html).
Pour déployer votre modèle, procédez comme suit :
1. Créez une session SageMaker AI, comme indiqué dans l'exemple suivant.
```
import boto3
import sagemaker
from sagemaker import Model, image_uris, serializers, deserializers
boto3_session=boto3.session.Session(region_name="us-west-2")
smr = boto3.client('sagemaker-runtime-demo')
sm = boto3.client('sagemaker')
role = sagemaker.get_execution_role() # execution role for the endpoint
sess= sagemaker.session.Session(boto3_session, sagemaker_client=sm, sagemaker_runtime_client=smr) # SageMaker AI session for interacting with different AWS APIs
region = sess._region_name # region name of the current SageMaker Studio Classic environment
account = sess.account_id() # account_id of the current SageMaker Studio Classic environment
# Configuration:
bucket_name = sess.default_bucket()
prefix = "torchserve"
output_path = f"s3://{bucket_name}/{prefix}"
print(f'account={account}, region={region}, role={role}, output_path={output_path}')
```
1. Créez un modèle non compressé dans SageMaker AI, comme indiqué dans l'exemple suivant.
```
from datetime import datetime
instance_type = "ml.g5.24xlarge"
endpoint_name = sagemaker.utils.name_from_base("ts-opt-30b")
s3_uri = {your_s3_bucket}/opt
model = Model(
name="torchserve-opt-30b" + datetime.now().strftime("%Y-%m-%d-%H-%M-%S"),
# Enable SageMaker uncompressed model artifacts
model_data={
"S3DataSource": {
"S3Uri": s3_uri,
"S3DataType": "S3Prefix",
"CompressionType": "None",
}
},
image_uri=container,
role=role,
sagemaker_session=sess,
env={"TS_INSTALL_PY_DEP_PER_MODEL": "true"},
)
print(model)
```
1. Déployez le modèle sur une instance Amazon EC2, comme illustré dans l’exemple suivant.
```
model.deploy(
initial_instance_count=1,
instance_type=instance_type,
endpoint_name=endpoint_name,
volume_size=512, # increase the size to store large model
model_data_download_timeout=3600, # increase the timeout to download large model
container_startup_health_check_timeout=600, # increase the timeout to load large model
)
```
1. Initialisez une classe pour traiter la réponse en streaming, comme illustré dans l’exemple suivant.
```
import io
class Parser:
"""
A helper class for parsing the byte stream input.
The output of the model will be in the following format:
```
b'{"outputs": [" a"]}\n'
b'{"outputs": [" challenging"]}\n'
b'{"outputs": [" problem"]}\n'
...
```
While usually each PayloadPart event from the event stream will contain a byte array
with a full json, this is not guaranteed and some of the json objects may be split across
PayloadPart events. For example:
```
{'PayloadPart': {'Bytes': b'{"outputs": '}}
{'PayloadPart': {'Bytes': b'[" problem"]}\n'}}
```
This class accounts for this by concatenating bytes written via the 'write' function
and then exposing a method which will return lines (ending with a '\n' character) within
the buffer via the 'scan_lines' function. It maintains the position of the last read
position to ensure that previous bytes are not exposed again.
"""
def __init__(self):
self.buff = io.BytesIO()
self.read_pos = 0
def write(self, content):
self.buff.seek(0, io.SEEK_END)
self.buff.write(content)
data = self.buff.getvalue()
def scan_lines(self):
self.buff.seek(self.read_pos)
for line in self.buff.readlines():
if line[-1] != b'\n':
self.read_pos += len(line)
yield line[:-1]
def reset(self):
self.read_pos = 0
```
1. Testez une prédiction de réponse en streaming, comme illustré dans l’exemple suivant.
```
import json
body = "Today the weather is really nice and I am planning on".encode('utf-8')
resp = smr.invoke_endpoint_with_response_stream(EndpointName=endpoint_name, Body=body, ContentType="application/json")
event_stream = resp['Body']
parser = Parser()
for event in event_stream:
parser.write(event['PayloadPart']['Bytes'])
for line in parser.scan_lines():
print(line.decode("utf-8"), end=' ')
```
Vous avez maintenant déployé votre modèle sur un point de terminaison d' SageMaker IA et vous devriez pouvoir l'invoquer pour obtenir des réponses. Pour plus d'informations sur les points de terminaison en temps réel de l' SageMaker IA, consultez[Points de terminaison à modèle unique](realtime-single-model.md).
# Barrières de protection de déploiement pour la mise à jour des modèles en production
Les barrières de protection de déploiement sont un ensemble d’options de déploiement de modèle dans Amazon SageMaker AI Inference pour mettre à jour vos modèles de machine learning en production. À l'aide des options de déploiement entièrement gérées, vous pouvez contrôler le passage du modèle actuel en production à un nouveau. Les modes de déplacement du trafic dans les déploiements bleus/verts, tels que canary et linéaire, vous donnent un contrôle précis sur le processus de déplacement du trafic de votre modèle actuel vers le nouveau au cours de la mise à jour. Il existe également des sauvegardes intégrées telles que les restaurations automatiques qui vous aident à détecter les problèmes rapidement et à prendre automatiquement des mesures correctives avant que ces problèmes n'affectent considérablement la production.
Les barrières de protection de déploiement offrent les avantages suivants :
+ **Sécurité de déploiement lors de la mise à jour des environnements de production.** Une mise à jour régressive d'un environnement de production peut entraîner des temps d'arrêt imprévus et un impact commercial, tels qu'une latence accrue du modèle et des taux d'erreur élevés. Les barrières de protection de déploiement vous aident à atténuer ces risques en fournissant les bonnes pratiques et des barrières de protection de sécurité opérationnelle intégrées.
+ **Déploiement entièrement géré.** SageMaker AI prend en charge la configuration et l’orchestration de ces déploiements, et les intègre aux mécanismes de mise à jour des points de terminaison. Vous n'avez pas besoin de créer et de maintenir des mécanismes d'orchestration, de surveillance ou de restauration. Vous pouvez tirer parti de SageMaker AI pour configurer et orchestrer ces déploiements, et vous concentrer sur l’exploitation du ML pour vos applications.
+ **Visibilité.** Vous pouvez suivre la progression de votre déploiement via l'API [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) ou via Amazon CloudWatch Events (pour les [points de terminaison pris en charge](deployment-guardrails-exclusions.md)). Pour en savoir plus sur les événements dans SageMaker AI, consultez la section Changement d’état de déploiement de point de terminaison dans [Événements qu'Amazon SageMaker AI envoie à Amazon EventBridge](automating-sagemaker-with-eventbridge.md). Notez que si votre point de terminaison utilise l'une des fonctions de la page [Exclusions](deployment-guardrails-exclusions.md), vous ne pouvez pas utiliser CloudWatch Events.
**Note**
Les barrières de protection de déploiement ne s'appliquent qu'aux types de points de terminaison [Inférence asynchrone](async-inference.md) et [Inférence en temps réel](realtime-endpoints.md).
## Comment démarrer
Nous prenons en charge deux types de déploiements pour mettre à jour les modèles en production : les déploiements bleus/verts et les déploiements propagés.
+ [Déploiements bleu/vert](deployment-guardrails-blue-green.md) : vous pouvez déplacer le trafic de votre ancienne flotte (la flotte bleue) vers une nouvelle flotte (flotte verte) avec les mises à jour. Les déploiements bleus/verts offrent [plusieurs modes de déplacement du trafic](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-blue-green.html). Un mode de transfert de trafic est une configuration qui spécifie comment SageMaker AI achemine le trafic des points de terminaison vers une nouvelle flotte contenant vos mises à jour. Les modes de transfert de trafic suivants vous offrent différents niveaux de contrôle sur le processus de mise à jour des points de terminaison :
+ [Utilisation du déplacement de trafic tout à la fois](deployment-guardrails-blue-green-all-at-once.md) déplace tout le trafic de vos points de terminaison de la flotte bleue vers la flotte verte. Une fois que le trafic passe à la flotte verte, vos alarmes Amazon CloudWatch préspécifiées commencent à contrôler la flotte verte pendant une durée définie (la *période de préparation*). Si aucune alarme ne se déclenche pendant la période de préparation, alors SageMaker AI résilie la flotte bleue.
+ [Utilisation du déplacement de trafic canary](deployment-guardrails-blue-green-canary.md) déplace une petite partie de votre trafic (un *canary*) vers la flotte verte et la surveille pendant une période de préparation. Si le test canary réussit sur la flotte verte, alors SageMaker AI déplace le reste du trafic de la flotte bleue vers la flotte verte avant de résilier la flotte bleue.
+ [Utilisation du déplacement de trafic linéaire](deployment-guardrails-blue-green-linear.md) déplace encore plus de personnalisation sur le nombre d'étapes de déplacement du trafic et le pourcentage de trafic à déplacer pour chaque étape. Alors que le déplacement Canary vous permet de déplacer le trafic en deux étapes, le déplacement linéaire étend cela à des étapes *n* espacées linéairement.
+ [Utilisation des déploiements propagés](deployment-guardrails-rolling.md) : vous pouvez mettre à jour votre point de terminaison au fur et à mesure que SageMaker AI provisionne progressivement de la capacité et déplace le trafic vers une nouvelle flotte par étapes correspondant à la taille de lot que vous spécifiez. Les instances de la nouvelle flotte sont mises à jour avec la nouvelle configuration de déploiement, et si aucune alarme CloudWatch ne se déclenche pendant la période de préparation, SageMaker AI nettoie les instances de l’ancienne flotte. Cette option vous permet de contrôler précisément le nombre d'instances ou le pourcentage de capacité déplacé à chaque étape.
Vous pouvez créer et gérer votre déploiement via les commandes AWS Command Line Interface et d'API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) et [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) SageMaker. Consultez chacune des pages de déploiement pour plus de détails sur la façon de configurer votre déploiement. Notez que si votre point de terminaison utilise l'une des fonctions répertoriées sur la page [Exclusions](deployment-guardrails-exclusions.md), vous ne pouvez pas utiliser de barrière de protection de déploiement.
Pour suivre des exemples guidés qui montrent comment utiliser les barrières de protection de déploiement, consultez nos exemples de [blocs-notes Jupyter](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-inference-deployment-guardrails) pour les modes de déplacement de trafic Canary et linéaire.
# Configuration et surveillance de la restauration automatique
Les CloudWatch alarmes Amazon sont indispensables pour utiliser les périodes de pause dans les garde-corps de déploiement. Vous ne pouvez utiliser la fonctionnalité de restauration automatique dans les garde-fous de déploiement que si vous configurez des CloudWatch alarmes capables de surveiller un terminal. Si l'une de vos alarmes se déclenche pendant la période de surveillance spécifiée, l' SageMaker IA initie une restauration complète de l'ancien terminal afin de protéger votre application. Si aucune CloudWatch alarme n'est configurée pour surveiller votre terminal, la fonctionnalité de restauration automatique ne fonctionne pas pendant votre déploiement.
Pour en savoir plus sur Amazon CloudWatch, consultez [Qu'est-ce qu'Amazon CloudWatch ?](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html) dans le *guide de CloudWatch l'utilisateur Amazon*.
**Note**
Assurez-vous que votre rôle d'exécution IAM est autorisé à effectuer l'action `cloudwatch:DescribeAlarms` sur les alarmes de restauration automatique que vous spécifiez.
## Exemples d'alarme
Pour vous aider à démarrer, nous fournissons les exemples suivants pour démontrer les capacités des CloudWatch alarmes. En plus d'utiliser ou de modifier les exemples suivants, vous pouvez créer vos propres alarmes et configurer les alarmes pour contrôler diverses métriques sur les flottes spécifiées pendant une certaine période. Pour voir d'autres mesures et dimensions de l' SageMaker IA que vous pouvez ajouter à vos alarmes, consultez[Métriques Amazon SageMaker AI sur Amazon CloudWatch](monitoring-cloudwatch.md).
**Topics**
+ [contrôler les erreurs d'appel sur les anciennes et nouvelles flottes](#deployment-guardrails-configuration-alarm-examples-errors-both)
+ [Contrôler la latence des modèles sur la nouvelle flotte](#deployment-guardrails-configuration-alarm-examples-latency-new)
### contrôler les erreurs d'appel sur les anciennes et nouvelles flottes
L' CloudWatch alarme suivante surveille le taux d'erreur moyen d'un terminal. Vous pouvez utiliser cette alarme avec n'importe quel type de changement de trafic de barrière de protection de déploiement pour fournir une surveillance globale à la fois sur l'ancienne et la nouvelle flotte. Si l'alarme se déclenche, l' SageMaker IA initie un retour à l'ancienne flotte.
Les erreurs d'appel provenant à la fois de l'ancienne flotte et de la nouvelle flotte contribuent au taux d'erreur moyen. Si le taux d'erreur moyen dépasse le seuil spécifié, l'alarme se déclenche. Cet exemple particulier surveille les erreurs 4xx (erreurs client) sur les anciennes et nouvelles flottes pendant la durée d'un déploiement. Vous pouvez également contrôler les erreurs 5xx (erreurs de serveur) à l'aide de la métrique `Invocation5XXErrors`.
**Note**
Pour ce type d'alarme, si votre ancienne flotte déclenche l'alarme pendant le déploiement, l' SageMaker IA met fin à votre déploiement. Par conséquent, si votre flotte de production actuelle provoque déjà des erreurs, envisagez d'utiliser ou de modifier l'un des exemples suivants qui surveille uniquement les erreurs de la nouvelle flotte.
```
#Applied deployment type: all types
{
"AlarmName": "EndToEndDeploymentHighErrorRateAlarm",
"AlarmDescription": "Monitors the error rate of 4xx errors",
"MetricName": "Invocation4XXErrors",
"Namespace": "AWS/SageMaker",
"Statistic": "Average",
"Dimensions": [
{
"Name": "EndpointName",
"Value":
},
{
"Name": "VariantName",
"Value": "AllTraffic"
}
],
"Period": 600,
"EvaluationPeriods": 2,
"Threshold": 1,
"ComparisonOperator": "GreaterThanThreshold",
"TreatMissingData": "notBreaching"
}
```
Dans l'exemple précédent, notez les valeurs dans les champs suivants :
+ Pour `AlarmName` et `AlarmDescription`, saisissez un nom et une description de votre choix pour l'alarme.
+ Pour `MetricName`, utilisez la valeur `Invocation4XXErrors` afin de contrôler les erreurs 4xx sur le point de terminaison
+ Pour `Namespace`, utilisez la valeur `AWS/SageMaker`. Vous pouvez également spécifier votre propre métrique personnalisée, le cas échéant.
+ Pour `Statistic`, utilisez `Average`. Cela signifie que l'alarme prend le taux d'erreur moyen sur les périodes d'évaluation pour calculer si ce taux a dépassé le seuil.
+ Pour la dimension `EndpointName`, utilisez le nom du point de terminaison que vous mettez à jour comme valeur.
+ Pour la dimension `VariantName`, utilisez la valeur `AllTraffic` pour spécifier tout le trafic des points de terminaison.
+ Pour `Period`, utilisez `600`. Cela définit les périodes d'évaluation de l'alarme à 10 minutes.
+ Pour `EvaluationPeriods`, utilisez `2`. Cette valeur indique à l'alarme de prendre en compte les deux périodes d'évaluation les plus récentes lors de la détermination de l'état de l'alarme.
### Contrôler la latence des modèles sur la nouvelle flotte
L'exemple CloudWatch d'alarme suivant surveille la latence du nouveau modèle de flotte pendant votre déploiement. Vous pouvez utiliser cette alarme pour contrôler uniquement la nouvelle flotte et exclure l'ancienne flotte. L'alarme dure pendant tout le déploiement. Cet exemple vous fournit une end-to-end surveillance complète de la nouvelle flotte et initie un retour à l'ancienne flotte si la nouvelle flotte rencontre des problèmes de temps de réponse.
CloudWatch publie les métriques avec la dimension une `EndpointConfigName:{New-Ep-Config}` fois que le nouveau parc commence à recevoir du trafic, et ces métriques sont valables même une fois le déploiement terminé.
Vous pouvez utiliser l'exemple d'alarme suivant avec n'importe quel type de déploiement.
```
#Applied deployment type: all types
{
"AlarmName": "NewEndpointConfigVersionHighModelLatencyAlarm",
"AlarmDescription": "Monitors the model latency on new fleet",
"MetricName": "ModelLatency",
"Namespace": "AWS/SageMaker",
"Statistic": "Average",
"Dimensions": [
{
"Name": "EndpointName",
"Value":
},
{
"Name": "VariantName",
"Value": "AllTraffic"
},
{
"Name": "EndpointConfigName",
"Value":
],
"Period": 300,
"EvaluationPeriods": 2,
"Threshold": 100000, # 100ms
"ComparisonOperator": "GreaterThanThreshold",
"TreatMissingData": "notBreaching"
}
```
Dans l'exemple précédent, notez les valeurs dans les champs suivants :
+ Pour `MetricName`, utilisez la valeur `ModelLatency` afin de contrôler le temps de réponse du modèle.
+ Pour `Namespace`, utilisez la valeur `AWS/SageMaker`. Vous pouvez également spécifier votre propre métrique personnalisée, le cas échéant.
+ Pour la dimension `EndpointName`, utilisez le nom du point de terminaison que vous mettez à jour comme valeur.
+ Pour la dimension `VariantName`, utilisez la valeur `AllTraffic` afin despécifier tout le trafic des points de terminaison.
+ Pour la dimension `EndpointConfigName`, la valeur doit faire référence au nom de configuration de votre point de terminaison nouveau ou mis à jour.
**Note**
Si vous souhaitez contrôler votre ancienne flotte au lieu de la nouvelle flotte, vous pouvez modifier la dimension `EndpointConfigName` afin de spécifier le nom de la configuration de votre ancienne flotte.
# Déploiements bleu/vert
Lorsque vous mettez à jour votre point de terminaison, Amazon SageMaker AI utilise automatiquement un déploiement bleu/vert pour maximiser la disponibilité de vos points de terminaison. Dans un déploiement bleu/vert, SageMaker AI provisionne une nouvelle flotte avec les mises à jour (la flotte verte). Ensuite, SageMaker AI déplace le trafic de l’ancienne flotte (la flotte bleue) vers la flotte verte. Une fois que la flotte verte fonctionne correctement pendant une période d’évaluation définie (appelée période de préparation), SageMaker AI résilie la flotte bleue. Avec les capacités supplémentaires des déploiements bleu/vert, vous pouvez utiliser les modes de transfert de trafic et la surveillance de la restauration automatique pour protéger votre point de terminaison d'un impact significatif sur la production.
La liste suivante décrit les principales caractéristiques des déploiements bleu/vert dans SageMaker AI :
+ **Modes de déplacement de trafic.** Les modes de déplacement de trafic pour les barrières de protection de déploiement vous permettent de contrôler le volume de trafic et le nombre d'étapes de déplacement de trafic entre la flotte bleue et la flotte verte. Cette capacité vous donne la possibilité d'évaluer progressivement les performances de la flotte verte sans vous engager pleinement dans un déplacement de l'intégralité du trafic.
+ **Période de préparation.** La période de préparation est une durée définie pour contrôler la flotte verte avant de passer à l'étape de déploiement suivante. Si l'une des alarmes prédéfinies se déclenche au cours d'une période de préparation, tout le trafic des points de terminaison est restauré sur la flotte bleue. La période de préparation vous aide à renforcer la confiance dans votre mise à jour avant de rendre le déplacement de trafic permanent.
+ **Restaurations automatiques.** Vous pouvez spécifier des alarmes Amazon CloudWatch que SageMaker AI utilise pour surveiller la flotte verte. Si un problème lié au code mis à jour déclenche l’une des alarmes, SageMaker AI lance une restauration automatique vers la flotte bleue afin de maintenir la disponibilité, minimisant ainsi les risques.
## Modes de déplacement de trafic
Les différents modes de déplacement de trafic dans les déploiements bleu/vert vous offrent un contrôle plus précis du déplacement de trafic entre la flotte bleue et la flotte verte. Les modes de déplacement de trafic disponibles pour les déploiements bleu/vert sont tout à la fois, Canary et linéaire. Le tableau suivant compare les différentes options.
**Important**
Pour les déploiements bleu/vert qui impliquent des périodes de déplacement de trafic ou de préparation en plusieurs étapes, vous êtes facturé pour les deux flottes pour la durée de la mise à jour, quel que soit le trafic envoyé vers la flotte. Cela contraste avec les déploiements bleu/vert avec un déplacement de trafic tout à la fois et aucune période de préparation, pour lesquels vous n'êtes facturé que pour une flotte au cours de la mise à jour.
| Nom | Définition | Avantages | Inconvénients | Recommandation |
| --- | --- | --- | --- | --- |
| Tout à la fois | Déplace tout le trafic vers la nouvelle flotte en une seule étape. | Minimise la durée globale de la mise à jour. | Les mises à jour régressives affectent l'intégralité du trafic. | Utilisez cette option pour réduire le temps et le coût de la mise à jour. |
| Canary | Les déplacements de trafic se déroulent en deux étapes. La première étape (Canary) déplace une petite partie du trafic, suivie de la deuxième étape, qui déplace le reste du trafic. | Limite le rayon d'explosion des mises à jour régressives uniquement à la flotte Canary. | Les deux flottes sont opérationnelles en parallèle pour l'ensemble du déploiement. | Utilisez cette option pour trouver un équilibre entre la minimisation du rayon d'explosion des mises à jour régressives et la minimisation du temps pendant lequel deux flottes sont opérationnelles. |
| Linéaire | Une partie fixe du trafic se déplace selon un nombre prédéfini d'étapes équidistantes. | Minimise le risque de mises à jour régressives en déplaçant le trafic sur plusieurs étapes. | La durée et le coût de la mise à jour sont proportionnels au nombre d'étapes. | Utilisez cette option pour minimiser les risques en répartissant le déploiement sur plusieurs étapes. |
## Démarrer
Une fois que vous avez spécifié la configuration de déploiement souhaitée, SageMaker AI gère le provisionnement des nouvelles instances, la résiliation des anciennes instances et le transfert du trafic pour vous. Vous pouvez créer et gérer votre déploiement via les commandes AWS Command Line Interface et d'API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) et [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) SageMaker existantes. Notez que si votre point de terminaison utilise l'une des fonctions répertoriées sur la page [Exclusions](deployment-guardrails-exclusions.md), vous ne pouvez pas utiliser de barrière de protection de déploiement. Consultez chacune des pages de déploiement pour plus de détails sur la façon de configurer votre déploiement :
+ [Mise à jour bleu/vert avec déplacement de trafic All At once (Tout à la fois)](deployment-guardrails-blue-green-all-at-once.md)
+ [Mise à jour bleu/vert avec déplacement de trafic Canary](deployment-guardrails-blue-green-canary.md)
+ [Mise à jour bleu/vert avec déplacement de trafic linéaire](deployment-guardrails-blue-green-linear.md)
Pour suivre des exemples guidés qui montrent comment utiliser les garde-corps de déploiement, consultez nos exemples de [blocs-notes Jupyter](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-inference-deployment-guardrails) pour les modes de changement de trafic Canary et linéaire.
# Utilisation du déplacement de trafic tout à la fois
Avec le déplacement tout à la fois du trafic, vous pouvez rapidement déployer une mise à jour du point de terminaison à l'aide des barrières de protection de sécurité d'un déploiement bleu/vert. Vous pouvez utiliser cette option de transfert de trafic pour minimiser la durée de mise à jour tout en profitant des garanties de disponibilité des déploiements bleu/vert. La fonction de période de préparation vous aide à contrôler les performances et les fonctionnalités de vos nouvelles instances avant de mettre fin à vos anciennes instances, garantissant que votre nouvelle flotte est pleinement opérationnelle.
Le diagramme suivant montre comment le déplacement de trafic gère simultanément les anciennes et les nouvelles flottes.
![\[Un déplacement réussi de l'intégralité du trafic de l'ancienne flotte vers la nouvelle flotte.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/deployment-guardrails-blue-green-all-at-once.png)
Lorsque vous utilisez le déplacement de trafic tout à la fois, SageMaker AI achemine l’intégralité du trafic vers la nouvelle flotte (flotte verte). Une fois que la flotte verte commence à recevoir du trafic, la période de préparation commence. La période de préparation est une durée définie pendant laquelle des alarmes Amazon CloudWatch prédéfinies surveillent les performances de la flotte verte. Si aucune alarme ne se déclenche pendant la période de préparation, SageMaker AI résilie l’ancienne flotte (flotte bleue). Si des alarmes se déclenchent pendant la période de préparation, une restauration automatique se déclenche et l'intégralité du trafic est restauré sur la flotte bleue.
## Prérequis
Avant de configurer un déploiement avec un déplacement de trafic All at once (Tout à la fois), vous devez créer des alarmes Amazon CloudWatch pour contrôler les métriques à partir de votre point de terminaison. Si l'une des alarmes se déclenche pendant la période de préparation, le trafic est restauré sur votre flotte bleue. Pour savoir comment configurer des alarmes CloudWatch sur un point de terminaison, consultez la page des prérequis [Configuration et surveillance de la restauration automatique](deployment-guardrails-configuration.md). Pour en savoir plus sur les alarmes CloudWatch, consultez [Utilisation des alarmes Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) dans le *Guide de l’utilisateur Amazon CloudWatch*.
## Configurer le déplacement de trafic All in once (Tout à la fois)
Une fois que vous êtes prêt pour le déploiement et que vous avez configuré les alarmes CloudWatch pour le point de terminaison, vous pouvez utiliser l’API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) SageMaker AI ou la commande [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) dans l’AWS Command Line Interface pour lancer le déploiement.
**Topics**
+ [Comment mettre à jour un point de terminaison (API)](#deployment-guardrails-blue-green-all-at-once-configure-api-update)
+ [Comment mettre à jour un point de terminaison avec une politique de mise à jour bleue/verte (API) existante](#deployment-guardrails-blue-green-all-at-once-configure-api-existing)
+ [Comment mettre à jour un point de terminaison (CLI)](#deployment-guardrails-blue-green-all-at-once-configure-cli-update)
### Comment mettre à jour un point de terminaison (API)
L'exemple suivant montre comment vous pouvez mettre à jour votre point de terminaison avec un déplacement de trafic All at once (Tout à la fois) à l'aide de [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) dans l'API Amazon SageMaker.
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"BlueGreenUpdatePolicy": {
"TrafficRoutingConfiguration": {
"Type": "ALL_AT_ONCE"
},
"TerminationWaitInSeconds": 600,
"MaximumExecutionTimeoutInSeconds": 1800
},
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
},
]
}
}
)
```
Pour configurer l'option de déplacement de trafic tout à la fois, procédez comme suit :
+ Pour `EndpointName`, utilisez le nom du point de terminaison existant que vous souhaitez mettre à jour.
+ Pour `EndpointConfigName`, utilisez le nom de la configuration de point de terminaison que vous souhaitez utiliser.
+ Sous `DeploymentConfig` et `BlueGreenUpdatePolicy`, dans `TrafficRoutingConfiguration`, définissez le paramètre `Type` sur `ALL_AT_ONCE`. Il est ainsi spécifié que le déploiement utilise le mode de déplacement de trafic All at once (Tout à la fois).
+ Pour `TerminationWaitInSeconds`, utilisez `600`. Ce paramètre indique à SageMaker AI d’attendre le laps de temps spécifié (en secondes) une fois que la flotte verte est entièrement active avant de résilier les instances de la flotte bleue. Dans cet exemple, SageMaker AI attend 10 minutes après la dernière période de préparation avant de résilier la flotte bleue.
+ Pour `MaximumExecutionTimeoutInSeconds`, utilisez `1800`. Ce paramètre définit la durée maximale pendant laquelle le déploiement peut s'exécuter avant qu'il n'expire. Dans l'exemple précédent, votre déploiement doit être exécuté en moins de 30 minutes.
+ Dans `AutoRollbackConfiguration`, dans le champ `Alarms`, vous pouvez ajouter vos alarmes CloudWatch par nom. Créez un `AlarmName: ` pour chaque alarme que vous souhaitez utiliser.
### Comment mettre à jour un point de terminaison avec une politique de mise à jour bleue/verte (API) existante
Lorsque vous utilisez l'API [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) pour créer un point de terminaison, vous pouvez éventuellement spécifier une configuration de déploiement à réutiliser pour les futures mises à jour du point de terminaison. Vous pouvez utiliser les mêmes options `DeploymentConfig` que l'exemple d'API UpdateEndpoint précédent. Il n'y a aucun changement dans le comportement de l'API CreateEndpoint. La spécification de la configuration de déploiement n'effectue pas automatiquement une mise à jour bleu/vert sur votre point de terminaison.
La possibilité d'utiliser une configuration de déploiement précédente se produit lorsque vous utilisez l'API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) pour mettre à jour votre point de terminaison. Lors de la mise à jour de votre point de terminaison, vous pouvez utiliser l'option `RetainDeploymentConfig` pour conserver la configuration de déploiement que vous avez spécifiée lors de la création du point de terminaison.
Lorsque vous appelez l'API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html), définissez `RetainDeploymentConfig` sur `True` pour conserver les options `DeploymentConfig` de votre configuration de point de terminaison d'origine.
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
RetainDeploymentConfig=True
)
```
### Comment mettre à jour un point de terminaison (CLI)
Si vous utilisez la AWS CLI, l'exemple suivant montre comment démarrer un déploiement bleu/vert tout à la fois à l'aide de la commande [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html).
```
update-endpoint
--endpoint-name
--endpoint-config-name
--deployment-config '"BlueGreenUpdatePolicy": {"TrafficRoutingConfiguration": {"Type": "ALL_AT_ONCE"},
"TerminationWaitInSeconds": 600, "MaximumExecutionTimeoutInSeconds": 1800},
"AutoRollbackConfiguration": {"Alarms": [{"AlarmName": ""}]}'
```
Pour configurer l'option de déplacement de trafic tout à la fois, procédez comme suit :
+ Pour `endpoint-name`, utilisez le nom du point de terminaison que vous souhaitez mettre à jour.
+ Pour `endpoint-config-name`, utilisez le nom de la configuration de point de terminaison que vous souhaitez utiliser.
+ Pour `deployment-config`, utilisez un objet JSON [BlueGreenUpdatePolicy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_BlueGreenUpdatePolicy.html).
**Note**
Si vous préférez enregistrer votre objet JSON dans un fichier, consultez [Générer un squelette AWS CLI et des paramètres d’entrée](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) dans le *Guide de l’utilisateur AWS CLI*.
# Utilisation du déplacement de trafic canary
Avec le déplacement de trafic Canary, vous pouvez tester une partie de votre trafic de point de terminaison sur la nouvelle flotte tandis que l'ancienne flotte dessert le reste du trafic. Cette étape de test est une barrière de protection de sécurité qui vérifie le bon fonctionnement de la nouvelle flotte avant de déplacer tout votre trafic vers la nouvelle flotte. Vous bénéficiez toujours des avantages d'un déploiement bleu/vert, et la fonction Canary ajoutée vous permet de vous assurer que votre nouvelle flotte (verte) peut servir l'inférence avant de la laisser gérer l'intégralité du trafic.
La partie de votre flotte verte qui s'allume pour recevoir du trafic s'appelle le Canary, et vous pouvez choisir la taille de ce Canary. Notez que la taille des Canary doit être inférieure ou égale à 50 % de la capacité de la nouvelle flotte. Une fois la période de préparation terminée et si aucune alarme Amazon CloudWatch prédéfinie ne se déclenche, le reste du trafic est déplacé de l'ancienne flotte (bleue) à la flotte verte. Le déplacement de trafic Canary vous offre plus de sécurité pendant votre déploiement, car tout problème avec le modèle mis à jour n'affecte que le Canary.
Le diagramme suivant montre comment le déplacement de trafic Canary gère la répartition du trafic entre les flottes bleue et verte.
![\[Un déplacement réussi en deux étapes de l'intégralité du trafic de l'ancienne flotte vers la nouvelle flotte.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/deployment-guardrails-blue-green-canary.png)
Une fois que SageMaker AI a provisionné la flotte verte, SageMaker AI achemine une partie du trafic entrant (par exemple, 25 %) vers le canary. Puis commence la période de préparation, pendant laquelle vos alarmes CloudWatch surveillent les performances de la flotte verte. Pendant ce temps, la flotte bleue et la flotte verte sont partiellement actives et reçoivent du trafic. Si l’une des alarmes se déclenche pendant la période de préparation, SageMaker AI lance une annulation et tout le trafic retourne à la flotte bleue. Si aucune des alarmes ne se déclenche, alors tout le trafic se déplace vers la flotte verte et s'ensuit une période de préparation finale. Si la période de préparation finale se termine sans déclencher aucune alarme, alors la flotte verte transmet tout le trafic et SageMaker AI résilie la flotte bleue.
## Prérequis
Avant de configurer un déploiement avec un déplacement de trafic Canary, vous devez créer des alarmes Amazon CloudWatch pour contrôler les métriques à partir de votre point de terminaison. Les alarmes sont actives pendant la période de préparation, et si une alarme se déclenche, tout le trafic du point de terminaison est restaurée vers la flotte bleue. Pour savoir comment configurer des alarmes CloudWatch sur un point de terminaison, consultez la page des prérequis [Configuration et surveillance de la restauration automatique](deployment-guardrails-configuration.md). Pour en savoir plus sur les alarmes CloudWatch, consultez [Utilisation des alarmes Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) dans le *Guide de l’utilisateur Amazon CloudWatch*.
## Configurer le changement de trafic Canary
Une fois que vous êtes prêt et que vous avez configuré les alarmes Amazon CloudWatch pour votre point de terminaison, vous pouvez utiliser l’API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) Amazon SageMaker AI ou la commande [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) dans l’AWS CLI pour lancer le déploiement.
**Topics**
+ [Comment mettre à jour un point de terminaison (API)](#deployment-guardrails-blue-green-canary-configure-api-update)
+ [Comment mettre à jour un point de terminaison avec une politique de mise à jour bleue/verte (API) existante](#deployment-guardrails-blue-green-canary-configure-api-existing)
+ [Comment mettre à jour un point de terminaison (CLI)](#deployment-guardrails-blue-green-canary-configure-cli-update)
### Comment mettre à jour un point de terminaison (API)
L'exemple suivant de l'API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) montre comment vous pouvez mettre à jour un point de terminaison avec un déplacement de trafic Canary.
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"BlueGreenUpdatePolicy": {
"TrafficRoutingConfiguration": {
"Type": "CANARY",
"CanarySize": {
"Type": "CAPACITY_PERCENT",
"Value": 30
},
"WaitIntervalInSeconds": 600
},
"TerminationWaitInSeconds": 600,
"MaximumExecutionTimeoutInSeconds": 1800
},
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
}
]
}
}
)
```
Pour configurer l'option de déplacement de trafic Canary, procédez comme suit :
+ Pour `EndpointName`, utilisez le nom du point de terminaison existant que vous souhaitez mettre à jour.
+ Pour `EndpointConfigName`, utilisez le nom de la configuration de point de terminaison que vous souhaitez utiliser.
+ Sous `DeploymentConfig` et `BlueGreenUpdatePolicy`, dans `TrafficRoutingConfiguration`, définissez le paramètre `Type` sur `CANARY`. Cela permet de spécifier que le déploiement utilise le déplacement de trafic Canary.
+ Dans le champ `CanarySize`, vous pouvez changer la taille du Canary en modifiant les paramètres `Type` et `Value`. Pour `Type`, utilisez `CAPACITY_PERCENT`, c'est-à-dire le pourcentage de votre flotte verte que vous souhaitez utiliser comme Canary, puis définissez `Value` sur `30`. Dans cet exemple, vous utilisez 30 % de la capacité de la flotte verte en tant que Canary. Notez que la taille des Canary doit être égale ou inférieure à 50 % de la capacité de la flotte verte.
+ Pour `WaitIntervalInSeconds`, utilisez `600`. Le paramètre indique à SageMaker AI d’attendre la durée spécifiée (en secondes) entre chaque déplacement d’intervalle. Cet intervalle est la durée de la période de préparation des Canary. Dans l’exemple précédent, SageMaker AI attend 10 minutes après le déplacement canary, puis termine le deuxième et dernier déplacement de trafic.
+ Pour `TerminationWaitInSeconds`, utilisez `600`. Ce paramètre indique à SageMaker AI d’attendre le laps de temps spécifié (en secondes) une fois que la flotte verte est entièrement active avant de résilier les instances de la flotte bleue. Dans cet exemple, SageMaker AI attend 10 minutes après la dernière période de préparation avant de résilier la flotte bleue.
+ Pour `MaximumExecutionTimeoutInSeconds`, utilisez `1800`. Ce paramètre définit la durée maximale pendant laquelle le déploiement peut s'exécuter avant qu'il n'expire. Dans l'exemple précédent, votre déploiement doit être exécuté en moins de 30 minutes.
+ Dans `AutoRollbackConfiguration`, dans le champ `Alarms`, vous pouvez ajouter vos alarmes CloudWatch par nom. Créez un `AlarmName: ` pour chaque alarme que vous souhaitez utiliser.
### Comment mettre à jour un point de terminaison avec une politique de mise à jour bleue/verte (API) existante
Lorsque vous utilisez l'API [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) pour créer un point de terminaison, vous pouvez éventuellement spécifier une configuration de déploiement à réutiliser pour les futures mises à jour du point de terminaison. Vous pouvez utiliser les mêmes options `DeploymentConfig` que l'exemple d'API UpdateEndpoint précédent. Il n'y a aucun changement dans le comportement de l'API CreateEndpoint. La spécification de la configuration de déploiement n'effectue pas automatiquement une mise à jour bleu/vert sur votre point de terminaison.
La possibilité d'utiliser une configuration de déploiement précédente se produit lorsque vous utilisez l'API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) pour mettre à jour votre point de terminaison. Lors de la mise à jour de votre point de terminaison, vous pouvez utiliser l'option `RetainDeploymentConfig` pour conserver la configuration de déploiement que vous avez spécifiée lors de la création du point de terminaison.
Lorsque vous appelez l'API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html), définissez `RetainDeploymentConfig` sur `True` pour conserver les options `DeploymentConfig` de votre configuration de point de terminaison d'origine.
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
RetainDeploymentConfig=True
)
```
### Comment mettre à jour un point de terminaison (CLI)
Si vous utilisez la AWS CLI, l'exemple suivant montre comment démarrer un déploiement Canary bleu/vert à l'aide de la commande [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html).
```
update-endpoint
--endpoint-name
--endpoint-config-name
--deployment-config '"BlueGreenUpdatePolicy": {"TrafficRoutingConfiguration": {"Type": "CANARY",
"CanarySize": {"Type": "CAPACITY_PERCENT", "Value": 30}, "WaitIntervalInSeconds": 600},
"TerminationWaitInSeconds": 600, "MaximumExecutionTimeoutInSeconds": 1800},
"AutoRollbackConfiguration": {"Alarms": [{"AlarmName": ""}]}'
```
Pour configurer l'option de déplacement de trafic Canary, procédez comme suit :
+ Pour `endpoint-name`, utilisez le nom du point de terminaison que vous souhaitez mettre à jour.
+ Pour `endpoint-config-name`, utilisez le nom de la configuration de point de terminaison que vous souhaitez utiliser.
+ Pour `deployment-config`, utilisez un objet JSON [BlueGreenUpdatePolicy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_BlueGreenUpdatePolicy.html).
**Note**
Si vous préférez enregistrer votre objet JSON dans un fichier, consultez [Générer un squelette AWS CLI et des paramètres d’entrée](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) dans le *Guide de l’utilisateur AWS CLI*.
# Utilisation du déplacement de trafic linéaire
Le déplacement de trafic linéaire vous permet de déplacer progressivement le trafic de votre ancienne flotte (flotte bleue) vers votre nouvelle flotte (flotte verte). Avec le déplacement du trafic linéaire, vous pouvez déplacer le trafic en plusieurs étapes, minimisant ainsi le risque d'interruption de votre point de terminaison. Cette option de déploiement bleu/vert vous offre le contrôle le plus granulaire sur le déplacement de trafic.
Vous pouvez choisir soit le nombre d'instances, soit le pourcentage de la capacité de la flotte verte à activer à chaque étape. Chaque étape linéaire ne devrait représenter qu'entre 10 et 50 % de la capacité de la flotte verte. Pour chaque étape, il y a une période de préparation au cours de laquelle vos alarmes Amazon CloudWatch préspécifiées surveillent les métriques sur la flotte verte. Une fois la période de préparation terminée et si aucune alarme ne se déclenche, la partie active de votre flotte verte continue de recevoir du trafic et une nouvelle étape commence. Si des alarmes se déclenchent pendant l'une des périodes de préparation, 100 % du trafic du point de terminaison revient à la flotte bleue.
Le diagramme suivant montre comment le déplacement de trafic linéaire achemine le trafic vers les flottes bleue et verte.
![\[Déplacement de trafic linéaire réussi en trois étapes de l’ancienne flotte vers la nouvelle flotte.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/deployment-guardrails-blue-green-linear.png)
Une fois que SageMaker AI a provisionné la nouvelle flotte, la première partie de la flotte verte s’active et reçoit le trafic. SageMaker AI désactive la partie de même taille de la flotte bleue et la période de préparation commence. Si des alarmes se déclenchent, tout le trafic du point de terminaison est restauré vers la flotte bleue. Si la période de préparation prend fin, l'étape suivante commence. Une autre partie de la flotte verte s'active et reçoit du trafic, une partie de la flotte bleue se désactive et une autre période de préparation commence. Le même processus se répète jusqu'à ce que la flotte bleue soit complètement désactivée et que la flotte verte soit pleinement active et reçoive tout le trafic. Si une alarme se déclenche à tout moment, SageMaker AI met fin au processus de déplacement et l’intégralité du trafic est restauré vers la flotte bleue.
## Prérequis
Avant de configurer un déploiement avec un déplacement de trafic linéaire, vous devez créer des alarmes CloudWatch pour contrôler les métriques à partir de votre point de terminaison. Les alarmes sont actives pendant la période de préparation, et si une alarme se déclenche, tout le trafic du point de terminaison est restaurée vers la flotte bleue. Pour savoir comment configurer des alarmes CloudWatch sur un point de terminaison, consultez la page des prérequis [Configuration et surveillance de la restauration automatique](deployment-guardrails-configuration.md). Pour en savoir plus sur les alarmes CloudWatch, consultez [Utilisation des alarmes Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) dans le *Guide de l’utilisateur Amazon CloudWatch*.
## Configurer le changement de trafic linéaire
Une fois que vous êtes prêt pour le déploiement et que vous avez configuré les alarmes CloudWatch pour le point de terminaison, vous pouvez utiliser l’API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) Amazon SageMaker AI ou la commande [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) dans l’AWS CLI pour lancer le déploiement.
**Topics**
+ [Comment mettre à jour un point de terminaison (API)](#deployment-guardrails-blue-green-linear-configure-api-update)
+ [Comment mettre à jour un point de terminaison avec une politique de mise à jour bleue/verte (API) existante](#deployment-guardrails-blue-green-linear-configure-api-existing)
+ [Comment mettre à jour un point de terminaison (CLI)](#deployment-guardrails-blue-green-canary-configure-cli-update)
### Comment mettre à jour un point de terminaison (API)
L'exemple suivant de l'API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) montre comment vous pouvez mettre à jour un point de terminaison avec un déplacement de trafic linéaire.
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"BlueGreenUpdatePolicy": {
"TrafficRoutingConfiguration": {
"Type": "LINEAR",
"LinearStepSize": {
"Type": "CAPACITY_PERCENT",
"Value": 20
},
"WaitIntervalInSeconds": 300
},
"TerminationWaitInSeconds": 300,
"MaximumExecutionTimeoutInSeconds": 3600
},
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
}
]
}
}
)
```
Pour configurer l'option de déplacement de trafic linéaire, procédez comme suit :
+ Pour `EndpointName`, utilisez le nom du point de terminaison existant que vous souhaitez mettre à jour.
+ Pour `EndpointConfigName`, utilisez le nom de la configuration de point de terminaison que vous souhaitez utiliser.
+ Sous `DeploymentConfig` et `BlueGreenUpdatePolicy`, dans `TrafficRoutingConfiguration`, définissez le paramètre `Type` sur `LINEAR`. Cela permet de spécifier que le déploiement utilise le déplacement de trafic linéaire.
+ Dans le champ `LinearStepSize`, vous pouvez changer la taille des étapes en modifiant les paramètres `Type` et `Value`. Pour `Type`, utilisez `CAPACITY_PERCENT`, c'est-à-dire le pourcentage de votre flotte verte que vous souhaitez utiliser comme taille d'étape, puis définissez `Value` sur `20`. Dans cet exemple, vous activez 20 % de la capacité de la flotte verte pour chaque étape de déplacement de trafic. Notez que lors de la personnalisation de la taille de votre étape linéaire, vous ne devez utiliser que des étapes qui représentent 10 à 50 % de la capacité de la flotte verte.
+ Pour `WaitIntervalInSeconds`, utilisez `300`. Le paramètre indique à SageMaker AI d’attendre la durée spécifiée (en secondes) entre chaque déplacement de trafic. Cet intervalle est la durée de la période de préparation entre chaque étape linéaire. Dans l’exemple précédent, SageMaker AI attend 5 minutes entre chaque déplacement de trafic.
+ Pour `TerminationWaitInSeconds`, utilisez `300`. Ce paramètre indique à SageMaker AI d’attendre le laps de temps spécifié (en secondes) une fois que la flotte verte est entièrement active avant de résilier les instances de la flotte bleue. Dans cet exemple, SageMaker AI attend 5 minutes après la dernière période de préparation avant de résilier la flotte bleue.
+ Pour `MaximumExecutionTimeoutInSeconds`, utilisez `3600`. Ce paramètre définit la durée maximale pendant laquelle le déploiement peut s'exécuter avant qu'il n'expire. Dans l'exemple précédent, votre déploiement doit être exécuté en moins d'une heure.
+ Dans `AutoRollbackConfiguration`, dans le champ `Alarms`, vous pouvez ajouter vos alarmes CloudWatch par nom. Créez un `AlarmName: ` pour chaque alarme que vous souhaitez utiliser.
### Comment mettre à jour un point de terminaison avec une politique de mise à jour bleue/verte (API) existante
Lorsque vous utilisez l'API [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) pour créer un point de terminaison, vous pouvez éventuellement spécifier une configuration de déploiement à réutiliser pour les futures mises à jour du point de terminaison. Vous pouvez utiliser les mêmes options `DeploymentConfig` que l'exemple d'API UpdateEndpoint précédent. Il n'y a aucun changement dans le comportement de l'API CreateEndpoint. La spécification de la configuration de déploiement n'effectue pas automatiquement une mise à jour bleu/vert sur votre point de terminaison.
La possibilité d'utiliser une configuration de déploiement précédente se produit lorsque vous utilisez l'API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) pour mettre à jour votre point de terminaison. Lors de la mise à jour de votre point de terminaison, vous pouvez utiliser l'option `RetainDeploymentConfig` pour conserver la configuration de déploiement que vous avez spécifiée lors de la création du point de terminaison.
Lorsque vous appelez l'API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html), définissez `RetainDeploymentConfig` sur `True` pour conserver les options `DeploymentConfig` de votre configuration de point de terminaison d'origine.
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
RetainDeploymentConfig=True
)
```
### Comment mettre à jour un point de terminaison (CLI)
Si vous utilisez la AWS CLI, l'exemple suivant montre comment démarrer un déploiement linéaire bleu/vert à l'aide de la commande [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html).
```
update-endpoint
--endpoint-name
--endpoint-config-name
--deployment-config '{"BlueGreenUpdatePolicy": {"TrafficRoutingConfiguration": {"Type": "LINEAR",
"LinearStepSize": {"Type": "CAPACITY_PERCENT", "Value": 20}, "WaitIntervalInSeconds": 300},
"TerminationWaitInSeconds": 300, "MaximumExecutionTimeoutInSeconds": 3600},
"AutoRollbackConfiguration": {"Alarms": [{"AlarmName": ""}]}'
```
Pour configurer l'option de déplacement de trafic linéaire, procédez comme suit :
+ Pour `endpoint-name`, utilisez le nom du point de terminaison que vous souhaitez mettre à jour.
+ Pour `endpoint-config-name`, utilisez le nom de la configuration de point de terminaison que vous souhaitez utiliser.
+ Pour `deployment-config`, utilisez un objet JSON [BlueGreenUpdatePolicy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_BlueGreenUpdatePolicy.html).
**Note**
Si vous préférez enregistrer votre objet JSON dans un fichier, consultez [Générer un squelette AWS CLI et des paramètres d’entrée](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) dans le *Guide de l’utilisateur AWS CLI*.
# Utilisation des déploiements propagés
Lorsque vous mettez à jour votre point de terminaison, vous pouvez spécifier un déploiement propagé afin de déplacer progressivement le trafic de votre ancienne flotte vers une nouvelle flotte. Vous pouvez contrôler la taille des étapes de déplacement du trafic, ainsi que définir une période d'évaluation pour surveiller les nouvelles instances afin de détecter les problèmes avant de résilier les instances de l'ancienne flotte. Avec les déploiements propagés, les instances de l'ancienne flotte sont nettoyées après chaque déplacement de trafic vers la nouvelle flotte, ce qui réduit le nombre d'instances supplémentaires nécessaires pour mettre à jour votre point de terminaison. Cela est particulièrement utile pour les instances accélérées très demandées.
Les déploiements propagés remplacent progressivement le déploiement précédent de la version de votre modèle par la nouvelle version en mettant à jour votre point de terminaison dans des tailles de lots configurables. Le comportement de transfert du trafic des déploiements progressifs est similaire au [mode de transfert linéaire du trafic](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-blue-green-linear.html) dans blue/green les déploiements, mais les déploiements progressifs vous permettent de réduire les besoins en capacité par rapport aux déploiements. blue/green Grâce aux déploiements propagés, moins d'instances sont actives à la fois et vous pouvez contrôler de manière plus précise le nombre d'instances que vous souhaitez mettre à jour dans la nouvelle flotte. Vous devriez envisager d'utiliser un déploiement progressif plutôt qu'un blue/green déploiement si vous avez de grands modèles ou un point de terminaison de grande taille comportant de nombreuses instances.
La liste suivante décrit les principales fonctionnalités des déploiements progressifs dans Amazon SageMaker AI :
+ **Période de préparation.**La période de préparation est une durée définie pour contrôler la nouvelle flotte avant de passer à la phase de déploiement suivante. Si l'une des alarmes prédéfinies se déclenche au cours d'une période de préparation, tout le trafic des points de terminaison est restauré sur l'ancienne flotte. La période de préparation vous aide à renforcer la confiance dans votre mise à jour avant de rendre le déplacement de trafic permanent.
+ **Taille du lot propagé.** Vous pouvez contrôler de manière précise la taille de chaque lot pour le déplacement du trafic, ou le nombre d'instances que vous souhaitez mettre à jour dans chaque lot. Ce nombre peut varier de 5 à 50 % de la taille de votre flotte. Vous pouvez spécifier la taille du lot sous forme de nombre d'instances ou de pourcentage global de votre flotte.
+ **Restaurations automatiques.**Vous pouvez spécifier les CloudWatch alarmes Amazon que l' SageMaker IA utilise pour surveiller le nouveau parc. Si un problème lié au code mis à jour déclenche l'une des alarmes, l' SageMaker IA initie un retour automatique à l'ancienne flotte afin de maintenir la disponibilité, minimisant ainsi les risques.
**Note**
Si votre point de terminaison utilise l'une des fonctionnalités répertoriées sur la page [Exclusions](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-exclusions.html), vous ne pouvez pas utiliser de déploiement propagé.
## Comment ça marche
Lors d'un déploiement continu, l' SageMaker IA fournit l'infrastructure nécessaire pour transférer le trafic de l'ancienne flotte vers la nouvelle flotte sans avoir à fournir toutes les nouvelles instances en même temps. SageMaker L'IA utilise les étapes suivantes pour transférer le trafic :
1. SageMaker AI approvisionne le premier lot d'instances de la nouvelle flotte.
1. Une partie du trafic est transférée des anciennes instances vers le premier lot de nouvelles instances.
1. Après la période de cuisson, si aucune CloudWatch alarme Amazon n'est déclenchée, l' SageMaker IA nettoie un lot d'anciennes instances.
1. SageMaker L'IA continue de provisionner, de déplacer et de nettoyer les instances par lots jusqu'à ce que le déploiement soit terminé.
Si une alarme se déclenche pendant l'une des périodes de préparation, le trafic est restauré vers l'ancienne flotte dans des lots d'une taille que vous spécifiez. Vous pouvez également spécifier le déploiement propagé pour rediriger 100 % du trafic vers l'ancienne flotte si une alarme se déclenche.
Le schéma suivant montre la progression d'un déploiement propagé réussi, comme décrit dans les étapes précédentes.
![\[Étapes d’un déplacement réussi du trafic de l’ancienne flotte vers la nouvelle lors d’un déploiement propagé.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/deployment-guardrails-rolling-diagram.png)
Pour créer un déploiement propagé, il vous suffit de spécifier la configuration de déploiement souhaitée. SageMaker L'IA gère ensuite le provisionnement de nouvelles instances, la résiliation des anciennes instances et le transfert du trafic pour vous. Vous pouvez créer et gérer votre déploiement par le biais de l'[CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) SageMaker API [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)et des AWS Command Line Interface commandes existantes.
## Conditions préalables
Avant de configurer un déploiement continu, vous devez créer des CloudWatch alarmes Amazon pour surveiller les métriques depuis votre terminal. Si l'une des alarmes se déclenche pendant la période de préparation, le trafic commence alors à se restaurer sur votre ancienne flotte. Pour savoir comment configurer des CloudWatch alarmes sur un terminal, consultez la page des conditions préalables : [Configuration et surveillance de la restauration automatique](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-configuration.html). Pour en savoir plus sur les CloudWatch alarmes, consultez la section [Utilisation des CloudWatch alarmes Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html) dans le *guide de CloudWatch l'utilisateur Amazon*.
Consultez également la page [Exclusions](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-exclusions.html) pour vous assurer que votre point de terminaison répond aux exigences d'un déploiement propagé.
## Détermination de la taille du lot propagé
Avant de mettre à jour votre point de terminaison, déterminez la taille du lot que vous souhaitez utiliser pour transférer progressivement le trafic vers la nouvelle flotte.
Pour les déploiements propagés, vous pouvez spécifier une taille de lot comprise entre 5 et 50 % de la capacité de votre flotte. Si vous choisissez un lot de grande taille, le déploiement s'effectue plus rapidement. Cependant, gardez à l'esprit que le point de terminaison a besoin de plus de capacité lors de la mise à jour, ce qui correspond à peu près à la surcharge de la taille du lot. Si vous choisissez une taille de lot plus petite, le déploiement prend plus de temps, mais vous utilisez moins de capacité pendant le déploiement.
## Configuration d'un déploiement propagé
Une fois que vous êtes prêt pour votre déploiement et que vous avez configuré des CloudWatch alarmes pour votre terminal, vous pouvez utiliser l'[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API SageMaker AI ou la commande [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) AWS Command Line Interface pour lancer le déploiement.
**Comment mettre à jour un point de terminaison**
L'exemple suivant montre comment vous pouvez mettre à jour votre point de terminaison avec un déploiement continu à l'aide de la méthode [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/update_endpoint.html) du client SageMaker Boto3 AI.
Pour configurer un déploiement propagé, utilisez l'exemple et les champs suivants :
+ Pour `EndpointName`, utilisez le nom du point de terminaison existant que vous souhaitez mettre à jour.
+ Pour `EndpointConfigName`, utilisez le nom de la configuration de point de terminaison que vous souhaitez utiliser.
+ Dans l'`AutoRollbackConfiguration`objet, dans le `Alarms` champ, vous pouvez ajouter vos CloudWatch alarmes par leur nom. Créez un `AlarmName: ` pour chaque alarme que vous souhaitez utiliser.
+ Sous `DeploymentConfig`, pour l'objet `RollingUpdatePolicy`, spécifiez les champs suivants :
+ `MaximumExecutionTimeoutInSeconds` : la limite de temps pour le déploiement total. Le dépassement de cette limite entraîne un délai d'attente. La valeur maximale que vous pouvez spécifier pour ce champ est de 28 800 secondes, soit 8 heures.
+ `WaitIntervalInSeconds`— La durée de la période de cuisson, pendant laquelle l' SageMaker IA surveille les alarmes pour chaque lot du nouveau parc.
+ `MaximumBatchSize` : spécifiez le `Type` de lot que vous souhaitez utiliser (le nombre d'instances ou le pourcentage global de votre flotte) et la `Value`, ou la taille de chaque lot.
+ `RollbackMaximumBatchSize` : utilisez cet objet pour spécifier la stratégie de restauration en cas de déclenchement d'une alarme. Spécifiez le `Type` de lot que vous souhaitez utiliser (le nombre d'instances ou le pourcentage global de votre flotte) et la `Value`, ou la taille de chaque lot. Si vous ne spécifiez pas ces champs, ou si vous définissez la valeur sur 100 % de votre terminal, l' SageMaker IA utilise une stratégie de blue/green réduction et ramène tout le trafic vers l'ancien parc lorsqu'une alarme se déclenche.
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
},
]
},
"RollingUpdatePolicy": {
"MaximumExecutionTimeoutInSeconds": number,
"WaitIntervalInSeconds": number,
"MaximumBatchSize": {
"Type": "INSTANCE_COUNT" | "CAPACITY_PERCENTAGE" (default),
"Value": number
},
"RollbackMaximumBatchSize": {
"Type": "INSTANCE_COUNT" | "CAPACITY_PERCENTAGE" (default),
"Value": number
},
}
}
)
```
Après avoir mis à jour votre point de terminaison, vous souhaiterez peut-être vérifier le statut de votre déploiement propagé et vérifier son état. Vous pouvez consulter l'état de votre point de terminaison dans la console SageMaker AI, ou vous pouvez consulter l'état de votre point de terminaison à l'aide de l'[DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API.
Dans l'objet `VariantStatus` renvoyé par l'API `DescribeEndpoint`, le champ `Status` vous indique le déploiement actuel ou le statut opérationnel de votre point de terminaison. Pour plus d'informations sur les statuts possibles et leur signification, consultez [ProductionVariantStatus](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariantStatus.html).
Si vous avez tenté d'effectuer un déploiement propagé et que le statut de votre point de terminaison est `UpdateRollbackFailed`, consultez la section suivante pour obtenir de l'aide avec le dépannage.
## Gestion des défaillances
Si vos déploiements propagés échouent et que la restauration automatique échoue également, votre point de terminaison peut se retrouver avec un statut `UpdateRollbackFailed`. Ce statut signifie que différentes configurations de point de terminaison sont déployées sur les instances situées derrière votre point de terminaison et que celui-ci fonctionne avec un mélange d'anciennes et de nouvelles configurations de point de terminaison.
Vous pouvez effectuer un autre appel à l'[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API pour rétablir l'état de santé de votre terminal. Spécifiez la configuration de point de terminaison et la configuration de déploiement souhaitées (déploiement propagé, déploiement bleu/vert, ou aucun des deux) pour mettre à jour votre point de terminaison.
Vous pouvez appeler l'[DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API pour vérifier à nouveau l'état de votre point de terminaison, qui est renvoyé dans l'`VariantStatus`objet sous forme de `Status` champ. Si votre mise à jour est réussie, le `Status` de votre point de terminaison revient à `InService`.
# Exclusions
Lorsque vous effectuez un déploiement bleu/vert ou propagé, votre nouvelle configuration de point de terminaison doit porter le même nom de variante que l'ancienne configuration du point de terminaison. Il existe également des exclusions basées sur des fonctions qui rendent votre point de terminaison incompatible avec les barrières de protection de déploiement pour le moment. Si votre point de terminaison utilise l'une des fonctionnalités suivantes, vous ne pouvez pas utiliser de barrière de protection de déploiement sur votre point de terminaison et votre point de terminaison reviendra à un déploiement bleu/vert avec un déplacement du trafic tout à la fois et pas de période de préparation finale :
+ Conteneurs de marketplace
+ Points de terminaison qui utilisent des instances Inf1 (basées sur Inferentia)
Si vous effectuez un déploiement propagé, il existe des exclusions supplémentaires basées sur les fonctionnalités :
+ Points de terminaison d'inférence sans serveur
+ Points de terminaison d'inférence à variantes multiples
# Essais miroirs
Avec Amazon SageMaker AI, vous pouvez évaluer toute modification apportée à votre infrastructure de modèle en comparant ses performances à celles de l’infrastructure actuellement déployée. Cette pratique est connue sous le nom d’essai miroir. Les essais miroirs peuvent vous aider à détecter les erreurs de configuration et les problèmes de performances potentiels avant qu’ils n’affectent les utilisateurs finaux. Avec SageMaker AI, vous n’avez pas besoin d’investir dans la création de votre infrastructure d’essai miroir, vous pouvez donc vous concentrer sur le développement de modèles.
Vous pouvez utiliser cette fonction pour valider les modifications apportées à n’importe quel composant de votre variante de production, à savoir le modèle, le conteneur ou l’instance, sans aucun impact sur l’utilisateur final. Ils sont utiles dans les situations suivantes, mais sans s’y limiter :
+ Vous envisagez de promouvoir en production un nouveau modèle qui a été validé hors ligne, mais vous souhaitez évaluer des métriques de performances opérationnelles telles que la latence et le taux d’erreur avant de prendre cette décision.
+ Vous envisagez de modifier le conteneur de votre conteneur d’infrastructure, par exemple en corrigeant des vulnérabilités ou en effectuant une mise à niveau vers des versions plus récentes, et vous souhaitez évaluer l’impact de ces modifications avant de passer à la production.
+ Vous envisagez de modifier votre instance de ML et souhaitez évaluer les performances de la nouvelle instance avec des demandes d’inférence en direct.
La console SageMaker AI propose une expérience guidée pour gérer le flux de travail des essais miroirs. Vous pouvez configurer des essais miroirs pour une durée prédéfinie, surveiller la progression de l’essai via un tableau de bord en temps réel, effectuer un nettoyage une fois terminé et agir en fonction des résultats. Sélectionnez une variante de production sur laquelle effectuer des essais et SageMaker AI déploie automatiquement la nouvelle variante en mode shadow et lui achemine une copie des demandes d’inférence en temps réel au sein du même point de terminaison. Seules les réponses de la variante de production sont renvoyées à l’application appelante. Vous pouvez choisir de supprimer ou de journaliser les réponses de la variante shadow à des fins de comparaison hors ligne. Pour plus d’informations sur les variantes de production et shadow, consultez [Validation de modèles en production](model-validation.md).
Consultez [Création d’un test shadow](shadow-tests-create.md) pour des instructions sur la création d’un essai miroir.
**Note**
Il est possible que certaines fonctionnalités du point de terminaison rendent votre point de terminaison incompatible avec les essais miroirs. Si votre point de terminaison utilise l’une des fonctionnalités suivantes, vous ne pouvez pas utiliser d’essais miroirs sur votre point de terminaison et votre demande de configuration d’essais miroirs entraînera des erreurs de validation.
Inférence sans serveur
Inférence asynchrone
Conteneurs de marketplace
Points de terminaison multi-conteneurs
Points de terminaison multi-modèles
Points de terminaison qui utilisent des instances Inf1 (basées sur Inferentia)
# Création d’un test shadow
Vous pouvez créer un test shadow pour comparer les performances d’une variante shadow à celles d’une variante de production. Vous pouvez exécuter le test sur un point de terminaison existant qui répond à des demandes d’inférence ou vous pouvez créer un nouveau point de terminaison sur lequel exécuter le test.
Pour créer un shadow test, vous devez spécifier les informations suivantes :
+ *Variante de production* qui reçoit et répond à 100 % des demandes d’inférence entrantes.
+ *Variante shadow* qui reçoit un pourcentage des demandes entrantes, répliquées à partir de la variante de production, mais qui ne renvoie aucune réponse.
Pour chaque variante, vous pouvez utiliser l' SageMaker IA pour contrôler le modèle, le type d'instance et le nombre d'instances. Vous pouvez configurer le pourcentage de demandes entrantes, appelé pourcentage d'échantillonnage du trafic, que vous souhaitez répliquer vers votre variante fictive. SageMaker L'IA gère la réplication des demandes vers votre variante fictive et vous pouvez modifier le pourcentage d'échantillonnage du trafic lorsque votre test est planifié ou en cours d'exécution. Vous pouvez activer la capture de données en option pour journaliser les demandes et les réponses de vos variantes de production et de vos variantes shadow.
**Note**
SageMaker L'IA prend en charge un maximum d'une variante d'ombre par point de terminaison. Pour un point de terminaison doté d’une variante shadow, il ne peut y avoir qu’une seule variante de production.
Vous pouvez programmer le début du test à tout moment et le poursuivre pendant une durée spécifiée. La durée par défaut est de 7 jours et la durée maximale est de 30 jours. Une fois le test terminé, le point de terminaison revient à l’état dans lequel il se trouvait avant le début du test. Cela garantit que vous n’avez pas à nettoyer manuellement les ressources à la fin du test.
Vous pouvez surveiller un test en cours d'exécution via un tableau de bord dans la console SageMaker AI. Le tableau de bord fournit une comparaison côte à côte des métriques d’invocation et des métriques d’instance entre les variantes de production et les variantes shadow, ainsi qu’une vue tabulaire contenant des statistiques de métriques pertinentes. Ce tableau de bord est également disponible pour les tests terminés. Une fois que vous avez examiné les métriques, vous pouvez choisir de promouvoir la variante shadow en tant que nouvelle variante de production ou de conserver la variante de production existante. Une fois que vous avez promu la variante shadow, elle répond à toutes les demandes entrantes. Pour de plus amples informations, veuillez consulter [Promotion d’une variante shadow](shadow-tests-complete.md#shadow-tests-complete-promote).
La procédure suivante décrit comment créer un test parallèle via la console SageMaker AI. Le flux de travail varie selon que vous souhaitez utiliser un point de terminaison existant ou en créer un nouveau pour le test shadow.
**Topics**
+ [Conditions préalables](#shadow-tests-create-prerequisites)
+ [Saisir les détails du test shadow](#shadow-tests-create-console-shadow-test-details)
+ [Saisir les paramètres du test shadow](#shadow-tests-create-console-shadow-test-settings)
## Conditions préalables
Avant de créer un test parallèle avec la console SageMaker AI, vous devez disposer d'un modèle d' SageMaker IA prêt à être utilisé. Pour plus d'informations sur la création d'un modèle d' SageMaker IA, consultez[Déploiement de modèles pour l’inférence en temps réel](realtime-endpoints-deploy-models.md).
Vous pouvez commencer par des tests fictifs avec un point de terminaison existant avec une variante de production et une variante fantôme, un point de terminaison existant avec uniquement une variante de production ou simplement les modèles d' SageMaker IA que vous souhaitez comparer. Les tests shadow permettent de créer un point de terminaison et d’ajouter des variantes avant le début du test.
**Note**
Il est possible que certaines fonctionnalités du point de terminaison rendent votre point de terminaison incompatible avec les essais miroirs. Si votre point de terminaison utilise l’une des fonctionnalités suivantes, vous ne pouvez pas utiliser d’essais miroirs sur votre point de terminaison et votre demande de configuration d’essais miroirs entraînera des erreurs de validation.
Inférence sans serveur
Inférence asynchrone
Conteneurs de marketplace
Points de terminaison multi-conteneurs
Points de terminaison multimodèles
Points de terminaison qui utilisent des instances Inf1 (basées sur Inferentia)
## Saisir les détails du test shadow
Pour commencer à créer votre test shadow, remplissez la page **Enter shadow test details**(Saisir les détails du test shadow) en procédant comme suit :
1. Ouvrez la [console SageMaker AI](https://console.aws.amazon.com/sagemaker/).
1. Dans le volet de navigation de gauche, sélectionnez **Inference** (Inférence), puis **Shadow tests** (Tests shadow).
1. Choisissez **Create shadow test** (Créer un test shadow).
1. Sous **Name** (Nom), saisissez un nom pour le test.
1. (Facultatif) Dans le champ **Description**, saisissez une description du test.
1. **(Facultatif) Spécifiez **Tags** (Balises) à l’aide des paires Key** (Clé) et **Value** (Valeur).
1. Choisissez **Suivant**.
## Saisir les paramètres du test shadow
Après avoir rempli la page **Enter shadow test details**(Saisir les détails du test shadow), remplissez la page **Enter shadow test settings** (Saisir les paramètres du test shadow). Si vous possédez déjà un point de terminaison SageMaker AI Inference et une variante de production, suivez le flux de travail **Utiliser un point de terminaison existant**. Si vous n’avez pas encore de point de terminaison, suivez le flux de travail **Create a new endpoint** (Créer un point de terminaison).
------
#### [ Use an existing endpoint ]
Si vous souhaitez utiliser un point de terminaison existant pour votre test, remplissez la page **Enter shadow test settings** (Saisir les paramètres du test shadow) en procédant comme suit :
1. Choisissez un rôle auquel est attachée la politique IAM `AmazonSageMakerFullAccess`.
1. Choisissez **Utiliser un point de terminaison existant**, puis choisissez l’un des points de terminaison disponibles.
1. (Facultatif) Pour chiffrer le volume de stockage sur votre point de terminaison, choisissez une clé KMS existante ou choisissez **Enter a KMS key ARN** (Entrer un ARN de clé KMS) dans la liste déroulante sous **Encryption key** (Clé de chiffrement). Si vous choisissez la deuxième option, un champ permettant d’entrer l’ARN de la clé KMS apparaît. Entrez l’ARN de la clé KMS dans ce champ.
1. Si vous avez plusieurs variantes de production derrière ce point de terminaison, supprimez celles que vous ne souhaitez pas utiliser pour le test. Vous pouvez supprimer une variante de modèle en la sélectionnant, puis en choisissant **Remove** (Supprimer).
1. Si vous n’avez pas encore de variante shadow, ajoutez-en une. Pour ajouter une variante shadow, procédez comme suit :
1. Choisissez **Ajouter**.
1. Choisissez **Shadow variant** (Variante shadow).
1. Dans la boîte de dialogue **Add model** (Ajouter un modèle), sélectionnez le modèle à utiliser pour votre variante shadow.
1. Choisissez **Enregistrer**.
1. (Facultatif) À l’étape précédente, la variante shadow est ajoutée avec les paramètres par défaut. Pour modifier ces paramètres, sélectionnez la variante shadow et choisissez **Edit** (Modifier). La boîte de dialogue **Modifier la variante shadow** s’affiche. Pour plus d’informations sur comment remplir cette boîte de dialogue, consultez [Modifier un essai miroir](shadow-tests-view-monitor-edit-individual.md).
1. Dans la section **Schedule** (Calendrier), entrez la durée du test en procédant comme suit :
1. Choisissez la case sous **Duration** (Durée). Un calendrier contextuel s’affiche.
1. Sélectionnez les dates de début et de fin dans le calendrier ou saisissez les dates de début et de fin dans les champs **Start date** (Date de début) et **End date** (Date de fin), respectivement.
1. (Facultatif) Pour les champs **Start time** (Heure de début) et **End time** (Heure de fin), entrez les heures de début et de fin, respectivement, au format 24 heures.
1. Cliquez sur **Appliquer**.
La durée minimale est de 1 heure et la durée maximale de 30 jours.
1. (Facultatif) Activez l’option **Enable data capture** -Activer la capture de données) pour enregistrer les informations de demande d’inférence et de réponse de votre point de terminaison dans un compartiment Amazon S3, puis entrez l’emplacement du compartiment Amazon S3.
1. Choisissez **Create shadow test** (Créer un test shadow).
------
#### [ Create a new endpoint ]
Si n’avez pas de point de terminaison existant ou si vous voulez créez un nouveau point de terminaison pour votre test, remplissez la page **Enter shadow test settings** (Saisir les paramètres du test shadow) en procédant comme suit :
1. Choisissez un rôle auquel est attachée la politique IAM `AmazonSageMakerFullAccess`.
1. Choisissez **Create a new endpoint** (Créer un point de terminaison).
1. Sous **Name** (Nom), saisissez un nom pour le point de terminaison.
1. Ajoutez une variante de production et une variante shadow au point de terminaison :
+ Pour ajouter une variante de production, choisissez **Add** (Ajouter), puis choisissez **Production variant** (Variante de production). Dans la boîte de dialogue **Add model** (Ajouter un modèle), sélectionnez le modèle à utiliser pour votre variante de production, puis choisissez **Save** (Enregistrer).
+ Pour ajouter une variante shadow, choisissez **Add** (Ajouter), puis **Shadow variant** (Variante shadow). Dans la boîte de dialogue **Add model** (Ajouter un modèle), sélectionnez le modèle à utiliser pour votre variante shadow, puis choisissez **Save** (Enregistrer).
1. (Facultatif) À l'étape précédente, la variante shadow est ajoutée avec les paramètres par défaut. Pour modifier ces paramètres, sélectionnez la variante shadow et choisissez **Edit** (Modifier). La boîte de dialogue **Modifier la variante shadow** s’affiche. Pour plus d’informations sur comment remplir cette boîte de dialogue, consultez [Modifier un essai miroir](shadow-tests-view-monitor-edit-individual.md).
1. Dans la section **Schedule** (Calendrier), entrez la durée du test en procédant comme suit :
1. Choisissez la case sous **Duration** (Durée). Un calendrier contextuel s'affiche.
1. Sélectionnez les dates de début et de fin dans le calendrier ou saisissez les dates de début et de fin sous **Start date** (Date de début) et **End date** (Date de fin), respectivement.
1. (Facultatif) Sous **Start time** (Heure de début) et **End time** (Heure de fin), entrez les heures de début et de fin, respectivement, au format 24 heures.
1. Cliquez sur **Appliquer**.
La durée minimale est de 1 heure et la durée maximale de 30 jours.
1. (Facultatif) Activez l’option **Enable data capture** -Activer la capture de données) pour enregistrer les informations de demande d’inférence et de réponse de votre point de terminaison dans un compartiment Amazon S3, puis entrez l’emplacement du compartiment Amazon S3.
1. Choisissez **Create shadow test** (Créer un test shadow).
------
Une fois les procédures précédentes terminées, vous devriez maintenant avoir un test programmé pour commencer à la date et à l’heure de début que vous avez spécifiées. Vous pouvez afficher la progression du test à partir d’un tableau de bord. Pour plus d’informations sur l’affichage de votre test et les actions à effectuer, consultez [Comment afficher, surveiller et modifier des essais miroirs](shadow-tests-view-monitor-edit.md).
# Comment afficher, surveiller et modifier des essais miroirs
Vous pouvez afficher les statuts de vos essais miroirs, surveiller leur progression à partir d’un tableau de bord et effectuer des actions, telles que démarrer ou arrêter un essai de manière anticipée ou supprimer un essai. Les rubriques suivantes montrent comment vous pouvez afficher et modifier vos essais miroirs à l’aide de la console SageMaker AI.
**Topics**
+ [Afficher des essais miroirs](shadow-tests-view-monitor-edit-list.md)
+ [Surveiller un essai miroir](shadow-tests-view-monitor-edit-dashboard.md)
+ [Démarrer un essai miroir de manière anticipée](shadow-tests-view-monitor-edit-start.md)
+ [Supprimer un essai miroir](shadow-tests-view-monitor-edit-delete.md)
+ [Modifier un essai miroir](shadow-tests-view-monitor-edit-individual.md)
# Afficher des essais miroirs
Vous pouvez afficher les statuts de tous vos essais miroirs sur la page **Essais miroirs** de la console SageMaker AI.
Pour afficher vos essais dans la console, procédez comme suit :
1. Ouvrez la [console SageMaker AI](https://console.aws.amazon.com/sagemaker/).
1. Sous le volet de navigation, sélectionnez **Inférence**.
1. Choisissez **Essais miroirs** pour afficher la page qui répertorie tous vos essais miroirs. La page devrait ressembler à la capture d’écran suivante, avec tous les essais répertoriés dans la section **Essais miroirs**.
![\[Liste de tous les essais miroirs.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/juxtaposer/shadow-test-landing-page.png)
Vous pouvez consulter le statut d’un essai dans la console sur la page **Essais miroirs** en consultant le champ **Statut** de l’essai.
Les statuts possibles d’un essai sont les suivants :
+ `Creating` : SageMaker AI est en train de créer votre essai.
+ `Created` : SageMaker AI a fini de créer votre essai et celui-ci débutera à l’heure prévue.
+ `Updating` : lorsque vous apportez des modifications à votre essai, celui-ci apparaît comme en cours de mise à jour.
+ `Starting` : SageMaker AI commence votre essai.
+ `Running` : votre essai est en cours.
+ `Stopping` : SageMaker AI arrête votre essai.
+ `Completed` : votre essai est terminé.
+ `Cancelled` : lorsque vous terminez votre essai de manière anticipée, il apparaît comme annulé.
# Surveiller un essai miroir
Vous pouvez afficher les détails d’un essai miroir et le surveiller pendant qu’il est en cours ou une fois terminé. SageMaker AI présente un tableau de bord en temps réel qui compare les métriques opérationnelles telles que la latence du modèle et le taux d’erreur agrégé, des variantes de production et des variantes shadow.
Pour afficher les détails d’un essai individuel dans la console, procédez comme suit :
1. Sélectionnez l’essai que vous voulez surveiller dans la section **Essai miroir** de la page **Essais miroirs**.
1. Dans la liste déroulante **Actions**, choisissez **Afficher**. Une page de présentation contenant les détails de l’essai et un tableau de bord des métriques s’affiche.
La page de présentation comporte les trois sections suivantes.
**Récapitulatif**
Cette section résume la progression et le statut de l’essai. Il affiche également les statistiques récapitulatives de la métrique choisie dans la liste déroulante **Sélectionner une métrique** de la sous-section **Métriques**. La capture d’écran suivante montre cette section.
![\[Section récapitulative de la page de présentation.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/juxtaposer/shadow-test-summary.png)
Dans la capture d’écran précédente, les onglets **Paramètres** et **Détails** affichent les paramètres que vous avez sélectionnés et les détails que vous avez saisis lors de la création de l’essai.
**Analyse**
Cette section montre un tableau de bord de métriques avec des graphiques séparés pour les métriques suivantes :
+ `Invocations`
+ `InvocationsPerInstance`
+ `ModelLatency`
+ `Invocation4XXErrors`
+ `Invocation5XXErrors`
+ `InvocationModelErrors`
+ `CPUUtilization`
+ `MemoryUtilization`
+ `DiskUtilization`
Les trois dernières métriques surveillent l’utilisation des ressources d’exécution du conteneur modèle. Les autres sont des métriques CloudWatch que vous pouvez utiliser pour analyser les performances de votre variante. En général, moins d’erreurs indiquent un modèle plus stable. Une latence plus faible indique soit un modèle plus rapide, soit une infrastructure plus rapide. Pour plus d’informations sur les métriques CloudWatch, consultez [SageMaker Métriques d'invocation des terminaux AI](monitoring-cloudwatch.md#cloudwatch-metrics-endpoint-invocation). La capture d’écran suivante montre le tableau de bord des métriques.
![\[Tableau de bord d’analyse des métriques.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/juxtaposer/shadow-test-analysis.png)
**Environnement**
Cette section présente les variantes que vous avez comparées lors de l’essai. Si vous êtes satisfait des performances de la variante shadow, sur la base des métriques susmentionnées, vous pouvez promouvoir la variante shadow en production en choisissant **Déployer la variante shadow**. Pour plus de détails sur le déploiement d’une variante shadow, consultez [Promotion d’une variante shadow](shadow-tests-complete.md#shadow-tests-complete-promote). Vous pouvez également modifier le pourcentage d’échantillonnage du trafic et poursuivre les essais en choisissant **Modifier le trafic**. Pour plus de détails sur la modification d’une variante shadow, consultez [Modifier un essai miroir](shadow-tests-view-monitor-edit-individual.md). La capture d’écran suivante montre cette section.
![\[Section Environnement de la page de présentation.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/juxtaposer/shadow-test-environment.png)
# Démarrer un essai miroir de manière anticipée
Vous pouvez démarrer votre essai avant l’heure de début prévue. Si la nouvelle durée de l’essai dépasse 30 jours, SageMaker AI fixe automatiquement la fin de l’essai à 30 jours après la nouvelle heure de début. Cette action lance immédiatement l’essai. Si vous souhaitez modifier l’heure de début ou de fin de l’essai, consultez [Modifier un essai miroir](shadow-tests-view-monitor-edit-individual.md).
Pour démarrer immédiatement votre essai, avant l’heure de début prévue, via la console, procédez comme suit :
1. Sélectionnez l’essai que vous voulez démarrer immédiatement dans la section **Essai miroir** de la page **Essais miroirs**.
1. Dans la liste déroulante **Actions**, choisissez **Démarrer**. La boîte de dialogue **Démarrer le essai miroir ?** s’affiche.
1. Choisissez **Démarrer maintenant**.
# Supprimer un essai miroir
Vous pouvez supprimer un essai si vous n’en avez plus besoin. La suppression de votre essai supprime uniquement les métadonnées de l’essai et non votre point de terminaison, vos variantes ou les données capturées dans Amazon S3. Si vous souhaitez que votre point de terminaison cesse de fonctionner, vous devez le supprimer. Pour plus d’informations sur la suppression d’un point de terminaison, consultez [Supprimer les points de terminaison et les ressources](realtime-endpoints-delete-resources.md).
Pour supprimer un essai via la console, procédez comme suit :
1. Sélectionnez l’essai que vous voulez supprimer dans la section **Essai miroir** de la page **Essais miroirs**.
1. Dans la liste déroulante **Actions**, choisissez **Supprimer**. La boîte de dialogue **Supprimer un essai miroir** s’affiche.
1. Dans la boîte de dialogue **Pour confirmer la suppression, tapez *delete* dans le champ.**, saisissez **delete**.
1. Sélectionnez **Supprimer**.
# Modifier un essai miroir
Vous pouvez modifier les essais planifiés et en cours. Avant le début de votre essai, vous pouvez modifier la description, la configuration de la variante fictive, la date de début et la date de fin de l’essai. Vous pouvez également activer ou désactiver la capture de données.
Une fois l’essai commencé, vous pouvez uniquement modifier la description, le pourcentage d’échantillonnage du trafic pour la variante shadow et la date de fin.
Pour modifier les détails de votre essai via la console, procédez comme suit :
1. Sélectionnez l’essai que vous voulez modifier dans la section **Essai miroir** de la page **Essais miroirs**.
1. Dans la liste déroulante **Actions**, choisissez **Modifier**. La page **Saisir les détails du essai miroir** s’affiche.
1. (Facultatif) Dans le champ **Description**, saisissez une description de votre essai.
1. Choisissez **Suivant**. La page **Saisir les paramètres du essai miroir** s’affiche.
1. (Facultatif) Pour modifier votre variante shadow, procédez comme suit :
1. Sélectionnez la variante shadow et choisissez **Modifier**. La boîte de dialogue **Modifier la variante shadow** s’affiche. Si votre essai a déjà commencé, vous pouvez uniquement modifier le pourcentage d’échantillonnage du trafic.
1. (Facultatif) Dans **Nom**, saisissez le nouveau nom qui remplace l’ancien.
1. (Facultatif) Sous **Échantillon de trafic**, saisissez le nouveau pourcentage d’échantillonnage du trafic qui remplace l’ancien.
1. (Facultatif) Sous **Type d’instance**, choisissez le nouveau type d’instance dans la liste déroulante.
1. (Facultatif) Sous **Nombre d’instances**, saisissez le nouveau nombre d’instances qui remplace l’ancien.
1. Choisissez **Appliquer**.
Vous ne pouvez pas modifier le modèle dans votre variante shadow à l’aide de la procédure ci-dessus. Si vous souhaitez modifier le modèle, supprimez d’abord la variante shadow en la sélectionnant et en choisissant **Supprimer**. Ajoutez ensuite une nouvelle variante shadow.
1. (Facultatif) Pour modifier la durée de l’essai, procédez comme suit :
1. Choisissez la case sous **Durée** dans la section **Calendrier**. Un calendrier contextuel s’affiche.
1. Si votre essai n’a pas encore commencé, vous pouvez modifier les dates de début et de fin. Sélectionnez les nouvelles dates de début et de fin dans le calendrier ou saisissez les nouvelles dates de début et de fin sous **Date de début** et **Date de fin**, respectivement.
Si votre essai a déjà commencé, vous pouvez uniquement modifier la date de fin. Saisissez la nouvelle date de fin sous **Date de fin**.
1. (Facultatif) Si votre essai n’a pas encore commencé, vous pouvez modifier les heures de début et de fin. Saisissez les nouvelles heures de début et de fin sous **Heure de début** et **Heure de fin**, respectivement, au format 24 heures.
Si votre essai a déjà commencé, vous pouvez uniquement modifier l’heure de fin. Saisissez la nouvelle heure de fin sous **Heure de fin**, au format 24 heures.
1. Choisissez **Appliquer**.
1. (Facultatif) Activez ou désactivez l’option **Activer la capture de données**.
1. Choisissez **Modifier un essai miroir**.
# Réalisation d’un essai miroir
Votre test se termine automatiquement à la fin de la durée prévue, ou vous pouvez arrêter un essai en cours de manière anticipée. Une fois votre essai terminé, le statut de l’essai dans la section **Essais miroirs** de la page **Essais miroirs** indique **Terminé**. Vous pouvez ensuite passer en revue et analyser les dernières métriques de votre essai.
Vous pouvez utiliser le tableau de bord des métriques pour décider de promouvoir ou non la variante shadow en production. Pour plus d’informations sur l’analyse du tableau de bord des métriques de votre essai, consultez [Surveiller un essai miroir](shadow-tests-view-monitor-edit-dashboard.md).
Pour obtenir des instructions sur comment terminer votre essai avant l’heure de fin prévue, consultez [Terminer un essai miroir de manière anticipée](#shadow-tests-complete-early).
Pour obtenir des instructions sur la promotion de votre variante shadow en production, consultez [Promotion d’une variante shadow](#shadow-tests-complete-promote).
## Terminer un essai miroir de manière anticipée
L’une des raisons pour lesquelles vous souhaiterez peut-être effectuer un essai miroir en cours est si vous avez décidé que les métriques de votre variante shadow sont satisfaisantes et que vous souhaitez la promouvoir en production. Vous pouvez également décider de terminer l’essai si une ou plusieurs des variantes ne fonctionnent pas correctement.
Pour terminer votre essai avant la date de fin prévue, procédez de la façon suivante :
1. Sélectionnez l’essai que vous souhaitez marquer comme terminé dans la section **Essais miroirs** de la page **Essais miroirs**.
1. Dans la liste déroulante **Actions**, choisissez **Terminé**. La boîte de dialogue **Terminer l’essai miroir** apparaît.
1. Dans la boîte de dialogue, choisissez l’une des options suivantes :
+ **Oui, déployer la variante shadow**
+ **Non, supprimer la variante shadow**
1. (Facultatif) Dans la zone de texte **Commentaire**, saisissez la raison pour laquelle vous avez terminé l’essai avant l’heure de fin prévue.
1.
1. Si vous avez décidé de déployer la variante shadow, choisissez **Terminer et passer au déploiement**. La page **Déployer la variante shadow** s’affiche. Pour obtenir des instructions sur comment remplir cette page, consultez [Promotion d’une variante shadow](#shadow-tests-complete-promote).
1. Si vous décidez de supprimer la variante shadow, choisissez **Confirmer**.
## Promotion d’une variante shadow
Si vous avez décidé de remplacer votre variante de production par votre variante shadow, vous pouvez mettre à jour votre point de terminaison et promouvoir votre variante shadow pour répondre aux demandes d’inférence. Cela supprime votre variante de production actuelle de la production et la remplace par votre variante shadow.
Si votre essai miroir est toujours en cours, vous devez d’abord le terminer. Pour terminer votre essai miroir avant la fin prévue, suivez les instructions fournies dans [Terminer un essai miroir de manière anticipée](#shadow-tests-complete-early) avant de poursuivre cette section.
Lorsque vous promouvez une variante shadow en production, vous disposez des options suivantes pour le nombre d’instances de la variante shadow.
+ Vous pouvez conserver le nombre et le type d’instances de la variante de production. Si vous sélectionnez cette option, votre variante shadow est lancée en production avec le nombre d’instances actuel, ce qui garantit que votre modèle peut continuer à traiter le trafic de demandes à la même échelle.
+ Vous pouvez conserver le nombre d’instances et le type de votre variante shadow. Si vous souhaitez utiliser cette option, nous vous recommandons de réaliser un essai miroir avec un échantillonnage de trafic à 100 % pour vous assurer que la variante shadow peut traiter le trafic demandé à l’échelle actuelle.
+ Vous pouvez utiliser des valeurs personnalisées pour le nombre et le type d’instances. Si vous souhaitez utiliser cette option, nous vous recommandons de réaliser un essai miroir avec un échantillonnage de trafic à 100 % pour vous assurer que la variante shadow peut traiter le trafic demandé à l’échelle actuelle.
À moins que vous ne validiez le type ou le nombre d’instances, ou les deux, de la variante shadow, nous vous recommandons vivement de conserver le nombre et le type d’instances de la variante de production lors de la promotion de votre variante shadow.
Pour promouvoir votre variante shadow, procédez de la façon suivante :
1. Si votre essai miroir est terminé, procédez de la façon suivante :
1. Sélectionnez le test dans la section **Essai miroir** de la page **Essais miroirs**.
1. Dans la liste déroulante **Actions**, choisissez **Afficher**. Le tableau de bord s’affiche.
1. Choisissez **Déployer la variante shadow** dans la section **Environnement**. La page **Déployer la variante shadow** s’affiche.
Si votre essai n’est pas terminé, consultez [Terminer un essai miroir de manière anticipée](#shadow-tests-complete-early) pour le terminer.
1. Dans la section **Paramètres de la variante**, sélectionnez l’une des options suivantes :
+ **Conserver les paramètres de production**
+ **Conserver les paramètres shadow**
+ **Paramètres d’instance personnalisés**
Si vous avez sélectionné **Paramètres d’instance personnalisés**, procédez de la façon suivante :
1. Dans la liste déroulante **Type d’instance**, choisissez un type d’instance.
1. Sous **Nombre d’instances**, saisissez le nombre d’instances.
1. Dans la zone de texte **Entrez « déployer » pour confirmer le déploiement**, entrez **deploy**.
1. Choisissez **Déployer la variante shadow**.
Votre point de terminaison d’inférence SageMaker AI utilise désormais la variante shadow comme variante de production, et votre variante de production a été supprimée du point de terminaison.
# Bonnes pratiques
Lors de la création d’une expérience d’inférence, gardez à l’esprit les informations suivantes :
+ **Pourcentage d’échantillonnage du trafic** : l’échantillonnage de 100 % des demandes d’inférence vous permet de vérifier que votre variante shadow peut gérer le trafic de production lorsqu’elle est promue. Vous pouvez commencer avec un pourcentage d’échantillonnage de trafic plus faible et passer à la vitesse supérieure à mesure que vous gagnez en confiance avec votre variante, mais il est préférable de vous assurer d’avoir augmenté le trafic à 100 % avant la promotion.
+ **Type d’instance** : à moins que vous n’utilisiez des variantes shadow pour évaluer d’autres types ou tailles d’instance, nous vous recommandons d’utiliser le même type, la même taille et le même nombre d’instances afin de vous assurer que votre variante shadow peut gérer le volume de demandes d’inférence une fois que vous l’avez promue.
+ **Autoscaling** : pour vous assurer que votre variante shadow peut répondre à des pics de demandes d’inférence ou à des modifications des modèles de demandes d’inférence, nous vous recommandons vivement de configurer l’autoscaling sur vos variantes shadow. Pour savoir comment configurer l’autoscaling, consultez [Mise à l'échelle automatique des modèles Amazon SageMaker AI](endpoint-auto-scaling.md). Si vous avez configuré l’autoscaling, vous pouvez également valider les modifications apportées aux politiques d’autoscaling sans impact sur les utilisateurs.
+ **Surveillance des métriques** : une fois que vous avez lancé une expérience shadow et que vous avez reçu suffisamment d’appels, surveillez le tableau de bord des métriques pour vous assurer que les métriques telles que la latence et le taux d’erreur se situent dans des limites acceptables. Cela vous permet de détecter rapidement les erreurs de configuration et de prendre des mesures correctives. Pour plus d’informations sur comment surveiller les métriques d’une expérience d’inférence en cours, consultez [Comment afficher, surveiller et modifier des essais miroirs](shadow-tests-view-monitor-edit.md).
# Accès aux conteneurs via SSM
Amazon SageMaker AI vous permet de vous connecter en toute sécurité aux conteneurs Docker sur lesquels vos modèles sont déployés à des fins d'inférence à l'aide de AWS Systems Manager (SSM). Cela vous donne un accès au conteneur au niveau du shell afin que vous puissiez déboguer les processus exécutés dans le conteneur et enregistrer les commandes et les réponses avec Amazon CloudWatch. Vous pouvez également configurer une AWS PrivateLink connexion aux instances ML qui hébergent vos conteneurs pour accéder aux conteneurs via SSM en privé.
**Avertissement**
L'activation de l'accès SSM peut avoir un impact sur les performances de votre point de terminaison. Nous vous recommandons d'utiliser cette fonctionnalité avec vos points de terminaison de développement ou de test et non avec les points de terminaison en production. En outre, l' SageMaker IA applique automatiquement les correctifs de sécurité et remplace ou met fin aux instances de point de terminaison défectueuses dans les 10 minutes. Toutefois, pour les terminaux dotés de variantes de production compatibles SSM, l' SageMaker IA retarde d'un jour l'application des correctifs de sécurité et le remplacement ou l'arrêt des instances de point de terminaison défectueuses, afin de vous permettre de déboguer.
Les sections suivantes expliquent comment utiliser cette fonctionnalité.
## Allowlist
Vous devez contacter le service client et faire inscrire votre compte sur la liste d'autorisation pour utiliser cette fonctionnalité. Vous ne pouvez pas créer un point de terminaison avec l'accès à SSM activé si votre compte n'est pas autorisé dans la liste pour cet accès.
## Activer l'accès à SSM
Pour activer l'accès à SSM pour un conteneur existant sur un point de terminaison, mettez à jour le point de terminaison avec une nouvelle configuration de point de terminaison, avec le paramètre `EnableSSMAccess` défini sur `true`. L'exemple suivant fournit un exemple de configuration de point de terminaison.
```
{
"EndpointConfigName": "endpoint-config-name",
"ProductionVariants": [
{
"InitialInstanceCount": 1,
"InitialVariantWeight": 1.0,
"InstanceType": "ml.t2.medium",
"ModelName": model-name,
"VariantName": variant-name,
"EnableSSMAccess": true,
},
]
}
```
Pour plus d'informations sur l'activation de l'accès SSM, voir [Activer SSMAccess](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html#API_EnableSSMAccess).
## Configuration de l'IAM
### Autorisations IAM pour les points de terminaison
Si vous avez activé l'accès SSM pour une instance de point de terminaison, l' SageMaker IA démarre et gère l'[agent SSM](https://docs.aws.amazon.com/systems-manager/latest/userguide/ssm-agent.html) lorsqu'elle initie l'instance de point de terminaison. Pour permettre à l'agent SSM de communiquer avec les services SSM, ajoutez la politique suivante au rôle d'exécution sous lequel le point de terminaison s'exécute.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssmmessages:CreateControlChannel",
"ssmmessages:CreateDataChannel",
"ssmmessages:OpenControlChannel",
"ssmmessages:OpenDataChannel"
],
"Resource": "*"
}
]
}
```
------
### Autorisations IAM pour les utilisateurs
Ajoutez la politique suivante pour autoriser un utilisateur IAM à se connecter à une cible SSM lors d'une session SSM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:StartSession",
"ssm:TerminateSession"
],
"Resource": "*"
}
]
}
```
------
Vous pouvez restreindre le nombre de points de terminaison auxquels un utilisateur IAM peut se connecter en appliquant la politique suivante. Remplacez les *italicized placeholder text* par vos propres informations.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:StartSession"
],
"Resource": "arn:aws:sagemaker:us-east-2:111122223333:endpoint/endpoint-name"
}
]
}
```
------
## Accès SSM avec AWS PrivateLink
Si vos points de terminaison s'exécutent dans un cloud privé virtuel (VPC) qui n'est pas connecté à l'Internet public, vous pouvez activer AWS PrivateLink SSM. AWS PrivateLink restreint tout le trafic réseau entre vos instances de point de terminaison, SSM et Amazon EC2 vers le réseau Amazon. Pour plus d'informations sur la configuration de l'accès à SSM avec AWS PrivateLink, consultez [Configurer un point de terminaison d'un VPC pour Session Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-getting-started-privatelink.html).
## Journalisation avec Amazon CloudWatch Logs
Pour les points de terminaison compatibles avec l'accès SSM, vous pouvez enregistrer les erreurs depuis l'agent SSM avec Amazon Logs. CloudWatch Pour plus d'informations sur la façon de consigner les erreurs à l'aide des CloudWatch journaux, consultez la section [Journalisation de l'activité des sessions](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-logging.html). Le journal est disponible dans le flux de journaux SSM, `variant-name/ec2-instance-id/ssm`, sous le groupe de journaux du point de terminaison `/aws/sagemaker/endpoints/endpoint-name`. Pour plus d'informations sur la façon d'afficher le journal, voir [Afficher les données du journal envoyées à CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData).
Les variantes de production situées derrière votre point de terminaison peuvent comporter plusieurs modèles de conteneurs. Le journal de chaque modèle de conteneur est enregistré dans le flux de journaux. Chaque journal est précédé de `[sagemaker ssm logs][container-name]`, où `container-name` est soit le nom que vous avez donné au conteneur, soit le nom par défaut, tel que `container_0` et `container_1`.
## Accès aux modèles de conteneurs
Pour accéder à un conteneur de modèles sur votre instance de point de terminaison, vous avez besoin de son ID cible. L'ID cible est dans l'un des formats suivants :
+ `sagemaker-endpoint:endpoint-name_variant-name_ec2-instance-id` pour les conteneurs situés sur des points de terminaison de conteneur uniques
+ `sagemaker-endpoint:endpoint-name_variant-name_ec2-instance-id_container-name` pour les conteneurs situés sur des points de terminaison multi-conteneurs
L'exemple suivant montre comment vous pouvez utiliser le AWS CLI pour accéder à un modèle de conteneur à l'aide de son ID cible.
```
aws ssm start-session --target sagemaker-endpoint:prod-image-classifier_variant1_i-003a121c1b21a90a9_container_1
```
Si vous activez la journalisation, comme indiqué dans[Journalisation avec Amazon CloudWatch Logs](#ssm-access-logging), vous pouvez trouver la cible IDs de tous les conteneurs répertoriés au début du flux de journal SSM.
**Note**
Vous ne pouvez pas vous connecter à des conteneurs d'algorithmes 1P ou à des conteneurs de modèles obtenus à partir de l' SageMaker IA MarketPlace avec SSM. Vous pouvez toutefois vous connecter à des conteneurs d'apprentissage profond (DLCs) fournis par AWS ou à tout conteneur personnalisé dont vous êtes propriétaire.
Si vous avez activé l'isolation réseau pour un modèle de conteneur qui l'empêche d'effectuer des appels réseau sortants, vous ne pouvez pas démarrer de session SSM pour ce conteneur.
Vous ne pouvez accéder qu'à un conteneur à partir d'une seule session SSM. Pour accéder à un autre conteneur, même s'il se trouve derrière le même point de terminaison, démarrez une nouvelle session SSM avec l'ID cible de ce point de terminaison.
# Serveurs de modèles pour le déploiement de modèles avec Amazon SageMaker AI
Vous pouvez utiliser des modèles de serveurs populaires TorchServe, tels que DJL Serving et Triton Inference Server, pour déployer vos modèles sur l'IA. SageMaker Les rubriques suivantes expliquent comment procéder.
**Topics**
+ [Déployez des modèles avec TorchServe](deploy-models-frameworks-torchserve.md)
+ [Déploiement de modèles avec DJL Serving](deploy-models-frameworks-djl-serving.md)
+ [Déploiement de modèles avec Triton Inference Server](deploy-models-frameworks-triton.md)
# Déployez des modèles avec TorchServe
TorchServe est le modèle de serveur recommandé pour PyTorch, préinstallé dans le AWS PyTorch Deep Learning Container (DLC). Ce puissant outil offre aux clients une expérience cohérente et conviviale, offrant des performances élevées lors du déploiement de plusieurs PyTorch modèles sur différentes AWS instances, notamment le processeur, le GPU, le Neuron et le Graviton, quelle que soit la taille ou la distribution du modèle.
TorchServe prend en charge un large éventail de fonctionnalités avancées, notamment le traitement par lots dynamiques, le microtraitement, les A/B tests de modèles, le streaming, Torch XLA, TensorRT, ONNX et IPEX. De plus, il intègre parfaitement PyTorch la solution Pi pour les grands modèlesPPy, permettant une manipulation efficace des grands modèles. En outre, il TorchServe étend son support aux bibliothèques open source populaires telles que Accelerate DeepSpeed, Fast Transformers, etc., étendant ainsi encore ses capacités. AWS Les utilisateurs peuvent ainsi déployer et servir leurs PyTorch modèles en toute confiance, en tirant parti de sa polyvalence et de ses performances optimisées pour différentes configurations matérielles et types de modèles. TorchServe [Pour des informations plus détaillées, vous pouvez consulter la [PyTorchdocumentation](https://pytorch.org/serve/) et TorchServe plus encore GitHub.](https://github.com/pytorch/serve)
Le tableau suivant répertorie les solutions AWS PyTorch DLCs prises en charge par TorchServe.
| Type d’instance | SageMaker Lien vers le PyTorch DLC AI |
| --- | --- |
| CPU et GPU | [SageMaker PyTorch Conteneurs AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) |
| Neuron | [PyTorch Conteneurs Neuron](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) |
| Graviton | [SageMaker PyTorch Conteneurs AI Graviton](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) |
Les sections suivantes décrivent la configuration pour créer et tester PyTorch DLCs sur Amazon SageMaker AI.
## Prise en main
Avant de démarrer, vérifiez que les conditions préalables suivantes sont respectées :
1. Assurez-vous d'avoir accès à un AWS compte. Configurez votre environnement de manière à ce qu'ils AWS CLI puissent accéder à votre compte via un utilisateur AWS IAM ou un rôle IAM. Nous vous recommandons d'utiliser un rôle IAM. À des fins de test dans votre compte personnel, vous pouvez associer les politiques d'autorisations gérées suivantes au rôle IAM :
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AWS ServiceRoleForAmazonEKSNodegroup](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AWSServiceRoleForAmazonEKSNodegroup)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [Amazon S3 FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
1. Configurez vos dépendances de façon locale, comme indiqué dans l'exemple suivant :
```
from datetime import datetime
import os
import json
import logging
import time
# External Dependencies:
import boto3
from botocore.exceptions import ClientError
import sagemaker
sess = boto3.Session()
sm = sess.client("sagemaker")
region = sess.region_name
account = boto3.client("sts").get_caller_identity().get("Account")
smsess = sagemaker.Session(boto_session=sess)
role = sagemaker.get_execution_role()
# Configuration:
bucket_name = smsess.default_bucket()
prefix = "torchserve"
output_path = f"s3://{bucket_name}/{prefix}/models"
print(f"account={account}, region={region}, role={role}")
```
1. Récupérez l'image du PyTorch DLC, comme indiqué dans l'exemple suivant.
SageMaker Les images du PyTorch DLC AI sont disponibles dans toutes les AWS régions. Pour plus d'informations, consultez la [liste des images des conteneurs DLC](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only).
```
baseimage = sagemaker.image_uris.retrieve(
framework="pytorch",
region="",
py_version="py310",
image_scope="inference",
version="2.0.1",
instance_type="ml.g4dn.16xlarge",
)
```
1. Créez un espace de travail local.
```
mkdir -p workspace/
```
## Ajout d'un package
Les sections suivantes décrivent comment ajouter et préinstaller des packages à l'image de votre PyTorch DLC.
**Cas d'utilisation BYOC**
Les étapes suivantes expliquent comment ajouter un package à l'image de votre PyTorch DLC. Pour plus d'informations sur la personnalisation de votre conteneur, consultez la section [Création d'images personnalisées pour les AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md).
1. Supposons que vous souhaitiez ajouter un package à l'image du docker du PyTorch DLC. Créez un Dockerfile dans le répertoire `docker`, comme indiqué dans l'exemple suivant :
```
mkdir -p workspace/docker
cat workspace/docker/Dockerfile
ARG BASE_IMAGE
FROM $BASE_IMAGE
#Install any additional libraries
RUN pip install transformers==4.28.1
```
1. Créez et publiez l'image Docker personnalisée à l'aide du script [build\$1and\$1push.sh](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/docker/build_and_push.sh) suivant.
```
# Download script build_and_push.sh to workspace/docker
ls workspace/docker
build_and_push.sh Dockerfile
# Build and publish your docker image
reponame = "torchserve"
versiontag = "demo-0.1"
./build_and_push.sh {reponame} {versiontag} {baseimage} {region} {account}
```
**SageMaker Cas d'utilisation de la préinstallation de l'IA**
L'exemple suivant montre comment préinstaller un package dans votre conteneur de PyTorch DLC. Vous devez créer un fichier `requirements.txt` localement dans le répertoire `workspace/code`.
```
mkdir -p workspace/code
cat workspace/code/requirements.txt
transformers==4.28.1
```
## Création d'artefacts TorchServe de modèle
Dans l'exemple suivant, nous utilisons le [modèle MNIST](https://github.com/pytorch/serve/tree/master/examples/image_classifier/mnist) pré-entraîné. Nous créons un répertoire`workspace/mnist`, implémentons [mnist\$1handler.py](https://github.com/pytorch/serve/blob/master/examples/image_classifier/mnist/mnist_handler.py) en suivant les [instructions de service TorchServe personnalisées](https://github.com/pytorch/serve/blob/master/docs/custom_service.md#custom-service) et [configurons les paramètres du modèle (tels que la](https://github.com/pytorch/serve/tree/master/model-archiver#config-file) taille du lot et les travailleurs) dans [model-config.yaml](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/lama/model-config.yaml). Ensuite, nous utilisons l' TorchServe outil `torch-model-archiver` pour créer les artefacts du modèle et les télécharger sur Amazon S3.
1. Configurez les paramètres du modèle dans `model-config.yaml`.
```
ls -al workspace/mnist-dev
mnist.py
mnist_handler.py
mnist_cnn.pt
model-config.yaml
# config the model
cat workspace/mnist-dev/model-config.yaml
minWorkers: 1
maxWorkers: 1
batchSize: 4
maxBatchDelay: 200
responseTimeout: 300
```
1. Créez les artefacts du modèle en utilisant [torch-model-archiver ](https://github.com/pytorch/serve/tree/master/model-archiver#torch-model-archiver-for-torchserve).
```
torch-model-archiver --model-name mnist --version 1.0 --model-file workspace/mnist-dev/mnist.py --serialized-file workspace/mnist-dev/mnist_cnn.pt --handler workspace/mnist-dev/mnist_handler.py --config-file workspace/mnist-dev/model-config.yaml --archive-format tgz
```
Si vous souhaitez préinstaller un package, vous devez inclure le répertoire `code` dans le fichier `tar.gz`.
```
cd workspace
torch-model-archiver --model-name mnist --version 1.0 --model-file mnist-dev/mnist.py --serialized-file mnist-dev/mnist_cnn.pt --handler mnist-dev/mnist_handler.py --config-file mnist-dev/model-config.yaml --archive-format no-archive
cd mnist
mv ../code .
tar cvzf mnist.tar.gz .
```
1. Charger `mnist.tar.gz` dans Amazon S3.
```
# upload mnist.tar.gz to S3
output_path = f"s3://{bucket_name}/{prefix}/models"
aws s3 cp mnist.tar.gz {output_path}/mnist.tar.gz
```
## Utilisation de points de terminaison à modèle unique pour le déploiement avec TorchServe
L'exemple suivant vous montre comment créer un point de [terminaison d'inférence en temps réel à modèle unique](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html), déployer le modèle sur le point de terminaison et tester le point de terminaison à l'aide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/).
```
from sagemaker.model import Model
from sagemaker.predictor import Predictor
# create the single model endpoint and deploy it on SageMaker AI
model = Model(model_data = f'{output_path}/mnist.tar.gz',
image_uri = baseimage,
role = role,
predictor_cls = Predictor,
name = "mnist",
sagemaker_session = smsess)
endpoint_name = 'torchserve-endpoint-' + time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
predictor = model.deploy(instance_type='ml.g4dn.xlarge',
initial_instance_count=1,
endpoint_name = endpoint_name,
serializer=JSONSerializer(),
deserializer=JSONDeserializer())
# test the endpoint
import random
import numpy as np
dummy_data = {"inputs": np.random.rand(16, 1, 28, 28).tolist()}
res = predictor.predict(dummy_data)
```
## Utilisation de points de terminaison multimodèles pour le déploiement avec TorchServe
Les [points de terminaison multimodèles](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html) offrent une solution évolutive et économique pour l'hébergement d'un grand nombre de modèles au-delà d'un point de terminaison. Ils améliorent l'utilisation des points de terminaison en partageant la même flotte de ressources et un conteneur de service pour héberger tous vos modèles. Ils réduisent également les frais de déploiement, car l' SageMaker IA gère les modèles de chargement et de déchargement de manière dynamique, ainsi que le dimensionnement des ressources en fonction des modèles de trafic. Les points de terminaison multimodèles sont particulièrement utiles pour le deep learning et les modèles d'IA générative qui nécessitent une puissance de calcul accélérée.
En utilisant des points de terminaison multimodèles basés TorchServe sur l' SageMaker IA, vous pouvez accélérer votre développement en utilisant une pile de serveurs que vous connaissez bien, tout en tirant parti du partage des ressources et de la gestion simplifiée des modèles fournis par les points de terminaison multimodèles basés sur l' SageMaker IA.
L'exemple suivant vous montre comment créer un point de terminaison multimodèle, déployer le modèle sur le point de terminaison et tester le point de terminaison à l'aide du [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/). Vous trouverez des informations supplémentaires dans cet [exemple de bloc-notes](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/torchserve_multi_model_endpoint.ipynb).
```
from sagemaker.multidatamodel import MultiDataModel
from sagemaker.model import Model
from sagemaker.predictor import Predictor
# create the single model endpoint and deploy it on SageMaker AI
model = Model(model_data = f'{output_path}/mnist.tar.gz',
image_uri = baseimage,
role = role,
sagemaker_session = smsess)
endpoint_name = 'torchserve-endpoint-' + time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
mme = MultiDataModel(
name = endpoint_name,
model_data_prefix = output_path,
model = model,
sagemaker_session = smsess)
mme.deploy(
initial_instance_count = 1,
instance_type = "ml.g4dn.xlarge",
serializer=sagemaker.serializers.JSONSerializer(),
deserializer=sagemaker.deserializers.JSONDeserializer())
# list models
list(mme.list_models())
# create mnist v2 model artifacts
cp mnist.tar.gz mnistv2.tar.gz
# add mnistv2
mme.add_model(mnistv2.tar.gz)
# list models
list(mme.list_models())
predictor = Predictor(endpoint_name=mme.endpoint_name, sagemaker_session=smsess)
# test the endpoint
import random
import numpy as np
dummy_data = {"inputs": np.random.rand(16, 1, 28, 28).tolist()}
res = predictor.predict(date=dummy_data, target_model="mnist.tar.gz")
```
## Métriques
TorchServe prend en charge les métriques au niveau du système et au niveau du modèle. Vous pouvez activer les métriques en mode journal ou en mode Prometheus via la variable d'environnement `TS_METRICS_MODE`. Vous pouvez utiliser le fichier de configuration TorchServe central des métriques `metrics.yaml` pour spécifier les types de métriques à suivre, tels que le nombre de demandes, la latence, l'utilisation de la mémoire, l'utilisation du GPU, etc. En consultant ce fichier, vous pouvez obtenir des informations sur les performances et l'état des modèles déployés et surveiller efficacement le comportement TorchServe du serveur en temps réel. Pour des informations plus détaillées, consultez la [documentation sur TorchServe les métriques](https://github.com/pytorch/serve/blob/master/docs/metrics.md#torchserve-metrics).
Vous pouvez accéder aux journaux de TorchServe mesures similaires au format StatsD via le filtre de CloudWatch journal Amazon. Voici un exemple de journal de TorchServe mesures :
```
CPUUtilization.Percent:0.0|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
DiskAvailable.Gigabytes:318.0416717529297|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
```
# Déploiement de modèles avec DJL Serving
DJL Serving est une solution de service de modèle autonome universelle à hautes performances. Elle utilise plusieurs modèles ou flux de travail de deep learning et les rend disponibles via un point de terminaison HTTP.
Vous pouvez utiliser l'un des DJL Serving [Deep Learning Containers (DLCs)](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) pour y diffuser vos modèles. AWS Pour en savoir plus sur les types de modèles et les frameworks pris en charge, consultez le [ GitHubréférentiel DJL Serving](https://github.com/deepjavalibrary/djl-serving).
DJL Serving propose de nombreuses fonctionnalités qui vous aident à déployer vos modèles avec des performances élevées :
+ Facilité d'utilisation : DJL Serving peut fonctionner avec la plupart des modèles sans aucune modification. Vous apportez les artefacts de votre modèle et DJL Serving peut les héberger.
+ Prise en charge de plusieurs appareils et accélérateurs : DJL Serving prend en charge le déploiement de modèles sur CPUs GPUs, et AWS Inferentia.
+ Performances : DJL Serving exécute une inférence multithreads sur une seule machine virtuelle Java (JVM) afin d'augmenter le débit.
+ Traitement par lots dynamique : DJL Serving prend en charge le traitement par lots dynamique pour augmenter le débit.
+ Mise à l'échelle automatique : DJL Serving met automatiquement à l'échelle les applications de travail en fonction de la charge de trafic.
+ Support multimoteur — DJL Serving peut héberger simultanément des modèles utilisant différents frameworks (par exemple, PyTorch et TensorFlow).
+ Modèles d'ensemble et de flux de travail : DJL Serving prend en charge le déploiement de flux de travail complexes composés de plusieurs modèles et peut exécuter des parties du flux de travail sur CPUs et d'autres parties sur GPUs. Les modèles d'un flux de travail peuvent exploiter différents frameworks.
Les sections suivantes décrivent comment configurer un point de terminaison avec DJL Serving on SageMaker AI.
## Prise en main
Avant de démarrer, vérifiez que les conditions préalables suivantes sont respectées :
1. Assurez-vous d'avoir accès à un AWS compte. Configurez votre environnement de manière à ce qu'ils AWS CLI puissent accéder à votre compte via un utilisateur AWS IAM ou un rôle IAM. Nous vous recommandons d'utiliser un rôle IAM. À des fins de test dans votre compte personnel, vous pouvez associer les politiques d'autorisations gérées suivantes au rôle IAM :
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [Amazon S3 FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
1. Assurez-vous que le client [docker](https://docs.docker.com/get-docker/) est configuré sur votre système.
1. Connectez-vous à Amazon Elastic Container Registry et définissez les variables d'environnement suivantes :
```
export ACCOUNT_ID=
export REGION=
aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com
```
1. Extrayez l'image Docker.
```
docker pull 763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118
```
Pour toutes les images de conteneurs DJL Serving disponibles, consultez les [conteneurs d'inférence de grands modèles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers) et les [conteneurs d'inférence de CPU DJL Serving](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#djl-cpu-full-inference-containers). Lorsque vous choisissez une image dans les tableaux des liens précédents, remplacez la AWS région dans la colonne d'exemple d'URL par la région dans laquelle vous vous trouvez. Elles DLCs sont disponibles dans les régions répertoriées dans le tableau en haut de la page [Available Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
## Personnalisation de votre conteneur
Vous pouvez ajouter des packages aux images DLC de base pour personnaliser votre conteneur. Supposons que vous souhaitiez ajouter un package à l'image Docker `763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118`. Vous devez créer un fichier Docker avec l'image souhaitée comme image de base, ajouter les packages requis et envoyer l'image vers Amazon ECR.
Pour ajouter un package, exécutez les étapes suivantes :
1. Spécifiez les instructions pour exécuter les bibliothèques ou les packages souhaités dans le fichier Docker de l'image de base.
```
FROM 763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118
## add custom packages/libraries
RUN git clone https://github.com/awslabs/amazon-sagemaker-examples
```
1. Créez l'image Docker à partir de votre fichier Docker. Spécifiez votre référentiel Amazon ECR, le nom de l'image de base et une balise pour l'image. Si vous ne possédez pas de référentiel Amazon ECR, consultez [Utilisation d'Amazon ECR avec l' AWS CLI](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html) dans le *Guide de l'utilisateur Amazon ECR* pour savoir comment en créer un.
```
docker build -f Dockerfile -t /:
```
1. Transmettez l'image Docker dans le référentiel Amazon ECR.
```
docker push $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/:
```
Vous devriez maintenant disposer d'une image de conteneur personnalisée que vous pouvez utiliser pour le service de modèles. Pour d'autres exemples de personnalisation de votre conteneur, consultez [Building AWS Deep Learning Containers Custom Images](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md).
## Préparation des artefacts de votre modèle
Avant de déployer votre modèle sur l' SageMaker IA, vous devez empaqueter les artefacts de votre modèle dans un `.tar.gz` fichier. DJL Serving accepte les artefacts suivants dans vos archives :
+ Point de contrôle du modèle : fichiers qui stockent les poids de votre modèle.
+ `serving.properties` : fichier de configuration que vous pouvez ajouter pour chaque modèle. Placez `serving.properties` dans le même répertoire que votre fichier de modèle.
+ `model.py` : le code du gestionnaire d'inférence. Cela ne s'applique que lors de l'utilisation du mode Python. Si vous ne spécifiez pas `model.py`, djl-serving utilise l'un des gestionnaires par défaut.
Voici un exemple de structure `model.tar.gz` :
```
- model_root_dir # root directory
- serving.properties
- model.py # your custom handler file for Python, if you choose not to use the default handlers provided by DJL Serving
- model binary files # used for Java mode, or if you don't want to use option.model_id and option.s3_url for Python mode
```
DJL Serving prend en charge les moteurs Java alimentés par des moteurs DJL ou Python. Les artefacts précédents ne sont pas tous obligatoires ; les artefacts requis varient en fonction du mode que vous choisissez. Par exemple, en mode Python, il suffit de spécifier `option.model_id` dans le fichier `serving.properties` ; il n'est pas nécessaire de spécifier le point de contrôle du modèle à l'intérieur des conteneurs LMI. En mode Java, vous devez empaqueter le point de contrôle du modèle. Pour plus de détails sur la configuration `serving.properties` et le fonctionnement de différents moteurs, consultez [Modes de fonctionnement de DJL Serving](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md) (langue française non garantie).
## Utilisez des points de terminaison à modèle unique pour le déploiement avec DJL Serving
Après avoir préparé les artefacts de votre modèle, vous pouvez déployer votre modèle sur un point de terminaison d' SageMaker IA. Cette section explique comment déployer un modèle unique sur un point de terminaison avec DJL Serving. Si vous déployez plusieurs modèles, ignorez cette section et passez à [Utilisation de points de terminaison multimodèles pour le déploiement avec DJL Serving](#deploy-models-frameworks-djl-mme).
L'exemple suivant montre une méthode pour créer un objet de modèle à l'aide du SDK Amazon SageMaker Python. Vous devez spécifier les champs suivants :
+ `image_uri` : vous pouvez soit récupérer l'une des images de base de DJL Serving, comme indiqué dans cet exemple, soit spécifier une image Docker personnalisée à partir de votre référentiel Amazon ECR, si vous avez suivi les instructions indiquées dans [Personnalisation de votre conteneur](#deploy-models-frameworks-djl-byoc).
+ `model_s3_url` : il doit s'agir d'un URI Amazon S3 pointant vers votre fichier `.tar.gz`.
+ `model_name` : spécifiez le nom de l'objet de modèle.
```
import boto3
import sagemaker
from sagemaker.model import Model
from sagemaker import image_uris, get_execution_role
aws_region = "aws-region"
sagemaker_session = sagemaker.Session(boto_session=boto3.Session(region_name=aws_region))
role = get_execution_role()
def create_model(model_name, model_s3_url):
# Get the DJL DeepSpeed image uri
image_uri = image_uris.retrieve(
framework="djl-deepspeed",
region=sagemaker_session.boto_session.region_name,
version="0.20.0"
)
model = Model(
image_uri=image_uri,
model_data=model_s3_url,
role=role,
name=model_name,
sagemaker_session=sagemaker_session,
)
return model
```
## Utilisation de points de terminaison multimodèles pour le déploiement avec DJL Serving
Si vous souhaitez déployer plusieurs modèles sur un point de terminaison, l' SageMaker IA propose des points de terminaison multimodèles, qui constituent une solution évolutive et rentable pour déployer un grand nombre de modèles. DJL Serving prend également en charge le chargement simultané de plusieurs modèles et l'exécution d'une inférence sur chacun des modèles simultanément. Les conteneurs DJL Serving respectent les contrats de points de terminaison multimodèles SageMaker AI et peuvent être utilisés pour déployer des points de terminaison multimodèles.
Chaque modèle d'artefact individuel doit être empaqueté de la même manière que celle décrite dans la section [Préparation des artefacts de votre modèle](#deploy-models-frameworks-djl-artifacts) précédente. Vous pouvez définir des configurations spécifiques au modèle dans le fichier `serving.properties` et le code du gestionnaire d'inférence spécifique au modèle dans `model.py`. Pour un point de terminaison multimodèle, les modèles doivent être organisés de la manière suivante :
```
root_dir
|-- model_1.tar.gz
|-- model_2.tar.gz
|-- model_3.tar.gz
.
.
.
```
Le SDK Amazon SageMaker Python utilise l'[MultiDataModel](https://sagemaker.readthedocs.io/en/stable/api/inference/multi_data_model.html)objet pour instancier un point de terminaison multimodèle. L'URI Amazon S3 pour le répertoire racine doit être transmis en tant qu'argument `model_data_prefix` au constructeur `MultiDataModel`.
DJL Serving fournit également plusieurs paramètres de configuration pour gérer les besoins en mémoire du modèle, tels que `required_memory_mb` et `reserved_memory_mb`, qui peuvent être configurés pour chaque modèle dans le fichier [serving.properties](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md#servingproperties). Ces paramètres sont utiles pour gérer plus facilement les erreurs liées au manque de mémoire. Pour tous les paramètres configurables, voir [OutofMemory gestion dans djl-serving](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/out_of_memory_management.md).
La fonctionnalité de mise à l'échelle automatique de DJL Serving permet de garantir facilement que les modèles sont mis à l'échelle pour le trafic entrant. Par défaut, DJL Serving détermine le nombre maximum d'applications de travail pour un modèle pouvant être pris en charge en fonction du matériel disponible (tel que les cœurs de CPU ou les dispositifs GPU). Vous pouvez définir des limites inférieures et supérieures pour chaque modèle afin de garantir qu'un niveau de trafic minimum puisse toujours être atteint et qu'un seul modèle ne consomme pas toutes les ressources disponibles. Vous pouvez définir les propriétés suivantes dans le fichier [serving.properties](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md#servingproperties) :
+ `gpu.minWorkers`: Nombre minimum de travailleurs pour GPUs.
+ `gpu.maxWorkers`: Nombre maximum de travailleurs pour GPUs.
+ `cpu.minWorkers`: Nombre minimum de travailleurs pour CPUs.
+ `cpu.maxWorkers`: Nombre maximum de travailleurs pour CPUs.
[Pour un end-to-end exemple de déploiement d'un point de terminaison multimodèle sur l' SageMaker IA à l'aide d'un conteneur de service DJL, consultez l'exemple de bloc-notes Multi-model-Inference-Demo.ipynb.](https://github.com/deepjavalibrary/djl-demo/blob/master/aws/sagemaker/Multi-Model-Inference-Demo.ipynb)
# Déploiement de modèles avec Triton Inference Server
[Triton Inference Server](https://github.com/triton-inference-server/server) est un logiciel de service d’inférence open source qui rationalise l’inférence par IA. Avec Triton, vous pouvez déployer n'importe quel modèle construit avec plusieurs frameworks d'apprentissage profond et d'apprentissage automatique, notamment TensorRT,, ONNX TensorFlow PyTorch, OpenVINO, Python, RAPIDS FIL, etc.
Les conteneurs SageMaker AI Triton vous aident à déployer le serveur d'inférence Triton sur la plateforme d'hébergement SageMaker AI pour servir des modèles entraînés en production. Il prend en charge les différents modes de fonctionnement de SageMaker l'IA. Pour obtenir la liste des conteneurs Triton Inference Server disponibles sur SageMaker AI, consultez la section Conteneurs [NVIDIA Triton Inference (support SM uniquement](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only)).
Pour des exemples de end-to-end blocs-notes, nous vous recommandons de consulter le [amazon-sagemaker-examples référentiel](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-triton).
## Modes d'hébergement
Les modes d'hébergement SageMaker AI suivants sont pris en charge par les conteneurs Triton :
+ Points de terminaison à modèle unique
+ Il s'agit du mode de fonctionnement par défaut de l' SageMaker IA. Dans ce mode, le conteneur Triton peut charger un seul modèle ou un seul modèle d'ensemble.
+ Le nom du modèle doit être transmis en tant que propriété de l'environnement du conteneur, qui fait partie de l'appel d'API `CreateModel` SageMaker AI. La variable d'environnement utilisée pour transmettre le nom du modèle est `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME`.
+ Points de terminaison à modèle unique avec ensemble
+ Le serveur d'inférence Triton prend en charge un *ensemble*, qui est un pipeline, ou un DAG (graphe orienté acyclique) de modèles. Alors qu'un ensemble comprend techniquement plusieurs modèles, dans le mode point final par défaut d'un modèle unique, l' SageMaker IA peut traiter l'*ensemble proprement dit* (le méta-modèle qui représente le pipeline) comme le modèle principal à charger, puis charger les modèles associés.
+ Le nom du modèle de l'ensemble proprement dit doit être utilisé pour charger le modèle. Il doit être transmis en tant que propriété de l'environnement du conteneur, qui fait partie de l'appel d'`CreateModel` SageMaker API. La variable d'environnement utilisée pour transmettre le nom du modèle est `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME`.
+ Points de terminaison multimodèles
+ Dans ce mode, SageMaker l'IA peut servir plusieurs modèles sur un seul terminal. Vous pouvez utiliser ce mode en spécifiant la variable d'environnement `‘MultiModel’: true` en tant que propriété de l'environnement du conteneur, qui fait partie de l'appel d'`CreateModel` SageMaker API.
+ Par défaut, aucun modèle n'est chargé au démarrage de l'instance. Pour exécuter une demande d'inférence sur un modèle particulier, spécifiez le `*.tar.gz` fichier du modèle correspondant comme argument de la `TargetModel` propriété de l'appel d'`InvokeEndpoint` SageMaker API.
+ Points de terminaison multimodèles avec ensemble
+ Dans ce mode, l' SageMaker IA fonctionne comme décrit pour les points de terminaison multimodèles. Cependant, le conteneur SageMaker AI Triton peut charger plusieurs modèles d'ensemble, ce qui signifie que plusieurs pipelines de modèles peuvent s'exécuter sur la même instance. SageMaker L'IA traite chaque ensemble comme un seul modèle, et l'ensemble propre à chaque modèle peut être invoqué en spécifiant l'`*.tar.gz`archive correspondante en tant que`TargetModel`.
+ Pour une meilleure gestion de la mémoire pendant la `LOAD` et la `UNLOAD` de la mémoire dynamique, nous vous recommandons de réduire la taille de l'ensemble.
## Types de charge utile d'inférence
Triton prend en charge deux méthodes pour envoyer une charge utile d'inférence sur le réseau : `json` et `binary+json` (ou json codé en binaire). Dans les deux cas, la charge utile JSON inclut le type de données, la forme et le tenseur de demande d'inférence réel. Le tenseur de demande doit être un tenseur binaire.
Avec le format `binary+json`, vous devez spécifier la longueur des métadonnées de la demande dans l'en-tête pour permettre à Triton d'analyser correctement la charge utile binaire. Dans le conteneur SageMaker AI Triton, cela se fait à l'aide d'un `Content-Type` en-tête personnalisé :`application/vnd.sagemaker-triton.binary+json;json-header-size={}`. Cela est différent de l'utilisation de l'`Inference-Header-Content-Length`en-tête sur un serveur d'inférence Triton autonome, car les en-têtes personnalisés ne sont pas autorisés dans AI. SageMaker
## Utilisation de config.pbtxt pour définir la configuration du modèle
Pour les serveurs d'inférence Triton sur SageMaker IA, chaque modèle doit inclure un `config.pbtxt` fichier qui spécifie, au minimum, les configurations suivantes pour le modèle :
+ `name`: Bien que cela soit facultatif pour les modèles exécutés en dehors de l' SageMaker IA, nous vous recommandons de toujours donner un nom aux modèles à exécuter dans Triton on SageMaker AI.
+ [`platform` et/ou `backend`](https://github.com/triton-inference-server/backend/blob/main/README.md#backends) : la définition d'un backend est essentielle pour spécifier le type du modèle. Certains backends ont une classification supplémentaire, telle que `tensorflow_savedmodel` ou ` tensorflow_graphdef`. Ces options peuvent être spécifiées dans le cadre de la clé `platform`, en plus de la clé `backend`. Les backends les plus courants sont `tensorrt`, `onnxruntime`, `tensorflow`, `pytorch`, `python`, `dali`, `fil` et `openvino`.
+ `input` : spécifiez trois attributs pour l'entrée : `name`, `data_type` et `dims` (la forme).
+ `output` : spécifiez trois attributs pour la sortie : `name`, `data_type` et `dims` (la forme).
+ `max_batch_size` : définissez la taille du lot sur une valeur supérieure ou égale à 1 qui indique la taille de lot maximale que Triton doit utiliser avec le modèle.
Pour plus de détails sur la configuration`config.pbtxt`, consultez le GitHub [référentiel](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md) de Triton. Triton propose plusieurs configurations pour modifier le comportement du modèle. Certaines des options de configuration les plus courantes et les plus importantes sont les suivantes :
+ [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#instance-groups](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#instance-groups) : les groupes d'instances aident à spécifier le numéro et l'emplacement d'un modèle donné. Ils ont les attributs `count`, `kind` et `gpus` (utilisés quand `kind` est `KIND_GPU`). L'attribut `count` équivaut au nombre d'applications de travail. Pour le service des modèles réguliers, chaque application de travail a sa propre copie du modèle. De même, dans Triton, le `count` spécifie le nombre de copies du modèle par appareil. Par exemple, si le type `instance_group` est `KIND_CPU`, le CPU possède le nombre `count` de copies du modèle.
**Note**
Sur une instance de GPU, la configuration `instance_group` s'applique à chaque dispositif GPU. Par exemple, le nombre `count` de copies du modèle est placé sur chaque dispositif GPU, sauf si vous spécifiez explicitement quels dispositifs GPU doivent charger le modèle.
+ [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#dynamic-batcher](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#dynamic-batcher) et [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#stateful-models](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#stateful-models) : le traitement par lots dynamique est utilisé pour les modèles sans état et le traitement par lots de séquences est utilisé pour les modèles dynamiques (dans lesquels vous souhaitez acheminer une demande vers la même instance de modèle à chaque fois). Les planificateurs de traitement par lots activent une file d'attente par modèle, ce qui contribue à augmenter le débit, en fonction de la configuration du traitement par lots.
+ [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#ensemble-models](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#ensemble-models) : un modèle d'ensemble représente un *pipeline* d'un ou plusieurs modèles et la connexion des tenseurs d'entrée et de sortie entre eux. Il peut être configuré en spécifiant `platform` comme `ensemble`. La configuration de l'ensemble n'est qu'une représentation du pipeline du modèle. Sur l' SageMaker IA, tous les modèles d'un ensemble sont traités comme dépendants du modèle d'ensemble et sont considérés comme un modèle unique pour les métriques de l' SageMaker IA, telles que`LoadedModelCount`.
## Publication des métriques Triton par défaut sur Amazon CloudWatch
Le conteneur d'inférence NVIDIA Triton expose les métriques sur le port 8002 (configurable) pour les différents modèles et GPUs qui sont utilisées dans le serveur d'inférence Triton. Pour plus de détails sur les métriques par défaut disponibles, consultez la GitHub page consacrée aux métriques du [serveur d'inférence Triton](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/metrics.md). Ces métriques sont au format Prometheus et peuvent être récupérées à l'aide d'une configuration de récupération Prometheus.
À partir de la version v23.07, le conteneur SageMaker AI Triton prend en charge la publication de ces métriques sur Amazon en CloudWatch spécifiant quelques variables d'environnement. Afin de récupérer les métriques Prometheus, le conteneur AI Triton utilise SageMaker l'agent Amazon. CloudWatch
Les variables d'environnement requises que vous devez spécifier pour collecter des métriques sont les suivantes :
| Variable d'environnement | Description | Exemple de valeur |
| --- | --- | --- |
| `SAGEMAKER_TRITON_ALLOW_METRICS` | Spécifiez cette option pour autoriser Triton à publier des métriques sur son point de terminaison Prometheus. | "true" |
| `SAGEMAKER_TRITON_PUBLISH_METRICS_TO_CLOUDWATCH` | Spécifiez cette option pour démarrer les vérifications préalables nécessaires à la publication des statistiques sur Amazon CloudWatch. | "true" |
| `SAGEMAKER_TRITON_CLOUDWATCH_LOG_GROUP` | Spécifiez cette option pour pointer vers le groupe de journaux dans lequel les métriques sont écrites. | "/aws/SageMaker AI/Endpoints/TritonMetrics/SageMakerTwoEnsemblesTest" |
| `SAGEMAKER_TRITON_CLOUDWATCH_METRIC_NAMESPACE` | Spécifiez cette option pour pointer vers l'espace de noms des métriques dans lequel vous souhaitez voir et tracer les métriques. | "/aws/SageMaker AI/Endpoints/TritonMetrics/SageMakerTwoEnsemblesPublicTest" |
| `SAGEMAKER_TRITON_METRICS_PORT` | Spécifiez ce port comme 8002 ou tout autre port. Si SageMaker l'IA n'a pas bloqué le port spécifié, il est utilisé. Dans le cas contraire, un autre port non bloqué est automatiquement sélectionné. | « 8002 » |
Lorsque vous publiez des statistiques avec Triton on SageMaker AI, gardez à l'esprit les limites suivantes :
+ Bien que vous puissiez générer des métriques personnalisées via l'API C-API et le backend Python (versions 23.05 et ultérieures), celles-ci ne sont actuellement pas prises en charge pour la publication sur Amazon. CloudWatch
+ En mode points de terminaison multimodèles (MME) de l' SageMaker IA, Triton s'exécute dans un environnement qui nécessite l'activation de l'espacement des noms des modèles, car chaque modèle (à l'exception des modèles d'ensemble) est traité comme s'il se trouvait dans son propre référentiel de modèles. À l'heure actuelle, cela crée une limite pour les métriques. Lorsque l'espacement des noms des modèles est activé, Triton ne fait pas la distinction entre des métriques de deux modèles portant le même nom et appartenant à des ensembles différents. Pour contourner le problème, assurez-vous que chaque modèle déployé porte un nom unique. Cela facilite également la recherche de vos indicateurs CloudWatch.
## Variables d’environnement
Le tableau suivant répertorie les variables d'environnement prises en charge pour Triton on SageMaker AI.
| Variable d'environnement | Description | Type | Valeurs possibles |
| --- | --- | --- | --- |
| `SAGEMAKER_MULTI_MODEL` | Permet à Triton de fonctionner en mode points de terminaison multi-modèles basés sur l' SageMaker IA. | Booléen | `true`, `false` |
| `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME` | Spécifiez le modèle à charger en mode modèle unique SageMaker AI (par défaut). Pour le mode ensemble, spécifiez le nom de l'ensemble proprement dit. | String | **comme spécifié dans config.pbtxt |
| `SAGEMAKER_TRITON_PING_MODE` | `'ready'`est le mode par défaut dans le mode modèle unique de l' SageMaker IA, et `'live'` c'est le mode par défaut dans le mode endpoints multimodèles de l' SageMaker IA. | String | `ready`, `live` |
| `SAGEMAKER_TRITON_DISABLE_MODEL_NAMESPACING` | Dans le conteneur SageMaker AI Triton, ce paramètre est défini `true` par défaut. | Booléen | `true`, `false` |
| `SAGEMAKER_BIND_TO_PORT` | Lorsque vous utilisez l' SageMaker IA, le port par défaut est 8080. Vous pouvez le personnaliser pour un port différent dans les scénarios multi-conteneurs. | String | ** |
| `SAGEMAKER_SAFE_PORT_RANGE` | Ceci est défini par la plate-forme SageMaker AI lors de l'utilisation du mode multi-conteneurs. | String | **–** |
| `SAGEMAKER_TRITON_ALLOW_GRPC` | Bien que l' SageMaker IA ne supporte pas le GRPC actuellement, si vous utilisez Triton devant un proxy inverse personnalisé, vous pouvez choisir d'activer le GRPC. | Booléen | `true`, `false` |
| `SAGEMAKER_TRITON_GRPC_PORT` | Le port par défaut du GRPC est 8001, mais vous pouvez le modifier. | String | ** |
| `SAGEMAKER_TRITON_THREAD_COUNT` | Vous pouvez définir le nombre de threads du gestionnaire de requêtes HTTP par défaut. | String | ** |
| `SAGEMAKER_TRITON_LOG_VERBOSE` | `true`par défaut sur SageMaker AI, mais vous pouvez désactiver cette option de manière sélective. | Booléen | `true`, `false` |
| `SAGEMAKER_TRITON_LOG_INFO` | `false`par défaut sur SageMaker AI. | Booléen | `true`, `false` |
| `SAGEMAKER_TRITON_LOG_WARNING` | `false`par défaut sur SageMaker AI. | Booléen | `true`, `false` |
| `SAGEMAKER_TRITON_LOG_ERROR` | `false`par défaut sur SageMaker AI. | Booléen | `true`, `false` |
| `SAGEMAKER_TRITON_SHM_DEFAULT_BYTE_SIZE` | Spécifiez la taille du shm pour le backend Python, en octets. La valeur par défaut est de 16 Mo, mais elle peut être augmentée. | String | ** |
| `SAGEMAKER_TRITON_SHM_GROWTH_BYTE_SIZE` | Spécifiez la taille de croissance du shm pour le backend Python, en octets. La valeur par défaut est de 1 Mo, mais elle peut être augmentée pour permettre des incréments plus importants. | String | ** |
| `SAGEMAKER_TRITON_TENSORFLOW_VERSION` | La valeur par défaut est `2`. Triton ne prend plus en charge Tensorflow 2 depuis Triton v23.04. Vous pouvez configurer cette variable pour les versions précédentes. | String | ** |
| `SAGEMAKER_TRITON_MODEL_LOAD_GPU_LIMIT` | Limitez le pourcentage de mémoire de GPU maximal utilisé pour le chargement du modèle, le reste pouvant être utilisé pour les demandes d'inférence. | String | ** |
| `SAGEMAKER_TRITON_ALLOW_METRICS` | `false`par défaut sur SageMaker AI. | Booléen | `true`, `false` |
| `SAGEMAKER_TRITON_METRICS_PORT` | La valeur par défaut du port est 8002. | String | ** |
| `SAGEMAKER_TRITON_PUBLISH_METRICS_TO_CLOUDWATCH` | `false`par défaut sur SageMaker AI. Définissez cette variable sur `true` pour autoriser le transfert des métriques par défaut de Triton vers Amazon CloudWatch. Si cette option est activée, vous êtes responsable des CloudWatch coûts lorsque les statistiques sont publiées sur votre compte. | Booléen | `true`, `false` |
| `SAGEMAKER_TRITON_CLOUDWATCH_LOG_GROUP` | Obligatoire si vous avez activé la publication des statistiques sur CloudWatch. | String | ** |
| `SAGEMAKER_TRITON_CLOUDWATCH_METRIC_NAMESPACE` | Obligatoire si vous avez activé la publication des statistiques sur CloudWatch. | String | ** |
| `SAGEMAKER_TRITON_ADDITIONAL_ARGS` | Ajoute des arguments supplémentaires lors du démarrage du serveur Triton. | String | ** |
# Modélisez le déploiement à la périphérie avec SageMaker Edge Manager
**Avertissement**
SageMaker Edge Manager ne sera plus disponible le 26 avril 2024. Pour plus d'informations sur la poursuite du déploiement de vos modèles sur des appareils de périphérie, consultez [SageMaker Fin de vie d'Edge Manager](edge-eol.md).
Amazon SageMaker Edge Manager assure la gestion des modèles pour les appareils périphériques afin que vous puissiez optimiser, sécuriser, surveiller et gérer les modèles d'apprentissage automatique sur des flottes d'appareils périphériques tels que les caméras intelligentes, les robots, les ordinateurs personnels et les appareils mobiles.
## Pourquoi utiliser Edge Manager ?
De nombreux cas d'utilisation de machine learning (ML) nécessitent l'exécution de modèles ML sur une flotte de dispositifs, ce qui vous permet d'obtenir des prédictions en temps réel, de préserver la confidentialité des utilisateurs finaux et de réduire le coût de la connectivité réseau. Avec la disponibilité croissante de matériels périphériques basse consommation conçus pour le ML, il est désormais possible d'exécuter plusieurs modèles de réseau neuronal complexes sur des dispositifs périphériques.
Cependant, contrairement aux instances cloud, les périphériques sont limités en termes de calcul, de mémoire et de connectivité, ce qui rend l'exploitation de modèles ML difficile sur des dispositifs périphériques. Une fois le modèle déployé, vous devez contrôler les modèles en continu, car la dérive de modèle peut entraîner la dégradation de la qualité du modèle. La surveillance des modèles sur l'ensemble de vos flottes de dispositifs est difficile car vous devez écrire du code personnalisé pour collecter des échantillons de données à partir de votre dispositif et reconnaître l'asymétrie des prédictions. En outre, les modèles sont souvent codés en dur dans l'application. Pour mettre à jour le modèle, vous devez reconstruire et mettre à jour intégralement le firmware de l'application ou du périphérique, ce qui peut perturber vos opérations.
Avec SageMaker Edge Manager, vous pouvez optimiser, exécuter, surveiller et mettre à jour des modèles d'apprentissage automatique sur des flottes d'appareils en périphérie.
## Fonctionnement
De manière générale, le flux de travail SageMaker Edge Manager comporte cinq composants principaux : compiler des modèles avec SageMaker Neo, empaqueter des modèles compilés par Neo, déployer des modèles sur vos appareils, exécuter des modèles sur le moteur d'inférence SageMaker AI (agent Edge Manager) et gérer les modèles sur les appareils.
![\[Les cinq principaux composants du flux de travail SageMaker Edge Manager.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/smith/smith_overview.png)
SageMaker Edge Manager utilise SageMaker Neo pour optimiser vos modèles pour le matériel cible en un clic, puis pour signer cryptographiquement vos modèles avant le déploiement. À l'aide d' SageMaker Edge Manager, vous pouvez échantillonner les données d'entrée et de sortie des modèles à partir d'appareils Edge et les envoyer vers le cloud à des fins de surveillance et d'analyse, et consulter un tableau de bord qui suit et rend compte visuellement du fonctionnement des modèles déployés dans la console SageMaker AI.
SageMaker Edge Manager étend jusqu'à la périphérie des fonctionnalités qui n'étaient auparavant disponibles que dans le cloud, afin que les développeurs puissent continuellement améliorer la qualité des modèles en utilisant Amazon SageMaker Model Monitor pour détecter les dérives, puis réétiqueter les données avec SageMaker AI Ground Truth et réentraîner les modèles à SageMaker l'IA.
## Comment utiliser SageMaker Edge Manager ?
Si vous utilisez SageMaker Edge Manager pour la première fois, nous vous recommandons de procéder comme suit :
1. **Lisez la section [Démarrer](https://docs.aws.amazon.com/sagemaker/latest/dg/edge-manager-getting-started.html)** : cette section vous guide dans la configuration de votre première tâche d'empaquetage en périphérie et la création de votre première flotte.
1. **Découvrez les exemples de blocs-notes Jupyter d'Edge Manager - Les exemples** [de blocs-notes sont stockés dans le [amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples) GitHub référentiel, dans le dossier sagemaker\$1edge\$1manager.](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker_edge_manager)
# Premiers pas avec Amazon SageMaker AI Edge Manager
Ce guide explique comment effectuer les étapes nécessaires pour enregistrer, déployer et gérer un parc d'appareils, et comment satisfaire aux exigences d'Amazon SageMaker AI Edge Manager.
**Topics**
+ [Configuration](edge-getting-started-step1.md)
+ [Préparation de votre modèle pour le déploiement](edge-getting-started-step2.md)
+ [Enregistrement et authentification des flottes d’appareils](edge-getting-started-step3.md)
+ [Télécharger et configurer Edge Manager](edge-getting-started-step4.md)
+ [Exécuter l'agent](edge-getting-started-step5.md)
# Configuration
Avant de commencer à utiliser SageMaker Edge Manager pour gérer les modèles de vos flottes d'appareils, vous devez d'abord créer des rôles IAM pour SageMaker AI et. AWS IoT Vous souhaiterez également créer au moins un compartiment Amazon S3 dans lequel vous stockerez votre modèle préentraîné, le résultat de votre travail de compilation SageMaker Neo, ainsi que les données d'entrée provenant de vos appareils périphériques.
## Inscrivez-vous pour un Compte AWS
Si vous n'en avez pas Compte AWS, procédez comme suit pour en créer un.
**Pour vous inscrire à un Compte AWS**
1. Ouvrez l'[https://portal.aws.amazon.com/billing/inscription.](https://portal.aws.amazon.com/billing/signup)
1. Suivez les instructions en ligne.
Dans le cadre de la procédure d’inscription, vous recevrez un appel téléphonique ou un SMS et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.
Lorsque vous vous inscrivez à un Compte AWS, un *Utilisateur racine d'un compte AWS*est créé. Par défaut, seul l’utilisateur racine a accès à l’ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur, et à utiliser uniquement l’utilisateur racine pour effectuer les [tâches nécessitant un accès utilisateur racine](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS vous envoie un e-mail de confirmation une fois le processus d'inscription terminé. À tout moment, vous pouvez consulter l'activité actuelle de votre compte et gérer votre compte en accédant à [https://aws.amazon.com/](https://aws.amazon.com/)et en choisissant **Mon compte**.
## Création d’un utilisateur doté d’un accès administratif
Une fois que vous vous êtes inscrit à un utilisateur administratif Compte AWS, que vous Utilisateur racine d'un compte AWS l'avez sécurisé AWS IAM Identity Center, que vous l'avez activé et que vous en avez créé un, afin de ne pas utiliser l'utilisateur root pour les tâches quotidiennes.
**Sécurisez votre Utilisateur racine d'un compte AWS**
1. Connectez-vous en [AWS Management Console](https://console.aws.amazon.com/)tant que propriétaire du compte en choisissant **Utilisateur root** et en saisissant votre adresse Compte AWS e-mail. Sur la page suivante, saisissez votre mot de passe.
Pour obtenir de l’aide pour vous connecter en utilisant l’utilisateur racine, consultez [Connexion en tant qu’utilisateur racine](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) dans le *Guide de l’utilisateur Connexion à AWS *.
1. Activez l’authentification multifactorielle (MFA) pour votre utilisateur racine.
Pour obtenir des instructions, consultez la section [Activer un périphérique MFA virtuel pour votre utilisateur Compte AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) dans le guide de l'utilisateur *IAM*.
**Création d’un utilisateur doté d’un accès administratif**
1. Activez IAM Identity Center.
Pour obtenir des instructions, consultez [Activation d’ AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
1. Dans IAM Identity Center, octroyez un accès administratif à un utilisateur.
Pour un didacticiel sur l'utilisation du Répertoire IAM Identity Center comme source d'identité, voir [Configurer l'accès utilisateur avec la valeur par défaut Répertoire IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) dans le *Guide de AWS IAM Identity Center l'utilisateur*.
**Connexion en tant qu’utilisateur doté d’un accès administratif**
+ Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l’URL de connexion qui a été envoyée à votre adresse e-mail lorsque vous avez créé l’utilisateur IAM Identity Center.
Pour obtenir de l'aide pour vous connecter en utilisant un utilisateur d'IAM Identity Center, consultez la section [Connexion au portail AWS d'accès](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) dans le *guide de l'Connexion à AWS utilisateur*.
**Attribution d’un accès à d’autres utilisateurs**
1. Dans IAM Identity Center, créez un ensemble d’autorisations qui respecte la bonne pratique consistant à appliquer les autorisations de moindre privilège.
Pour obtenir des instructions, consultez [Création d’un ensemble d’autorisations](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
1. Attribuez des utilisateurs à un groupe, puis attribuez un accès par authentification unique au groupe.
Pour obtenir des instructions, consultez [Ajout de groupes](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
## Création de rôles et d'un stockage
SageMaker Edge Manager doit accéder à l'URI de votre compartiment Amazon S3. Pour faciliter cela, créez un rôle IAM capable d'exécuter l' SageMaker IA et autorisé à accéder à Amazon S3. Grâce à ce rôle, l' SageMaker IA peut s'exécuter sous votre compte et accéder à votre compartiment Amazon S3.
Vous pouvez créer un rôle IAM à l'aide de la console IAM, du AWS SDK pour Python (Boto3) ou. AWS CLI Voici un exemple de création d'un rôle IAM, d'attachement des politiques nécessaires avec la console IAM et de création d'un compartiment Amazon S3.
1. **Créez un rôle IAM pour Amazon SageMaker AI.**
1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.
1. Dans le panneau de navigation de la console IAM, sélectionnez **Roles** (Rôles), puis **Create role** (Créer un rôle).
1. Pour **Select type of trusted entity (Sélectionner le type d'entité de confiance)**, choisissez **Service AWS **.
1. Choisissez le service que vous voulez autoriser à endosser ce rôle. Dans ce cas, choisissez **SageMaker AI**. Choisissez ensuite **Suivant : Autorisations**.
+ Cela crée automatiquement une politique IAM qui accorde l'accès aux services associés tels qu'Amazon S3, Amazon ECR et CloudWatch Logs.
1. Choisissez **Next: Tags (Suivant : Identifications)**.
1. (Facultatif) Ajoutez des métadonnées au rôle en associant les identifications sous forme de paires clé-valeur. Pour plus d’informations sur l’utilisation de balises dans IAM, consultez [Balisage de ressources IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_tags.html).
1. Choisissez **Suivant : Examiner**.
1. Saisissez un **Role name (Nom de rôle)**.
1. Si possible, saisissez un nom de rôle ou un suffixe de nom de rôle. Les noms de rôles doivent être uniques au sein de votre AWS compte. Ils ne sont pas distingués au cas par cas. Par exemple, vous ne pouvez pas créer deux rôles nommés `PRODROLE` et `prodrole`. Dans la mesure AWS où d'autres ressources peuvent faire référence au rôle, vous ne pouvez pas modifier le nom du rôle une fois celui-ci créé.
1. (Facultatif) Dans le champ **Role description (Description du rôle)**, saisissez la description du nouveau rôle.
1. Passez en revue les informations du rôle, puis choisissez **Créer un rôle**.
Notez l'ARN du rôle SageMaker AI, que vous utilisez pour créer une tâche de compilation avec SageMaker Neo et une tâche d'empaquetage avec Edge Manager. Pour connaître l'ARN du rôle à l'aide de la console, procédez comme suit :
1. Accédez au IAMconsole : [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Sélectionnez **Roles (Rôles)**.
1. Recherchez le rôle que vous venez de créer en saisissant son nom dans le champ Recherche.
1. Sélectionnez le rôle.
1. L'ARN du rôle figure en haut de la page **Summary (Récapitulatif)**.
1. **Créez un rôle IAM pour AWS IoT.**
Le rôle AWS IoT IAM que vous créez est utilisé pour autoriser vos objets objets. Vous utilisez également le rôle IAM ARN pour créer et enregistrer des flottes d'appareils avec un objet client SageMaker AI.
Configurez un rôle IAM dans votre AWS compte que le fournisseur d'informations d'identification assumera au nom des appareils de votre parc d'appareils. Joignez ensuite une politique pour autoriser vos appareils à interagir avec les AWS IoT services.
Créez un rôle par programmation AWS IoT ou à l'aide de la console IAM, comme vous l'avez fait lorsque vous avez créé un rôle pour l'IA. SageMaker
1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.
1. Dans le panneau de navigation de la console IAM, sélectionnez **Roles** (Rôles), puis **Create role** (Créer un rôle).
1. Pour **Select type of trusted entity (Sélectionner le type d'entité de confiance)**, choisissez **Service AWS **.
1. Choisissez le service que vous voulez autoriser à endosser ce rôle. Dans ce cas, choisissez **IoT**. Sélectionnez **IoT** comme **Use Case (Cas d'utilisation)**.
1. Choisissez **Suivant : Autorisations**.
1. Choisissez **Next: Tags (Suivant : Identifications)**.
1. (Facultatif) Ajoutez des métadonnées au rôle en associant les identifications sous forme de paires clé-valeur. Pour plus d’informations sur l’utilisation de balises dans IAM, consultez [Balisage de ressources IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_tags.html).
1. Choisissez **Suivant : Examiner**.
1. Saisissez un **Role Name (Nom de rôle)**. Le nom du rôle doit commencer par `SageMaker AI`.
1. (Facultatif) Dans le champ **Role description (Description du rôle)**, saisissez la description du nouveau rôle.
1. Passez en revue les informations du rôle, puis choisissez **Créer un rôle**.
1. Une fois le rôle créé, choisissez **Roles (Rôles)** dans la console IAM. Recherchez le rôle que vous avez créé en saisissant son nom dans le champ **Search (Recherche)**.
1. Choisissez votre rôle.
1. Ensuite, choisissez **Attach Policies (Attacher des politiques)**.
1. Recherchez `AmazonSageMakerEdgeDeviceFleetPolicy` dans le champ **Search (Recherche)**. Sélectionnez `AmazonSageMakerEdgeDeviceFleetPolicy`.
1. Choisissez **Attach policy** (Attacher la politique).
1. Ajoutez l'instruction de politique suivante à la relation de confiance :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "credentials.iot.amazonaws.com"},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {"Service": "sagemaker.amazonaws.com"},
"Action": "sts:AssumeRole"
}
]
}
```
------
Une politique de confiance est un [document de politique JSON](https://docs.aws.amazon.com//IAM/latest/UserGuide/reference_policies_grammar) dans lequel vous définissez les mandataires auxquels vous faites confiance pour assumer le rôle. Pour plus d’informations sur les politiques de confiance, consultez [Termes et concepts relatifs aux rôles](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html).
1. Notez l'ARN du AWS IoT rôle. Vous utilisez le AWS IoT rôle ARN pour créer et enregistrer le parc d'appareils. Pour trouver l'ARN du rôle IAM avec la console :
1. Accédez à la console IAM : [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Sélectionnez **Rôles**.
1. Recherchez le rôle que vous avez créé en saisissant son nom dans le champ **Search (Recherche)**.
1. Sélectionnez le rôle.
1. L'ARN du rôle figure sur la page Summary (Récapitulatif).
1. **Créez un compartiment Amazon S3.**
SageMaker Neo et Edge Manager accèdent à votre modèle précompilé et à votre modèle compilé à partir d'un compartiment Amazon S3. Edge Manager stocke également des exemples de données de votre flotte de périphériques dans Amazon S3.
1. Ouvrez la console Amazon S3 à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Choisissez **Créer un compartiment**.
1. Pour **Bucket name (Nom de compartiment)**, saisissez un nom pour le compartiment.
1. Dans **Région**, choisissez la AWS région dans laquelle vous souhaitez que le bucket réside.
1. Dans **Bucket settings for Block Public Acces (Paramètres de compartiment pour bloquer l'accès public)**, choisissez les paramètres que vous voulez appliquer au compartiment.
1. Choisissez **Créer un compartiment**.
Pour plus d’informations sur la création de compartiments Amazon S3, consultez [Démarrer avec Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html).
# Préparation de votre modèle pour le déploiement
Dans cette section, vous allez créer des objets AWS IoT clients et SageMaker IA, télécharger un modèle d'apprentissage automatique préentraîné, télécharger votre modèle dans votre compartiment Amazon S3, compiler votre modèle pour votre appareil cible avec SageMaker Neo et empaqueter votre modèle afin qu'il puisse être déployé avec l'agent Edge Manager.
1. **Importez des bibliothèques et créez des objets clients.**
Ce didacticiel utilise le AWS SDK pour Python (Boto3) pour créer des clients afin d'interagir avec l' SageMaker IA, Amazon S3 et AWS IoT.
Importez Boto3, spécifiez votre région et initialisez les objets clients dont vous avez besoin, comme illustré dans l'exemple suivant :
```
import boto3
import json
import time
AWS_REGION = 'us-west-2'# Specify your Region
bucket = 'bucket-name'
sagemaker_client = boto3.client('sagemaker', region_name=AWS_REGION)
iot_client = boto3.client('iot', region_name=AWS_REGION)
```
Définissez les variables et attribuez-leur le rôle ARN que vous avez créé pour l' SageMaker IA et AWS IoT sous forme de chaînes :
```
# Replace with the role ARN you created for SageMaker
sagemaker_role_arn = "arn:aws:iam:::role/*"
# Replace with the role ARN you created for AWS IoT.
# Note: The name must start with 'SageMaker'
iot_role_arn = "arn:aws:iam:::role/SageMaker*"
```
1. **Entraînez un modèle de machine learning.**
Consultez [Train a Model with Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html) pour plus d'informations sur la façon de former un modèle d'apprentissage automatique à l'aide de l' SageMaker IA. En variante, vous pouvez télécharger le modèle que vous avez entraîné localement, directement dans un compartiment d'URI Amazon S3.
Si vous n'avez pas encore de modèle, vous pouvez utiliser un modèle pré-entraîné pour les étapes suivantes de ce didacticiel. Par exemple, vous pouvez enregistrer les modèles MobileNet V2 depuis le TensorFlow framework. MobileNet V2 est un modèle de classification d'images optimisé pour les applications mobiles. Pour plus d'informations sur la MobileNet V2, consultez le [MobileNet GitHub fichier README.](https://github.com/tensorflow/models/tree/master/research/slim/nets/mobilenet)
Tapez ce qui suit dans votre bloc-notes Jupyter pour enregistrer le modèle V2 pré-entraîné MobileNet :
```
# Save the MobileNet V2 model to local storage
import tensorflow as tf
model = tf.keras.applications.MobileNetV2()
model.save(“mobilenet_v2.h5”)
```
**Note**
Si vous ne l'avez pas TensorFlow installé, vous pouvez le faire en exécutant `pip install tensorflow=2.4`
Utilisez TensorFlow la version 2.4 ou inférieure pour ce didacticiel.
Le modèle sera enregistré dans le fichier `mobilenet_v2.h5`. Avant d'empaqueter le modèle, vous devez d'abord le compiler à l'aide de SageMaker Neo. Vérifiez si votre version de TensorFlow (ou un autre framework de votre choix) est actuellement prise en charge par SageMaker Neo. [Cadres, périphériques, systèmes et architectures pris en charge](neo-supported-devices-edge.md)
SageMaker Neo nécessite que les modèles soient stockés sous forme de fichier TAR compressé. Ré-empaquetez-le en tant que fichier TAR compressé (\$1.tar.gz) :
```
# Package MobileNet V2 model into a TAR file
import tarfile
tarfile_name='mobilenet-v2.tar.gz'
with tarfile.open(tarfile_name, mode='w:gz') as archive:
archive.add('mobilenet-v2.h5')
```
1. **Chargez votre modèle sur Amazon S3.**
Une fois que vous avez un modèle de machine learning, stockez-le dans un compartiment Amazon S3. L'exemple suivant utilise une AWS CLI commande pour télécharger le modèle dans le compartiment Amazon S3 que vous avez créé précédemment dans un répertoire appelé *models*. Saisissez ce qui suit dans votre bloc-notes Jupyter :
```
!aws s3 cp mobilenet-v2.tar.gz s3://{bucket}/models/
```
1. **Compilez votre modèle avec SageMaker Neo.**
Compilez votre modèle d'apprentissage automatique avec SageMaker Neo pour un appareil de pointe. Vous devez connaître l'URI du compartiment Amazon S3 où vous avez stocké le modèle entraîné, le cadre de machine learning que vous avez utilisé pour entraîner votre modèle, la forme de l'entrée de votre modèle et votre dispositif cible.
Pour le modèle MobileNet V2, utilisez ce qui suit :
```
framework = 'tensorflow'
target_device = 'jetson_nano'
data_shape = '{"data":[1,3,224,224]}'
```
SageMaker Neo nécessite une forme de saisie de modèle et un format de modèle spécifiques basés sur le cadre d'apprentissage profond que vous utilisez. Pour plus d’informations sur l’enregistrement de votre modèle, consultez [Quelles sont les formes de données d'entrée attendues par SageMaker Neo ?](neo-compilation-preparing-model.md#neo-job-compilation-expected-inputs). Pour plus d’informations sur les périphériques et les cadres pris en charge par Neo, consultez [Cadres, périphériques, systèmes et architectures pris en charge](neo-supported-devices-edge.md).
Utilisez l'`CreateCompilationJob`API pour créer une tâche de compilation avec SageMaker Neo. Donnez un nom à la tâche de compilation, à l'ARN du rôle SageMaker AI, à l'URI Amazon S3 où votre modèle est stocké, à la forme d'entrée du modèle, au nom du framework, à l'URI Amazon S3 où vous souhaitez que SageMaker AI stocke votre modèle compilé et à votre périphérique périphérique cible.
```
# Specify the path where your model is stored
model_directory = 'models'
s3_model_uri = 's3://{}/{}/{}'.format(bucket, model_directory, tarfile_name)
# Store compiled model in S3 within the 'compiled-models' directory
compilation_output_dir = 'compiled-models'
s3_output_location = 's3://{}/{}/'.format(bucket, compilation_output_dir)
# Give your compilation job a name
compilation_job_name = 'getting-started-demo'
sagemaker_client.create_compilation_job(CompilationJobName=compilation_job_name,
RoleArn=sagemaker_role_arn,
InputConfig={
'S3Uri': s3_model_uri,
'DataInputConfig': data_shape,
'Framework' : framework.upper()},
OutputConfig={
'S3OutputLocation': s3_output_location,
'TargetDevice': target_device},
StoppingCondition={'MaxRuntimeInSeconds': 900})
```
1. **Empaquetez votre modèle compilé.**
Les tâches d'empaquetage SageMaker utilisent des modèles compilés par Neo et apportent les modifications nécessaires pour déployer le modèle à l'aide du moteur d'inférence, l'agent Edge Manager. Pour empaqueter votre modèle, créez une tâche d'empaquetage Edge à l'aide de l'`create_edge_packaging`API ou de la console SageMaker AI.
Vous devez fournir le nom que vous avez utilisé pour votre tâche de compilation Neo, un nom pour la tâche d'empaquetage, un ARN de rôle (voir la section [Configuration](edge-getting-started-step1.md)), un nom pour le modèle, une version de modèle et l'URI du compartiment Amazon S3 pour la sortie de la tâche d'empaquetage. Veuillez noter que les noms des tâches d’empaquetage Edge Manager sont sensibles à la casse. Voici un exemple de création d'une tâche d'empaquetage à l'aide de l'API.
```
edge_packaging_name='edge-packaging-demo'
model_name="sample-model"
model_version="1.1"
```
Définissez l'URI Amazon S3 où vous voulez stocker le modèle empaqueté.
```
# Output directory where you want to store the output of the packaging job
packaging_output_dir = 'packaged_models'
packaging_s3_output = 's3://{}/{}'.format(bucket, packaging_output_dir)
```
Utilisez `CreateEdgePackagingJob` pour empaqueter votre modèle néo-compilé. Indiquez un nom pour votre tâche d'empaquetage Edge et le nom que vous avez fourni pour votre tâche de compilation (dans cet exemple, il a été stocké dans la variable `compilation_job_name`). Fournissez également un nom pour votre modèle, une version pour votre modèle (ceci est utilisé pour vous aider à savoir quelle version du modèle vous utilisez) et l'URI S3 dans lequel vous souhaitez que SageMaker AI stocke le modèle packagé.
```
sagemaker_client.create_edge_packaging_job(
EdgePackagingJobName=edge_packaging_name,
CompilationJobName=compilation_job_name,
RoleArn=sagemaker_role_arn,
ModelName=model_name,
ModelVersion=model_version,
OutputConfig={
"S3OutputLocation": packaging_s3_output
}
)
```
# Enregistrement et authentification des flottes d’appareils
Dans cette section, vous allez créer votre AWS IoT objet, créer un parc d'appareils, enregistrer votre parc d'appareils afin qu'il puisse interagir avec le cloud, créer des certificats X.509 pour authentifier vos appareils AWS IoT Core, associer l'alias de rôle généré lors de la création de votre parc, obtenir un point de terminaison AWS spécifique au compte pour le fournisseur d'informations d'identification, obtenir un fichier Amazon Root CA officiel et télécharger le fichier Amazon CA sur Amazon S3. AWS IoT
1. **Créez des AWS IoT objets.**
SageMaker Edge Manager tire parti des AWS IoT Core services pour faciliter la connexion entre les appareils de périphérie et les points de terminaison dans le AWS cloud. Vous pouvez tirer parti des AWS IoT fonctionnalités existantes après avoir configuré vos appareils pour qu'ils fonctionnent avec Edge Manager.
Pour connecter votre appareil à AWS IoT, vous devez créer *des objets AWS IoT ,* créer et enregistrer un certificat client auprès de AWS l'IoT, et créer et configurer le rôle IAM pour vos appareils.
Créez d'abord des AWS IoT objets avec le AWS IoT client (`iot_client`) que vous avez créé précédemment avec Boto3. L'exemple suivant montre comment créer deux objets IoT :
```
iot_thing_name = 'sample-device'
iot_thing_type = 'getting-started-demo'
iot_client.create_thing_type(
thingTypeName=iot_thing_type
)
# Create an AWS IoT thing objects
iot_client.create_thing(
thingName=iot_thing_name,
thingTypeName=iot_thing_type
)
```
1. **Créez votre flotte de dispositifs.**
Créez un parc d'appareils avec l'objet client SageMaker AI défini à l'étape précédente. Vous pouvez également utiliser la console SageMaker AI pour créer un parc d'appareils.
```
import time
device_fleet_name="demo-device-fleet" + str(time.time()).split('.')[0]
device_name="sagemaker-edge-demo-device" + str(time.time()).split('.')[0]
```
Spécifiez votre ARN de rôle IoT. Cela permet d' AWS IoT accorder des informations d'identification temporaires aux appareils.
```
device_model_directory='device_output'
s3_device_fleet_output = 's3://{}/{}'.format(bucket, device_model_directory)
sagemaker_client.create_device_fleet(
DeviceFleetName=device_fleet_name,
RoleArn=iot_role_arn, # IoT Role ARN specified in previous step
OutputConfig={
'S3OutputLocation': s3_device_fleet_output
}
)
```
Un alias de AWS IoT rôle est créé lorsque vous créez un parc d'appareils. Cet alias de rôle est associé à l' AWS IoT utilisation ultérieure de l'`iot_client`objet.
1. **Enregistrez votre flotte de dispositifs.**
Pour interagir avec le cloud, vous devez enregistrer votre appareil auprès d' SageMaker Edge Manager. Dans cet exemple, vous enregistrez un seul dispositif dans la flotte que vous avez créée. Pour enregistrer le dispositif, vous devez fournir un nom de dispositif et le nom AWS IoT , comme illustré dans l'exemple suivant :
```
# Device name should be 36 characters
device_name = "sagemaker-edge-demo-device" + str(time.time()).split('.')[0]
sagemaker_client.register_devices(
DeviceFleetName=device_fleet_name,
Devices=[
{
"DeviceName": device_name,
"IotThingName": iot_thing_name
}
]
)
```
1. **Créez des certificats X.509.**
Après avoir créé l' AWS IoT objet objet, vous devez créer un certificat de périphérique X.509 pour votre objet objet. Ce certificat authentifie votre dispositif auprès de AWS IoT Core.
Utilisez ce qui suit pour créer une clé privée, une clé publique et un fichier de certificat X.509 à l'aide du AWS IoT client défini (`iot_client`) précédemment.
```
# Creates a 2048-bit RSA key pair and issues an X.509 # certificate
# using the issued public key.
create_cert = iot_client.create_keys_and_certificate(
setAsActive=True
)
# Get certificate from dictionary object and save in its own
with open('./device.pem.crt', 'w') as f:
for line in create_cert['certificatePem'].split('\n'):
f.write(line)
f.write('\n')
# Get private key from dictionary object and save in its own
with open('./private.pem.key', 'w') as f:
for line in create_cert['keyPair']['PrivateKey'].split('\n'):
f.write(line)
f.write('\n')
# Get a private key from dictionary object and save in its own
with open('./public.pem.key', 'w') as f:
for line in create_cert['keyPair']['PublicKey'].split('\n'):
f.write(line)
f.write('\n')
```
1. **Associez l'alias de rôle à AWS IoT.**
Lorsque vous créez un parc d'appareils avec SageMaker AI (`sagemaker_client.create_device_fleet()`), un alias de rôle est généré pour vous. Un alias de AWS IoT rôle fournit un mécanisme permettant aux appareils connectés de s'authentifier à AWS IoT l'aide de certificats X.509, puis d'obtenir des informations d' AWS identification de courte durée à partir d'un rôle IAM associé à un alias de rôle. AWS IoT L'alias de rôle vous permet de modifier le rôle du dispositif sans mettre à jour le dispositif. Utilisez `DescribeDeviceFleet` pour obtenir le nom de l'alias du rôle et l'ARN.
```
# Print Amazon Resource Name (ARN) and alias that has access
# to AWS Internet of Things (IoT).
sagemaker_client.describe_device_fleet(DeviceFleetName=device_fleet_name)
# Store iot role alias string in a variable
# Grabs role ARN
full_role_alias_name = sagemaker_client.describe_device_fleet(DeviceFleetName=device_fleet_name)['IotRoleAlias']
start_index = full_role_alias_name.find('SageMaker') # Find beginning of role name
role_alias_name = full_role_alias_name[start_index:]
```
Utilisez le `iot_client` pour associer plus facilement l'alias de rôle généré lors de la création du parc d'appareils à AWS IoT :
```
role_alias = iot_client.describe_role_alias(
roleAlias=role_alias_name)
```
Pour plus d’informations sur l’alias de rôle IAM, consultez [L’alias de rôle permet d’accéder aux services inutilisés](https://docs.aws.amazon.com/iot/latest/developerguide/audit-chk-role-alias-unused-svcs.html).
Vous avez créé et enregistré un certificat auprès d'une AWS IoT version antérieure pour une authentification réussie de votre appareil. Maintenant, vous devez créer et attacher une politique au certificat afin d'autoriser la demande pour le jeton de sécurité.
```
alias_policy = {
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": role_alias['roleAliasDescription']['roleAliasArn']
}
}
policy_name = 'aliaspolicy-'+ str(time.time()).split('.')[0]
aliaspolicy = iot_client.create_policy(policyName=policy_name,
policyDocument=json.dumps(alias_policy))
# Attach policy
iot_client.attach_policy(policyName=policy_name,
target=create_cert['certificateArn'])
```
1. **Obtenez un point de terminaison AWS spécifique à votre compte pour le fournisseur d'informations d'identification.**
Les dispositifs périphériques ont besoin d'un point de terminaison pour prendre en charge les informations d'identification. Obtenez votre point de terminaison spécifique au compte AWS pour le fournisseur d'informations d'identification.
```
# Get the unique endpoint specific to your AWS account that is making the call.
iot_endpoint = iot_client.describe_endpoint(
endpointType='iot:CredentialProvider'
)
endpoint="https://{}/role-aliases/{}/credentials".format(iot_endpoint['endpointAddress'],role_alias_name)
```
1. **Obtenez le fichier officiel de l'autorité de certification Amazon Root et téléchargez-le dans le compartiment Amazon S3.**
Utilisez ce qui suit dans votre bloc-notes Jupyter ou AWS CLI (si vous utilisez votre terminal, supprimez le « \$1 » (fonction magique) :
```
!wget https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
Utilisez le point de terminaison pour adresser une demande HTTPS au fournisseur d'informations d'identification pour qu'il renvoie un jeton de sécurité. L'exemple de commande suivant utilise `curl`, mais vous pouvez utiliser n'importe quel client HTTP.
```
!curl --cert device.pem.crt --key private.pem.key --cacert AmazonRootCA1.pem $endpoint
```
Si le certificat est vérifié, téléchargez les clés et le certificat dans votre URI du compartiment Amazon S3 :
```
!aws s3 cp private.pem.key s3://{bucket}/authorization-files/
!aws s3 cp device.pem.crt s3://{bucket}/authorization-files/
!aws s3 cp AmazonRootCA1.pem s3://{bucket}/authorization-files/
```
Nettoyez votre répertoire de travail en déplaçant vos clés et votre certificat vers un autre répertoire :
```
# Optional - Clean up working directory
!mkdir authorization-files
!mv private.pem.key device.pem.crt AmazonRootCA1.pem authorization-files/
```
# Télécharger et configurer Edge Manager
L'agent Edge Manager est un moteur d'inférence pour vos dispositifs périphériques. Utilisez l'agent pour réaliser des prédictions avec les modèles chargés sur vos dispositifs périphériques. L'agent collecte également des métriques de modèle et capture des données à intervalles définis.
Dans cette section, vous allez configurer votre dispositif avec l'agent. Pour ce faire, copiez d'abord un artefact de version et signez le certificat racine du compartiment de publication localement sur votre machine. Après avoir décompressé l'artefact de version, téléchargez-le dans Amazon S3. Ensuite, définissez et enregistrez un fichier de configuration pour l'agent. Un modèle est fourni, que vous pouvez copier et coller. Enfin, copiez les artefacts de version, le fichier de configuration et les informations d'identification sur votre dispositif.
1. **Téléchargez l'agent SageMaker Edge Manager.**
L'agent est publié au format binaire pour les systèmes d'exploitation pris en charge. Cet exemple exécute l'inférence sur un Jetson Nano qui utilise un système d'exploitation Linux et possède une ARM64 architecture. Pour plus d’informations sur les dispositifs à utiliser, dont le système d’exploitation et l’architecture sont pris en charge, consultez [Périphériques, architectures de puces et systèmes pris en charge](neo-supported-devices-edge-devices.md).
Récupérez la dernière version des fichiers binaires depuis le bucket de publication d' SageMaker Edge Manager depuis la région us-west-2.
```
!aws s3 ls s3://sagemaker-edge-release-store-us-west-2-linux-armv8/Releases/ | sort -r
```
Cela renvoie les artefacts de version triés par leur version.
```
PRE 1.20210512.96da6cc/
PRE 1.20210305.a4bc999/
PRE 1.20201218.81f481f/
PRE 1.20201207.02d0e97/
```
La version a le format suivant : `..`. Voici ses trois composantes :
+ `` : la version de sortie. La version de sortie est actuellement définie sur `1`.
+ `` : horodatage de la version d'artefact.
+ : ID de validation du référentiel à partir duquel la version est générée.
Copiez le fichier TAR zippé localement ou directement sur votre dispositif. L'exemple suivant montre comment copier le dernier artefact de version au moment où ce document a été publié.
```
!aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-x64/Releases/1.20201218.81f481f/1.20201218.81f481f.tgz ./
```
Une fois que vous avez l'artefact, décompressez le fichier TAR zippé. La procédure suivante sert à décompresser le fichier TAR et le stocker dans un répertoire appelé `agent_demo` :
```
!mkdir agent_demo
!tar -xvzf 1.20201218.81f481f.tgz -C ./agent_demo
```
Téléchargez les artefacts de version de l'agent dans votre compartiment Amazon S3. L'exemple de code suivant copie le contenu dans `agent_demo` et le télécharge dans votre compartiment Amazon S3, dans un répertoire appelé `agent_demo` :
```
!aws s3 cp --recursive ./agent_demo s3://{bucket}/agent_demo
```
Vous avez également besoin des certificats racine de signature à partir du compartiment de publication :
```
!aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-x64/Certificates/us-west-2/us-west-2.pem ./
```
Téléchargez le certificat racine de signature dans votre compartiment Amazon S3 :
```
!aws s3 cp us-west-2.pem s3://{bucket}/authorization-files/
```
1. **Définissez un fichier de configuration de l'agent SageMaker Edge Manager.**
Tout d'abord, définissez le fichier de configuration d'agent comme suit :
```
sagemaker_edge_config = {
"sagemaker_edge_core_device_name": "device_name",
"sagemaker_edge_core_device_fleet_name": "device_fleet_name",
"sagemaker_edge_core_capture_data_buffer_size": 30,
"sagemaker_edge_core_capture_data_push_period_seconds": 4,
"sagemaker_edge_core_folder_prefix": "demo_capture",
"sagemaker_edge_core_region": "us-west-2",
"sagemaker_edge_core_root_certs_path": "/agent_demo/certificates",
"sagemaker_edge_provider_aws_ca_cert_file": "/agent_demo/iot-credentials/AmazonRootCA1.pem",
"sagemaker_edge_provider_aws_cert_file": "/agent_demo/iot-credentials/device.pem.crt",
"sagemaker_edge_provider_aws_cert_pk_file": "/agent_demo/iot-credentials/private.pem.key",
"sagemaker_edge_provider_aws_iot_cred_endpoint": "endpoint",
"sagemaker_edge_provider_provider": "Aws",
"sagemaker_edge_provider_s3_bucket_name": bucket,
"sagemaker_edge_core_capture_data_destination": "Cloud"
}
```
Remplacez les éléments suivants :
+ `"device_name"` par le nom de votre dispositif (cette chaîne a été stockée à une étape précédente dans une variable nommée `device_name`).
+ `"device_fleet_name` par le nom de votre flotte de dispositifs (cette chaîne a été stockée à une étape précédente dans une variable nommée `device_fleet_name`).
+ `"endpoint"`avec le point de AWS terminaison spécifique à votre compte pour le fournisseur d'informations d'identification (cette chaîne a été stockée lors d'une étape précédente dans une variable nommée`endpoint`).
Ensuite, enregistrez-le en tant que fichier JSON :
```
edge_config_file = open("sagemaker_edge_config.json", "w")
json.dump(sagemaker_edge_config, edge_config_file, indent = 6)
edge_config_file.close()
```
Téléchargez le fichier de configuration dans votre compartiment Amazon S3 :
```
!aws s3 cp sagemaker_edge_config.json s3://{bucket}/
```
1. **Copiez les artefacts de version, le fichier de configuration et les informations d'identification sur votre dispositif.**
Les instructions suivantes sont exécutées directement sur le dispositif périphérique.
**Note**
Vous devez d'abord installer Python, le AWS SDK pour Python (Boto3), et le AWS CLI sur votre périphérique Edge.
Ouvrez un terminal sur votre appareil. Créez un dossier pour stocker les artefacts de version, vos informations d'identification et le fichier de configuration.
```
mkdir agent_demo
cd agent_demo
```
Copiez le contenu des artefacts de version que vous avez stockés dans votre compartiment Amazon S3 sur votre dispositif :
```
# Copy release artifacts
aws s3 cp s3:///agent_demo/ ./ --recursive
```
(Le contenu de l'artefact de version a été stocké dans un répertoire appelé `agent_demo` à une étape précédente). Remplacez `