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.
# Utilisation du DLAMI avec Neuron AWS
Un flux de travail typique avec le SDK AWS Neuron consiste à compiler un modèle d'apprentissage automatique préalablement entraîné sur un serveur de compilation. Ensuite, distribuez les artefacts aux instances Inf1 pour exécution. AWS Apprentissage profond (deep learning) AMIs (DLAMI) est préinstallé avec tout ce dont vous avez besoin pour compiler et exécuter l'inférence dans une instance Inf1 qui utilise Inferentia.
Les sections suivantes décrivent comment utiliser le DLAMI avec Inferentia.
**Topics**
+ [Utilisation de TensorFlow -Neuron et du compilateur Neuron AWS](tutorial-inferentia-tf-neuron.md)
+ [Utilisation de AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
+ [Utilisation de MXNet -Neuron et du compilateur Neuron AWS](tutorial-inferentia-mxnet-neuron.md)
+ [Utilisation de MXNet -Neuron Model Serving](tutorial-inferentia-mxnet-neuron-serving.md)
+ [Utilisation de PyTorch -Neuron et du compilateur Neuron AWS](tutorial-inferentia-pytorch-neuron.md)
# Utilisation de TensorFlow -Neuron et du compilateur Neuron AWS
Ce didacticiel montre comment utiliser le compilateur AWS Neuron pour compiler le modèle Keras ResNet -50 et l'exporter en tant que modèle enregistré au format. SavedModel Ce format est un format interchangeable typique des TensorFlow modèles. Vous apprendrez également à exécuter l'inférence sur une instance Inf1 avec un exemple d'entrée.
Pour plus d'informations sur le SDK Neuron, consultez la documentation du SDK [AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html).
**Topics**
+ [Conditions préalables](#tutorial-inferentia-tf-neuron-prerequisites)
+ [Activation de l'environnement Conda](#tutorial-inferentia-tf-neuron-activate)
+ [Compilation Resnet50](#tutorial-inferentia-tf-neuron-compilation)
+ [ResNet50 Inférence](#tutorial-inferentia-tf-neuron-inference)
## Conditions préalables
Avant d'utiliser ce didacticiel, vous devez avoir terminé les étapes de configuration figurant dans [Lancement d'une instance DLAMI avec Neuron AWS](tutorial-inferentia-launching.md). Vous devez également être familiarisé avec le deep learning et l'utilisation du DLAMI.
## Activation de l'environnement Conda
Activez l'environnement TensorFlow -Neuron conda à l'aide de la commande suivante :
```
source activate aws_neuron_tensorflow_p36
```
Pour quitter l'environnement Conda actuel, exécutez la commande suivante :
```
source deactivate
```
## Compilation Resnet50
Créez un script Python appelé **tensorflow\$1compile\$1resnet50.py** ayant le contenu suivant. Ce script Python compile le modèle Keras ResNet 50 et l'exporte en tant que modèle enregistré.
```
import os
import time
import shutil
import tensorflow as tf
import tensorflow.neuron as tfn
import tensorflow.compat.v1.keras as keras
from tensorflow.keras.applications.resnet50 import ResNet50
from tensorflow.keras.applications.resnet50 import preprocess_input
# Create a workspace
WORKSPACE = './ws_resnet50'
os.makedirs(WORKSPACE, exist_ok=True)
# Prepare export directory (old one removed)
model_dir = os.path.join(WORKSPACE, 'resnet50')
compiled_model_dir = os.path.join(WORKSPACE, 'resnet50_neuron')
shutil.rmtree(model_dir, ignore_errors=True)
shutil.rmtree(compiled_model_dir, ignore_errors=True)
# Instantiate Keras ResNet50 model
keras.backend.set_learning_phase(0)
model = ResNet50(weights='imagenet')
# Export SavedModel
tf.saved_model.simple_save(
session = keras.backend.get_session(),
export_dir = model_dir,
inputs = {'input': model.inputs[0]},
outputs = {'output': model.outputs[0]})
# Compile using Neuron
tfn.saved_model.compile(model_dir, compiled_model_dir)
# Prepare SavedModel for uploading to Inf1 instance
shutil.make_archive(compiled_model_dir, 'zip', WORKSPACE, 'resnet50_neuron')
```
Compilez le modèle à l'aide de la commande suivante :
```
python tensorflow_compile_resnet50.py
```
Le processus de compilation prendra quelques minutes. Une fois celui-ci terminée, votre sortie devrait ressembler à ce qui suit :
```
...
INFO:tensorflow:fusing subgraph neuron_op_d6f098c01c780733 with neuron-cc
INFO:tensorflow:Number of operations in TensorFlow session: 4638
INFO:tensorflow:Number of operations after tf.neuron optimizations: 556
INFO:tensorflow:Number of operations placed on Neuron runtime: 554
INFO:tensorflow:Successfully converted ./ws_resnet50/resnet50 to ./ws_resnet50/resnet50_neuron
...
```
Après la compilation, le modèle enregistré est compressé dans **ws\$1resnet50/resnet50\$1neuron.zip**. Décompressez le modèle et téléchargez l'exemple d'image pour l'inférence à l'aide des commandes suivantes :
```
unzip ws_resnet50/resnet50_neuron.zip -d .
curl -O https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg
```
## ResNet50 Inférence
Créez un script Python appelé **tensorflow\$1infer\$1resnet50.py** ayant le contenu suivant. Ce script exécute l'inférence sur le modèle téléchargé à l'aide d'un modèle d'inférence compilé précédemment.
```
import os
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications import resnet50
# Create input from image
img_sgl = image.load_img('kitten_small.jpg', target_size=(224, 224))
img_arr = image.img_to_array(img_sgl)
img_arr2 = np.expand_dims(img_arr, axis=0)
img_arr3 = resnet50.preprocess_input(img_arr2)
# Load model
COMPILED_MODEL_DIR = './ws_resnet50/resnet50_neuron/'
predictor_inferentia = tf.contrib.predictor.from_saved_model(COMPILED_MODEL_DIR)
# Run inference
model_feed_dict={'input': img_arr3}
infa_rslts = predictor_inferentia(model_feed_dict);
# Display results
print(resnet50.decode_predictions(infa_rslts["output"], top=5)[0])
```
Exécutez l'inférence sur le modèle à l'aide de la commande suivante :
```
python tensorflow_infer_resnet50.py
```
Le résultat doit être similaire à ce qui suit :
```
...
[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]
```
**Étape suivante**
[Utilisation de AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
# Utilisation de AWS Neuron Serving TensorFlow
Ce didacticiel montre comment construire un graphe et ajouter une étape de compilation AWS Neuron avant d'exporter le modèle enregistré pour l'utiliser avec TensorFlow Serving. TensorFlow Le service est un système de service qui vous permet d'étendre l'inférence sur un réseau. Neuron TensorFlow Serving utilise la même API que le TensorFlow Serving normal. La seule différence est qu'un modèle enregistré doit être compilé pour AWS Inferentia et que le point d'entrée est un nom `tensorflow_model_server_neuron` binaire différent. Le binaire se trouve dans le `/usr/local/bin/tensorflow_model_server_neuron` DLAMI et y est préinstallé.
Pour plus d'informations sur le SDK Neuron, consultez la documentation du SDK [AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html).
**Topics**
+ [Conditions préalables](#tutorial-inferentia-tf-neuron--serving-prerequisites)
+ [Activation de l'environnement Conda](#tutorial-inferentia-tf-neuron-serving-activate)
+ [Compilation et exportation du modèle enregistré](#tutorial-inferentia-tf-neuron-serving-compile)
+ [Servir le modèle enregistré](#tutorial-inferentia-tf-neuron-serving-serving)
+ [Génération de demandes d'inférence au serveur de modèle](#tutorial-inferentia-tf-neuron-serving-inference)
## Conditions préalables
Avant d'utiliser ce didacticiel, vous devez avoir terminé les étapes de configuration figurant dans [Lancement d'une instance DLAMI avec Neuron AWS](tutorial-inferentia-launching.md). Vous devez également être familiarisé avec le deep learning et l'utilisation du DLAMI.
## Activation de l'environnement Conda
Activez l'environnement TensorFlow -Neuron conda à l'aide de la commande suivante :
```
source activate aws_neuron_tensorflow_p36
```
Si vous devez quitter l'environnement Conda actuel, exécutez :
```
source deactivate
```
## Compilation et exportation du modèle enregistré
Créez un script Python appelé `tensorflow-model-server-compile.py` avec le contenu suivant. Ce script construit un graphe et le compile à l'aide de Neuron. Il exporte ensuite le graphe compilé en tant que modèle enregistré.
```
import tensorflow as tf
import tensorflow.neuron
import os
tf.keras.backend.set_learning_phase(0)
model = tf.keras.applications.ResNet50(weights='imagenet')
sess = tf.keras.backend.get_session()
inputs = {'input': model.inputs[0]}
outputs = {'output': model.outputs[0]}
# save the model using tf.saved_model.simple_save
modeldir = "./resnet50/1"
tf.saved_model.simple_save(sess, modeldir, inputs, outputs)
# compile the model for Inferentia
neuron_modeldir = os.path.join(os.path.expanduser('~'), 'resnet50_inf1', '1')
tf.neuron.saved_model.compile(modeldir, neuron_modeldir, batch_size=1)
```
Compilez le modèle à l'aide de la commande suivante :
```
python tensorflow-model-server-compile.py
```
Le résultat doit être similaire à ce qui suit :
```
...
INFO:tensorflow:fusing subgraph neuron_op_d6f098c01c780733 with neuron-cc
INFO:tensorflow:Number of operations in TensorFlow session: 4638
INFO:tensorflow:Number of operations after tf.neuron optimizations: 556
INFO:tensorflow:Number of operations placed on Neuron runtime: 554
INFO:tensorflow:Successfully converted ./resnet50/1 to /home/ubuntu/resnet50_inf1/1
```
## Servir le modèle enregistré
Une fois le modèle compilé, vous pouvez utiliser la commande suivante pour servir le modèle enregistré avec le binaire tensorflow\$1model\$1server\$1neuron :
```
tensorflow_model_server_neuron --model_name=resnet50_inf1 \
--model_base_path=$HOME/resnet50_inf1/ --port=8500 &
```
Le résultat doit être similaire à ce qui suit. Le modèle compilé est installé dans la DRAM du dispositif Inferentia par le serveur pour préparer l'inférence.
```
...
2019-11-22 01:20:32.075856: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:311] SavedModel load for tags { serve }; Status: success. Took 40764 microseconds.
2019-11-22 01:20:32.075888: I tensorflow_serving/servables/tensorflow/saved_model_warmup.cc:105] No warmup data file found at /home/ubuntu/resnet50_inf1/1/assets.extra/tf_serving_warmup_requests
2019-11-22 01:20:32.075950: I tensorflow_serving/core/loader_harness.cc:87] Successfully loaded servable version {name: resnet50_inf1 version: 1}
2019-11-22 01:20:32.077859: I tensorflow_serving/model_servers/server.cc:353] Running gRPC ModelServer at 0.0.0.0:8500 ...
```
## Génération de demandes d'inférence au serveur de modèle
Créez un script Python appelé `tensorflow-model-server-infer.py` avec le contenu suivant. Ce script exécute l'inférence via gRPC, qui est une infrastructure de service.
```
import numpy as np
import grpc
import tensorflow as tf
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.resnet50 import preprocess_input
from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_service_pb2_grpc
from tensorflow.keras.applications.resnet50 import decode_predictions
if __name__ == '__main__':
channel = grpc.insecure_channel('localhost:8500')
stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
img_file = tf.keras.utils.get_file(
"./kitten_small.jpg",
"https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg")
img = image.load_img(img_file, target_size=(224, 224))
img_array = preprocess_input(image.img_to_array(img)[None, ...])
request = predict_pb2.PredictRequest()
request.model_spec.name = 'resnet50_inf1'
request.inputs['input'].CopyFrom(
tf.contrib.util.make_tensor_proto(img_array, shape=img_array.shape))
result = stub.Predict(request)
prediction = tf.make_ndarray(result.outputs['output'])
print(decode_predictions(prediction))
```
Exécutez l'inférence sur le modèle à l'aide de gRPC avec la commande suivante :
```
python tensorflow-model-server-infer.py
```
Le résultat doit être similaire à ce qui suit :
```
[[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]]
```
# Utilisation de MXNet -Neuron et du compilateur Neuron AWS
L'API de compilation MXNet -Neuron fournit une méthode pour compiler un modèle de graphe que vous pouvez exécuter sur un appareil AWS Inferentia.
Dans cet exemple, vous utilisez l'API pour compiler un modèle ResNet -50 et l'utiliser pour exécuter l'inférence.
Pour plus d'informations sur le SDK Neuron, consultez la documentation du SDK [AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html).
**Topics**
+ [Conditions préalables](#tutorial-inferentia-mxnet-neuron-prerequisites)
+ [Activation de l'environnement Conda](#tutorial-inferentia-mxnet-neuron-activate)
+ [Compilation Resnet50](#tutorial-inferentia-mxnet-neuron-compilation)
+ [ResNet50 Inférence](#tutorial-inferentia-mxnet-neuron-inference)
## Conditions préalables
Avant d'utiliser ce didacticiel, vous devez avoir terminé les étapes de configuration figurant dans [Lancement d'une instance DLAMI avec Neuron AWS](tutorial-inferentia-launching.md). Vous devez également être familiarisé avec le deep learning et l'utilisation du DLAMI.
## Activation de l'environnement Conda
Activez l'environnement MXNet -Neuron conda à l'aide de la commande suivante :
```
source activate aws_neuron_mxnet_p36
```
Pour quitter l'environnement Conda actuel, exécutez :
```
source deactivate
```
## Compilation Resnet50
Créez un script Python appelé **mxnet\$1compile\$1resnet50.py** avec le contenu suivant. Ce script utilise l'API Python de compilation MXNet -Neuron pour compiler un modèle ResNet -50.
```
import mxnet as mx
import numpy as np
print("downloading...")
path='http://data.mxnet.io/models/imagenet/'
mx.test_utils.download(path+'resnet/50-layers/resnet-50-0000.params')
mx.test_utils.download(path+'resnet/50-layers/resnet-50-symbol.json')
print("download finished.")
sym, args, aux = mx.model.load_checkpoint('resnet-50', 0)
print("compile for inferentia using neuron... this will take a few minutes...")
inputs = { "data" : mx.nd.ones([1,3,224,224], name='data', dtype='float32') }
sym, args, aux = mx.contrib.neuron.compile(sym, args, aux, inputs)
print("save compiled model...")
mx.model.save_checkpoint("compiled_resnet50", 0, sym, args, aux)
```
Compilez le modèle à l'aide de la commande suivante :
```
python mxnet_compile_resnet50.py
```
La compilation prendra quelques minutes. Une fois la compilation terminée, les fichiers suivants se trouveront dans votre répertoire actuel :
```
resnet-50-0000.params
resnet-50-symbol.json
compiled_resnet50-0000.params
compiled_resnet50-symbol.json
```
## ResNet50 Inférence
Créez un script Python appelé **mxnet\$1infer\$1resnet50.py** avec le contenu suivant. Ce script télécharge un exemple d'image qu’il utilise pour exécuter l'inférence avec le modèle compilé.
```
import mxnet as mx
import numpy as np
path='http://data.mxnet.io/models/imagenet/'
mx.test_utils.download(path+'synset.txt')
fname = mx.test_utils.download('https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg')
img = mx.image.imread(fname)
# convert into format (batch, RGB, width, height)
img = mx.image.imresize(img, 224, 224)
# resize
img = img.transpose((2, 0, 1))
# Channel first
img = img.expand_dims(axis=0)
# batchify
img = img.astype(dtype='float32')
sym, args, aux = mx.model.load_checkpoint('compiled_resnet50', 0)
softmax = mx.nd.random_normal(shape=(1,))
args['softmax_label'] = softmax
args['data'] = img
# Inferentia context
ctx = mx.neuron()
exe = sym.bind(ctx=ctx, args=args, aux_states=aux, grad_req='null')
with open('synset.txt', 'r') as f:
labels = [l.rstrip() for l in f]
exe.forward(data=img)
prob = exe.outputs[0].asnumpy()
# print the top-5
prob = np.squeeze(prob)
a = np.argsort(prob)[::-1]
for i in a[0:5]:
print('probability=%f, class=%s' %(prob[i], labels[i]))
```
Exécutez l'inférence avec le modèle compilé à l'aide de la commande suivante :
```
python mxnet_infer_resnet50.py
```
Le résultat doit être similaire à ce qui suit :
```
probability=0.642454, class=n02123045 tabby, tabby cat
probability=0.189407, class=n02123159 tiger cat
probability=0.100798, class=n02124075 Egyptian cat
probability=0.030649, class=n02127052 lynx, catamount
probability=0.016278, class=n02129604 tiger, Panthera tigris
```
**Étape suivante**
[Utilisation de MXNet -Neuron Model Serving](tutorial-inferentia-mxnet-neuron-serving.md)
# Utilisation de MXNet -Neuron Model Serving
Dans ce didacticiel, vous apprendrez à utiliser un MXNet modèle préentraîné pour effectuer une classification d'images en temps réel avec Multi Model Server (MMS). Le MMS est un easy-to-use outil flexible destiné à servir des modèles d'apprentissage profond entraînés à l'aide de n'importe quel framework d'apprentissage automatique ou d'apprentissage profond. Ce tutoriel inclut une étape de compilation à l'aide de AWS Neuron et une implémentation du MMS à l'aide de. MXNet
Pour plus d'informations sur le SDK Neuron, consultez la documentation du SDK [AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html).
**Topics**
+ [Conditions préalables](#tutorial-inferentia-mxnet-neuron-serving-prerequisites)
+ [Activation de l'environnement Conda](#tutorial-inferentia-mxnet-neuron-serving-activate)
+ [Téléchargement de l'exemple de code](#tutorial-inferentia-mxnet-neuron-serving-download)
+ [Compilation du modèle.](#tutorial-inferentia-mxnet-neuron-serving-compile)
+ [Exécution de l'inférence](#tutorial-inferentia-mxnet-neuron-serving-inference)
## Conditions préalables
Avant d'utiliser ce didacticiel, vous devez avoir terminé les étapes de configuration figurant dans [Lancement d'une instance DLAMI avec Neuron AWS](tutorial-inferentia-launching.md). Vous devez également être familiarisé avec le deep learning et l'utilisation du DLAMI.
## Activation de l'environnement Conda
Activez l'environnement MXNet -Neuron conda à l'aide de la commande suivante :
```
source activate aws_neuron_mxnet_p36
```
Pour quitter l'environnement Conda actuel, exécutez :
```
source deactivate
```
## Téléchargement de l'exemple de code
Pour exécuter cet exemple, téléchargez l'exemple de code à l'aide des commandes suivantes :
```
git clone https://github.com/awslabs/multi-model-server
cd multi-model-server/examples/mxnet_vision
```
## Compilation du modèle.
Créez un script Python appelé `multi-model-server-compile.py` avec le contenu suivant. Ce script compile le modèle ResNet 50 sur la cible de l'appareil Inferentia.
```
import mxnet as mx
from mxnet.contrib import neuron
import numpy as np
path='http://data.mxnet.io/models/imagenet/'
mx.test_utils.download(path+'resnet/50-layers/resnet-50-0000.params')
mx.test_utils.download(path+'resnet/50-layers/resnet-50-symbol.json')
mx.test_utils.download(path+'synset.txt')
nn_name = "resnet-50"
#Load a model
sym, args, auxs = mx.model.load_checkpoint(nn_name, 0)
#Define compilation parameters# - input shape and dtype
inputs = {'data' : mx.nd.zeros([1,3,224,224], dtype='float32') }
# compile graph to inferentia target
csym, cargs, cauxs = neuron.compile(sym, args, auxs, inputs)
# save compiled model
mx.model.save_checkpoint(nn_name + "_compiled", 0, csym, cargs, cauxs)
```
Pour compiler le modèle, utilisez la commande suivante :
```
python multi-model-server-compile.py
```
Le résultat doit être similaire à ce qui suit :
```
...
[21:18:40] src/nnvm/legacy_json_util.cc:209: Loading symbol saved by previous version v0.8.0. Attempting to upgrade...
[21:18:40] src/nnvm/legacy_json_util.cc:217: Symbol successfully upgraded!
[21:19:00] src/operator/subgraph/build_subgraph.cc:698: start to execute partition graph.
[21:19:00] src/nnvm/legacy_json_util.cc:209: Loading symbol saved by previous version v0.8.0. Attempting to upgrade...
[21:19:00] src/nnvm/legacy_json_util.cc:217: Symbol successfully upgraded!
```
Créez un fichier nommé `signature.json` avec le contenu suivant pour configurer le nom et la forme de l'entrée :
```
{
"inputs": [
{
"data_name": "data",
"data_shape": [
1,
3,
224,
224
]
}
]
}
```
Téléchargez le fichier `synset.txt` à l'aide de la commande suivante. Ce fichier est une liste de noms pour les classes de ImageNet prédiction.
```
curl -O https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/synset.txt
```
Créez une classe de service personnalisée en suivant le modèle figurant dans le dossier `model_server_template`. Copiez le modèle dans votre répertoire de travail actuel à l'aide de la commande suivante :
```
cp -r ../model_service_template/* .
```
Modifiez le module `mxnet_model_service.py` pour remplacer le contexte `mx.cpu()` par le contexte `mx.neuron()` comme suit. Vous devez également commenter la copie de données inutile `model_input` car MXNet -Neuron ne prend pas en charge le NDArray et Gluon. APIs
```
...
self.mxnet_ctx = mx.neuron() if gpu_id is None else mx.gpu(gpu_id)
...
#model_input = [item.as_in_context(self.mxnet_ctx) for item in model_input]
```
Empaquetez le modèle avec l'archiveur de modèle à l'aide des commandes suivantes :
```
cd ~/multi-model-server/examples
model-archiver --force --model-name resnet-50_compiled --model-path mxnet_vision --handler mxnet_vision_service:handle
```
## Exécution de l'inférence
Démarrez le serveur multimodèle et chargez le modèle qui utilise l' RESTful API à l'aide des commandes suivantes. Assurez-vous que **neuron-rtd** s'exécute avec les paramètres par défaut.
```
cd ~/multi-model-server/
multi-model-server --start --model-store examples > /dev/null # Pipe to log file if you want to keep a log of MMS
curl -v -X POST "http://localhost:8081/models?initial_workers=1&max_workers=4&synchronous=true&url=resnet-50_compiled.mar"
sleep 10 # allow sufficient time to load model
```
Exécutez l'inférence à l'aide d'un exemple d'image avec les commandes suivantes :
```
curl -O https://raw.githubusercontent.com/awslabs/multi-model-server/master/docs/images/kitten_small.jpg
curl -X POST http://127.0.0.1:8080/predictions/resnet-50_compiled -T kitten_small.jpg
```
Le résultat doit être similaire à ce qui suit :
```
[
{
"probability": 0.6388034820556641,
"class": "n02123045 tabby, tabby cat"
},
{
"probability": 0.16900072991847992,
"class": "n02123159 tiger cat"
},
{
"probability": 0.12221276015043259,
"class": "n02124075 Egyptian cat"
},
{
"probability": 0.028706775978207588,
"class": "n02127052 lynx, catamount"
},
{
"probability": 0.01915954425930977,
"class": "n02129604 tiger, Panthera tigris"
}
]
```
Pour effectuer un nettoyage après le test, émettez une commande de suppression via l' RESTful API et arrêtez le serveur de modèles à l'aide des commandes suivantes :
```
curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled
multi-model-server --stop
```
Vous devriez voir la sortie suivante :
```
{
"status": "Model \"resnet-50_compiled\" unregistered"
}
Model server stopped.
Found 1 models and 1 NCGs.
Unloading 10001 (MODEL_STATUS_STARTED) :: success
Destroying NCG 1 :: success
```
# Utilisation de PyTorch -Neuron et du compilateur Neuron AWS
L'API de compilation PyTorch -Neuron fournit une méthode pour compiler un modèle de graphe que vous pouvez exécuter sur un appareil AWS Inferentia.
Un modèle formé doit être compilé sur une cible Inferentia avant de pouvoir être déployé sur des instances Inf1. Le didacticiel suivant compile le modèle torchvision ResNet 50 et l'exporte en tant que module enregistré. TorchScript Ce modèle est ensuite utilisé pour exécuter l'inférence.
Pour plus de commodité, ce didacticiel utilise une instance Inf1 pour la compilation et l'inférence. En pratique, vous pouvez compiler votre modèle à l'aide d'un autre type d'instance, par exemple la famille d'instances c5. Vous devez ensuite déployer votre modèle compilé sur le serveur d'inférence Inf1. Pour plus d'informations, consultez la documentation du [ PyTorch SDK AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html).
**Topics**
+ [Conditions préalables](#tutorial-inferentia-pytorch-neuron-prerequisites)
+ [Activation de l'environnement Conda](#tutorial-inferentia-pytorch-neuron-activate)
+ [Compilation Resnet50](#tutorial-inferentia-pytorch-neuron-compilation)
+ [ResNet50 Inférence](#tutorial-inferentia-pytorch-neuron-inference)
## Conditions préalables
Avant d'utiliser ce didacticiel, vous devez avoir terminé les étapes de configuration figurant dans [Lancement d'une instance DLAMI avec Neuron AWS](tutorial-inferentia-launching.md). Vous devez également être familiarisé avec le deep learning et l'utilisation du DLAMI.
## Activation de l'environnement Conda
Activez l'environnement PyTorch -Neuron conda à l'aide de la commande suivante :
```
source activate aws_neuron_pytorch_p36
```
Pour quitter l'environnement Conda actuel, exécutez :
```
source deactivate
```
## Compilation Resnet50
Créez un script Python appelé **pytorch\$1trace\$1resnet50.py** avec le contenu suivant. Ce script utilise l'API Python de compilation PyTorch -Neuron pour compiler un modèle ResNet -50.
**Note**
Il existe une dépendance entre les versions de Torchvision et le package Torch dont vous devez tenir compte lorsque vous compilez des modèles Torchvision. Ces règles de dépendance peuvent être gérées via pip. Torchvision==0.6.1 correspond à la version torch==1.5.1, tandis que torchvision==0.8.2 correspond à la version torch==1.7.1.
```
import torch
import numpy as np
import os
import torch_neuron
from torchvision import models
image = torch.zeros([1, 3, 224, 224], dtype=torch.float32)
## Load a pretrained ResNet50 model
model = models.resnet50(pretrained=True)
## Tell the model we are using it for evaluation (not training)
model.eval()
model_neuron = torch.neuron.trace(model, example_inputs=[image])
## Export to saved model
model_neuron.save("resnet50_neuron.pt")
```
Exécutez le script de compilation.
```
python pytorch_trace_resnet50.py
```
La compilation prendra quelques minutes. Lorsque la compilation est terminée, le modèle compilé est enregistré `resnet50_neuron.pt` dans le répertoire local.
## ResNet50 Inférence
Créez un script Python appelé **pytorch\$1infer\$1resnet50.py** avec le contenu suivant. Ce script télécharge un exemple d'image qu’il utilise pour exécuter l'inférence avec le modèle compilé.
```
import os
import time
import torch
import torch_neuron
import json
import numpy as np
from urllib import request
from torchvision import models, transforms, datasets
## Create an image directory containing a small kitten
os.makedirs("./torch_neuron_test/images", exist_ok=True)
request.urlretrieve("https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg",
"./torch_neuron_test/images/kitten_small.jpg")
## Fetch labels to output the top classifications
request.urlretrieve("https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json","imagenet_class_index.json")
idx2label = []
with open("imagenet_class_index.json", "r") as read_file:
class_idx = json.load(read_file)
idx2label = [class_idx[str(k)][1] for k in range(len(class_idx))]
## Import a sample image and normalize it into a tensor
normalize = transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
eval_dataset = datasets.ImageFolder(
os.path.dirname("./torch_neuron_test/"),
transforms.Compose([
transforms.Resize([224, 224]),
transforms.ToTensor(),
normalize,
])
)
image, _ = eval_dataset[0]
image = torch.tensor(image.numpy()[np.newaxis, ...])
## Load model
model_neuron = torch.jit.load( 'resnet50_neuron.pt' )
## Predict
results = model_neuron( image )
# Get the top 5 results
top5_idx = results[0].sort()[1][-5:]
# Lookup and print the top 5 labels
top5_labels = [idx2label[idx] for idx in top5_idx]
print("Top 5 labels:\n {}".format(top5_labels) )
```
Exécutez l'inférence avec le modèle compilé à l'aide de la commande suivante :
```
python pytorch_infer_resnet50.py
```
Le résultat doit être similaire à ce qui suit :
```
Top 5 labels:
['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby']
```