Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Chip AWS Inferentia Dengan DLAMI
AWS Inferentia adalah chip pembelajaran mesin khusus yang dirancang oleh AWS yang dapat Anda gunakan untuk prediksi inferensi kinerja tinggi. Untuk menggunakan chip, siapkan instans Amazon Elastic Compute Cloud dan gunakan kit pengembangan perangkat lunak AWS Neuron (SDK) untuk memanggil chip Inferentia. Untuk memberikan pengalaman Inferensia terbaik kepada pelanggan, Neuron telah dibangun ke dalam AWS Deep Learning AMIs (DLAMI).
Topik berikut menunjukkan kepada Anda bagaimana memulai menggunakan Inferentia dengan DLAMI.
**Topics**
+ [Meluncurkan Instance DLAMI dengan Neuron AWS](tutorial-inferentia-launching.md)
+ [Menggunakan DLAMI dengan Neuron AWS](tutorial-inferentia-using.md)
# Meluncurkan Instance DLAMI dengan Neuron AWS
DLAMI terbaru siap digunakan AWS dengan Inferentia dan dilengkapi dengan AWS paket Neuron API. Untuk meluncurkan instans DLAMI, [lihat Meluncurkan dan Mengonfigurasi](https://docs.aws.amazon.com/dlami/latest/devguide/launch-config.html) DLAMI. Setelah Anda memiliki DLAMI, gunakan langkah-langkah di sini untuk memastikan bahwa chip Inferentia AWS dan sumber daya Neuron AWS Anda aktif.
**Topics**
+ [Verifikasi Instance Anda](#tutorial-inferentia-launching-verify)
+ [Mengidentifikasi Perangkat AWS Inferensia](#tutorial-inferentia-launching-identify)
+ [Lihat Penggunaan Sumber Daya](#tutorial-inferentia-launching-resource-usage)
+ [Menggunakan Neuron Monitor (neuron-monitor)](#tutorial-inferentia-launching-neuron-monitor)
+ [Meningkatkan Perangkat Lunak Neuron](#tutorial-inferentia-launching-upgrade)
## Verifikasi Instance Anda
Sebelum menggunakan instance Anda, verifikasi bahwa itu diatur dan dikonfigurasi dengan benar dengan Neuron.
## Mengidentifikasi Perangkat AWS Inferensia
Untuk mengidentifikasi jumlah perangkat Inferentia pada instans Anda, gunakan perintah berikut:
```
neuron-ls
```
Jika instans Anda memiliki perangkat Inferentia yang terpasang padanya, output Anda akan terlihat mirip dengan yang berikut ini:
```
+--------+--------+--------+-----------+--------------+
| 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 |
+--------+--------+--------+-----------+--------------+
```
Output yang disediakan diambil dari instance INF1.6xLarge dan menyertakan kolom berikut:
+ PERANGKAT NEURON: ID logis yang ditetapkan ke NeuronDevice. ID ini digunakan saat mengonfigurasi beberapa runtime untuk menggunakan yang berbeda. NeuronDevices
+ NEURON CORES: Jumlah NeuronCores hadir di NeuronDevice.
+ MEMORI NEURON: Jumlah memori DRAM di. NeuronDevice
+ PERANGKAT YANG TERHUBUNG: Lainnya NeuronDevices terhubung ke NeuronDevice.
+ PCI BDF: ID Fungsi Perangkat Bus PCI (BDF) dari file. NeuronDevice
## Lihat Penggunaan Sumber Daya
Lihat informasi yang berguna tentang NeuronCore dan pemanfaatan vCPU, penggunaan memori, model yang dimuat, dan aplikasi Neuron dengan perintah. `neuron-top` `neuron-top`Peluncuran tanpa argumen akan menampilkan data untuk semua aplikasi pembelajaran mesin yang memanfaatkan NeuronCores.
```
neuron-top
```
Ketika aplikasi menggunakan empat NeuronCores, output akan terlihat mirip dengan gambar berikut:
![\[Output dari neuron-top perintah, dengan informasi untuk salah satu dari empat yang NeuronCores disorot.\]](http://docs.aws.amazon.com/id_id/dlami/latest/devguide/images/neuron-top-output.png)
[Untuk informasi lebih lanjut tentang sumber daya untuk memantau dan mengoptimalkan aplikasi inferensi berbasis Neuron, lihat Alat Neuron.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/index.html)
## Menggunakan Neuron Monitor (neuron-monitor)
Neuron Monitor mengumpulkan metrik dari runtime Neuron yang berjalan di sistem dan mengalirkan data yang dikumpulkan ke stdout dalam format JSON. Metrik ini diatur ke dalam grup metrik yang Anda konfigurasikan dengan menyediakan file konfigurasi. Untuk informasi lebih lanjut tentang Monitor Neuron, lihat [Panduan Pengguna untuk Monitor Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-tools/neuron-monitor-user-guide.html).
## Meningkatkan Perangkat Lunak Neuron
[Untuk informasi tentang cara memperbarui perangkat lunak Neuron SDK dalam DLAMI, lihat AWS Panduan Pengaturan Neuron.](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-intro/neuron-install-guide.html)
**Langkah Selanjutnya**
[Menggunakan DLAMI dengan Neuron AWS](tutorial-inferentia-using.md)
# Menggunakan DLAMI dengan Neuron AWS
Alur kerja khas dengan AWS Neuron SDK adalah mengkompilasi model pembelajaran mesin yang dilatih sebelumnya di server kompilasi. Setelah ini, distribusikan artefak ke instance Inf1 untuk dieksekusi. AWS Deep Learning AMIs (DLAMI) sudah diinstal sebelumnya dengan semua yang Anda butuhkan untuk mengkompilasi dan menjalankan inferensi dalam instance Inf1 yang menggunakan Inferentia.
Bagian berikut menjelaskan cara menggunakan DLAMI dengan Inferentia.
**Topics**
+ [Menggunakan TensorFlow -Neuron dan Kompiler AWS Neuron](tutorial-inferentia-tf-neuron.md)
+ [Menggunakan TensorFlow Penyajian AWS Neuron](tutorial-inferentia-tf-neuron-serving.md)
+ [Menggunakan MXNet -Neuron dan Kompiler AWS Neuron](tutorial-inferentia-mxnet-neuron.md)
+ [Menggunakan Penyajian Model MXNet -Neuron](tutorial-inferentia-mxnet-neuron-serving.md)
+ [Menggunakan PyTorch -Neuron dan Kompiler AWS Neuron](tutorial-inferentia-pytorch-neuron.md)
# Menggunakan TensorFlow -Neuron dan Kompiler AWS Neuron
Tutorial ini menunjukkan cara menggunakan kompiler AWS Neuron untuk mengkompilasi model Keras ResNet -50 dan mengekspornya sebagai model yang disimpan dalam format. SavedModel Format ini adalah format TensorFlow model yang dapat dipertukarkan khas. Anda juga belajar cara menjalankan inferensi pada instance Inf1 dengan input contoh.
Untuk informasi lebih lanjut tentang Neuron SDK, lihat dokumentasi [AWS Neuron SDK](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html).
**Topics**
+ [Prasyarat](#tutorial-inferentia-tf-neuron-prerequisites)
+ [Aktifkan lingkungan Conda](#tutorial-inferentia-tf-neuron-activate)
+ [Resnet50 Kompilasi](#tutorial-inferentia-tf-neuron-compilation)
+ [ResNet50 Inferensi](#tutorial-inferentia-tf-neuron-inference)
## Prasyarat
Sebelum menggunakan tutorial ini, Anda seharusnya telah menyelesaikan langkah-langkah pengaturan di[Meluncurkan Instance DLAMI dengan Neuron AWS](tutorial-inferentia-launching.md). Anda juga harus memiliki keakraban dengan pembelajaran mendalam dan menggunakan DLAMI.
## Aktifkan lingkungan Conda
Aktifkan lingkungan conda TensorFlow -Neuron menggunakan perintah berikut:
```
source activate aws_neuron_tensorflow_p36
```
Untuk keluar dari lingkungan conda saat ini, jalankan perintah berikut:
```
source deactivate
```
## Resnet50 Kompilasi
Buat skrip Python yang disebut **tensorflow\$1compile\$1resnet50.py** yang memiliki konten berikut. Skrip Python ini mengkompilasi model Keras ResNet 50 dan mengekspornya sebagai model yang disimpan.
```
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')
```
Kompilasi model menggunakan perintah berikut:
```
python tensorflow_compile_resnet50.py
```
Proses kompilasi akan memakan waktu beberapa menit. Ketika selesai, output Anda akan terlihat seperti berikut:
```
...
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
...
```
Setelah kompilasi, model yang disimpan di-zip di**ws\$1resnet50/resnet50\$1neuron.zip**. Buka zip model dan unduh gambar sampel untuk inferensi menggunakan perintah berikut:
```
unzip ws_resnet50/resnet50_neuron.zip -d .
curl -O https://raw.githubusercontent.com/awslabs/mxnet-model-server/master/docs/images/kitten_small.jpg
```
## ResNet50 Inferensi
Buat skrip Python yang disebut **tensorflow\$1infer\$1resnet50.py** yang memiliki konten berikut. Skrip ini menjalankan inferensi pada model yang diunduh menggunakan model inferensi yang dikompilasi sebelumnya.
```
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])
```
Jalankan inferensi pada model menggunakan perintah berikut:
```
python tensorflow_infer_resnet50.py
```
Output Anda akan terlihat seperti berikut:
```
...
[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]
```
**Langkah Selanjutnya**
[Menggunakan TensorFlow Penyajian AWS Neuron](tutorial-inferentia-tf-neuron-serving.md)
# Menggunakan TensorFlow Penyajian AWS Neuron
Tutorial ini menunjukkan cara membuat grafik dan menambahkan langkah kompilasi AWS Neuron sebelum mengekspor model yang disimpan untuk digunakan dengan TensorFlow Serving. TensorFlow Melayani adalah sistem penyajian yang memungkinkan Anda meningkatkan inferensi di seluruh jaringan. Neuron TensorFlow Serving menggunakan API yang sama dengan TensorFlow Serving normal. Satu-satunya perbedaan adalah bahwa model yang disimpan harus dikompilasi untuk AWS Inferentia dan titik masuknya adalah biner yang berbeda bernama`tensorflow_model_server_neuron`. Biner ditemukan di `/usr/local/bin/tensorflow_model_server_neuron` dan sudah diinstal sebelumnya di DLAMI.
Untuk informasi lebih lanjut tentang Neuron SDK, lihat dokumentasi [AWS Neuron SDK](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/tensorflow-neuron/index.html).
**Topics**
+ [Prasyarat](#tutorial-inferentia-tf-neuron--serving-prerequisites)
+ [Aktifkan lingkungan Conda](#tutorial-inferentia-tf-neuron-serving-activate)
+ [Kompilasi dan Ekspor Model Tersimpan](#tutorial-inferentia-tf-neuron-serving-compile)
+ [Melayani Model Tersimpan](#tutorial-inferentia-tf-neuron-serving-serving)
+ [Hasilkan permintaan inferensi ke server model](#tutorial-inferentia-tf-neuron-serving-inference)
## Prasyarat
Sebelum menggunakan tutorial ini, Anda seharusnya telah menyelesaikan langkah-langkah pengaturan di[Meluncurkan Instance DLAMI dengan Neuron AWS](tutorial-inferentia-launching.md). Anda juga harus memiliki keakraban dengan pembelajaran mendalam dan menggunakan DLAMI.
## Aktifkan lingkungan Conda
Aktifkan lingkungan conda TensorFlow -Neuron menggunakan perintah berikut:
```
source activate aws_neuron_tensorflow_p36
```
Jika Anda perlu keluar dari lingkungan conda saat ini, jalankan:
```
source deactivate
```
## Kompilasi dan Ekspor Model Tersimpan
Buat skrip Python yang disebut `tensorflow-model-server-compile.py` dengan konten berikut. Skrip ini membuat grafik dan mengkompilasinya menggunakan Neuron. Kemudian mengekspor grafik yang dikompilasi sebagai model yang disimpan.
```
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)
```
Kompilasi model menggunakan perintah berikut:
```
python tensorflow-model-server-compile.py
```
Output Anda akan terlihat seperti berikut:
```
...
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
```
## Melayani Model Tersimpan
Setelah model dikompilasi, Anda dapat menggunakan perintah berikut untuk menyajikan model yang disimpan dengan biner tensorflow\$1model\$1server\$1neuron:
```
tensorflow_model_server_neuron --model_name=resnet50_inf1 \
--model_base_path=$HOME/resnet50_inf1/ --port=8500 &
```
Output Anda akan terlihat seperti berikut ini. Model yang dikompilasi dipentaskan di DRAM perangkat Inferentia oleh server untuk mempersiapkan inferensi.
```
...
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 ...
```
## Hasilkan permintaan inferensi ke server model
Membuat skrip Python yang disebut `tensorflow-model-server-infer.py` dengan konten berikut. Skrip ini menjalankan inferensi melalui gRPC, yang merupakan kerangka kerja layanan.
```
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))
```
Jalankan inferensi pada model dengan menggunakan gRPC dengan perintah berikut:
```
python tensorflow-model-server-infer.py
```
Output Anda akan terlihat seperti berikut:
```
[[('n02123045', 'tabby', 0.6918919), ('n02127052', 'lynx', 0.12770271), ('n02123159', 'tiger_cat', 0.08277027), ('n02124075', 'Egyptian_cat', 0.06418919), ('n02128757', 'snow_leopard', 0.009290541)]]
```
# Menggunakan MXNet -Neuron dan Kompiler AWS Neuron
API kompilasi MXNet -Neuron menyediakan metode untuk mengkompilasi grafik model yang dapat Anda jalankan pada perangkat AWS Inferentia.
Dalam contoh ini, Anda menggunakan API untuk mengkompilasi model ResNet -50 dan menggunakannya untuk menjalankan inferensi.
Untuk informasi lebih lanjut tentang Neuron SDK, lihat dokumentasi [AWS Neuron SDK](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html).
**Topics**
+ [Prasyarat](#tutorial-inferentia-mxnet-neuron-prerequisites)
+ [Aktifkan Lingkungan Conda](#tutorial-inferentia-mxnet-neuron-activate)
+ [Resnet50 Kompilasi](#tutorial-inferentia-mxnet-neuron-compilation)
+ [ResNet50 Inferensi](#tutorial-inferentia-mxnet-neuron-inference)
## Prasyarat
Sebelum menggunakan tutorial ini, Anda seharusnya telah menyelesaikan langkah-langkah pengaturan di[Meluncurkan Instance DLAMI dengan Neuron AWS](tutorial-inferentia-launching.md). Anda juga harus memiliki keakraban dengan pembelajaran mendalam dan menggunakan DLAMI.
## Aktifkan Lingkungan Conda
Aktifkan lingkungan conda MXNet -Neuron menggunakan perintah berikut:
```
source activate aws_neuron_mxnet_p36
```
Untuk keluar dari lingkungan conda saat ini, jalankan:
```
source deactivate
```
## Resnet50 Kompilasi
Membuat skrip Python yang disebut **mxnet\$1compile\$1resnet50.py** dengan konten berikut. Skrip ini menggunakan kompilasi MXNet -Neuron Python API untuk mengkompilasi ResNet model -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)
```
Kompilasi model menggunakan perintah berikut:
```
python mxnet_compile_resnet50.py
```
Kompilasi akan memakan waktu beberapa menit. Ketika kompilasi telah selesai, file-file berikut akan berada di direktori Anda saat ini:
```
resnet-50-0000.params
resnet-50-symbol.json
compiled_resnet50-0000.params
compiled_resnet50-symbol.json
```
## ResNet50 Inferensi
Membuat skrip Python yang disebut **mxnet\$1infer\$1resnet50.py** dengan konten berikut. Skrip ini mengunduh gambar sampel dan menggunakannya untuk menjalankan inferensi dengan model yang dikompilasi.
```
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]))
```
Jalankan inferensi dengan model yang dikompilasi menggunakan perintah berikut:
```
python mxnet_infer_resnet50.py
```
Output Anda akan terlihat seperti berikut:
```
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
```
**Langkah Selanjutnya**
[Menggunakan Penyajian Model MXNet -Neuron](tutorial-inferentia-mxnet-neuron-serving.md)
# Menggunakan Penyajian Model MXNet -Neuron
Dalam tutorial ini, Anda belajar menggunakan MXNet model pra-terlatih untuk melakukan klasifikasi gambar real-time dengan Multi Model Server (MMS). MMS adalah easy-to-use alat yang fleksibel dan untuk melayani model pembelajaran mendalam yang dilatih menggunakan pembelajaran mesin atau kerangka pembelajaran mendalam. Tutorial ini mencakup langkah kompilasi menggunakan AWS Neuron dan implementasi MMS menggunakan MXNet.
Untuk informasi lebih lanjut tentang Neuron SDK, lihat dokumentasi [AWS Neuron SDK](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/mxnet-neuron/index.html).
**Topics**
+ [Prasyarat](#tutorial-inferentia-mxnet-neuron-serving-prerequisites)
+ [Aktifkan Lingkungan Conda](#tutorial-inferentia-mxnet-neuron-serving-activate)
+ [Unduh Kode Contoh](#tutorial-inferentia-mxnet-neuron-serving-download)
+ [Kompilasi Model](#tutorial-inferentia-mxnet-neuron-serving-compile)
+ [Jalankan Inferensi](#tutorial-inferentia-mxnet-neuron-serving-inference)
## Prasyarat
Sebelum menggunakan tutorial ini, Anda seharusnya telah menyelesaikan langkah-langkah pengaturan di[Meluncurkan Instance DLAMI dengan Neuron AWS](tutorial-inferentia-launching.md). Anda juga harus memiliki keakraban dengan pembelajaran mendalam dan menggunakan DLAMI.
## Aktifkan Lingkungan Conda
Aktifkan lingkungan conda MXNet -Neuron dengan menggunakan perintah berikut:
```
source activate aws_neuron_mxnet_p36
```
Untuk keluar dari lingkungan conda saat ini, jalankan:
```
source deactivate
```
## Unduh Kode Contoh
Untuk menjalankan contoh ini, unduh kode contoh menggunakan perintah berikut:
```
git clone https://github.com/awslabs/multi-model-server
cd multi-model-server/examples/mxnet_vision
```
## Kompilasi Model
Membuat skrip Python yang disebut `multi-model-server-compile.py` dengan konten berikut. Skrip ini mengkompilasi model ResNet 50 ke target perangkat 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)
```
Untuk mengkompilasi model, gunakan perintah berikut:
```
python multi-model-server-compile.py
```
Output Anda akan terlihat seperti berikut:
```
...
[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!
```
Buat file bernama `signature.json` dengan konten berikut untuk mengkonfigurasi nama input dan bentuk:
```
{
"inputs": [
{
"data_name": "data",
"data_shape": [
1,
3,
224,
224
]
}
]
}
```
Download `synset.txt` file dengan menggunakan perintah berikut. File ini adalah daftar nama untuk kelas ImageNet prediksi.
```
curl -O https://s3.amazonaws.com/model-server/model_archive_1.0/examples/squeezenet_v1.1/synset.txt
```
Buat kelas layanan kustom mengikuti template di `model_server_template` folder. Salin template ke direktori kerja Anda saat ini dengan menggunakan perintah berikut:
```
cp -r ../model_service_template/* .
```
Edit `mxnet_model_service.py` modul untuk mengganti `mx.cpu()` konteks dengan `mx.neuron()` konteks sebagai berikut. Anda juga perlu mengomentari salinan data yang tidak perlu `model_input` karena MXNet -Neuron tidak mendukung NDArray dan APIs Gluon.
```
...
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]
```
Package model dengan model-archiver menggunakan perintah berikut:
```
cd ~/multi-model-server/examples
model-archiver --force --model-name resnet-50_compiled --model-path mxnet_vision --handler mxnet_vision_service:handle
```
## Jalankan Inferensi
Mulai Multi Model Server dan muat model yang menggunakan RESTful API dengan menggunakan perintah berikut. Pastikan **neuron-rtd** itu berjalan dengan pengaturan default.
```
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
```
Jalankan inferensi menggunakan contoh gambar dengan perintah berikut:
```
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
```
Output Anda akan terlihat seperti berikut:
```
[
{
"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"
}
]
```
Untuk membersihkan setelah pengujian, keluarkan perintah delete melalui RESTful API dan hentikan server model menggunakan perintah berikut:
```
curl -X DELETE http://127.0.0.1:8081/models/resnet-50_compiled
multi-model-server --stop
```
Anda akan melihat output berikut:
```
{
"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
```
# Menggunakan PyTorch -Neuron dan Kompiler AWS Neuron
API kompilasi PyTorch -Neuron menyediakan metode untuk mengkompilasi grafik model yang dapat Anda jalankan pada perangkat AWS Inferentia.
Model terlatih harus dikompilasi ke target Inferentia sebelum dapat digunakan pada instance Inf1. Tutorial berikut mengkompilasi model torchvision ResNet 50 dan mengekspornya sebagai modul yang disimpan. TorchScript Model ini kemudian digunakan untuk menjalankan inferensi.
Untuk kenyamanan, tutorial ini menggunakan instance Inf1 untuk kompilasi dan inferensi. Dalam praktiknya, Anda dapat mengkompilasi model Anda menggunakan tipe instance lain, seperti keluarga instance c5. Anda kemudian harus menerapkan model yang dikompilasi ke server inferensi Inf1. Untuk informasi lebih lanjut, lihat [Dokumentasi AWS Neuron PyTorch SDK](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html).
**Topics**
+ [Prasyarat](#tutorial-inferentia-pytorch-neuron-prerequisites)
+ [Aktifkan Lingkungan Conda](#tutorial-inferentia-pytorch-neuron-activate)
+ [Resnet50 Kompilasi](#tutorial-inferentia-pytorch-neuron-compilation)
+ [ResNet50 Inferensi](#tutorial-inferentia-pytorch-neuron-inference)
## Prasyarat
Sebelum menggunakan tutorial ini, Anda seharusnya telah menyelesaikan langkah-langkah pengaturan di[Meluncurkan Instance DLAMI dengan Neuron AWS](tutorial-inferentia-launching.md). Anda juga harus memiliki keakraban dengan pembelajaran mendalam dan menggunakan DLAMI.
## Aktifkan Lingkungan Conda
Aktifkan lingkungan conda PyTorch -Neuron menggunakan perintah berikut:
```
source activate aws_neuron_pytorch_p36
```
Untuk keluar dari lingkungan conda saat ini, jalankan:
```
source deactivate
```
## Resnet50 Kompilasi
Membuat skrip Python yang disebut **pytorch\$1trace\$1resnet50.py** dengan konten berikut. Skrip ini menggunakan kompilasi PyTorch -Neuron Python API untuk mengkompilasi ResNet model -50.
**catatan**
Ada ketergantungan antara versi torchvision dan paket obor yang harus Anda ketahui saat mengkompilasi model torchvision. Aturan ketergantungan ini dapat dikelola melalui pip. Torchvision==0.6.1 cocok dengan rilis torch==1.5.1, sedangkan torchvision==0.8.2 cocok dengan rilis 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")
```
Jalankan skrip kompilasi.
```
python pytorch_trace_resnet50.py
```
Kompilasi akan memakan waktu beberapa menit. Ketika kompilasi telah selesai, model yang dikompilasi disimpan seperti `resnet50_neuron.pt` di direktori lokal.
## ResNet50 Inferensi
Membuat skrip Python yang disebut **pytorch\$1infer\$1resnet50.py** dengan konten berikut. Skrip ini mengunduh gambar sampel dan menggunakannya untuk menjalankan inferensi dengan model yang dikompilasi.
```
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) )
```
Jalankan inferensi dengan model yang dikompilasi menggunakan perintah berikut:
```
python pytorch_infer_resnet50.py
```
Output Anda akan terlihat seperti berikut:
```
Top 5 labels:
['tiger', 'lynx', 'tiger_cat', 'Egyptian_cat', 'tabby']
```