Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# El chip AWS Inferentia con DLAMI
AWS Inferentia es un chip de aprendizaje automático personalizado diseñado por AWS el usuario para realizar predicciones de inferencias de alto rendimiento. Para usar el chip, configure una instancia de Amazon Elastic Compute Cloud y use el kit de desarrollo de software (SDK) AWS Neuron para invocar el chip Inferentia. Para proporcionar a los clientes la mejor experiencia de Inferentia, Neuron está incorporado en la AWS Deep Learning AMIs (DLAMI).
En los siguientes temas se muestra cómo comenzar a usar Inferentia con la DLAMI.
**Topics**
+ [Lanzamiento de una instancia DLAMI con Neuron AWS](tutorial-inferentia-launching.md)
+ [Uso del DLAMI con Neuron AWS](tutorial-inferentia-using.md)
# Lanzamiento de una instancia DLAMI con Neuron AWS
La última versión de DLAMI está lista para usarse AWS con Inferentia e incluye el paquete de API Neuron. AWS Para iniciar una instancia de la DLAMI, consulte [Lanzamiento y configuración de una DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html). Una vez que tenga un DLAMI, siga los pasos que se indican a continuación para asegurarse de que AWS su chip AWS Inferentia y sus recursos de Neuron estén activos.
**Topics**
+ [Comprobación de la instancia](#tutorial-inferentia-launching-verify)
+ [Identificación de los dispositivos de inferencia AWS](#tutorial-inferentia-launching-identify)
+ [Visualización del uso de recursos](#tutorial-inferentia-launching-resource-usage)
+ [Uso de Neuron Monitor (monitor de neuronas)](#tutorial-inferentia-launching-neuron-monitor)
+ [Actualización del software Neuron](#tutorial-inferentia-launching-upgrade)
## Comprobación de la instancia
Antes de usar la instancia, compruebe que esté correctamente instalada y configurada con Neuron.
## Identificación de los dispositivos de inferencia AWS
Para identificar el número de dispositivos de Inferencia de la instancia, utilice el siguiente comando:
```
neuron-ls
```
Si su instancia tiene dispositivos de Inferentia asociados a ella, la salida tendrá un aspecto similar al siguiente:
```
+--------+--------+--------+-----------+--------------+
| 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 |
+--------+--------+--------+-----------+--------------+
```
El resultado suministrado se toma de una instancia INF1.6xLarge e incluye las siguientes columnas:
+ DISPOSITIVO NEURONAL: el identificador lógico asignado al. NeuronDevice Este ID se usa al configurar varios tiempos de ejecución para usar diferentes. NeuronDevices
+ NÚCLEOS NEURONALES: el número de núcleos NeuronCores presentes en. NeuronDevice
+ MEMORIA NEURONAL: La cantidad de memoria DRAM en el. NeuronDevice
+ DISPOSITIVOS CONECTADOS: Otros NeuronDevices conectados al. NeuronDevice
+ PCI BDF: El identificador de la función de dispositivo de bus PCI (BDF) del. NeuronDevice
## Visualización del uso de recursos
Vea información útil sobre NeuronCore el uso de la vCPU, el uso de la memoria, los modelos cargados y las aplicaciones de Neuron con el comando. `neuron-top` Si se inicia `neuron-top` sin argumentos, se mostrarán los datos de todas las aplicaciones de aprendizaje automático que se utilicen. NeuronCores
```
neuron-top
```
Cuando una aplicación utiliza cuatro NeuronCores, el resultado debe tener un aspecto similar al de la imagen siguiente:
![\[El resultado del neuron-top comando, con la información de uno de los cuatro NeuronCores resaltada.\]](http://docs.aws.amazon.com/es_es/dlami/latest/devguide/images/neuron-top-output.png)
Para obtener más información sobre los recursos para supervisar y optimizar las aplicaciones de inferencia basadas en Neuron, consulte [Neuron Tools](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/index.html).
## Uso de Neuron Monitor (monitor de neuronas)
Neuron Monitor recopila las métricas de los tiempos de ejecución de Neuron que se ejecutan en el sistema y transmite los datos recopilados a la salida estándar en formato JSON. Estas métricas se organizan en grupos de métricas que se configuran proporcionando un archivo de configuración. Para obtener más información sobre Neuron Monitor, consulte la [User Guide for Neuron Monitor](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/neuron-monitor-user-guide.html).
## Actualización del software Neuron
[Para obtener información sobre cómo actualizar el software Neuron SDK en DLAMI, consulte AWS la Guía de configuración de Neuron.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-intro/neuron-install-guide.html)
**Paso siguiente**
[Uso del DLAMI con Neuron AWS](tutorial-inferentia-using.md)
# Uso del DLAMI con Neuron AWS
Un flujo de trabajo típico con el SDK de AWS Neuron consiste en compilar un modelo de aprendizaje automático previamente entrenado en un servidor de compilación. Después, distribuya los artefactos a las instancias de Inf1 para su ejecución. AWS Deep Learning AMIs (DLAMI) viene preinstalado con todo lo que necesita para compilar y ejecutar inferencias en una instancia de Inf1 que usa Inferentia.
En las siguientes secciones se describe cómo utilizar la DLAMI con Inferentia.
**Topics**
+ [TensorFlowUso de AWS -Neuron y el compilador Neuron](tutorial-inferentia-tf-neuron.md)
+ [Uso de AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
+ [Uso de MXNet -Neuron y el compilador Neuron AWS](tutorial-inferentia-mxnet-neuron.md)
+ [Uso del modelo MXNet -Neuron Serving](tutorial-inferentia-mxnet-neuron-serving.md)
+ [Uso de PyTorch -Neuron y el compilador Neuron AWS](tutorial-inferentia-pytorch-neuron.md)
# TensorFlowUso de AWS -Neuron y el compilador Neuron
Este tutorial muestra cómo usar el compilador AWS Neuron para compilar el modelo Keras ResNet -50 y exportarlo como un modelo guardado en formato. SavedModel Este formato es un formato típico TensorFlow de modelos intercambiables. También aprenderá a ejecutar la inferencia en una instancia Inf1 con entrada de ejemplo.
Para obtener más información sobre el SDK de Neuron, consulte la [documentación del SDK de AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html).
**Topics**
+ [Requisitos previos](#tutorial-inferentia-tf-neuron-prerequisites)
+ [Activación del entorno Conda](#tutorial-inferentia-tf-neuron-activate)
+ [Compilación de Resnet50](#tutorial-inferentia-tf-neuron-compilation)
+ [ResNet50 Inferencia](#tutorial-inferentia-tf-neuron-inference)
## Requisitos previos
Antes de utilizar este tutorial, debería haber completado los pasos de configuración de [Lanzamiento de una instancia DLAMI con Neuron AWS](tutorial-inferentia-launching.md). También debe estar familiarizado con el aprendizaje profundo y con el uso de la DLAMI.
## Activación del entorno Conda
Active el entorno conda TensorFlow -Neuron mediante el siguiente comando:
```
source activate aws_neuron_tensorflow_p36
```
Para salir del entorno Conda actual, ejecute el siguiente comando:
```
source deactivate
```
## Compilación de Resnet50
Cree un script de Python llamada denominado **tensorflow\$1compile\$1resnet50.py** que tenga el siguiente contenido. Este script de Python compila el modelo Keras ResNet 50 y lo exporta como un modelo guardado.
```
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 el modelo con el siguiente comando:
```
python tensorflow_compile_resnet50.py
```
El proceso de compilación tardará unos minutos. Cuando concluya, la salida debe tener el siguiente aspecto:
```
...
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
...
```
Después de la compilación, el modelo guardado se comprime en **ws\$1resnet50/resnet50\$1neuron.zip**. Descomprima el modelo y descargue la imagen de muestra para la inferencia mediante los siguientes 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 Inferencia
Cree un script de Python llamada denominado **tensorflow\$1infer\$1resnet50.py** que tenga el siguiente contenido. Este script ejecuta la inferencia en el modelo descargado utilizando un modelo de inferencia compilado previamente.
```
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])
```
Ejecute la inferencia en el modelo mediante el siguiente comando:
```
python tensorflow_infer_resnet50.py
```
El resultado debería tener el siguiente aspecto:
```
...
[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]
```
**Paso siguiente**
[Uso de AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
# Uso de AWS Neuron Serving TensorFlow
Este tutorial muestra cómo construir un gráfico y añadir un paso de compilación de AWS Neuron antes de exportar el modelo guardado para usarlo con TensorFlow Serving. TensorFlow Serving es un sistema de servidor que permite ampliar las inferencias en una red. Neuron TensorFlow Serving utiliza la misma API que el Serving normal. TensorFlow La única diferencia es que se debe compilar un modelo guardado para AWS Inferentia y el punto de entrada es un nombre binario diferente. `tensorflow_model_server_neuron` El binario se encuentra en `/usr/local/bin/tensorflow_model_server_neuron` y está preinstalado en la DLAMI.
Para obtener más información sobre el SDK de Neuron, consulte la [documentación del SDK de AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html).
**Topics**
+ [Requisitos previos](#tutorial-inferentia-tf-neuron--serving-prerequisites)
+ [Activación del entorno Conda](#tutorial-inferentia-tf-neuron-serving-activate)
+ [Compilación y exportación del modelo guardado](#tutorial-inferentia-tf-neuron-serving-compile)
+ [Distribución del modelo guardado](#tutorial-inferentia-tf-neuron-serving-serving)
+ [Generación de solicitudes de inferencia al servidor de modelos](#tutorial-inferentia-tf-neuron-serving-inference)
## Requisitos previos
Antes de utilizar este tutorial, debería haber completado los pasos de configuración de [Lanzamiento de una instancia DLAMI con Neuron AWS](tutorial-inferentia-launching.md). También debe estar familiarizado con el aprendizaje profundo y con el uso de la DLAMI.
## Activación del entorno Conda
Active el entorno conda TensorFlow -Neuron mediante el siguiente comando:
```
source activate aws_neuron_tensorflow_p36
```
Si necesita salir del entorno Conda actual, ejecute:
```
source deactivate
```
## Compilación y exportación del modelo guardado
Cree un script de Python denominado `tensorflow-model-server-compile.py` con el siguiente contenido. Este script construye un gráfico y lo compila con Neuron. A continuación, exporta el gráfico compilado como un modelo guardado.
```
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 el modelo con el siguiente comando:
```
python tensorflow-model-server-compile.py
```
El resultado debería tener el siguiente aspecto:
```
...
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
```
## Distribución del modelo guardado
Una vez compilado el modelo, puede usar el siguiente comando para distribuir el modelo guardado con el binario tensorflow\$1model\$1server\$1neuron:
```
tensorflow_model_server_neuron --model_name=resnet50_inf1 \
--model_base_path=$HOME/resnet50_inf1/ --port=8500 &
```
El resultado debería tener el siguiente aspecto. El servidor almacena el modelo compilado de manera provisional en la DRAM del dispositivo de Inferentia para preparar la inferencia.
```
...
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 ...
```
## Generación de solicitudes de inferencia al servidor de modelos
Cree un script de Python denominado `tensorflow-model-server-infer.py` con el siguiente contenido. Este script ejecuta la inferencia a través de gRPC, que es el marco de trabajo de servicio.
```
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))
```
Ejecute la inferencia en el modelo utilizando gRPC con el siguiente comando:
```
python tensorflow-model-server-infer.py
```
El resultado debería tener el siguiente aspecto:
```
[[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]]
```
# Uso de MXNet -Neuron y el compilador Neuron AWS
La API de compilación MXNet -Neuron proporciona un método para compilar un gráfico modelo que se puede ejecutar en un dispositivo de inferencia. AWS
En este ejemplo, usa la API para compilar un modelo ResNet -50 y usarlo para ejecutar inferencias.
Para obtener más información sobre el SDK de Neuron, consulte la [documentación del SDK de AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html).
**Topics**
+ [Requisitos previos](#tutorial-inferentia-mxnet-neuron-prerequisites)
+ [Activación del entorno Conda](#tutorial-inferentia-mxnet-neuron-activate)
+ [Compilación de Resnet50](#tutorial-inferentia-mxnet-neuron-compilation)
+ [ResNetInferencia 5.0](#tutorial-inferentia-mxnet-neuron-inference)
## Requisitos previos
Antes de utilizar este tutorial, debería haber completado los pasos de configuración de [Lanzamiento de una instancia DLAMI con Neuron AWS](tutorial-inferentia-launching.md). También debe estar familiarizado con el aprendizaje profundo y con el uso de la DLAMI.
## Activación del entorno Conda
Active el entorno conda MXNet -Neuron mediante el siguiente comando:
```
source activate aws_neuron_mxnet_p36
```
Para salir del entorno Conda actual, ejecute:
```
source deactivate
```
## Compilación de Resnet50
Cree un script de Python denominado **mxnet\$1compile\$1resnet50.py** con el siguiente contenido. Este script usa la API de Python de MXNet compilación -Neuron para compilar un modelo 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)
```
Compile el modelo con el siguiente comando:
```
python mxnet_compile_resnet50.py
```
La compilación tardará unos minutos. Cuando haya finalizado, los siguientes archivos estarán en su directorio actual:
```
resnet-50-0000.params
resnet-50-symbol.json
compiled_resnet50-0000.params
compiled_resnet50-symbol.json
```
## ResNetInferencia 5.0
Cree un script de Python denominado **mxnet\$1infer\$1resnet50.py** con el siguiente contenido. Este script descarga una imagen de muestra y la utiliza para ejecutar la inferencia con el 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]))
```
Ejecute la inferencia con el modelo compilado mediante el siguiente comando:
```
python mxnet_infer_resnet50.py
```
El resultado debería tener el siguiente aspecto:
```
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
```
**Paso siguiente**
[Uso del modelo MXNet -Neuron Serving](tutorial-inferentia-mxnet-neuron-serving.md)
# Uso del modelo MXNet -Neuron Serving
En este tutorial, aprenderá a utilizar un MXNet modelo previamente entrenado para realizar la clasificación de imágenes en tiempo real con Multi Model Server (MMS). El MMS es una easy-to-use herramienta flexible para utilizar modelos de aprendizaje profundo que se entrenan con cualquier marco de aprendizaje automático o aprendizaje profundo. Este tutorial incluye un paso de compilación con AWS Neuron y una implementación del MMS con. MXNet
Para obtener más información sobre el SDK de Neuron, consulte la [documentación del SDK de AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html).
**Topics**
+ [Requisitos previos](#tutorial-inferentia-mxnet-neuron-serving-prerequisites)
+ [Activación del entorno Conda](#tutorial-inferentia-mxnet-neuron-serving-activate)
+ [Descarga del código de ejemplo](#tutorial-inferentia-mxnet-neuron-serving-download)
+ [Compile el modelo.](#tutorial-inferentia-mxnet-neuron-serving-compile)
+ [Ejecutar inferencia](#tutorial-inferentia-mxnet-neuron-serving-inference)
## Requisitos previos
Antes de utilizar este tutorial, debería haber completado los pasos de configuración de [Lanzamiento de una instancia DLAMI con Neuron AWS](tutorial-inferentia-launching.md). También debe estar familiarizado con el aprendizaje profundo y con el uso de la DLAMI.
## Activación del entorno Conda
Active el entorno conda MXNet -Neuron mediante el siguiente comando:
```
source activate aws_neuron_mxnet_p36
```
Para salir del entorno Conda actual, ejecute:
```
source deactivate
```
## Descarga del código de ejemplo
Para ejecutar este ejemplo, descargue el código de ejemplo mediante los siguientes comandos:
```
git clone https://github.com/awslabs/multi-model-server
cd multi-model-server/examples/mxnet_vision
```
## Compile el modelo.
Cree un script de Python denominado `multi-model-server-compile.py` con el siguiente contenido. Este script compila el modelo ResNet 50 con el objetivo 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)
```
Para compilar el modelo, utilice el siguiente comando:
```
python multi-model-server-compile.py
```
El resultado debería tener el siguiente aspecto:
```
...
[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!
```
Cree un archivo `signature.json` con el siguiente contenido para configurar el nombre y la forma de entrada:
```
{
"inputs": [
{
"data_name": "data",
"data_shape": [
1,
3,
224,
224
]
}
]
}
```
Descargue el archivo `synset.txt` con el siguiente comando. Este archivo es una lista de nombres para ImageNet las clases de predicción.
```
curl -O https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/synset.txt
```
Cree una clase de servicio personalizada siguiendo la plantilla de la carpeta `model_server_template`. Copie la plantilla en su directorio de trabajo actual mediante el siguiente comando:
```
cp -r ../model_service_template/* .
```
Edite el módulo `mxnet_model_service.py` para reemplazar el contexto `mx.cpu()` por el contexto `mx.neuron()` de la siguiente manera. También debe comentar la copia de datos innecesaria, `model_input` ya que MXNet -Neuron no es compatible con NDArray y 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]
```
Empaquete el modelo con model-archiver utilizando los siguientes comandos:
```
cd ~/multi-model-server/examples
model-archiver --force --model-name resnet-50_compiled --model-path mxnet_vision --handler mxnet_vision_service:handle
```
## Ejecutar inferencia
Inicie el servidor multimodelo y cargue el modelo que usa la RESTful API mediante los siguientes comandos. Asegúrese de que **neuron-rtd** se está ejecutando con la configuración predeterminada.
```
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
```
Ejecute la inferencia utilizando una imagen de ejemplo con los siguientes 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
```
El resultado debería tener el siguiente aspecto:
```
[
{
"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 limpiar después de la prueba, ejecute un comando de eliminación a través de la RESTful API y detenga el servidor de modelos mediante los siguientes comandos:
```
curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled
multi-model-server --stop
```
Debería ver los siguientes datos de salida:
```
{
"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
```
# Uso de PyTorch -Neuron y el compilador Neuron AWS
La API de compilación PyTorch -Neuron proporciona un método para compilar un gráfico modelo que se puede ejecutar en un dispositivo de inferencia. AWS
Un modelo entrenado debe compilarse en un destino de Inferentia antes de poder implementarlo en instancias Inf1. El siguiente tutorial compila el modelo torchvision ResNet 50 y lo exporta como un módulo guardado. TorchScript A continuación, el modelo se utiliza para ejecutar la inferencia.
Para mayor comodidad, el tutorial utiliza una instancia Inf1 tanto para la compilación como para la inferencia. En la práctica, puede compilar el modelo con otro tipo de instancia, como la familia de instancias c5. A continuación, debe implementar el modelo compilado en el servidor de inferencia Inf1. Para obtener más información, consulte la documentación del SDK de [AWS Neuron PyTorch ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html).
**Topics**
+ [Requisitos previos](#tutorial-inferentia-pytorch-neuron-prerequisites)
+ [Activación del entorno Conda](#tutorial-inferentia-pytorch-neuron-activate)
+ [Compilación de Resnet50](#tutorial-inferentia-pytorch-neuron-compilation)
+ [ResNetInferencia 5.0](#tutorial-inferentia-pytorch-neuron-inference)
## Requisitos previos
Antes de utilizar este tutorial, debería haber completado los pasos de configuración de [Lanzamiento de una instancia DLAMI con Neuron AWS](tutorial-inferentia-launching.md). También debe estar familiarizado con el aprendizaje profundo y con el uso de la DLAMI.
## Activación del entorno Conda
Active el entorno conda PyTorch -Neuron mediante el siguiente comando:
```
source activate aws_neuron_pytorch_p36
```
Para salir del entorno Conda actual, ejecute:
```
source deactivate
```
## Compilación de Resnet50
Cree un script de Python denominado **pytorch\$1trace\$1resnet50.py** con el siguiente contenido. Este script usa la API de Python de PyTorch compilación -Neuron para compilar un modelo ResNet -50.
**nota**
Hay una dependencia entre las versiones de torchvision y el paquete de torch que debe tener en cuenta al compilar los modelos de torchvision. Estas reglas de dependencia se pueden gestionar a través de pip. Torchvision==0.6.1 coincide con la versión torch==1.5.1, mientras que torchvision==0.8.2 coincide con la versión 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")
```
Ejecute el script de compilación.
```
python pytorch_trace_resnet50.py
```
La compilación tardará unos minutos. Cuando haya finalizado, el modelo compilado se guardará como `resnet50_neuron.pt` en el directorio local.
## ResNetInferencia 5.0
Cree un script de Python denominado **pytorch\$1infer\$1resnet50.py** con el siguiente contenido. Este script descarga una imagen de muestra y la utiliza para ejecutar la inferencia con el 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) )
```
Ejecute la inferencia con el modelo compilado mediante el siguiente comando:
```
python pytorch_infer_resnet50.py
```
El resultado debería tener el siguiente aspecto:
```
Top 5 labels:
['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby']
```