Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Création d’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 SageMaker AI 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 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 :

Création de votre modèle avec ModelBuilder

ModelBuilder est une classe Python qui prend un modèle de cadre, 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 construction 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 en savoir plus sur la classe ModelBuilder, consultez 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.

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

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

Lorsque vous invoquez un point de terminaison SageMaker AI, les données sont envoyées par l’intermédiaire de données utiles HTTP de 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 :

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.

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 en savoir plus sur SchemaBuilder, consultez 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.

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 utilise InferenceSpec pour générer un modèle avec le pipeline HuggingFace. Pour en savoir plus sur InferenceSpec, consultez 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.

À des fins de contrôle d’intégrité, SageMaker AI crée un package des fichiers nécessaires au déploiement et les sérialise dans le cadre de la fonction de génération ModelBuilder. 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’API CreateModel en tant que variable d’environnement lors de 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, SageMaker AI 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 instance ml.c6i.xlarge. 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’objet ResourceRequirements, vous pouvez demander un nombre minimum de processeurs, 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 de 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 modèle XGBoost 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.

Exemples ModelBuilder

Pour d’autres exemples d’utilisation de ModelBuilder pour créer vos modèles, consultez les exemples de blocs-notes ModelBuilder.