Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Il chip AWS Inferentia con DLAMI
AWS Inferentia è un chip di machine learning personalizzato progettato da AWS cui è possibile utilizzare per previsioni di inferenza ad alte prestazioni. Per utilizzare il chip, configura un'istanza Amazon Elastic Compute Cloud e utilizza il kit di sviluppo software (SDK) AWS Neuron per richiamare il chip Inferentia. Per offrire ai clienti la migliore esperienza con Inferentia, Neuron è stato integrato in ( AWS Deep Learning AMIs DLAMI).
I seguenti argomenti mostrano come iniziare a usare Inferentia con DLAMI.
**Topics**
+ [
# Avvio di un'istanza DLAMI con Neuron AWS
](tutorial-inferentia-launching.md)
+ [
# Usare il DLAMI con Neuron AWS
](tutorial-inferentia-using.md)
# Avvio di un'istanza DLAMI con Neuron AWS
L'ultimo DLAMI è pronto per l'uso con AWS Inferentia e viene fornito con il AWS pacchetto API Neuron. Per avviare un'istanza DLAMI, vedere [Avvio e configurazione](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html) di un DLAMI. Dopo aver installato un DLAMI, segui questi passaggi per assicurarti che il tuo chip AWS Inferentia e le risorse AWS Neuron siano attivi.
**Topics**
+ [
## Verifica la tua istanza
](#tutorial-inferentia-launching-verify)
+ [
## Identificazione dei dispositivi AWS Inferentia
](#tutorial-inferentia-launching-identify)
+ [
## Visualizza l'utilizzo delle risorse
](#tutorial-inferentia-launching-resource-usage)
+ [
## Utilizzo di Neuron Monitor (neuron-monitor)
](#tutorial-inferentia-launching-neuron-monitor)
+ [
## Aggiornamento del software Neuron
](#tutorial-inferentia-launching-upgrade)
## Verifica la tua istanza
Prima di usare l'istanza, verifica che sia correttamente configurata e configurata con Neuron.
## Identificazione dei dispositivi AWS Inferentia
Per identificare il numero di dispositivi Inferentia sulla tua istanza, usa il seguente comando:
```
neuron-ls
```
Se all'istanza sono collegati dispositivi Inferentia, l'output sarà simile al seguente:
```
+--------+--------+--------+-----------+--------------+
| NEURON | NEURON | NEURON | CONNECTED | PCI |
| DEVICE | CORES | MEMORY | DEVICES | BDF |
+--------+--------+--------+-----------+--------------+
| 0 | 4 | 8 GB | 1 | 0000:00:1c.0 |
| 1 | 4 | 8 GB | 2, 0 | 0000:00:1d.0 |
| 2 | 4 | 8 GB | 3, 1 | 0000:00:1e.0 |
| 3 | 4 | 8 GB | 2 | 0000:00:1f.0 |
+--------+--------+--------+-----------+--------------+
```
L'output fornito è tratto da un'istanza INF1.6xLarge e include le seguenti colonne:
+ NEURON DEVICE: L'ID logico assegnato a. NeuronDevice Questo ID viene utilizzato quando si configurano più runtime per utilizzarne diversi. NeuronDevices
+ NEURON CORES: Il numero di NeuronCores core presenti in. NeuronDevice
+ NEURON MEMORY: La quantità di memoria DRAM contenuta in. NeuronDevice
+ DISPOSITIVI COLLEGATI: Altri NeuronDevices collegati a. NeuronDevice
+ PCI BDF: L'ID PCI Bus Device Function (BDF) di. NeuronDevice
## Visualizza l'utilizzo delle risorse
Visualizza informazioni utili sull' NeuronCore utilizzo della vCPU, sull'utilizzo della memoria, sui modelli caricati e sulle applicazioni Neuron con il comando. `neuron-top` L'avvio `neuron-top` senza argomenti mostrerà i dati per tutte le applicazioni di machine learning che utilizzano. NeuronCores
```
neuron-top
```
Quando un'applicazione ne utilizza quattro NeuronCores, l'output dovrebbe essere simile all'immagine seguente:
![\[L'output del neuron-top comando, con le informazioni relative a una delle quattro NeuronCores evidenziate.\]](http://docs.aws.amazon.com/it_it/dlami/latest/devguide/images/neuron-top-output.png)
[Per ulteriori informazioni sulle risorse per monitorare e ottimizzare le applicazioni di inferenza basate su Neuron, consulta Neuron Tools.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/index.html)
## Utilizzo di Neuron Monitor (neuron-monitor)
Neuron Monitor raccoglie le metriche dai runtime Neuron in esecuzione sul sistema e trasmette i dati raccolti a stdout in formato JSON. Queste metriche sono organizzate in gruppi di metriche che puoi configurare fornendo un file di configurazione. Per ulteriori informazioni su Neuron Monitor, consulta la [Guida per l'utente](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/neuron-monitor-user-guide.html) di Neuron Monitor.
## Aggiornamento del software Neuron
[Per informazioni su come aggiornare il software Neuron SDK all'interno di DLAMI, consultate la Neuron Setup Guide. AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-intro/neuron-install-guide.html)
**Fase succcessiva**
[Usare il DLAMI con Neuron AWS](tutorial-inferentia-using.md)
# Usare il DLAMI con Neuron AWS
Un tipico flusso di lavoro con AWS Neuron SDK consiste nel compilare un modello di machine learning precedentemente addestrato su un server di compilazione. Successivamente, distribuisci gli artefatti alle istanze Inf1 per l'esecuzione. AWS Deep Learning AMIs (DLAMI) è preinstallato con tutto il necessario per compilare ed eseguire l'inferenza in un'istanza Inf1 che utilizza Inferentia.
Le seguenti sezioni descrivono come usare DLAMI con Inferentia.
**Topics**
+ [
# Utilizzo di TensorFlow -Neuron e del Neuron Compiler AWS
](tutorial-inferentia-tf-neuron.md)
+ [
# Utilizzo di AWS Neuron Serving TensorFlow
](tutorial-inferentia-tf-neuron-serving.md)
+ [
# Utilizzo di MXNet -Neuron e del Neuron Compiler AWS
](tutorial-inferentia-mxnet-neuron.md)
+ [
# Utilizzo di MXNet -Neuron Model Serving
](tutorial-inferentia-mxnet-neuron-serving.md)
+ [
# Utilizzo di PyTorch -Neuron e del Neuron Compiler AWS
](tutorial-inferentia-pytorch-neuron.md)
# Utilizzo di TensorFlow -Neuron e del Neuron Compiler AWS
Questo tutorial mostra come utilizzare il compilatore AWS Neuron per compilare il modello Keras ResNet -50 ed esportarlo come modello salvato in formato. SavedModel Questo formato è un tipico formato intercambiabile del modello. TensorFlow Il tutorial illustra anche come eseguire l'inferenza su un'istanza di Inf1 con input di esempio.
[Per ulteriori informazioni su Neuron SDK, consulta la documentazione di Neuron SDK.AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html)
**Topics**
+ [
## Prerequisiti
](#tutorial-inferentia-tf-neuron-prerequisites)
+ [
## Attivare l'ambiente Conda
](#tutorial-inferentia-tf-neuron-activate)
+ [
## Compilazione Resnet50
](#tutorial-inferentia-tf-neuron-compilation)
+ [
## ResNet50 Inferenza
](#tutorial-inferentia-tf-neuron-inference)
## Prerequisiti
Prima di utilizzare questo tutorial, è necessario aver completato la procedura di configurazione in [Avvio di un'istanza DLAMI con Neuron AWS](tutorial-inferentia-launching.md). È inoltre necessario avere dimestichezza con il deep learning e l'uso del DLAMI.
## Attivare l'ambiente Conda
Attiva l'ambiente TensorFlow -Neuron conda usando il seguente comando:
```
source activate aws_neuron_tensorflow_p36
```
Per uscire dall'ambiente Conda corrente, eseguire il comando seguente:
```
source deactivate
```
## Compilazione Resnet50
Creare uno script Python chiamato **tensorflow\$1compile\$1resnet50.py** che abbia il seguente contenuto. Questo script Python compila il modello Keras ResNet 50 e lo esporta come modello salvato.
```
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')
```
Compilare il modello utilizzando il seguente comando:
```
python tensorflow_compile_resnet50.py
```
Il processo di compilazione richiederà alcuni minuti. Al termine, l'output dovrebbe essere simile al seguente:
```
...
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
...
```
Dopo la compilazione, il modello salvato viene compresso a **ws\$1resnet50/resnet50\$1neuron.zip**. Decomprimere il modello e scaricare l'immagine di esempio per l'inferenza utilizzando i seguenti comandi:
```
unzip ws_resnet50/resnet50_neuron.zip -d .
curl -O https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg
```
## ResNet50 Inferenza
Creare uno script Python chiamato **tensorflow\$1infer\$1resnet50.py** che abbia il seguente contenuto. Questo script esegue l'inferenza sul modello scaricato utilizzando un modello di inferenza precedentemente compilato.
```
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])
```
Eseguire l'inferenza sul modello utilizzando il seguente comando:
```
python tensorflow_infer_resnet50.py
```
L'aspetto dell'output deve essere simile al seguente:
```
...
[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]
```
**Fase succcessiva**
[Utilizzo di AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
# Utilizzo di AWS Neuron Serving TensorFlow
Questo tutorial mostra come costruire un grafico e aggiungere una fase di compilazione di AWS Neuron prima di esportare il modello salvato da utilizzare con Serving. TensorFlow TensorFlow Serving è un sistema di servizio che consente di aumentare l'inferenza su una rete. Neuron TensorFlow Serving utilizza la stessa API del normale Serving. TensorFlow L'unica differenza è che un modello salvato deve essere compilato per AWS Inferentia e il punto di ingresso è un nome binario diverso. `tensorflow_model_server_neuron` Il file binario si trova in `/usr/local/bin/tensorflow_model_server_neuron` ed è preinstallato nel DLAMI.
[Per ulteriori informazioni su Neuron SDK, consulta la documentazione di Neuron SDK.AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html)
**Topics**
+ [
## Prerequisiti
](#tutorial-inferentia-tf-neuron--serving-prerequisites)
+ [
## Attivare l'ambiente Conda
](#tutorial-inferentia-tf-neuron-serving-activate)
+ [
## Compilare ed esportare il modello salvato
](#tutorial-inferentia-tf-neuron-serving-compile)
+ [
## Servire il modello salvato
](#tutorial-inferentia-tf-neuron-serving-serving)
+ [
## Generare richieste di inferenza al server del modello
](#tutorial-inferentia-tf-neuron-serving-inference)
## Prerequisiti
Prima di utilizzare questo tutorial, è necessario aver completato la procedura di configurazione in [Avvio di un'istanza DLAMI con Neuron AWS](tutorial-inferentia-launching.md). È inoltre necessario avere dimestichezza con il deep learning e l'uso del DLAMI.
## Attivare l'ambiente Conda
Attiva l'ambiente TensorFlow -Neuron conda usando il seguente comando:
```
source activate aws_neuron_tensorflow_p36
```
Se è necessario uscire dall'ambiente Conda corrente, eseguire:
```
source deactivate
```
## Compilare ed esportare il modello salvato
Crea uno script Python chiamato `tensorflow-model-server-compile.py` con il seguente contenuto. Questo script costruisce un grafico e lo compila usando Neuron. Esporta quindi il grafico compilato come modello salvato.
```
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)
```
Compilare il modello utilizzando il seguente comando:
```
python tensorflow-model-server-compile.py
```
L'aspetto dell'output deve essere simile al seguente:
```
...
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
```
## Servire il modello salvato
Una volta compilato il modello, è possibile utilizzare il seguente comando per servire il modello salvato con il binario tensorflow\$1model\$1server\$1neuron:
```
tensorflow_model_server_neuron --model_name=resnet50_inf1 \
--model_base_path=$HOME/resnet50_inf1/ --port=8500 &
```
L'aspetto dell'output sarà simile al seguente. Il modello compilato viene inserito nella DRAM del dispositivo Inferentia dal server per prepararsi all'inferenza.
```
...
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 ...
```
## Generare richieste di inferenza al server del modello
Creare uno script Python chiamato `tensorflow-model-server-infer.py` con il seguente contenuto. Questo script esegue inferenza tramite gRPC, che è framework di servizio.
```
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))
```
Eseguire l'inferenza sul modello utilizzando gRPC con il seguente comando:
```
python tensorflow-model-server-infer.py
```
L'aspetto dell'output deve essere simile al seguente:
```
[[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]]
```
# Utilizzo di MXNet -Neuron e del Neuron Compiler AWS
L'API di compilazione MXNet -Neuron fornisce un metodo per compilare un grafico modello che è possibile eseguire su un dispositivo Inferentia. AWS
In questo esempio, si utilizza l'API per compilare un modello ResNet -50 e utilizzarlo per eseguire l'inferenza.
[Per ulteriori informazioni su Neuron SDK, consulta la documentazione di Neuron SDK.AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html)
**Topics**
+ [
## Prerequisiti
](#tutorial-inferentia-mxnet-neuron-prerequisites)
+ [
## Attivare l'ambiente Conda
](#tutorial-inferentia-mxnet-neuron-activate)
+ [
## Compilazione Resnet50
](#tutorial-inferentia-mxnet-neuron-compilation)
+ [
## ResNet50 Inferenza
](#tutorial-inferentia-mxnet-neuron-inference)
## Prerequisiti
Prima di utilizzare questo tutorial, è necessario aver completato la procedura di configurazione in [Avvio di un'istanza DLAMI con Neuron AWS](tutorial-inferentia-launching.md). È inoltre necessario avere dimestichezza con il deep learning e l'uso del DLAMI.
## Attivare l'ambiente Conda
Attiva l'ambiente MXNet -Neuron conda usando il seguente comando:
```
source activate aws_neuron_mxnet_p36
```
Per uscire dall'ambiente conda corrente, eseguire:
```
source deactivate
```
## Compilazione Resnet50
Creare uno script Python chiamato **mxnet\$1compile\$1resnet50.py** con il seguente contenuto. Questo script utilizza l'API Python di compilazione MXNet -Neuron per compilare un modello -50. ResNet
```
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)
```
Compilare il modello utilizzando il seguente comando:
```
python mxnet_compile_resnet50.py
```
La compilazione richiederà alcuni minuti. Al termine della compilazione, i seguenti file si troveranno nella directory corrente:
```
resnet-50-0000.params
resnet-50-symbol.json
compiled_resnet50-0000.params
compiled_resnet50-symbol.json
```
## ResNet50 Inferenza
Creare uno script Python chiamato **mxnet\$1infer\$1resnet50.py** con il seguente contenuto. Questo script scarica un'immagine di esempio e la usa per eseguire l'inferenza con il modello compilato.
```
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]))
```
Eseguire l'inferenza con il modello compilato utilizzando il seguente comando:
```
python mxnet_infer_resnet50.py
```
L'aspetto dell'output deve essere simile al seguente:
```
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
```
**Fase succcessiva**
[Utilizzo di MXNet -Neuron Model Serving](tutorial-inferentia-mxnet-neuron-serving.md)
# Utilizzo di MXNet -Neuron Model Serving
In questo tutorial imparerai a utilizzare un MXNet modello pre-addestrato per eseguire la classificazione delle immagini in tempo reale con Multi Model Server (MMS). MMS è uno easy-to-use strumento flessibile per fornire modelli di deep learning addestrati utilizzando qualsiasi framework di machine learning o deep learning. Questo tutorial include una fase di compilazione utilizzando AWS Neuron e un'implementazione dell'utilizzo di MMS. MXNet
[Per ulteriori informazioni su Neuron SDK, consulta la documentazione di Neuron SDK.AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html)
**Topics**
+ [
## Prerequisiti
](#tutorial-inferentia-mxnet-neuron-serving-prerequisites)
+ [
## Attivare l'ambiente Conda
](#tutorial-inferentia-mxnet-neuron-serving-activate)
+ [
## Scarica il codice di esempio
](#tutorial-inferentia-mxnet-neuron-serving-download)
+ [
## Compila il modello
](#tutorial-inferentia-mxnet-neuron-serving-compile)
+ [
## Eseguire l’inferenza
](#tutorial-inferentia-mxnet-neuron-serving-inference)
## Prerequisiti
Prima di utilizzare questo tutorial, è necessario aver completato la procedura di configurazione in [Avvio di un'istanza DLAMI con Neuron AWS](tutorial-inferentia-launching.md). È inoltre necessario avere dimestichezza con il deep learning e l'uso del DLAMI.
## Attivare l'ambiente Conda
Attiva l'ambiente MXNet -Neuron conda usando il seguente comando:
```
source activate aws_neuron_mxnet_p36
```
Per uscire dall'ambiente conda corrente, eseguire:
```
source deactivate
```
## Scarica il codice di esempio
Per eseguire questo esempio, scaricare il codice di esempio utilizzando i seguenti comandi:
```
git clone https://github.com/awslabs/multi-model-server
cd multi-model-server/examples/mxnet_vision
```
## Compila il modello
Creare uno script Python chiamato `multi-model-server-compile.py` con il seguente contenuto. Questo script compila il modello ResNet 50 nella destinazione del dispositivo 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)
```
Per compilare il modello, utilizzare il seguente comando:
```
python multi-model-server-compile.py
```
L'aspetto dell'output deve essere simile al seguente:
```
...
[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!
```
Creare un file denominato `signature.json` con il seguente contenuto per configurare il nome e la forma di input:
```
{
"inputs": [
{
"data_name": "data",
"data_shape": [
1,
3,
224,
224
]
}
]
}
```
Scaricare il file `synset.txt` utilizzando il comando seguente: Questo file è un elenco di nomi per ImageNet le classi di previsione.
```
curl -O https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/synset.txt
```
Creare una classe di servizio personalizzata seguendo il modello nella cartella `model_server_template`. Copiare il modello nella directory di lavoro corrente utilizzando il seguente comando:
```
cp -r ../model_service_template/* .
```
Modificare il modulo `mxnet_model_service.py` per sostituire il contesto `mx.cpu()` con il contesto `mx.neuron()` come segue. È inoltre necessario commentare la copia dei dati non necessaria `model_input` perché MXNet -Neuron non supporta and Gluon. NDArray 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]
```
Comprimere il modello con model-archiver utilizzando i seguenti comandi:
```
cd ~/multi-model-server/examples
model-archiver --force --model-name resnet-50_compiled --model-path mxnet_vision --handler mxnet_vision_service:handle
```
## Eseguire l’inferenza
Avvia il Multi Model Server e carica il modello che utilizza l' RESTful API utilizzando i seguenti comandi. Assicurarsi che **neuron-rtd** sia in esecuzione con le impostazioni predefinite.
```
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
```
Eseguire l'inferenza utilizzando un'immagine di esempio con i seguenti comandi:
```
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
```
L'aspetto dell'output deve essere simile al seguente:
```
[
{
"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"
}
]
```
Per eseguire la pulizia dopo il test, emettete un comando di eliminazione tramite l' RESTful API e arrestate il server del modello utilizzando i seguenti comandi:
```
curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled
multi-model-server --stop
```
Verrà visualizzato l’output seguente:
```
{
"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
```
# Utilizzo di PyTorch -Neuron e del Neuron Compiler AWS
L'API di compilazione PyTorch -Neuron fornisce un metodo per compilare un grafico modello che è possibile eseguire su un dispositivo Inferentia. AWS
Un modello addestrato deve essere compilato in un target Inferentia prima di poter essere distribuito nelle istanze di Inf1. Il seguente tutorial compila il modello torchvision ResNet 50 e lo esporta come modulo salvato. TorchScript Questo modello viene quindi utilizzato per eseguire l'inferenza.
Per comodità, questa esercitazione utilizza un'istanza di Inf1 sia per la compilazione sia per l'inferenza. In pratica, è possibile compilare il modello utilizzando un altro tipo di istanza, ad esempio la famiglia di istanze c5. È quindi necessario distribuire il modello compilato al server di inferenza Inf1. Per ulteriori informazioni, consulta la documentazione di [AWS Neuron SDK PyTorch ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html).
**Topics**
+ [
## Prerequisiti
](#tutorial-inferentia-pytorch-neuron-prerequisites)
+ [
## Attivare l'ambiente Conda
](#tutorial-inferentia-pytorch-neuron-activate)
+ [
## Compilazione Resnet50
](#tutorial-inferentia-pytorch-neuron-compilation)
+ [
## ResNet50 Inferenza
](#tutorial-inferentia-pytorch-neuron-inference)
## Prerequisiti
Prima di utilizzare questo tutorial, è necessario aver completato la procedura di configurazione in [Avvio di un'istanza DLAMI con Neuron AWS](tutorial-inferentia-launching.md). È inoltre necessario avere dimestichezza con il deep learning e l'uso del DLAMI.
## Attivare l'ambiente Conda
Attiva l'ambiente PyTorch -Neuron conda usando il seguente comando:
```
source activate aws_neuron_pytorch_p36
```
Per uscire dall'ambiente conda corrente, eseguire:
```
source deactivate
```
## Compilazione Resnet50
Creare uno script Python chiamato **pytorch\$1trace\$1resnet50.py** con il seguente contenuto. Questo script utilizza l'API Python di compilazione PyTorch -Neuron per compilare un modello -50. ResNet
**Nota**
Esiste una dipendenza tra le versioni di torchvision e il pacchetto torch di cui dovresti essere a conoscenza durante la compilazione dei modelli torchvision. Queste regole di dipendenza possono essere gestite tramite pip. Torchvision==0.6.1 corrisponde alla versione torch==1.5.1, mentre torchvision==0.8.2 corrisponde alla versione 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")
```
Eseguire lo script di compilazione.
```
python pytorch_trace_resnet50.py
```
La compilazione richiederà alcuni minuti. Al termine della compilazione, il modello compilato viene salvato come `resnet50_neuron.pt` nella directory locale.
## ResNet50 Inferenza
Creare uno script Python chiamato **pytorch\$1infer\$1resnet50.py** con il seguente contenuto. Questo script scarica un'immagine di esempio e la usa per eseguire l'inferenza con il modello compilato.
```
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) )
```
Eseguire l'inferenza con il modello compilato utilizzando il seguente comando:
```
python pytorch_infer_resnet50.py
```
L'aspetto dell'output deve essere simile al seguente:
```
Top 5 labels:
['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby']
```