Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Cré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).