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.
# Instances cloud
Amazon SageMaker Neo prend en charge la compilation pour les cadres de machine learning les plus courants, tels que TensorFlow, PyTorch, MXNet, etc. Vous pouvez déployer votre modèle compilé sur des instances cloud et des AWS Inferentia. Pour obtenir la liste complète des cadres et types d’instance pris en charge, consultez [Cadres et types d’instances pris en charge](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-supported-cloud.html).
Vous pouvez compiler votre modèle de l’une des trois façons suivantes : via l’AWS CLI, la console SageMaker AI ou le kit SDK SageMaker AI pour Python. Pour plus d’informations, consultez [Utiliser Neo pour compiler un modèle](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-job-compilation.html). Une fois vos artefacts de modèle compilés, ils sont stockés dans l'URI du compartiment Amazon S3 que vous avez spécifié lors de la tâche de compilation. Vous pouvez déployer votre modèle compilé sur des instances cloud et AWS Inferentia à l’aide du kit SDK SageMaker pour Python, du kit AWS SDK pour Python (Boto3), de l’AWS CLI ou de la console AWS.
Si vous déployez votre modèle à l'aide de la AWS CLI, la console ou Boto3, vous devez sélectionner un URI Amazon ECR d'image Docker pour votre conteneur principal. Consultez [Images de conteneur d’inférence Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html) pour obtenir la liste des URI Amazon ECR.
**Topics**
+ [
# Cadres et types d’instance pris en charge
](neo-supported-cloud.md)
+ [
# Déploiement d'un modèle
](neo-deployment-hosting-services.md)
+ [
# Demandes d’inférence avec un service déployé
](neo-requests.md)
+ [
# Images de conteneur d'inférence
](neo-deployment-hosting-services-container-images.md)
# Cadres et types d’instance pris en charge
Amazon SageMaker Neo prend en charge les cadres de deep learning les plus courants pour la compilation et le déploiement. Vous pouvez déployer votre modèle sur des instances cloud ou des types d’instances AWS Inferentia.
La section suivante décrit les cadres pris en charge par SageMaker Neo et les instances cloud cible sur lesquelles vous pouvez compiler et déployer. Pour obtenir des informations sur le déploiement de votre modèle compilé sur une instance cloud ou Inferentia, consultez [Déploiement d’un modèle avec des instances cloud](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services.html).
## Instances cloud
SageMaker Neo prend en charge les cadres de deep learning suivants pour les instances cloud CPU et GPU :
| Cadre | Version du cadre | Version de modèle | Modèles | Formats de modèle (packagés dans \$1.tar.gz) | Boîtes à outils |
| --- | --- | --- | --- | --- | --- |
| MXNet | 1.8.0 | Prend en charge la version 1.8.0 ou antérieure | classification d’images, détection d’objets, segmentation sémantique, estimation de pose, reconnaissance d’activités | Un fichier de symboles (.json) et un fichier de paramètres (.params) | GluonCV v0.8.0 |
| ONNX | 1.7.0 | Prend en charge la version 1.7.0 ou antérieure | Classification d’images, SVM | Un fichier de modèle (.onnx) | |
| Keras | 2.2.4 | Prend en charge la version 2.2.4 ou antérieure | Classification d’images | Un fichier de définition de modèle (.h5) | |
| PyTorch | 1.4, 1.5, 1.6, 1.7, 1.8, 1.12, 1.13 ou 2.0 | Prend en charge 1.4, 1.5, 1.6, 1.7, 1.8, 1.12, 1.13 et 2.0 | Classification d’images Les versions 1.13 et 2.0 prennent en charge la détection d’objets, le transformeur de vision et HuggingFace | Un fichier de définition de modèle (.pt ou .pth) avec dtype d’entrée float32 | |
| TensorFlow | 1.15.3 ou 2.9 | Prend en charge 1.15.3 et 2.9 | Classification d’images | Pour les modèles enregistrés, Neo attend un fichier .pb ou .pbtxt, ainsi qu’un répertoire de variables contenant des variables Pour les modèles figés, Neo attend uniquement un fichier .pb ou .pbtxt | |
| XGBoost | 1.3.3 | Prend en charge la version 1.3.3 ou antérieure | Arbres de décision | Un fichier de modèles XGBoost (.model) dans lequel le nombre de nœuds d’une arborescence est inférieur à 2^31 | |
**Note**
« Model Version » est la version du cadre utilisé pour entraîner et exporter le modèle.
## Types d’instances
Vous pouvez déployer votre modèle compilé SageMaker AI sur l’une des instances cloud ci-dessous :
| Instance | Type de calcul |
| --- | --- |
| `ml_c4` | Standard |
| `ml_c5` | Standard |
| `ml_m4` | Standard |
| `ml_m5` | Standard |
| `ml_p2` | Calcul accéléré |
| `ml_p3` | Calcul accéléré |
| `ml_g4dn` | Calcul accéléré |
Pour obtenir des informations sur le vCPU disponible, la mémoire et le prix à l’heure pour chaque type d’instance, consultez [Tarification Amazon SageMaker](https://aws.amazon.com/sagemaker/pricing/).
**Note**
Lors de la compilation d’instances `ml_*` avec un cadre PyTorch, dans le champ **Options de compilateur** de **Configuration de la sortie**, fournissez le type de données correct (`dtype`) de l’entrée du modèle.
La valeur par défaut est définie sur `"float32"`.
## AWS Inferentia
SageMaker Neo prend en charge les frameworks de deep learning suivants pour Inf1 :
| Cadre | Version du cadre | Version de modèle | Modèles | Formats de modèle (packagés dans \$1.tar.gz) | Boîtes à outils |
| --- | --- | --- | --- | --- | --- |
| MXNet | 1.5 ou 1.8 | Prend en charge les versions 1.8, 1.5 et antérieures | classification d’images, détection d’objets, segmentation sémantique, estimation de pose, reconnaissance d’activités | Un fichier de symboles (.json) et un fichier de paramètres (.params) | GluonCV v0.8.0 |
| PyTorch | 1.7, 1.8 ou 1.9 | Prend en charge les versions 1.9 et antérieures | Classification d’images | Un fichier de définition de modèle (.pt ou .pth) avec dtype d’entrée float32 | |
| TensorFlow | 1.15 ou 2.5 | Prend en charge les versions 2.5, 1.15 et antérieures | Classification d’images | Pour les modèles enregistrés, Neo attend un fichier .pb ou .pbtxt, ainsi qu’un répertoire de variables contenant des variables Pour les modèles figés, Neo attend uniquement un fichier .pb ou .pbtxt | |
**Note**
« Model Version » est la version du cadre utilisé pour entraîner et exporter le modèle.
Vous pouvez déployer votre modèle SageMaker Neo-compilé sur des instances Amazon EC2 Inf1 basées sur AWS Inferentia. AWS Inferentia est la première puce de silicium personnalisée d’Amazon conçue pour accélérer le deep learning. Actuellement, vous pouvez utiliser l’instance `ml_inf1` pour déployer vos modèles compilés.
### AWS Inferentia2 et AWS Trainium
À l’heure actuelle, vous pouvez déployer votre modèle compilé par SageMaker Neo sur des instances Amazon EC2 Inf2 AWS basées sur Inferentia2 (dans la région USA Est (Ohio)) et sur des instances Amazon EC2 Trn1 AWS basées sur Trainium (dans la région USA Est (Virginie du Nord)). Pour plus d’informations sur les modèles pris en charge sur ces instances, consultez [Directives d’ajustement de l’architecture des modèles](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/general/arch/model-architecture-fit.html) dans la documentation AWS Neuron et les exemples dans le [référentiel Neuron Github](https://github.com/aws-neuron/aws-neuron-sagemaker-samples).
# 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)**.
# Demandes d’inférence avec un service déployé
Si vous avez suivi les instructions[Déploiement d'un modèle](neo-deployment-hosting-services.md), vous devriez avoir un point de terminaison SageMaker AI configuré et en cours d'exécution. Indépendamment de la façon dont vous avez déployé votre modèle néo-compilé, vous pouvez envoyer des demandes d'inférence de trois façons différentes :
**Topics**
+ [
# Demander des inférences à partir d'un service déployé (Amazon SageMaker SDK)
](neo-requests-sdk.md)
+ [
# Demande d'inférences à partir d'un service déployé (Boto3)
](neo-requests-boto3.md)
+ [
# Demander des inférences à partir d'un service déployé (AWS CLI)
](neo-requests-cli.md)
# Demander des inférences à partir d'un service déployé (Amazon SageMaker SDK)
Utilisez les exemples de code suivants pour demander des inférences à partir de votre service déployé en fonction du cadre que vous avez utilisé pour entraîner votre modèle. Les exemples de code sont similaires pour les différents cadres. La principale différence est que le type de contenu est TensorFlow requis`application/json`.
## PyTorch et MXNet
Si vous utilisez la version **PyTorch 1.4 ou une version ultérieure ou** la **MXNet version 1.7.0 ou une version ultérieure** et que vous disposez d'un point de terminaison Amazon SageMaker AI`InService`, vous pouvez effectuer des demandes d'inférence à l'aide `predictor` du package du SDK SageMaker AI pour Python.
**Note**
L'API varie en fonction de la version du SDK SageMaker AI pour Python :
Pour la version 1.x, utilisez le [https://sagemaker.readthedocs.io/en/v1.72.0/api/inference/predictors.html#sagemaker.predictor.RealTimePredictor](https://sagemaker.readthedocs.io/en/v1.72.0/api/inference/predictors.html#sagemaker.predictor.RealTimePredictor) et l'API [https://sagemaker.readthedocs.io/en/v1.72.0/api/inference/predictors.html#sagemaker.predictor.RealTimePredictor.predict](https://sagemaker.readthedocs.io/en/v1.72.0/api/inference/predictors.html#sagemaker.predictor.RealTimePredictor.predict).
Pour la version 2.x, utilisez le [https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html#sagemaker.predictor.Predictor](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html#sagemaker.predictor.Predictor) et l'API [https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html#sagemaker.predictor.Predictor.predict](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html#sagemaker.predictor.Predictor.predict).
L'exemple de code suivant montre comment les utiliser pour envoyer une image APIs à des fins d'inférence :
------
#### [ SageMaker Python SDK v1.x ]
```
from sagemaker.predictor import RealTimePredictor
endpoint = 'insert name of your endpoint here'
# Read image into memory
payload = None
with open("image.jpg", 'rb') as f:
payload = f.read()
predictor = RealTimePredictor(endpoint=endpoint, content_type='application/x-image')
inference_response = predictor.predict(data=payload)
print (inference_response)
```
------
#### [ SageMaker Python SDK v2.x ]
```
from sagemaker.predictor import Predictor
endpoint = 'insert name of your endpoint here'
# Read image into memory
payload = None
with open("image.jpg", 'rb') as f:
payload = f.read()
predictor = Predictor(endpoint)
inference_response = predictor.predict(data=payload)
print (inference_response)
```
------
## TensorFlow
L'exemple de code suivant montre comment utiliser l'API du SDK SageMaker Python pour envoyer une image à des fins d'inférence :
```
from sagemaker.predictor import Predictor
from PIL import Image
import numpy as np
import json
endpoint = 'insert the name of your endpoint here'
# Read image into memory
image = Image.open(input_file)
batch_size = 1
image = np.asarray(image.resize((224, 224)))
image = image / 128 - 1
image = np.concatenate([image[np.newaxis, :, :]] * batch_size)
body = json.dumps({"instances": image.tolist()})
predictor = Predictor(endpoint)
inference_response = predictor.predict(data=body)
print(inference_response)
```
# Demande d'inférences à partir d'un service déployé (Boto3)
Vous pouvez soumettre des demandes d'inférence à l'aide du [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)client et de l'API SageMaker AI SDK for Python (Boto3) une fois que vous disposez d'un point de terminaison AI. SageMaker `InService` L'exemple de code suivant montre comment envoyer une image pour inférence :
------
#### [ PyTorch and MXNet ]
```
import boto3
import json
endpoint = 'insert name of your endpoint here'
runtime = boto3.Session().client('sagemaker-runtime')
# Read image into memory
with open(image, 'rb') as f:
payload = f.read()
# Send image via InvokeEndpoint API
response = runtime.invoke_endpoint(EndpointName=endpoint, ContentType='application/x-image', Body=payload)
# Unpack response
result = json.loads(response['Body'].read().decode())
```
------
#### [ TensorFlow ]
Pour TensorFlow soumettre une entrée avec `application/json` pour le type de contenu.
```
from PIL import Image
import numpy as np
import json
import boto3
client = boto3.client('sagemaker-runtime')
input_file = 'path/to/image'
image = Image.open(input_file)
batch_size = 1
image = np.asarray(image.resize((224, 224)))
image = image / 128 - 1
image = np.concatenate([image[np.newaxis, :, :]] * batch_size)
body = json.dumps({"instances": image.tolist()})
ioc_predictor_endpoint_name = 'insert name of your endpoint here'
content_type = 'application/json'
ioc_response = client.invoke_endpoint(
EndpointName=ioc_predictor_endpoint_name,
Body=body,
ContentType=content_type
)
```
------
#### [ XGBoost ]
Pour une XGBoost candidature, vous devez plutôt envoyer un texte CSV :
```
import boto3
import json
endpoint = 'insert your endpoint name here'
runtime = boto3.Session().client('sagemaker-runtime')
csv_text = '1,-1.0,1.0,1.5,2.6'
# Send CSV text via InvokeEndpoint API
response = runtime.invoke_endpoint(EndpointName=endpoint, ContentType='text/csv', Body=csv_text)
# Unpack response
result = json.loads(response['Body'].read().decode())
```
------
Notez que BYOM autorise un type de contenu personnalisé. Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html).
# Demander des inférences à partir d'un service déployé (AWS CLI)
Les demandes d'inférence peuvent être effectuées une [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)fois que vous avez un point de terminaison `InService` Amazon SageMaker AI. Vous pouvez faire des demandes d'inférence avec la AWS Command Line Interface (AWS CLI). L'exemple de code suivant montre comment envoyer une image pour inférence :
```
aws sagemaker-runtime invoke-endpoint --endpoint-name 'insert name of your endpoint here' --body fileb://image.jpg --content-type=application/x-image 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 TensorFlow soumettre une entrée avec `application/json` comme type de contenu.
```
aws sagemaker-runtime invoke-endpoint --endpoint-name 'insert name of your endpoint here' --body fileb://input.json --content-type=application/json output_file.txt
```
# Images de conteneur d'inférence
SageMaker Neo fournit désormais des informations d'URI sur les images d'inférence pour les `ml_*` cibles. Pour de plus amples informations, veuillez consulter [DescribeCompilationJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeCompilationJob.html#sagemaker-DescribeCompilationJob-response-InferenceImage).
Selon votre cas d'utilisation, remplacez la partie en surbrillance dans le modèle d'URI d'image d'inférence fourni ci-dessous par les valeurs qui conviennent.
## Amazon SageMaker AI XGBoost
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/xgboost-neo:latest
```
Remplacez *aws\$1account\$1id* dans le tableau à la fin de cette page en fonction de celui *aws\$1region* que vous avez utilisé.
## Keras
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-keras:fx_version-instance_type-py3
```
Remplacez *aws\$1account\$1id* dans le tableau à la fin de cette page en fonction de celui *aws\$1region* que vous avez utilisé.
Remplacez *fx\$1version* par `2.2.4`.
Remplacez *instance\$1type* par l'un `cpu` ou l'autre`gpu`.
## MXNet
------
#### [ CPU or GPU instance types ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-inference-mxnet:fx_version-instance_type-py3
```
Remplacez *aws\$1account\$1id* dans le tableau à la fin de cette page en fonction de celui *aws\$1region* que vous avez utilisé.
Remplacez *fx\$1version* par `1.8.0`.
Remplacez *instance\$1type* par l'un `cpu` ou l'autre`gpu`.
------
#### [ Inferentia1 ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-mxnet:fx_version-instance_type-py3
```
Remplacez *aws\$1region* par l'un `us-east-1` ou l'autre`us-west-2`.
Remplacez *aws\$1account\$1id* dans le tableau à la fin de cette page en fonction de celui *aws\$1region* que vous avez utilisé.
Remplacez *fx\$1version* par `1.5.1`.
Remplacez *`instance_type`* par `inf`.
------
## ONNX
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-onnx:fx_version-instance_type-py3
```
Remplacez *aws\$1account\$1id* dans le tableau à la fin de cette page en fonction de celui *aws\$1region* que vous avez utilisé.
Remplacez *fx\$1version* par `1.5.0`.
Remplacez *instance\$1type* par l'un `cpu` ou l'autre`gpu`.
## PyTorch
------
#### [ CPU or GPU instance types ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-inference-pytorch:fx_version-instance_type-py3
```
Remplacez *aws\$1account\$1id* dans le tableau à la fin de cette page en fonction de celui *aws\$1region* que vous avez utilisé.
Remplacez *fx\$1version* par `1.4``1.5`,`1.6`,`1.7`,`1.8`,`1.12`,`1.13`, ou`2.0`.
Remplacez *instance\$1type* par l'un `cpu` ou l'autre`gpu`.
------
#### [ Inferentia1 ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-pytorch:fx_version-instance_type-py3
```
Remplacez *aws\$1region* par l'un `us-east-1` ou l'autre`us-west-2`.
Remplacez *aws\$1account\$1id* dans le tableau à la fin de cette page en fonction de celui *aws\$1region* que vous avez utilisé.
Remplacez *fx\$1version* par `1.5.1`.
Remplacez *`instance_type`* par `inf`.
------
#### [ Inferentia2 and Trainium1 ]
```
763104351884.dkr.ecr.aws_region.amazonaws.com/pytorch-inference-neuronx:1.13.1-neuronx-py38-sdk2.10.0-ubuntu20.04
```
Remplacez *aws\$1region* par `us-east-2` pour Inferentia2 et `us-east-1` pour Trainium1.
------
## TensorFlow
------
#### [ CPU or GPU instance types ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-inference-tensorflow:fx_version-instance_type-py3
```
Remplacez *aws\$1account\$1id* dans le tableau à la fin de cette page en fonction de celui *aws\$1region* que vous avez utilisé.
Remplacez *fx\$1version* par `1.15.3` ou `2.9`.
Remplacez *instance\$1type* par l'un `cpu` ou l'autre`gpu`.
------
#### [ Inferentia1 ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-tensorflow:fx_version-instance_type-py3
```
Remplacez *aws\$1account\$1id* dans le tableau à la fin de cette page en fonction de celui *aws\$1region* que vous avez utilisé. Veuillez noter que, pour type d’instance `inf`, seuls `us-east-1` et `us-west-2` sont pris en charge.
Remplacez *fx\$1version* par `1.15.0`.
Remplacez *instance\$1type* par `inf`.
------
#### [ Inferentia2 and Trainium1 ]
```
763104351884.dkr.ecr.aws_region.amazonaws.com/tensorflow-inference-neuronx:2.10.1-neuronx-py38-sdk2.10.0-ubuntu20.04
```
Remplacez *aws\$1region* par `us-east-2` pour Inferentia2 et `us-east-1` pour Trainium1.
------
Le tableau suivant correspond *aws\$1account\$1id* à*aws\$1region*. Utilisez ce tableau pour trouver l'URI d'image d'inférence correcte dont vous avez besoin pour votre application.
| aws\$1account\$1id | aws\$1region |
| --- | --- |
| 785573368785 | us-east-1 |
| 007439368137 | us-east-2 |
| 710691900526 | us-west-1 |
| 301217895009 | us-west-2 |
| 802834080501 | eu-west-1 |
| 205493899709 | eu-west-2 |
| 254080097072 | eu-west-3 |
| 601324751636 | eu-north-1 |
| 966458181534 | eu-south-1 |
| 746233611703 | eu-central-1 |
| 110948597952 | ap-east-1 |
| 763008648453 | ap-south-1 |
| 941853720454 | ap-northeast-1 |
| 151534178276 | ap-northeast-2 |
| 925152966179 | ap-northeast-3 |
| 324986816169 | ap-southeast-1 |
| 355873309152 | ap-southeast-2 |
| 474822919863 | cn-northwest-1 |
| 472730292857 | cn-north-1 |
| 756306329178 | sa-east-1 |
| 464438896020 | ca-central-1 |
| 836785723513 | me-south-1 |
| 774647643957 | af-south-1 |
| 275950707576 | il-central-1 |