As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# O chip de AWS inferência com DLAMI
AWS O Inferentia é um chip de aprendizado de máquina personalizado projetado por AWS ele que você pode usar para previsões de inferência de alto desempenho. Para usar o chip, configure uma instância Amazon Elastic Compute Cloud e use o kit de desenvolvimento de software (SDK) AWS Neuron para invocar o chip Inferentia. Para fornecer aos clientes a melhor experiência no Inferentia, o Neuron foi integrado à AMIs de deep learning da AWS (DLAMI).
Os tópicos a seguir mostram como começar a usar o Inferentia com a DLAMI.
**Topics**
+ [Lançamento de uma instância DLAMI com Neuron AWS](tutorial-inferentia-launching.md)
+ [Usando o DLAMI com Neuron AWS](tutorial-inferentia-using.md)
# Lançamento de uma instância DLAMI com Neuron AWS
O DLAMI mais recente está pronto para uso AWS com o Inferentia e vem com AWS o pacote Neuron API. Para iniciar uma instância da DLAMI, consulte [Iniciar e configurar uma DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html). Depois de ter um DLAMI, use as etapas aqui para garantir que AWS seu chip de inferência AWS e os recursos do Neuron estejam ativos.
**Topics**
+ [Verifique a instância](#tutorial-inferentia-launching-verify)
+ [Identificação de AWS dispositivos de inferência](#tutorial-inferentia-launching-identify)
+ [Exibir o uso de recursos](#tutorial-inferentia-launching-resource-usage)
+ [Como usar o Monitor do Neuron](#tutorial-inferentia-launching-neuron-monitor)
+ [Atualização do software Neuron](#tutorial-inferentia-launching-upgrade)
## Verifique a instância
Antes de usar a instância, verifique se ela está corretamente definida e configurada com o Neuron.
## Identificação de AWS dispositivos de inferência
Para identificar o número de dispositivos do Inferentia na sua instância, use o seguinte comando:
```
neuron-ls
```
Se a instância tiver dispositivos do Inferentia conectados a ela, a saída será semelhante à seguinte:
```
+--------+--------+--------+-----------+--------------+
| 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 |
+--------+--------+--------+-----------+--------------+
```
O resultado fornecido é obtido de uma instância Inf1.6xlarge e inclui as seguintes colunas:
+ DISPOSITIVO NEURONAL: O ID lógico atribuído ao NeuronDevice. Esse ID é usado ao configurar vários tempos de execução para usar diferentes. NeuronDevices
+ NÚCLEOS DE NEURÔNIOS: O número de NeuronCores presentes no NeuronDevice.
+ MEMÓRIA NEURONAL: A quantidade de memória DRAM no. NeuronDevice
+ DISPOSITIVOS CONECTADOS: Outros NeuronDevices conectados ao NeuronDevice.
+ PCI BDF: O ID da função de dispositivo de barramento PCI (BDF) do. NeuronDevice
## Exibir o uso de recursos
Visualize informações úteis sobre a NeuronCore utilização da vCPU, o uso da memória, os modelos carregados e os aplicativos Neuron com o comando. `neuron-top` O lançamento `neuron-top` sem argumentos mostrará os dados de todos os aplicativos de aprendizado de máquina que utilizam NeuronCores.
```
neuron-top
```
Quando um aplicativo está usando quatro NeuronCores, a saída deve ser semelhante à imagem a seguir:
![\[A saída do neuron-top comando, com as informações de um dos quatro NeuronCores destacadas.\]](http://docs.aws.amazon.com/pt_br/dlami/latest/devguide/images/neuron-top-output.png)
Para obter mais informações sobre recursos para monitorar e otimizar aplicações de inferência que usam como base o Neuron, consulte [Ferramentas do Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/index.html).
## Como usar o Monitor do Neuron
O Monitor do Neuron coleta métricas dos runtimes do Neuron em execução no sistema e transmite os dados coletados para stdout no formato JSON. Elas são organizadas em grupos de métricas que você configura fornecendo um arquivo de configuração. Para obter mais informações sobre o Monitor do Neuron, consulte o [Guia do usuário do monitor do Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/neuron-monitor-user-guide.html).
## Atualização do software Neuron
[Para obter informações sobre como atualizar o software Neuron SDK no DLAMI, consulte o Guia de configuração do Neuron. AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-intro/neuron-install-guide.html)
**Próxima etapa**
[Usando o DLAMI com Neuron AWS](tutorial-inferentia-using.md)
# Usando o DLAMI com Neuron AWS
Um fluxo de trabalho típico com o AWS Neuron SDK é compilar um modelo de aprendizado de máquina previamente treinado em um servidor de compilação. Depois disso, distribua os artefatos para as instâncias Inf1 para execução. AMIs de deep learning da AWS (DLAMI) vem pré-instalado com tudo o que você precisa para compilar e executar inferência em uma instância Inf1 que usa Inferentia.
As seções a seguir descrevem como usar a DLAMI com o Inferentia.
**Topics**
+ [Usando TensorFlow -Neuron e o compilador Neuron AWS](tutorial-inferentia-tf-neuron.md)
+ [Usando AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
+ [Usando MXNet -Neuron e o compilador Neuron AWS](tutorial-inferentia-mxnet-neuron.md)
+ [Usando o MXNet -Neuron Model Serving](tutorial-inferentia-mxnet-neuron-serving.md)
+ [Usando PyTorch -Neuron e o compilador Neuron AWS](tutorial-inferentia-pytorch-neuron.md)
# Usando TensorFlow -Neuron e o compilador Neuron AWS
Este tutorial mostra como usar o compilador AWS Neuron para compilar o modelo Keras ResNet -50 e exportá-lo como um modelo salvo em formato. SavedModel Esse formato é um formato típico de TensorFlow modelo intercambiável. Você também aprenderá a executar a inferência em uma instância do Inf1 com exemplo de entrada.
Para obter mais informações sobre o SDK do Neuron, consulte a [Documentação do SDK do AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html).
**Topics**
+ [Pré-requisitos](#tutorial-inferentia-tf-neuron-prerequisites)
+ [Ative o ambiente Conda](#tutorial-inferentia-tf-neuron-activate)
+ [Compilação ResNet50](#tutorial-inferentia-tf-neuron-compilation)
+ [ResNet50 Inferência](#tutorial-inferentia-tf-neuron-inference)
## Pré-requisitos
Antes de usar este tutorial, você precisa ter concluído os passos da configuração em [Lançamento de uma instância DLAMI com Neuron AWS](tutorial-inferentia-launching.md). Também é necessário conhecer a aprendizagem profunda e o uso da DLAMI.
## Ative o ambiente Conda
Ative o ambiente TensorFlow -Neuron conda usando o seguinte comando:
```
source activate aws_neuron_tensorflow_p36
```
Para sair do ambiente Conda atual, execute o seguinte comando:
```
source deactivate
```
## Compilação ResNet50
Crie um script Python chamado **tensorflow\$1compile\$1resnet50.py** com o seguinte conteúdo. Esse script Python compila o modelo Keras ResNet 50 e o exporta como um modelo salvo.
```
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')
```
Compile o modelo usando o seguinte comando:
```
python tensorflow_compile_resnet50.py
```
O processo de compilação leva alguns minutos. Quando concluído, sua saída será semelhante a:
```
...
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
...
```
Após a compilação, o modelo salvo será compactado em **ws\$1resnet50/resnet50\$1neuron.zip**. Descompacte o modelo e faça download da imagem de exemplo para a inferência, usando os seguintes comandos:
```
unzip ws_resnet50/resnet50_neuron.zip -d .
curl -O https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg
```
## ResNet50 Inferência
Crie um script Python chamado **tensorflow\$1infer\$1resnet50.py** com o seguinte conteúdo. Esse script executa a inferência no modelo obtido por download usando um modelo de inferência previamente compilado.
```
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])
```
Execute a inferência no modelo usando o seguinte comando:
```
python tensorflow_infer_resnet50.py
```
A saída será semelhante a:
```
...
[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]
```
**Próxima etapa**
[Usando AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
# Usando AWS Neuron Serving TensorFlow
Este tutorial mostra como construir um gráfico e adicionar uma etapa de compilação do AWS Neuron antes de exportar o modelo salvo para uso com o Serving. TensorFlow TensorFlow Serving é um sistema de atendimento que permite ampliar a inferência em uma rede. O Neuron TensorFlow Serving usa a mesma API do TensorFlow Serving normal. A única diferença é que um modelo salvo deve ser compilado para AWS Inferentia e o ponto de entrada é um binário diferente chamado`tensorflow_model_server_neuron`. O binário é encontrado em `/usr/local/bin/tensorflow_model_server_neuron` e é pré-instalado na DLAMI.
Para obter mais informações sobre o SDK do Neuron, consulte a [Documentação do SDK do AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html).
**Topics**
+ [Pré-requisitos](#tutorial-inferentia-tf-neuron--serving-prerequisites)
+ [Ative o ambiente Conda](#tutorial-inferentia-tf-neuron-serving-activate)
+ [Compile e exporte o modelo salvo](#tutorial-inferentia-tf-neuron-serving-compile)
+ [Fornecer o modelo salvo](#tutorial-inferentia-tf-neuron-serving-serving)
+ [Gerar solicitações de inferência para o modelo de servidor](#tutorial-inferentia-tf-neuron-serving-inference)
## Pré-requisitos
Antes de usar este tutorial, você precisa ter concluído os passos da configuração em [Lançamento de uma instância DLAMI com Neuron AWS](tutorial-inferentia-launching.md). Também é necessário conhecer a aprendizagem profunda e o uso da DLAMI.
## Ative o ambiente Conda
Ative o ambiente TensorFlow -Neuron conda usando o seguinte comando:
```
source activate aws_neuron_tensorflow_p36
```
Se você precisar sair do ambiente Conda atual, execute:
```
source deactivate
```
## Compile e exporte o modelo salvo
Crie um script Python chamado `tensorflow-model-server-compile.py` com o conteúdo a seguir. Ele constrói um gráfico e o compila usando o Neuron. Depois, exporta o gráfico compilado como modelo salvo.
```
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)
```
Compile o modelo usando o seguinte comando:
```
python tensorflow-model-server-compile.py
```
A saída será semelhante a:
```
...
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
```
## Fornecer o modelo salvo
Depois que o modelo foi compilado, você pode usar o seguinte comando para fornecer o modelo salvo com o binário tensorflow\$1model\$1server\$1neuron:
```
tensorflow_model_server_neuron --model_name=resnet50_inf1 \
--model_base_path=$HOME/resnet50_inf1/ --port=8500 &
```
A saída será semelhante à seguinte: O modelo compilado é preparado na DRAM do dispositivo do Inferentia, pelo servidor, para preparar para a inferência.
```
...
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 ...
```
## Gerar solicitações de inferência para o modelo de servidor
Crie um script Python chamado `tensorflow-model-server-infer.py` com o conteúdo a seguir. Esse script executa a inferência via gRPC, que é um framework de serviço.
```
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))
```
Execute a inferência no modelo usando gRPC com o seguinte comando:
```
python tensorflow-model-server-infer.py
```
A saída será semelhante a:
```
[[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]]
```
# Usando MXNet -Neuron e o compilador Neuron AWS
A API de compilação MXNet -Neuron fornece um método para compilar um gráfico de modelo que você pode executar em um dispositivo Inferentia. AWS
Neste exemplo, você usa a API para compilar um modelo ResNet -50 e usá-lo para executar inferência.
Para obter mais informações sobre o SDK do Neuron, consulte a [Documentação do SDK do AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html).
**Topics**
+ [Pré-requisitos](#tutorial-inferentia-mxnet-neuron-prerequisites)
+ [Ative o ambiente Conda](#tutorial-inferentia-mxnet-neuron-activate)
+ [Compilação ResNet50](#tutorial-inferentia-mxnet-neuron-compilation)
+ [ResNet50 Inferência](#tutorial-inferentia-mxnet-neuron-inference)
## Pré-requisitos
Antes de usar este tutorial, você precisa ter concluído os passos da configuração em [Lançamento de uma instância DLAMI com Neuron AWS](tutorial-inferentia-launching.md). Também é necessário conhecer a aprendizagem profunda e o uso da DLAMI.
## Ative o ambiente Conda
Ative o ambiente MXNet -Neuron conda usando o seguinte comando:
```
source activate aws_neuron_mxnet_p36
```
Para sair do ambiente Conda atual, execute:
```
source deactivate
```
## Compilação ResNet50
Crie um script Python chamado **mxnet\$1compile\$1resnet50.py** com o conteúdo a seguir. Esse script usa a API Python de compilação MXNet -Neuron para compilar um modelo -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)
```
Compile o modelo usando o seguinte comando:
```
python mxnet_compile_resnet50.py
```
A compilação demora alguns minutos. Quando ela terminar, os seguintes arquivos estarão no diretório atual:
```
resnet-50-0000.params
resnet-50-symbol.json
compiled_resnet50-0000.params
compiled_resnet50-symbol.json
```
## ResNet50 Inferência
Crie um script Python chamado **mxnet\$1infer\$1resnet50.py** com o conteúdo a seguir. Esse script faz download de uma imagem de amostra e a usa para executar a inferência com o modelo compilado.
```
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]))
```
Execute a inferência com o modelo compilado usando o seguinte comando:
```
python mxnet_infer_resnet50.py
```
A saída será semelhante a:
```
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
```
**Próxima etapa**
[Usando o MXNet -Neuron Model Serving](tutorial-inferentia-mxnet-neuron-serving.md)
# Usando o MXNet -Neuron Model Serving
Neste tutorial, você aprende a usar um MXNet modelo pré-treinado para realizar a classificação de imagens em tempo real com o Multi Model Server (MMS). O MMS é uma easy-to-use ferramenta flexível para servir modelos de aprendizado profundo que são treinados usando qualquer estrutura de aprendizado de máquina ou aprendizado profundo. Este tutorial inclui uma etapa de compilação usando o AWS Neuron e uma implementação do MMS usando. MXNet
Para obter mais informações sobre o SDK do Neuron, consulte a [Documentação do SDK do AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html).
**Topics**
+ [Pré-requisitos](#tutorial-inferentia-mxnet-neuron-serving-prerequisites)
+ [Ative o ambiente Conda](#tutorial-inferentia-mxnet-neuron-serving-activate)
+ [Faça download do código de exemplo](#tutorial-inferentia-mxnet-neuron-serving-download)
+ [Compile o modelo.](#tutorial-inferentia-mxnet-neuron-serving-compile)
+ [Execute a inferência](#tutorial-inferentia-mxnet-neuron-serving-inference)
## Pré-requisitos
Antes de usar este tutorial, você precisa ter concluído os passos da configuração em [Lançamento de uma instância DLAMI com Neuron AWS](tutorial-inferentia-launching.md). Também é necessário conhecer a aprendizagem profunda e o uso da DLAMI.
## Ative o ambiente Conda
Ative o ambiente MXNet -Neuron conda usando o seguinte comando:
```
source activate aws_neuron_mxnet_p36
```
Para sair do ambiente Conda atual, execute:
```
source deactivate
```
## Faça download do código de exemplo
Para executar o exemplo, faça download do código de exemplo usando os seguintes comandos:
```
git clone https://github.com/awslabs/multi-model-server
cd multi-model-server/examples/mxnet_vision
```
## Compile o modelo.
Crie um script Python chamado `multi-model-server-compile.py` com o conteúdo a seguir. Esse script compila o modelo ResNet 50 para o alvo do 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)
```
Para compilar o modelo, use o seguinte comando:
```
python multi-model-server-compile.py
```
A saída será semelhante a:
```
...
[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!
```
Crie um arquivo chamado `signature.json` com o seguinte conteúdo para configurar o nome e a forma de entrada:
```
{
"inputs": [
{
"data_name": "data",
"data_shape": [
1,
3,
224,
224
]
}
]
}
```
Faça download do arquivo `synset.txt` usando o seguinte comando: Esse arquivo é uma lista de nomes para classes de ImageNet predição.
```
curl -O https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/synset.txt
```
Crie uma classe de serviço personalizada seguindo o modelo na pasta `model_server_template`. Copie o modelo para o diretório de trabalho atual usando o seguinte comando:
```
cp -r ../model_service_template/* .
```
Edite o módulo `mxnet_model_service.py` para substituir o contexto `mx.cpu()` pelo contexto `mx.neuron()`, da seguinte forma. Você também precisa comentar a cópia de dados desnecessária `model_input` porque MXNet -Neuron não suporta o NDArray e o 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]
```
Empacote o modelo com arquivador de modelos, usando os seguintes comandos:
```
cd ~/multi-model-server/examples
model-archiver --force --model-name resnet-50_compiled --model-path mxnet_vision --handler mxnet_vision_service:handle
```
## Execute a inferência
Inicie o Multi Model Server e carregue o modelo que usa a RESTful API usando os comandos a seguir. Certifique-se de que o **neuron-rtd** está sendo executado com as configurações padrão.
```
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
```
Execute a inferência usando uma imagem de exemplo com os seguintes comandos:
```
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
```
A saída será semelhante a:
```
[
{
"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"
}
]
```
Para limpar após o teste, emita um comando delete por meio da RESTful API e interrompa o servidor de modelos usando os seguintes comandos:
```
curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled
multi-model-server --stop
```
A seguinte saída deverá ser mostrada:
```
{
"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
```
# Usando PyTorch -Neuron e o compilador Neuron AWS
A API de compilação PyTorch -Neuron fornece um método para compilar um gráfico de modelo que você pode executar em um dispositivo Inferentia. AWS
Um modelo treinado deve ser compilado para um destino Inferentia antes que ele possa ser implantado em instâncias Inf1. O tutorial a seguir compila o modelo torchvision ResNet 50 e o exporta como um módulo salvo. TorchScript Esse modelo é, assim sendo, usado para executar inferência.
Por conveniência, este tutorial usa uma instância Inf1 para compilação e inferência. Na prática, você pode compilar o modelo usando outro tipo de instância, como a família de instâncias c5. Depois, você deve implantar o modelo compilado no servidor de inferência Inf1. Para obter mais informações, consulte a documentação do [AWS Neuron PyTorch SDK.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html)
**Topics**
+ [Pré-requisitos](#tutorial-inferentia-pytorch-neuron-prerequisites)
+ [Ative o ambiente Conda](#tutorial-inferentia-pytorch-neuron-activate)
+ [Compilação ResNet50](#tutorial-inferentia-pytorch-neuron-compilation)
+ [ResNet50 Inferência](#tutorial-inferentia-pytorch-neuron-inference)
## Pré-requisitos
Antes de usar este tutorial, você precisa ter concluído os passos da configuração em [Lançamento de uma instância DLAMI com Neuron AWS](tutorial-inferentia-launching.md). Também é necessário conhecer a aprendizagem profunda e o uso da DLAMI.
## Ative o ambiente Conda
Ative o ambiente PyTorch -Neuron conda usando o seguinte comando:
```
source activate aws_neuron_pytorch_p36
```
Para sair do ambiente Conda atual, execute:
```
source deactivate
```
## Compilação ResNet50
Crie um script Python chamado **pytorch\$1trace\$1resnet50.py** com o conteúdo a seguir. Esse script usa a API Python de compilação PyTorch -Neuron para compilar um modelo -50. ResNet
**nota**
Há uma dependência entre as versões do torchvision e do pacote torch que você deve conhecer ao compilar os modelos do torchvision. Essas regras de dependência podem ser gerenciadas por meio do pip. Torchvision==0.6.1 corresponde à versão torch==1.5.1, enquanto torchvision==0.8.2 corresponde à versão 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")
```
Execute o script de compilação.
```
python pytorch_trace_resnet50.py
```
A compilação demora alguns minutos. Quando terminar, o modelo compilado será salvo como `resnet50_neuron.pt` no diretório local.
## ResNet50 Inferência
Crie um script Python chamado **pytorch\$1infer\$1resnet50.py** com o conteúdo a seguir. Esse script faz download de uma imagem de amostra e a usa para executar a inferência com o modelo compilado.
```
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) )
```
Execute a inferência com o modelo compilado usando o seguinte comando:
```
python pytorch_infer_resnet50.py
```
A saída será semelhante a:
```
Top 5 labels:
['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby']
```