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 d'un modèle Pour déployer un modèle SageMaker compilé par Amazon Neo sur un point de terminaison HTTPS, vous devez configurer et créer le point de terminaison du modèle à l'aide des services d'hébergement Amazon SageMaker AI. Actuellement, les développeurs peuvent utiliser Amazon SageMaker APIs pour déployer des modules sur des instances ml.c5, ml.c4, ml.m5, ml.m4, ml.p3, ml.p2 et ml.inf1. Pour les instances [Inferentia](https://aws.amazon.com/machine-learning/inferentia/) et [Trainium](https://aws.amazon.com/machine-learning/trainium/), les modèles doivent être compilés spécifiquement pour ces instances. Les modèles compilés pour d'autres types d'instance peuvent ne pas fonctionner avec les instances Inferentia ou Trainium. Lorsque vous déployez un modèle compilé, vous devez utiliser la même instance pour la cible que celle utilisée pour la compilation. Cela crée un point de terminaison d' SageMaker IA que vous pouvez utiliser pour effectuer des inférences. [Vous pouvez déployer un modèle compilé Neo à l'aide de l'un des outils suivants : le [SDK Amazon SageMaker AI pour Python](https://sagemaker.readthedocs.io/en/stable/), le [SDK pour Python [AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/reference/)(Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) et la console AI. SageMaker ](https://console.aws.amazon.com/sagemaker) **Note** Pour déployer un modèle à l'aide AWS CLI de la console ou de Boto3, consultez [Neo Inference Container Images](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html) pour sélectionner l'URI de l'image d'inférence pour votre conteneur principal. **Topics** + [Conditions préalables](neo-deployment-hosting-services-prerequisites.md) + [Déployer un modèle compilé à l'aide du SageMaker SDK](neo-deployment-hosting-services-sdk.md) + [Déploiement d'un modèle compilé à l'aide de Boto3](neo-deployment-hosting-services-boto3.md) + [Déployez un modèle compilé à l'aide du AWS CLI](neo-deployment-hosting-services-cli.md) + [Déploiement d'un modèle compilé à l'aide de la console](neo-deployment-hosting-services-console.md) # Conditions préalables **Note** Suivez les instructions de cette section si vous avez compilé votre modèle à l'aide de AWS SDK pour Python (Boto3) AWS CLI, ou de la console SageMaker AI. Pour créer un modèle SageMaker compilé au format NEO, vous avez besoin des éléments suivants : 1. Un URI Amazon ECR d'image Docker. Vous pouvez en sélectionner un répondant à vos besoins dans [cette liste](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html). 1. Un fichier de script de point d'entrée : 1. **Pour PyTorch et MXNet modèles :** *Si vous avez entraîné votre modèle à l'aide de l' SageMaker IA*, le script d'entraînement doit implémenter les fonctions décrites ci-dessous. Le script d'entraînement sert de script de point d'entrée pendant l'inférence. Dans l'exemple détaillé dans [Formation, compilation et déploiement MNIST avec MXNet Module et SageMaker Neo](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_neo_compilation_jobs/mxnet_mnist/mxnet_mnist_neo.html), le script d'entraînement (`mnist.py`) implémente les fonctions requises. *Si vous n'avez pas entraîné votre modèle à l'aide de l' SageMaker IA*, vous devez fournir un fichier de script de point d'entrée (`inference.py`) qui peut être utilisé au moment de l'inférence. En fonction du framework MXNet ou du script d'inférence PyTorch, l'emplacement du script d'inférence doit être conforme à la structure de [répertoire de modèles du SDK SageMaker Python pour MxNet ou à la structure](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html#model-directory-structure) de [répertoire de modèles](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#model-directory-structure) pour. PyTorch Lorsque vous utilisez des images Neo Inference Optimized Container avec **PyTorch**et **MXNet**sur des types d'instances de CPU et de GPU, le script d'inférence doit implémenter les fonctions suivantes : + `model_fn` : charge le modèle. (Facultatif) + `input_fn` : convertit la charge utile de demande entrante en un tableau numpy. + `predict_fn` : réalise la prédiction. + `output_fn` : convertit la sortie de la prédiction en charge utile de réponse. + En variante, vous pouvez définir `transform_fn` de sorte à combiner `input_fn`, `predict_fn` et `output_fn`. Vous trouverez ci-dessous des exemples de `inference.py` script dans un répertoire nommé `code` (`code/inference.py`) for **PyTorch et MXNet (Gluon and Module).** Les exemples chargent d'abord le modèle, puis le servent sur des données d'image sur un GPU : ------ #### [ MXNet Module ] ``` import numpy as np import json import mxnet as mx import neomx # noqa: F401 from collections import namedtuple Batch = namedtuple('Batch', ['data']) # Change the context to mx.cpu() if deploying to a CPU endpoint ctx = mx.gpu() def model_fn(model_dir): # The compiled model artifacts are saved with the prefix 'compiled' sym, arg_params, aux_params = mx.model.load_checkpoint('compiled', 0) mod = mx.mod.Module(symbol=sym, context=ctx, label_names=None) exe = mod.bind(for_training=False, data_shapes=[('data', (1,3,224,224))], label_shapes=mod._label_shapes) mod.set_params(arg_params, aux_params, allow_missing=True) # Run warm-up inference on empty data during model load (required for GPU) data = mx.nd.empty((1,3,224,224), ctx=ctx) mod.forward(Batch([data])) return mod def transform_fn(mod, image, input_content_type, output_content_type): # pre-processing decoded = mx.image.imdecode(image) resized = mx.image.resize_short(decoded, 224) cropped, crop_info = mx.image.center_crop(resized, (224, 224)) normalized = mx.image.color_normalize(cropped.astype(np.float32) / 255, mean=mx.nd.array([0.485, 0.456, 0.406]), std=mx.nd.array([0.229, 0.224, 0.225])) transposed = normalized.transpose((2, 0, 1)) batchified = transposed.expand_dims(axis=0) casted = batchified.astype(dtype='float32') processed_input = casted.as_in_context(ctx) # prediction/inference mod.forward(Batch([processed_input])) # post-processing prob = mod.get_outputs()[0].asnumpy().tolist() prob_json = json.dumps(prob) return prob_json, output_content_type ``` ------ #### [ MXNet Gluon ] ``` import numpy as np import json import mxnet as mx import neomx # noqa: F401 # Change the context to mx.cpu() if deploying to a CPU endpoint ctx = mx.gpu() def model_fn(model_dir): # The compiled model artifacts are saved with the prefix 'compiled' block = mx.gluon.nn.SymbolBlock.imports('compiled-symbol.json',['data'],'compiled-0000.params', ctx=ctx) # Hybridize the model & pass required options for Neo: static_alloc=True & static_shape=True block.hybridize(static_alloc=True, static_shape=True) # Run warm-up inference on empty data during model load (required for GPU) data = mx.nd.empty((1,3,224,224), ctx=ctx) warm_up = block(data) return block def input_fn(image, input_content_type): # pre-processing decoded = mx.image.imdecode(image) resized = mx.image.resize_short(decoded, 224) cropped, crop_info = mx.image.center_crop(resized, (224, 224)) normalized = mx.image.color_normalize(cropped.astype(np.float32) / 255, mean=mx.nd.array([0.485, 0.456, 0.406]), std=mx.nd.array([0.229, 0.224, 0.225])) transposed = normalized.transpose((2, 0, 1)) batchified = transposed.expand_dims(axis=0) casted = batchified.astype(dtype='float32') processed_input = casted.as_in_context(ctx) return processed_input def predict_fn(processed_input_data, block): # prediction/inference prediction = block(processed_input_data) return prediction def output_fn(prediction, output_content_type): # post-processing prob = prediction.asnumpy().tolist() prob_json = json.dumps(prob) return prob_json, output_content_type ``` ------ #### [ PyTorch 1.4 and Older ] ``` import os import torch import torch.nn.parallel import torch.optim import torch.utils.data import torch.utils.data.distributed import torchvision.transforms as transforms from PIL import Image import io import json import pickle def model_fn(model_dir): """Load the model and return it. Providing this function is optional. There is a default model_fn available which will load the model compiled using SageMaker Neo. You can override it here. Keyword arguments: model_dir -- the directory path where the model artifacts are present """ # The compiled model is saved as "compiled.pt" model_path = os.path.join(model_dir, 'compiled.pt') with torch.neo.config(model_dir=model_dir, neo_runtime=True): model = torch.jit.load(model_path) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = model.to(device) # We recommend that you run warm-up inference during model load sample_input_path = os.path.join(model_dir, 'sample_input.pkl') with open(sample_input_path, 'rb') as input_file: model_input = pickle.load(input_file) if torch.is_tensor(model_input): model_input = model_input.to(device) model(model_input) elif isinstance(model_input, tuple): model_input = (inp.to(device) for inp in model_input if torch.is_tensor(inp)) model(*model_input) else: print("Only supports a torch tensor or a tuple of torch tensors") return model def transform_fn(model, request_body, request_content_type, response_content_type): """Run prediction and return the output. The function 1. Pre-processes the input request 2. Runs prediction 3. Post-processes the prediction output. """ # preprocess decoded = Image.open(io.BytesIO(request_body)) preprocess = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize( mean=[ 0.485, 0.456, 0.406], std=[ 0.229, 0.224, 0.225]), ]) normalized = preprocess(decoded) batchified = normalized.unsqueeze(0) # predict device = torch.device("cuda" if torch.cuda.is_available() else "cpu") batchified = batchified.to(device) output = model.forward(batchified) return json.dumps(output.cpu().numpy().tolist()), response_content_type ``` ------ #### [ PyTorch 1.5 and Newer ] ``` import os import torch import torch.nn.parallel import torch.optim import torch.utils.data import torch.utils.data.distributed import torchvision.transforms as transforms from PIL import Image import io import json import pickle def model_fn(model_dir): """Load the model and return it. Providing this function is optional. There is a default_model_fn available, which will load the model compiled using SageMaker Neo. You can override the default here. The model_fn only needs to be defined if your model needs extra steps to load, and can otherwise be left undefined. Keyword arguments: model_dir -- the directory path where the model artifacts are present """ # The compiled model is saved as "model.pt" model_path = os.path.join(model_dir, 'model.pt') device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = torch.jit.load(model_path, map_location=device) model = model.to(device) return model def transform_fn(model, request_body, request_content_type, response_content_type): """Run prediction and return the output. The function 1. Pre-processes the input request 2. Runs prediction 3. Post-processes the prediction output. """ # preprocess decoded = Image.open(io.BytesIO(request_body)) preprocess = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize( mean=[ 0.485, 0.456, 0.406], std=[ 0.229, 0.224, 0.225]), ]) normalized = preprocess(decoded) batchified = normalized.unsqueeze(0) # predict device = torch.device("cuda" if torch.cuda.is_available() else "cpu") batchified = batchified.to(device) output = model.forward(batchified) return json.dumps(output.cpu().numpy().tolist()), response_content_type ``` ------ 1. **Pour les instances inf1 ou les images de conteneur onnx, xgboost, keras** Pour toutes les autres images de conteneur optimisées pour l'inférence Neo, ou les types d'instances Inferentia, le script de point d'entrée doit mettre en œuvre les fonctions suivantes pour le Runtime Deep Learning Neo : + `neo_preprocess` : convertit la charge utile de demande entrante en un tableau numpy. + `neo_postprocess` : convertit la sortie de la prédiction du Runtime Deep Learning Neo dans le corps de la réponse. **Note** Les deux fonctions précédentes n'utilisent aucune des fonctionnalités de MXNet PyTorch, ou TensorFlow. Pour obtenir des exemples d’utilisation de ces fonctions, consultez [Exemples de blocs-notes de compilation de modèles Neo](https://docs.aws.amazon.com//sagemaker/latest/dg/neo.html#neo-sample-notebooks). 1. **Pour les TensorFlow modèles** Si votre modèle nécessite une logique de pré- et de post-traitement personnalisée avant l'envoi des données au modèle, vous devez spécifier un fichier script de point d'entrée `inference.py` utilisable au moment de l'inférence. Le script doit mettre en œuvre une paire de fonctions `input_handler` et `output_handler` ou une seule fonction de gestionnaire. **Note** Veuillez noter que si la fonction de gestionnaire est mise en œuvre, `input_handler` et `output_handler` sont ignorées. Voici un exemple de code de script `inference.py` que vous pouvez assembler avec le modèle de compilation pour effectuer un pré- et un post-traitement personnalisé sur un modèle de classification d'image. Le client SageMaker AI envoie le fichier image en tant que type de `application/x-image` contenu à la `input_handler` fonction, où il est converti en JSON. Le fichier image converti est ensuite envoyé au [serveur de modèles Tensorflow (TFX)](https://www.tensorflow.org/tfx/serving/api_rest) à l'aide de l'API REST. ``` import json import numpy as np import json import io from PIL import Image def input_handler(data, context): """ Pre-process request input before it is sent to TensorFlow Serving REST API Args: data (obj): the request data, in format of dict or string context (Context): an object containing request and configuration details Returns: (dict): a JSON-serializable dict that contains request body and headers """ f = data.read() f = io.BytesIO(f) image = Image.open(f).convert('RGB') batch_size = 1 image = np.asarray(image.resize((512, 512))) image = np.concatenate([image[np.newaxis, :, :]] * batch_size) body = json.dumps({"signature_name": "serving_default", "instances": image.tolist()}) return body def output_handler(data, context): """Post-process TensorFlow Serving output before it is returned to the client. Args: data (obj): the TensorFlow serving response context (Context): an object containing request and configuration details Returns: (bytes, string): data to return to client, response content type """ if data.status_code != 200: raise ValueError(data.content.decode('utf-8')) response_content_type = context.accept_header prediction = data.content return prediction, response_content_type ``` S'il n'y a pas de prétraitement ou de post-traitement personnalisé, le client SageMaker AI convertit l'image du fichier en JSON de la même manière avant de l'envoyer au point de terminaison SageMaker AI. Pour plus d'informations, consultez la section [Déploiement vers TensorFlow des points de terminaison du SDK SageMaker Python](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#providing-python-scripts-for-pre-pos-processing). 1. L'URI du compartiment Amazon S3 qui contient les artefacts du modèle compilé. # Déployer un modèle compilé à l'aide du SageMaker SDK Vous devez satisfaire à la section [des prérequis](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) si le modèle a été compilé à l'aide de AWS SDK pour Python (Boto3) AWS CLI, ou de la console Amazon SageMaker AI. Suivez l'un des cas d'utilisation suivants pour déployer un modèle compilé avec SageMaker Neo en fonction de la façon dont vous avez compilé votre modèle. **Topics** + [Si vous avez compilé votre modèle à l'aide du SageMaker SDK](#neo-deployment-hosting-services-sdk-deploy-sm-sdk) + [Si vous avez compilé votre modèle en utilisant MXNet ou PyTorch](#neo-deployment-hosting-services-sdk-deploy-sm-boto3) + [Si vous avez compilé votre modèle à l'aide de Boto3, de SageMaker la console ou de la CLI pour TensorFlow](#neo-deployment-hosting-services-sdk-deploy-sm-boto3-tensorflow) ## Si vous avez compilé votre modèle à l'aide du SageMaker SDK Le gestionnaire d'objet [sagemaker.Model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html?highlight=sagemaker.Model) pour le modèle compilé fournit la fonction [deploy()](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html?highlight=sagemaker.Model#sagemaker.model.Model.deploy) pour vous aider à créer un point de terminaison pour servir des demandes d'inférence. La fonctionnalité vous permet de définir le nombre et le type d'instances utilisés pour le point de terminaison. Vous devez choisir une instance pour laquelle vous avez compilé votre modèle. Par exemple, dans le travail compilé dans la section [Compile a Model (Amazon SageMaker SDK)](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-job-compilation-sagemaker-sdk.html), c'est`ml_c5`. ``` predictor = compiled_model.deploy(initial_instance_count = 1, instance_type = 'ml.c5.4xlarge') # Print the name of newly created endpoint print(predictor.endpoint_name) ``` ## Si vous avez compilé votre modèle en utilisant MXNet ou PyTorch Créez le modèle d' SageMaker IA et déployez-le à l'aide de l'API deploy () dans le cadre du modèle spécifique au framework. APIs Car MXNet c'est le [MXNetmodèle](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html?highlight=MXNetModel#mxnet-model) et pour PyTorch, c'est le cas [ PyTorchModel](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html?highlight=PyTorchModel#sagemaker.pytorch.model.PyTorchModel). Lorsque vous créez et déployez un modèle d' SageMaker IA, vous devez définir la variable d'`MMS_DEFAULT_RESPONSE_TIMEOUT`environnement sur `500` et spécifier le `entry_point` paramètre en tant que script d'inférence (`inference.py`) et le `source_dir` paramètre en tant qu'emplacement du répertoire (`code`) du script d'inférence. Pour préparer le script d'inférence (`inference.py`) suivez l'étape Prérequis. L'exemple suivant montre comment utiliser ces fonctions pour déployer un modèle compilé à l'aide du SDK SageMaker AI pour Python : ------ #### [ MXNet ] ``` from sagemaker.mxnet import MXNetModel # Create SageMaker model and deploy an endpoint sm_mxnet_compiled_model = MXNetModel( model_data='insert S3 path of compiled MXNet model archive', role='AmazonSageMaker-ExecutionRole', entry_point='inference.py', source_dir='code', framework_version='1.8.0', py_version='py3', image_uri='insert appropriate ECR Image URI for MXNet', env={'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'}, ) # Replace the example instance_type below to your preferred instance_type predictor = sm_mxnet_compiled_model.deploy(initial_instance_count = 1, instance_type = 'ml.p3.2xlarge') # Print the name of newly created endpoint print(predictor.endpoint_name) ``` ------ #### [ PyTorch 1.4 and Older ] ``` from sagemaker.pytorch import PyTorchModel # Create SageMaker model and deploy an endpoint sm_pytorch_compiled_model = PyTorchModel( model_data='insert S3 path of compiled PyTorch model archive', role='AmazonSageMaker-ExecutionRole', entry_point='inference.py', source_dir='code', framework_version='1.4.0', py_version='py3', image_uri='insert appropriate ECR Image URI for PyTorch', env={'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'}, ) # Replace the example instance_type below to your preferred instance_type predictor = sm_pytorch_compiled_model.deploy(initial_instance_count = 1, instance_type = 'ml.p3.2xlarge') # Print the name of newly created endpoint print(predictor.endpoint_name) ``` ------ #### [ PyTorch 1.5 and Newer ] ``` from sagemaker.pytorch import PyTorchModel # Create SageMaker model and deploy an endpoint sm_pytorch_compiled_model = PyTorchModel( model_data='insert S3 path of compiled PyTorch model archive', role='AmazonSageMaker-ExecutionRole', entry_point='inference.py', source_dir='code', framework_version='1.5', py_version='py3', image_uri='insert appropriate ECR Image URI for PyTorch', ) # Replace the example instance_type below to your preferred instance_type predictor = sm_pytorch_compiled_model.deploy(initial_instance_count = 1, instance_type = 'ml.p3.2xlarge') # Print the name of newly created endpoint print(predictor.endpoint_name) ``` ------ **Note** Les politiques `AmazonSageMakerFullAccess` et `AmazonS3ReadOnlyAccess` doivent être attachées au rôle IAM `AmazonSageMaker-ExecutionRole`. ## Si vous avez compilé votre modèle à l'aide de Boto3, de SageMaker la console ou de la CLI pour TensorFlow Créez un objet `TensorFlowModel`, puis appelez la fonction deploy : ``` role='AmazonSageMaker-ExecutionRole' model_path='S3 path for model file' framework_image='inference container arn' tf_model = TensorFlowModel(model_data=model_path, framework_version='1.15.3', role=role, image_uri=framework_image) instance_type='ml.c5.xlarge' predictor = tf_model.deploy(instance_type=instance_type, initial_instance_count=1) ``` Pour plus d’informations, consultez [Déploiement direct à partir d’artefacts du modèle](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#deploying-directly-from-model-artifacts). Vous pouvez sélectionner un URI Amazon ECR d'image Docker répondant à vos besoins dans [cette liste](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html). Pour plus d'informations sur la création d'un `TensorFlowModel` objet, consultez le [SageMaker SDK.](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-serving-model) **Note** La latence de votre première demande d'inférence peut être élevée si vous déployez votre modèle sur un GPU. Cela vient du fait qu'un noyau de calcul optimisé est créé sur la première demande d'inférence. Nous vous recommandons de créer un fichier de préparation des demandes d'inférence, que vous stockerez à côté de votre fichier de modèle avant de l'envoyer à un TFX. C'est ce que l'on appelle « préparer » le modèle. L'extrait de code suivant montre comment produire le fichier de préparation pour l'exemple de classification d'image dans la section [Prérequis](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) : ``` import tensorflow as tf from tensorflow_serving.apis import classification_pb2 from tensorflow_serving.apis import inference_pb2 from tensorflow_serving.apis import model_pb2 from tensorflow_serving.apis import predict_pb2 from tensorflow_serving.apis import prediction_log_pb2 from tensorflow_serving.apis import regression_pb2 import numpy as np with tf.python_io.TFRecordWriter("tf_serving_warmup_requests") as writer: img = np.random.uniform(0, 1, size=[224, 224, 3]).astype(np.float32) img = np.expand_dims(img, axis=0) test_data = np.repeat(img, 1, axis=0) request = predict_pb2.PredictRequest() request.model_spec.name = 'compiled_models' request.model_spec.signature_name = 'serving_default' request.inputs['Placeholder:0'].CopyFrom(tf.compat.v1.make_tensor_proto(test_data, shape=test_data.shape, dtype=tf.float32)) log = prediction_log_pb2.PredictionLog( predict_log=prediction_log_pb2.PredictLog(request=request)) writer.write(log.SerializeToString()) ``` Pour plus d'informations sur la façon de « réchauffer » votre modèle, consultez la [page TensorFlow TFX](https://www.tensorflow.org/tfx/serving/saved_model_warmup). # Déploiement d'un modèle compilé à l'aide de Boto3 Vous devez satisfaire à la section [des prérequis](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) si le modèle a été compilé à l'aide de AWS SDK pour Python (Boto3) AWS CLI, ou de la console Amazon SageMaker AI. Suivez les étapes ci-dessous pour créer et déployer un modèle SageMaker compilé au format Neo à l'aide du [SDK Amazon Web Services pour Python (](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)Boto3). **Topics** + [Déploiement du modèle](#neo-deployment-hosting-services-boto3-steps) ## Déploiement du modèle Une fois que vous avez satisfait aux [conditions requises](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites), utilisez le `create_model``create_enpoint_config`, et `create_endpoint` APIs. L'exemple suivant montre comment les utiliser APIs pour déployer un modèle compilé avec Neo : ``` import boto3 client = boto3.client('sagemaker') # create sagemaker model create_model_api_response = client.create_model( ModelName='my-sagemaker-model', PrimaryContainer={ 'Image': , 'ModelDataUrl': 's3://path/to/model/artifact/model.tar.gz', 'Environment': {} }, ExecutionRoleArn='ARN for AmazonSageMaker-ExecutionRole' ) print ("create_model API response", create_model_api_response) # create sagemaker endpoint config create_endpoint_config_api_response = client.create_endpoint_config( EndpointConfigName='sagemaker-neomxnet-endpoint-configuration', ProductionVariants=[ { 'VariantName': , 'ModelName': 'my-sagemaker-model', 'InitialInstanceCount': 1, 'InstanceType': }, ] ) print ("create_endpoint_config API response", create_endpoint_config_api_response) # create sagemaker endpoint create_endpoint_api_response = client.create_endpoint( EndpointName='provide your endpoint name', EndpointConfigName=, ) print ("create_endpoint API response", create_endpoint_api_response) ``` **Note** Les politiques `AmazonSageMakerFullAccess` et `AmazonS3ReadOnlyAccess` doivent être attachées au rôle IAM `AmazonSageMaker-ExecutionRole`. Pour la syntaxe complète de `create_model``create_endpoint_config`, `create_endpoint` APIs, et [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), voir [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config), et [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), respectivement. Si vous n'avez pas entraîné votre modèle à l'aide de l' SageMaker IA, spécifiez les variables d'environnement suivantes : ------ #### [ MXNet and PyTorch ] ``` "Environment": { "SAGEMAKER_PROGRAM": "inference.py", "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code", "SAGEMAKER_CONTAINER_LOG_LEVEL": "20", "SAGEMAKER_REGION": "insert your region", "MMS_DEFAULT_RESPONSE_TIMEOUT": "500" } ``` ------ #### [ TensorFlow ] ``` "Environment": { "SAGEMAKER_PROGRAM": "inference.py", "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code", "SAGEMAKER_CONTAINER_LOG_LEVEL": "20", "SAGEMAKER_REGION": "insert your region" } ``` ------ Si vous avez entraîné votre modèle à l'aide de l' SageMaker IA, spécifiez la variable d'environnement `SAGEMAKER_SUBMIT_DIRECTORY` sous la forme de l'URI complet du compartiment Amazon S3 qui contient le script d'entraînement. # Déployez un modèle compilé à l'aide du AWS CLI Vous devez satisfaire à la section [des prérequis](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) si le modèle a été compilé à l'aide de AWS SDK pour Python (Boto3) AWS CLI, ou de la console Amazon SageMaker AI. Suivez les étapes ci-dessous pour créer et déployer un modèle SageMaker compilé au format NEO à l'aide du [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/). **Topics** + [Déploiement du modèle](#neo-deploy-cli) ## Déploiement du modèle Une fois que vous avez satisfait aux [conditions requises](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites), utilisez les `create-endpoint` AWS CLI commandes `create-model``create-enpoint-config`, et. Les étapes suivantes expliquent comment utiliser ces commandes pour déployer un modèle compilé avec Neo : ### Création d'un modèle [Dans Neo Inference Container Images](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html), sélectionnez l'URI de l'image d'inférence, puis utilisez l'`create-model`API pour créer un modèle d' SageMaker IA. Vous pouvez effectuer cette opération en deux étapes : 1. Créez un fichier `create_model.json`. Dans le fichier, spécifiez le nom du modèle, l'URI de l'image, le chemin d'accès au `model.tar.gz` fichier dans votre compartiment Amazon S3 et votre rôle d'exécution SageMaker AI : ``` { "ModelName": "insert model name", "PrimaryContainer": { "Image": "insert the ECR Image URI", "ModelDataUrl": "insert S3 archive URL", "Environment": {"See details below"} }, "ExecutionRoleArn": "ARN for AmazonSageMaker-ExecutionRole" } ``` Si vous avez entraîné votre modèle à l'aide de l' SageMaker IA, spécifiez la variable d'environnement suivante : ``` "Environment": { "SAGEMAKER_SUBMIT_DIRECTORY" : "[Full S3 path for *.tar.gz file containing the training script]" } ``` Si vous n'avez pas entraîné votre modèle à l'aide de l' SageMaker IA, spécifiez les variables d'environnement suivantes : ------ #### [ MXNet and PyTorch ] ``` "Environment": { "SAGEMAKER_PROGRAM": "inference.py", "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code", "SAGEMAKER_CONTAINER_LOG_LEVEL": "20", "SAGEMAKER_REGION": "insert your region", "MMS_DEFAULT_RESPONSE_TIMEOUT": "500" } ``` ------ #### [ TensorFlow ] ``` "Environment": { "SAGEMAKER_PROGRAM": "inference.py", "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code", "SAGEMAKER_CONTAINER_LOG_LEVEL": "20", "SAGEMAKER_REGION": "insert your region" } ``` ------ **Note** Les politiques `AmazonSageMakerFullAccess` et `AmazonS3ReadOnlyAccess` doivent être attachées au rôle IAM `AmazonSageMaker-ExecutionRole`. 1. Exécutez la commande suivante : ``` aws sagemaker create-model --cli-input-json file://create_model.json ``` Pour obtenir la syntaxe complète de l'API `create-model`, consultez [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html). ### Création d'une configuration de point de terminaison Après avoir créé un modèle d' SageMaker IA, créez la configuration du point de terminaison à l'aide de l'`create-endpoint-config`API. Pour ce faire, créez un fichier JSON avec les spécifications de votre configuration de point de terminaison. Par exemple, vous pouvez utiliser le modèle de code suivant et l'enregistrer comme `create_config.json` : ``` { "EndpointConfigName": "", "ProductionVariants": [ { "VariantName": "", "ModelName": "my-sagemaker-model", "InitialInstanceCount": 1, "InstanceType": "", "InitialVariantWeight": 1.0 } ] } ``` Exécutez maintenant la AWS CLI commande suivante pour créer la configuration de votre point de terminaison : ``` aws sagemaker create-endpoint-config --cli-input-json file://create_config.json ``` Pour obtenir la syntaxe complète de l'API `create-endpoint-config`, consultez [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). ### Création d’un point de terminaison Après avoir créé votre configuration de point de terminaison, créez un point de terminaison à l'aide de l'API `create-endpoint` : ``` aws sagemaker create-endpoint --endpoint-name '' --endpoint-config-name '' ``` Pour obtenir la syntaxe complète de l'API `create-endpoint`, consultez [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html). # Déploiement d'un modèle compilé à l'aide de la console Vous devez satisfaire à la section des [prérequis](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) si le modèle a été compilé à l'aide AWS SDK pour Python (Boto3) de la AWS CLI console Amazon AI ou de la console Amazon SageMaker AI. Suivez les étapes ci-dessous pour créer et déployer un modèle compilé SageMaker AI Neo à l'aide de la console SageMaker AI [https://console.aws.amazon.com SageMaker /AI](https://console.aws.amazon.com/sagemaker/). **Topics** + [Déploiement du modèle](#deploy-the-model-console-steps) ## Déploiement du modèle Une fois les [prérequis](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) satisfaits, procédez comme suit pour déployer un modèle compilé avec Neo : 1. Choisissez **Modèles**, puis **Créer des modèles** depuis le groupe **Déduction**. Sur la page **Create model** (Créer un modèle), renseignez les champs **Model name** (Nom du modèle), **IAM role** (Rôle IAM) et **VPC**, si nécessaire. ![\[Création d'un modèle Neo pour l'inférence\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/create-pipeline-model.png) 1. Pour ajouter des informations sur le conteneur utilisé pour déployer votre modèle, choisissez **Add container (Ajouter un conteneur)**, puis **Next (Suivant)**. Renseignez les champs **Container input options** (Options d'entrée du conteneur), **Location of inference code image** (Emplacement de l'image du code d'inférence), **Location of model artifacts** (Emplacement des artefacts du modèle), ainsi que **Container host name** (Nom d'hôte du conteneur) et **Environmental variables** (Variables d'environnement) éventuellement. ![\[Création d'un modèle Neo pour l'inférence\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo-deploy-console-container-definition.png) 1. Pour déployer des modèles compilés par Neo, choisissez l'une des options suivantes : + **Container input options (Options d'entrée du conteneur)** : **fournissez des artefacts du modèle et une image d'inférence**. + **Location of inference code image (Emplacement de l'image du code d'inférence)** : choisissez l'URI de l'image d'inférence dans [Neo Inference Container Images (Images du conteneur d'inférence Neo)](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html) en fonction de la région AWS et du type d'application. + **Location of model artifacts (Emplacement des artefacts du modèle)** : saisissez l'URI du compartiment Amazon S3 de l'artefact du modèle compilé généré par l'API de compilation Neo. + **Variables d'environnement** : + Laissez ce champ vide pour **SageMaker XGBoost**. + Si vous avez entraîné votre modèle à l'aide de l' SageMaker IA, spécifiez la variable d'environnement `SAGEMAKER_SUBMIT_DIRECTORY` sous la forme de l'URI du compartiment Amazon S3 qui contient le script d'entraînement. + Si vous n'avez pas entraîné votre modèle à l'aide de l' SageMaker IA, spécifiez les variables d'environnement suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/neo-deployment-hosting-services-console.html) 1. Confirmez l'exactitude des informations des conteneurs, puis choisissez **Create model (Créer un modèle)**. Sur la **Create model landing page (page d'accueil Créer un modèle)**, choisissez **Create endpoint (Créer un point de terminaison)**. ![\[Page d'accueil Créer un modèle\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo-deploy-console-create-model-land-page.png) 1. Sur le schéma, **Créer et configurer un point de terminaison**, spécifiez le **Nom du point de terminaison**. Pour **Attach endpoint configuration (Attacher une configuration de point de terminaison)** choisissez **Create a new endpoint configuration (Créer une nouvelle configuration de point de terminaison)**. ![\[Interface utilisateur Créer et configurer un point de terminaison de la console Neo.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo-deploy-console-config-endpoint.png) 1. Sur la page **Nouvelle configuration du point de terminaison**, spécifiez le **Nom de configuration du point de terminaison**. ![\[Interface utilisateur Nouvelle configuration de point de terminaison de la console Neo.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo-deploy-console-new-endpoint-config.png) 1. Choisissez **Edit (Modifier)** en regard du nom du modèle et spécifiez le **Type d'instance** correct sur la page **Edit Production Variant (Modifier la variante de production)**. Il est impératif que la valeur **Type d'instance** corresponde à celle spécifiée dans votre tâche de compilation. ![\[Interface utilisateur Nouvelle configuration de point de terminaison de la console Neo.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo-deploy-console-edit-production-variant.png) 1. Choisissez **Enregistrer**. 1. Sur la page **New endpoint configuration (Nouvelle configuration de point de terminaison)**, choisissez **Create endpoint configuration (Créer une configuration de point de terminaison)**, puis choisissez **Create endpoint (Créer un point de terminaison)**.