Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Der AWS Inferentia-Chip mit DLAMI
AWS Inferentia ist ein maßgeschneiderter Chip für maschinelles Lernen, der speziell für leistungsstarke AWS Inferenzvorhersagen entwickelt wurde. Um den Chip zu verwenden, richten Sie eine Amazon Elastic Compute Cloud-Instanz ein und verwenden Sie das AWS Neuron Software Development Kit (SDK), um den Inferentia-Chip aufzurufen. Um Kunden das beste Inferentia-Erlebnis zu bieten, wurde Neuron in das AWS Deep Learning AMIs (DLAMI) integriert.
Die folgenden Themen zeigen Ihnen, wie Sie mit der Verwendung von Inferentia mit dem DLAMI beginnen können.
**Topics**
+ [Starten einer DLAMI-Instanz mit Neuron AWS](tutorial-inferentia-launching.md)
+ [Verwendung des DLAMI mit Neuron AWS](tutorial-inferentia-using.md)
# Starten einer DLAMI-Instanz mit Neuron AWS
Das neueste DLAMI ist sofort mit AWS Inferentia einsatzbereit und wird mit dem AWS Neuron API-Paket geliefert. Informationen zum Starten einer DLAMI-Instanz finden Sie unter [Starten und Konfigurieren einer](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html) DLAMI-Instanz. Nachdem Sie ein DLAMI haben, gehen Sie wie hier beschrieben vor, um sicherzustellen, dass Ihr AWS Inferentia-Chip und Ihre AWS Neuron-Ressourcen aktiv sind.
**Topics**
+ [Verifizieren der Instance](#tutorial-inferentia-launching-verify)
+ [Identifizieren von AWS Inferentia-Geräten](#tutorial-inferentia-launching-identify)
+ [Anzeigen des Ressourcenverbrauchs](#tutorial-inferentia-launching-resource-usage)
+ [Verwendung von Neuron Monitor (Neuron-Monitor)](#tutorial-inferentia-launching-neuron-monitor)
+ [Aktualisierung der Neuron-Software](#tutorial-inferentia-launching-upgrade)
## Verifizieren der Instance
Bevor Sie Ihre Instance verwenden, stellen Sie sicher, dass sie ordnungsgemäß eingerichtet und mit Neuron konfiguriert ist.
## Identifizieren von AWS Inferentia-Geräten
Verwenden Sie den folgenden Befehl, um die Anzahl der Inferentia-Geräte auf Ihrer Instance zu ermitteln:
```
neuron-ls
```
Wenn an Ihre Instance Inferentia-Geräte angeschlossen sind, sieht Ihre Ausgabe in etwa wie folgt aus:
```
+--------+--------+--------+-----------+--------------+
| 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 |
+--------+--------+--------+-----------+--------------+
```
Die bereitgestellte Ausgabe stammt aus einer INF1.6XLarge-Instance und umfasst die folgenden Spalten:
+ NEURON DEVICE: Die logische ID, die dem zugewiesen ist. NeuronDevice Diese ID wird verwendet, wenn mehrere Laufzeiten für die Verwendung verschiedener Laufzeiten konfiguriert werden. NeuronDevices
+ NEURON-KERNE: Die Anzahl der NeuronCores vorhandenen Kerne in der. NeuronDevice
+ NEURONENSPEICHER: Die Menge an DRAM-Speicher im. NeuronDevice
+ ANGESCHLOSSENE GERÄTE: Andere, die NeuronDevices mit dem verbunden sind. NeuronDevice
+ PCI BDF: Die PCI-Bus-Gerätefunktions-ID (BDF) des. NeuronDevice
## Anzeigen des Ressourcenverbrauchs
Zeigen Sie mit dem Befehl nützliche Informationen NeuronCore zur vCPU-Auslastung, zur Speichernutzung, zu geladenen Modellen und Neuron-Anwendungen an`neuron-top`. Wenn Sie `neuron-top` ohne Argumente starten, werden Daten für alle maschinellen Lernanwendungen angezeigt, die dies verwenden. NeuronCores
```
neuron-top
```
Wenn eine Anwendung vier verwendet NeuronCores, sollte die Ausgabe der folgenden Abbildung ähneln:
![\[Die Ausgabe des neuron-top Befehls, wobei Informationen für eine von vier Optionen NeuronCores hervorgehoben sind.\]](http://docs.aws.amazon.com/de_de/dlami/latest/devguide/images/neuron-top-output.png)
[Weitere Informationen zu Ressourcen zur Überwachung und Optimierung neuronaler Inferenzanwendungen finden Sie unter Neuron Tools.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/index.html)
## Verwendung von Neuron Monitor (Neuron-Monitor)
Neuron Monitor sammelt Metriken aus den Neuron-Laufzeiten, die auf dem System laufen, und streamt die gesammelten Daten im JSON-Format auf stdout. Diese Metriken sind in Metrikgruppen organisiert, die Sie konfigurieren, indem Sie eine Konfigurationsdatei bereitstellen. Weitere Informationen zu Neuron Monitor finden Sie im [Benutzerhandbuch für Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/neuron-monitor-user-guide.html) Monitor.
## Aktualisierung der Neuron-Software
[Informationen zum Aktualisieren der Neuron SDK-Software in DLAMI finden Sie im AWS Neuron Setup Guide.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-intro/neuron-install-guide.html)
**Nächster Schritt**
[Verwendung des DLAMI mit Neuron AWS](tutorial-inferentia-using.md)
# Verwendung des DLAMI mit Neuron AWS
Ein typischer Arbeitsablauf mit dem AWS Neuron SDK besteht darin, ein zuvor trainiertes Modell für maschinelles Lernen auf einem Kompilierungsserver zu kompilieren. Verteilen Sie anschließend die Artefakte zur Ausführung an die Inf1-Instanzen. AWS Deep Learning AMIs (DLAMI) ist mit allem vorinstalliert, was Sie zum Kompilieren und Ausführen von Inferenzen in einer Inf1-Instanz benötigen, die Inferentia verwendet.
In den folgenden Abschnitten wird beschrieben, wie Sie das DLAMI mit Inferentia verwenden.
**Topics**
+ [Verwendung von TensorFlow -Neuron und dem Neuron Compiler AWS](tutorial-inferentia-tf-neuron.md)
+ [Verwenden von AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
+ [Verwendung von -Neuron MXNet und dem Neuron Compiler AWS](tutorial-inferentia-mxnet-neuron.md)
+ [Verwenden von MXNet -Neuron Model Serving](tutorial-inferentia-mxnet-neuron-serving.md)
+ [Verwenden von PyTorch -Neuron und dem Neuron Compiler AWS](tutorial-inferentia-pytorch-neuron.md)
# Verwendung von TensorFlow -Neuron und dem Neuron Compiler AWS
Dieses Tutorial zeigt, wie Sie mit dem AWS Neuron-Compiler das Keras ResNet -50-Modell kompilieren und als gespeichertes Modell im Format exportieren. SavedModel Dieses Format ist ein typisches TensorFlow austauschbares Modellformat. Sie lernen außerdem, wie die Inferenz für eine Inf1-Instance mit Beispieldaten ausgeführt wird.
Weitere Informationen zum Neuron SDK finden Sie in der [AWS Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html) SDK-Dokumentation.
**Topics**
+ [Voraussetzungen](#tutorial-inferentia-tf-neuron-prerequisites)
+ [Aktivieren der Conda-Umgebung](#tutorial-inferentia-tf-neuron-activate)
+ [Resnet50-Kompilierung](#tutorial-inferentia-tf-neuron-compilation)
+ [ResNet50 Inferenz](#tutorial-inferentia-tf-neuron-inference)
## Voraussetzungen
Bevor Sie dieses Tutorial verwenden, müssen Sie die Einrichtungsschritte in [Starten einer DLAMI-Instanz mit Neuron AWS](tutorial-inferentia-launching.md) abgeschlossen haben. Sie sollten auch mit Deep Learning und der Verwendung des DLAMI vertraut sein.
## Aktivieren der Conda-Umgebung
Aktivieren Sie die TensorFlow -Neuron Conda-Umgebung mit dem folgenden Befehl:
```
source activate aws_neuron_tensorflow_p36
```
Führen Sie den folgenden Befehl aus, um die aktuelle Conda-Umgebung zu verlassen:
```
source deactivate
```
## Resnet50-Kompilierung
Erstellen Sie das Python-Skript **tensorflow\$1compile\$1resnet50.py** mit folgendem Inhalt. Dieses Python-Skript kompiliert das Keras ResNet 50-Modell und exportiert es als gespeichertes Modell.
```
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')
```
Kompilieren Sie das Modell mit dem folgenden Befehl:
```
python tensorflow_compile_resnet50.py
```
Der Kompilierungsprozess dauert einige Minuten. Nach Abschluss sollte die Ausgabe so aussehen:
```
...
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
...
```
Nach der Kompilierung wird das gespeicherte Modell gezippt: **ws\$1resnet50/resnet50\$1neuron.zip**. Entzippen Sie das Modell und laden Sie das Beispielbild mit den folgenden Befehlen herunter:
```
unzip ws_resnet50/resnet50_neuron.zip -d .
curl -O https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg
```
## ResNet50 Inferenz
Erstellen Sie das Python-Skript **tensorflow\$1infer\$1resnet50.py** mit dem folgenden Inhalt. Dieses Skript führt die Inferenz für das heruntergeladene Modell unter Verwendung eines zuvor kompilierten Inferenzmodells aus.
```
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])
```
Führen Sie die Inferenz für das Modell mit dem folgenden Befehl aus:
```
python tensorflow_infer_resnet50.py
```
Die Ausgabe sollte folgendermaßen aussehen:
```
...
[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]
```
**Nächster Schritt**
[Verwenden von AWS Neuron Serving TensorFlow](tutorial-inferentia-tf-neuron-serving.md)
# Verwenden von AWS Neuron Serving TensorFlow
Dieses Tutorial zeigt, wie Sie ein Diagramm erstellen und einen AWS Neuron-Kompilierungsschritt hinzufügen, bevor Sie das gespeicherte Modell zur Verwendung mit TensorFlow Serving exportieren. TensorFlow Serving ist ein Serversystem, mit dem Sie Inferenzen in einem Netzwerk skalieren können. Neuron TensorFlow Serving verwendet dieselbe API wie normales Serving. TensorFlow Der einzige Unterschied besteht darin, dass ein gespeichertes Modell für AWS Inferentia kompiliert werden muss und der Einstiegspunkt eine andere Binärdatei mit dem Namen ist. `tensorflow_model_server_neuron` Die Binärdatei befindet sich im DLAMI `/usr/local/bin/tensorflow_model_server_neuron` und ist dort vorinstalliert.
[Weitere Informationen zum Neuron SDK finden Sie in der Neuron SDK-Dokumentation.AWS](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html)
**Topics**
+ [Voraussetzungen](#tutorial-inferentia-tf-neuron--serving-prerequisites)
+ [Aktivieren der Conda-Umgebung](#tutorial-inferentia-tf-neuron-serving-activate)
+ [Kompilieren und Exportieren des gespeicherten Modells](#tutorial-inferentia-tf-neuron-serving-compile)
+ [Bereitstellen des gespeicherten Modells](#tutorial-inferentia-tf-neuron-serving-serving)
+ [Generieren von Inferenzanforderungen an den Modell-Server](#tutorial-inferentia-tf-neuron-serving-inference)
## Voraussetzungen
Bevor Sie dieses Tutorial verwenden, müssen Sie die Einrichtungsschritte in [Starten einer DLAMI-Instanz mit Neuron AWS](tutorial-inferentia-launching.md) abgeschlossen haben. Sie sollten auch mit Deep Learning und der Verwendung des DLAMI vertraut sein.
## Aktivieren der Conda-Umgebung
Aktivieren Sie die TensorFlow -Neuron Conda-Umgebung mit dem folgenden Befehl:
```
source activate aws_neuron_tensorflow_p36
```
Wenn Sie die aktuelle Conda-Umgebung verlassen müssen, führen Sie Folgendes aus:
```
source deactivate
```
## Kompilieren und Exportieren des gespeicherten Modells
Erstellen Sie ein Python-Skript namens `tensorflow-model-server-compile.py` mit dem folgenden Inhalt. Dieses Skript erstellt ein Diagramm und kompiliert es mit Neuron. Anschließend wird das kompilierte Diagramm als gespeichertes Modell exportiert.
```
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)
```
Kompilieren Sie das Modell mit dem folgenden Befehl:
```
python tensorflow-model-server-compile.py
```
Die Ausgabe sollte folgendermaßen aussehen:
```
...
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
```
## Bereitstellen des gespeicherten Modells
Nachdem das Modell kompiliert wurde, können Sie den folgenden Befehl verwenden, um das gespeicherte Modell mit der Binärdatei tensorflow\$1model\$1server\$1neuron bereitzustellen:
```
tensorflow_model_server_neuron --model_name=resnet50_inf1 \
--model_base_path=$HOME/resnet50_inf1/ --port=8500 &
```
Die Ausgabe sollte wie folgt aussehen. Das kompilierte Modell wird vom Server im DRAM des Inferentia-Geräts gespeichert, um die Inferenz vorzubereiten.
```
...
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 ...
```
## Generieren von Inferenzanforderungen an den Modell-Server
Erstellen Sie das Python-Skript namens `tensorflow-model-server-infer.py` mit folgendem Inhalt. Dieses Skript führt die Inferenz über gRPC (Service-Framework) aus.
```
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))
```
Führen Sie die Inferenz für das Modell aus, indem Sie gRPC mit dem folgenden Befehl verwenden:
```
python tensorflow-model-server-infer.py
```
Die Ausgabe sollte folgendermaßen aussehen:
```
[[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]]
```
# Verwendung von -Neuron MXNet und dem Neuron Compiler AWS
Die MXNet -Neuron-Kompilierungs-API bietet eine Methode zum Kompilieren eines Modelldiagramms, das Sie auf einem Inferentia-Gerät ausführen können. AWS
In diesem Beispiel verwenden Sie die API, um ein ResNet -50-Modell zu kompilieren und damit Inferenzen auszuführen.
[Weitere Informationen zum Neuron SDK finden Sie in der Neuron SDK-Dokumentation AWS .](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html)
**Topics**
+ [Voraussetzungen](#tutorial-inferentia-mxnet-neuron-prerequisites)
+ [Aktivieren der Conda-Umgebung](#tutorial-inferentia-mxnet-neuron-activate)
+ [Resnet50-Kompilierung](#tutorial-inferentia-mxnet-neuron-compilation)
+ [ResNet50 Folgerung](#tutorial-inferentia-mxnet-neuron-inference)
## Voraussetzungen
Bevor Sie dieses Tutorial verwenden, müssen Sie die Einrichtungsschritte in [Starten einer DLAMI-Instanz mit Neuron AWS](tutorial-inferentia-launching.md) abgeschlossen haben. Sie sollten auch mit Deep Learning und der Verwendung des DLAMI vertraut sein.
## Aktivieren der Conda-Umgebung
Aktivieren Sie die MXNet -Neuron Conda-Umgebung mit dem folgenden Befehl:
```
source activate aws_neuron_mxnet_p36
```
Führen Sie Folgendes aus, um die aktuelle Conda-Umgebung zu verlassen:
```
source deactivate
```
## Resnet50-Kompilierung
Erstellen Sie das Python-Skript namens **mxnet\$1compile\$1resnet50.py** mit folgendem Inhalt. Dieses Skript verwendet die Python-API zur Kompilierung von MXNet -Neuron, um ein ResNet -50-Modell zu kompilieren.
```
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)
```
Kompilieren Sie das Modell mit dem folgenden Befehl:
```
python mxnet_compile_resnet50.py
```
Die Kompilierung dauert einige Minuten. Wenn die Kompilierung abgeschlossen ist, befinden sich die folgenden Dateien in Ihrem aktuellen Verzeichnis:
```
resnet-50-0000.params
resnet-50-symbol.json
compiled_resnet50-0000.params
compiled_resnet50-symbol.json
```
## ResNet50 Folgerung
Erstellen Sie das Python-Skript namens **mxnet\$1infer\$1resnet50.py** mit folgendem Inhalt. Mit diesem Skript wird ein Beispiel-Image heruntergeladen, das dazu verwendet wird, um die Inferenz für das kompilierte Modell auszuführen.
```
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]))
```
Führen Sie die Inferenz mit folgendem Befehl mit dem kompilierten Modell aus:
```
python mxnet_infer_resnet50.py
```
Die Ausgabe sollte folgendermaßen aussehen:
```
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
```
**Nächster Schritt**
[Verwenden von MXNet -Neuron Model Serving](tutorial-inferentia-mxnet-neuron-serving.md)
# Verwenden von MXNet -Neuron Model Serving
In diesem Tutorial lernen Sie, ein vortrainiertes MXNet Modell zu verwenden, um Bildklassifizierung in Echtzeit mit Multi Model Server (MMS) durchzuführen. MMS ist ein flexibles easy-to-use Tool zur Bereitstellung von Deep-Learning-Modellen, die mit einem beliebigen Framework für maschinelles Lernen oder Deep Learning trainiert wurden. Dieses Tutorial beinhaltet einen Kompilierungsschritt mit AWS Neuron und eine Implementierung von MMS mit. MXNet
[Weitere Informationen zum Neuron SDK finden Sie in der Neuron SDK-Dokumentation AWS .](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html)
**Topics**
+ [Voraussetzungen](#tutorial-inferentia-mxnet-neuron-serving-prerequisites)
+ [Aktivieren der Conda-Umgebung](#tutorial-inferentia-mxnet-neuron-serving-activate)
+ [Herunterladen des Beispielcodes](#tutorial-inferentia-mxnet-neuron-serving-download)
+ [Kompilieren des Modells](#tutorial-inferentia-mxnet-neuron-serving-compile)
+ [Ausführen der Inferenz](#tutorial-inferentia-mxnet-neuron-serving-inference)
## Voraussetzungen
Bevor Sie dieses Tutorial verwenden, müssen Sie die Einrichtungsschritte in [Starten einer DLAMI-Instanz mit Neuron AWS](tutorial-inferentia-launching.md) abgeschlossen haben. Sie sollten auch mit Deep Learning und der Verwendung des DLAMI vertraut sein.
## Aktivieren der Conda-Umgebung
Aktivieren Sie die MXNet -Neuron Conda-Umgebung mit dem folgenden Befehl:
```
source activate aws_neuron_mxnet_p36
```
Führen Sie Folgendes aus, um die aktuelle Conda-Umgebung zu verlassen:
```
source deactivate
```
## Herunterladen des Beispielcodes
Um dieses Beispiel auszuführen, laden Sie den Beispielcode mit den folgenden Befehlen herunter:
```
git clone https://github.com/awslabs/multi-model-server
cd multi-model-server/examples/mxnet_vision
```
## Kompilieren des Modells
Erstellen Sie das Python-Skript namens `multi-model-server-compile.py` mit folgendem Inhalt. Dieses Skript kompiliert das Modell ResNet 50 für das Inferentia-Geräteziel.
```
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)
```
Verwenden Sie den folgenden Befehl, um das Modell zu kompilieren:
```
python multi-model-server-compile.py
```
Die Ausgabe sollte folgendermaßen aussehen:
```
...
[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!
```
Erstellen Sie eine Datei namens `signature.json` mit dem folgenden Inhalt, um den Eingabenamen und das Shape zu konfigurieren:
```
{
"inputs": [
{
"data_name": "data",
"data_shape": [
1,
3,
224,
224
]
}
]
}
```
Sie können die Datei `synset.txt` mit dem folgenden Befehl herunterladen. Diese Datei ist eine Liste mit Namen für ImageNet Vorhersageklassen.
```
curl -O https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/synset.txt
```
Erstellen Sie eine benutzerdefinierte Service-Klasse unter Verwendung der Vorlage im Ordner `model_server_template`. Kopieren Sie die Vorlage mit dem folgenden Befehl in das aktuelle Arbeitsverzeichnis:
```
cp -r ../model_service_template/* .
```
Bearbeiten Sie das Modul `mxnet_model_service.py`, indem Sie den Kontext `mx.cpu()` wie folgt durch den Kontext `mx.neuron()` ersetzen. Sie müssen auch die überflüssige Datenkopie für auskommentieren`model_input`, weil MXNet -Neuron das NDArray und Gluon nicht unterstützt. 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]
```
Erstellen Sie mit den folgenden Befehlen ein Paket des Modells mit model-archiver:
```
cd ~/multi-model-server/examples
model-archiver --force --model-name resnet-50_compiled --model-path mxnet_vision --handler mxnet_vision_service:handle
```
## Ausführen der Inferenz
Starten Sie den Multi Model Server und laden Sie das Modell, das die RESTful API verwendet, mithilfe der folgenden Befehle. Stellen Sie sicher, dass **neuron-rtd** mit den Standardeinstellungen ausgeführt wird.
```
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
```
Führen Sie die Inferenz mit den folgenden Befehlen mit einem Beispielbild aus:
```
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
```
Die Ausgabe sollte folgendermaßen aussehen:
```
[
{
"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"
}
]
```
Um nach dem Test zu bereinigen, geben Sie über die RESTful API einen Löschbefehl aus und beenden Sie den Modellserver mit den folgenden Befehlen:
```
curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled
multi-model-server --stop
```
Die Ausgabe sollte folgendermaßen aussehen:
```
{
"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
```
# Verwenden von PyTorch -Neuron und dem Neuron Compiler AWS
Die PyTorch -Neuron-Kompilierungs-API bietet eine Methode zum Kompilieren eines Modelldiagramms, das Sie auf einem Inferentia-Gerät ausführen können. AWS
Ein trainiertes Modell muss für ein Inferentia-Ziel kompiliert werden, bevor es auf Inf1-Instances bereitgestellt werden kann. Das folgende Tutorial kompiliert das Torchvision ResNet 50-Modell und exportiert es als gespeichertes Modul. TorchScript Dieses Modell wird dann zum Ausführen der Inferenz verwendet.
Der Einfachheit halber wird in diesem Tutorial eine Inf1-Instance sowohl für die Kompilierung als auch für die Inferenz verwendet. In der Praxis können Sie Ihr Modell mit einem anderen Instance-Typ kompilieren, z. B. mit der c5-Instance-Familie. Anschließend müssen Sie das kompilierte Modell auf dem Inf1-Inferenzserver bereitstellen. Weitere Informationen finden Sie in der [AWS Neuron PyTorch ](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html) SDK-Dokumentation.
**Topics**
+ [Voraussetzungen](#tutorial-inferentia-pytorch-neuron-prerequisites)
+ [Aktivieren der Conda-Umgebung](#tutorial-inferentia-pytorch-neuron-activate)
+ [Resnet50-Kompilierung](#tutorial-inferentia-pytorch-neuron-compilation)
+ [ResNet50 Inferenz](#tutorial-inferentia-pytorch-neuron-inference)
## Voraussetzungen
Bevor Sie dieses Tutorial verwenden, müssen Sie die Einrichtungsschritte in [Starten einer DLAMI-Instanz mit Neuron AWS](tutorial-inferentia-launching.md) abgeschlossen haben. Sie sollten auch mit Deep Learning und der Verwendung des DLAMI vertraut sein.
## Aktivieren der Conda-Umgebung
Aktivieren Sie die PyTorch -Neuron Conda-Umgebung mit dem folgenden Befehl:
```
source activate aws_neuron_pytorch_p36
```
Führen Sie Folgendes aus, um die aktuelle Conda-Umgebung zu verlassen:
```
source deactivate
```
## Resnet50-Kompilierung
Erstellen Sie das Python-Skript namens **pytorch\$1trace\$1resnet50.py** mit folgendem Inhalt. Dieses Skript verwendet die Python-API zur Kompilierung von PyTorch -Neuron, um ein ResNet -50-Modell zu kompilieren.
**Anmerkung**
Es besteht eine Abhängigkeit zwischen den Versionen von Torchvision und dem Torch-Paket, die Sie beim Kompilieren von Torchvision-Modellen beachten sollten. Diese Abhängigkeitsregeln können über Pip verwaltet werden. Torchvision==0.6.1 entspricht der Version Torch==1.5.1, während Torchvision==0.8.2 der Version Torch==1.7.1 entspricht.
```
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")
```
Führen Sie das Kompilierungsskript aus.
```
python pytorch_trace_resnet50.py
```
Die Kompilierung wird ein paar Minuten dauern. Nach Abschluss der Kompilierung wird das kompilierte Modell wie `resnet50_neuron.pt` im lokalen Verzeichnis gespeichert.
## ResNet50 Inferenz
Erstellen Sie das Python-Skript namens **pytorch\$1infer\$1resnet50.py** mit folgendem Inhalt. Mit diesem Skript wird ein Beispiel-Image heruntergeladen, das dazu verwendet wird, um die Inferenz für das kompilierte Modell auszuführen.
```
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) )
```
Führen Sie die Inferenz mit folgendem Befehl mit dem kompilierten Modell aus:
```
python pytorch_infer_resnet50.py
```
Die Ausgabe sollte folgendermaßen aussehen:
```
Top 5 labels:
['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby']
```