

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 de AWS Neuron Serving TensorFlow
<a name="tutorial-inferentia-tf-neuron-serving"></a>

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
<a name="tutorial-inferentia-tf-neuron--serving-prerequisites"></a>

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
<a name="tutorial-inferentia-tf-neuron-serving-activate"></a>

 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é
<a name="tutorial-inferentia-tf-neuron-serving-compile"></a>

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é
<a name="tutorial-inferentia-tf-neuron-serving-serving"></a>

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
<a name="tutorial-inferentia-tf-neuron-serving-inference"></a>

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)]]
```