Menjalankan workflow inferensi TensorFlow dengan TensorRT5 dan GPU NVIDIA T4

Tutorial ini membahas cara menjalankan inferensi deep learning pada workload berskala besar menggunakan GPU NVIDIA TensorRT5 yang berjalan di Compute Engine.

Sebelum memulai, berikut beberapa hal penting:

  • Inferensi deep learning adalah tahap dalam proses machine learning ketika model terlatih digunakan untuk mengenali, memproses, dan mengklasifikasikan hasil.
  • NVIDIA TensorRT adalah platform yang dioptimalkan untuk menjalankan workload deep learning.
  • GPU digunakan untuk mempercepat workflow yang intensif data seperti machine learning dan pemrosesan data. Berbagai GPU NVIDIA tersedia di Compute Engine. Tutorial ini menggunakan GPU T4, karena GPU T4 dirancang khusus untuk workflow inferensi deep learning.

Tujuan

Dalam tutorial ini, prosedur berikut dibahas:

  • Menyiapkan model menggunakan grafik yang dilatih sebelumnya.
  • Menguji kecepatan inferensi untuk model dengan mode pengoptimalan yang berbeda.
  • Mengonversi model kustom menjadi TensorRT.
  • Menyiapkan cluster multi-zona. Cluster multi-zona ini dikonfigurasi sebagai berikut:
    • Dibangun berdasarkan Deep Learning VM Image. Image ini telah diinstal sebelumnya dengan TensorFlow, TensorFlow Serving, dan TensorRT5.
    • Penskalaan otomatis diaktifkan. Penskalaan otomatis dalam tutorial ini didasarkan pada penggunaan GPU.
    • Load balancing diaktifkan.
    • Firewall diaktifkan.
  • Menjalankan workflow inferensi di cluster multi-zona.

Ringkasan arsitektur konfigurasi tutorial ini secara garis besar.

Biaya

Biaya untuk menjalankan tutorial ini bervariasi menurut bagian.

Anda dapat menghitung biaya menggunakan kalkulator harga.

Guna memperkirakan biaya untuk menyiapkan model Anda dan menguji kecepatan inferensi pada berbagai kecepatan pengoptimalan, gunakan spesifikasi berikut:

  • 1 instance VM: n1-standard-8 (vCPU: 8, RAM: 30 GB)
  • 1 GPU NVIDIA T4

Untuk memperkirakan biaya penyiapan cluster multizona, gunakan spesifikasi berikut:

  • 2 instance VM: n1-standard-16 (vCPU: 16, RAM: 60 GB)
  • 4 GPU NVIDIA T4 untuk setiap instance VM
  • SSD 100 GB untuk setiap instance VM
  • 1 Aturan penerusan

Sebelum memulai

Penyiapan project

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

    Buka pemilih project

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Aktifkan API Compute Engine and Cloud Machine Learning .

    Mengaktifkan API

    5.

  5. Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

    Buka pemilih project

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Aktifkan API Compute Engine and Cloud Machine Learning .

    Mengaktifkan API

    8.

Penyiapan alat

Untuk menggunakan Google Cloud CLI dalam tutorial ini:

  1. Instal Google Cloud CLI atau update ke versi terbaru.
  2. Tetapkan region dan zona default (opsional).

Menyiapkan model

Bagian ini membahas pembuatan instance virtual machine (VM) yang digunakan untuk menjalankan model. Bagian ini juga membahas cara mendownload model dari katalog model resmi TensorFlow.

  1. Membuat instance VM. Tutorial ini dibuat menggunakan tf-ent-2-10-cu113. Untuk versi image terbaru, lihat Memilih sistem operasi dalam dokumentasi Deep Learning VM Image.

    export IMAGE_FAMILY="tf-ent-2-10-cu113"
export ZONE="us-central1-b"
export INSTANCE_NAME="model-prep"
gcloud compute instances create $INSTANCE_NAME \
   --zone=$ZONE \
   --image-family=$IMAGE_FAMILY \
   --machine-type=n1-standard-8 \
   --image-project=deeplearning-platform-release \
   --maintenance-policy=TERMINATE \
   --accelerator="type=nvidia-tesla-t4,count=1" \
   --metadata="install-nvidia-driver=True"

  2. Pilih sebuah model. Tutorial ini menggunakan model ResNet. Model ResNet ini dilatih menggunakan set data ImageNet yang berada di TensorFlow.

    Untuk mendownload model ResNet ke instance VM Anda, jalankan perintah berikut:

    wget -q http://download.tensorflow.org/models/official/resnetv2_imagenet_frozen_graph.pb

    Simpan lokasi model ResNet Anda di variabel $WORKDIR. Ganti MODEL_LOCATION dengan direktori kerja yang berisi model yang telah didownload.

    export WORKDIR=MODEL_LOCATION

Menjalankan uji kecepatan inferensi

Bagian ini membahas prosedur berikut:

  • Menyiapkan model ResNet.
  • Menjalankan pengujian inferensi pada berbagai mode pengoptimalan.
  • Meninjau hasil pengujian inferensi.

Ringkasan proses pengujian

TensorRT dapat meningkatkan kecepatan performanya untuk workflow inferensi, tetapi peningkatan yang paling signifikan berasal dari proses kuantisasi.

Kuantisasi model adalah proses mengurangi presisi bobot untuk suatu model. Misalnya, jika bobot awal sebuah model adalah FP32, Anda dapat mengurangi presisinya ke FP16, INT8, atau bahkan INT4. Penting bagi Anda untuk memilih kompromi yang tepat antara kecepatan (presisi bobot) dan akurasi model. Untungnya, TensorFlow memiliki fungsionalitas untuk keperluan ini, yang mengukur akurasi versus kecepatan, atau metrik lainnya seperti throughput, latensi, rasio konversi node, dan total waktu pelatihan.

Prosedur

  1. Siapkan model ResNet. Untuk menyiapkan model ini, jalankan perintah berikut:

    git clone https://github.com/tensorflow/models.git
cd models
git checkout f0e10716160cd048618ccdd4b6e18336223a172f
touch research/__init__.py
touch research/tensorrt/__init__.py
cp research/tensorrt/labellist.json .
cp research/tensorrt/image.jpg ..

  2. Jalankan pengujian. Penyelesaian perintah ini membutuhkan waktu beberapa lama.

    python -m research.tensorrt.tensorrt \
   --frozen_graph=$WORKDIR/resnetv2_imagenet_frozen_graph.pb \
   --image_file=$WORKDIR/image.jpg \
   --native --fp32 --fp16 --int8 \
   --output_dir=$WORKDIR

    Di mana:

    • $WORKDIR adalah direktori tempat Anda mendownload model ResNet.
    • Argumen --native adalah mode kuantisasi berbeda yang akan diuji.

  3. Tinjau hasilnya. Setelah pengujian selesai, Anda dapat membandingkan hasil inferensi untuk setiap mode pengoptimalan.

    Predictions:
Precision:  native [u'seashore, coast, seacoast, sea-coast', u'promontory, headland, head, foreland', u'breakwater, groin, groyne, mole, bulwark, seawall, jetty',     u'lakeside, lakeshore', u'grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus']
Precision:  FP32 [u'seashore, coast, seacoast, sea-coast', u'promontory, headland, head, foreland', u'breakwater, groin, groyne, mole, bulwark, seawall, jetty', u'lakeside,   lakeshore', u'sandbar, sand bar']
Precision:  FP16 [u'seashore, coast, seacoast, sea-coast', u'promontory, headland, head, foreland', u'breakwater, groin, groyne, mole, bulwark, seawall, jetty', u'lakeside,   lakeshore', u'sandbar, sand bar']
Precision:  INT8 [u'seashore, coast, seacoast, sea-coast', u'promontory, headland, head, foreland', u'breakwater, groin, groyne, mole, bulwark, seawall, jetty', u'grey         whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus', u'lakeside, lakeshore']

    Untuk melihat hasil lengkapnya, jalankan perintah berikut:

    cat $WORKDIR/log.txt

    Hasil performa.

    Dari hasil tersebut dapat dilihat bahwa FP32 dan FP16 identik. Artinya, jika Anda sudah nyaman menggunakan TensorRT, Anda pasti dapat langsung mulai menggunakan FP16. INT8, menunjukkan hasil yang sedikit lebih buruk.

    Selain itu, Anda dapat melihat bahwa menjalankan model dengan TensorRT5 menunjukkan hasil berikut:

    • Menggunakan pengoptimalan FP32, throughput meningkat 40% dari 314 fps menjadi 440 fps. Pada saat yang sama, latensi berkurang sekitar 30%, dari 0,40 md menjadi 0,28 md.
    • Menggunakan pengoptimalan FP16, bukan grafik TensorFlow native, kecepatan meningkat 214% dari 314 menjadi 988 fps. Pada saat yang sama, latensi berkurang 0,12 md, turun hampir 3x lipat.
    • Menggunakan INT8, Anda dapat melihat kecepatan meningkat 385% dari 314 fps menjadi 1.524 fps sementara latensi turun menjadi 0,08 md.

Mengonversi model kustom menjadi TensorRT

Untuk konversi ini, Anda dapat menggunakan model INT8.

  1. Download modelnya. Untuk mengonversi model kustom menjadi grafik TensorRT, Anda memerlukan model tersimpan. Untuk mendapatkan model ResNet INT8 tersimpan, jalankan perintah berikut:

    wget http://download.tensorflow.org/models/official/20181001_resnet/savedmodels/resnet_v2_fp32_savedmodel_NCHW.tar.gz
tar -xzvf resnet_v2_fp32_savedmodel_NCHW.tar.gz

  2. Konversi model menjadi grafik TensorRT menggunakan TFTools. Untuk mengonversi model menggunakan TFTools, jalankan perintah berikut:

    git clone https://github.com/GoogleCloudPlatform/ml-on-gcp.git
cd ml-on-gcp/dlvm/tools
python ./convert_to_rt.py \
   --input_model_dir=$WORKDIR/resnet_v2_fp32_savedmodel_NCHW/1538687196 \
   --output_model_dir=$WORKDIR/resnet_v2_int8_NCHW/00001 \
   --batch_size=128 \
   --precision_mode="INT8"

    Sekarang Anda memiliki model INT8 di direktori $WORKDIR/resnet_v2_int8_NCHW/00001.

    Untuk memastikan bahwa semuanya telah disiapkan dengan benar, coba jalankan pengujian inferensi.

    tensorflow_model_server --model_base_path=$WORKDIR/resnet_v2_int8_NCHW/ --rest_api_port=8888

  3. Upload model ke Cloud Storage. Langkah ini diperlukan agar model dapat digunakan dari cluster multi-zona yang disiapkan di bagian berikutnya. Untuk mengupload model, selesaikan langkah-langkah berikut:

    1. Arsipkan model.

      tar -zcvf model.tar.gz ./resnet_v2_int8_NCHW/

    2. Upload arsip. Ganti GCS_PATH dengan jalur ke bucket Cloud Storage Anda.

      export GCS_PATH=GCS_PATH
gcloud storage cp model.tar.gz $GCS_PATH

      Jika perlu, Anda bisa mendapatkan grafik frozen INT8 dari Cloud Storage di URL ini:

      gs://cloud-samples-data/dlvm/t4/model.tar.gz

Menyiapkan cluster multi-zona

Membuat cluster

Setelah memiliki model di platform Cloud Storage, sekarang Anda dapat membuat cluster.

  1. Buat template instance. Template instance merupakan resource berguna untuk membuat instance baru. Lihat Template Instance. Ganti YOUR_PROJECT_NAME dengan project ID Anda.

    export INSTANCE_TEMPLATE_NAME="tf-inference-template"
export IMAGE_FAMILY="tf-ent-2-10-cu113"
export PROJECT_NAME=YOUR_PROJECT_NAME

gcloud beta compute --project=$PROJECT_NAME instance-templates create $INSTANCE_TEMPLATE_NAME \
     --machine-type=n1-standard-16 \
     --maintenance-policy=TERMINATE \
     --accelerator=type=nvidia-tesla-t4,count=4 \
     --min-cpu-platform=Intel\ Skylake \
     --tags=http-server,https-server \
     --image-family=$IMAGE_FAMILY \
     --image-project=deeplearning-platform-release \
     --boot-disk-size=100GB \
     --boot-disk-type=pd-ssd \
     --boot-disk-device-name=$INSTANCE_TEMPLATE_NAME \
     --metadata startup-script-url=gs://cloud-samples-data/dlvm/t4/start_agent_and_inf_server_4.sh
    • Template instance ini mencakup skrip startup yang ditentukan oleh parameter metadata.
      • Jalankan skrip startup ini selama pembuatan instance di setiap instance yang menggunakan template ini.
      • Skrip startup ini melakukan langkah-langkah berikut:
        • Menginstal agen pemantauan yang memantau penggunaan GPU di instance itu.
        • Mendownload model.
        • Memulai layanan inferensi.
      • Dalam skrip startup, tf_serve.py berisi logika inferensi. Contoh ini mencakup file Python sangat kecil yang didasarkan pada paket TFServe.
      • Untuk melihat skrip startup, lihat startup_inf_script.sh.

  2. Buat grup instance terkelola (MIG). Grup instance terkelola ini diperlukan untuk menyiapkan banyak instance yang berjalan di zona tertentu. Instance dibuat berdasarkan template instance yang dihasilkan pada langkah sebelumnya.

    export INSTANCE_GROUP_NAME="deeplearning-instance-group"
export INSTANCE_TEMPLATE_NAME="tf-inference-template"
gcloud compute instance-groups managed create $INSTANCE_GROUP_NAME \
   --template $INSTANCE_TEMPLATE_NAME \
   --base-instance-name deeplearning-instances \
   --size 2 \
   --zones us-central1-a,us-central1-b

    • Anda dapat membuat instance ini di sembarang zona yang tersedia yang mendukung GPU T4. Pastikan kuota GPU tersedia di zona itu.

    • Pembuatan instance memerlukan waktu beberapa lama. Anda dapat melihat progresnya dengan menjalankan perintah berikut:

      export INSTANCE_GROUP_NAME="deeplearning-instance-group"
       
      gcloud compute instance-groups managed list-instances $INSTANCE_GROUP_NAME --region us-central1

      Pembuatan instance.

    • Setelah grup instance terkelola dibuat, Anda akan melihat output yang mirip dengan berikut ini:

      Instance yang sedang berjalan.

  3. Pastikan metrik tersedia di halaman Cloud Monitoring pada Google Cloud.

    1. Di konsol Google Cloud, buka halaman Monitoring.

      Buka Monitoring

    2. Jika Metrics Explorer ditampilkan di panel navigasi, klik Metrics Explorer. Jika tidak, pilih Resources, lalu pilih Metrics Explorer.

    3. Telusuri gpu_utilization.

      Inisiasi Monitoring.

    4. Saat data mulai masuk, Anda akan melihat sesuatu seperti ini:

      Monitoring berjalan.

Mengaktifkan penskalaan otomatis

  1. Aktifkan penskalaan otomatis untuk grup instance terkelola.

    export INSTANCE_GROUP_NAME="deeplearning-instance-group"

gcloud compute instance-groups managed set-autoscaling $INSTANCE_GROUP_NAME \
   --custom-metric-utilization metric=custom.googleapis.com/gpu_utilization,utilization-target-type=GAUGE,utilization-target=85 \
   --max-num-replicas 4 \
   --cool-down-period 360 \
   --region us-central1

    custom.googleapis.com/gpu_utilization adalah jalur lengkap ke metrik kita. Contoh ini menetapkan level 85, yang berarti bahwa setiap kali penggunaan GPU mencapai 85, platform akan membuat instance baru di grup kita.

  2. Uji penskalaan otomatis. Untuk menguji penskalaan otomatis, Anda perlu menjalankan langkah berikut:

    1. SSH ke instance. Lihat bagian Terhubung ke Instance.

    2. Gunakan alat gpu-burn untuk memuat GPU hingga pemakaian 100% selama 600 detik:

      git clone https://github.com/GoogleCloudPlatform/ml-on-gcp.git
cd ml-on-gcp/third_party/gpu-burn
git checkout c0b072aa09c360c17a065368294159a6cef59ddf
make
./gpu_burn 600 > /dev/null &

    3. Lihat halaman Cloud Monitoring. Amati penskalaan otomatis. Cluster akan meningkatkan skala dengan menambahkan satu instance lagi.

      Penskalaan otomatis di cluster.

    4. Di Konsol Google Cloud, buka halaman Instance groups.

      Buka Instance groups

    5. Klik grup instance terkelola deeplearning-instance-group.

    6. Klik tab Monitoring.

      Pada tahap ini, logika penskalaan otomatis Anda akan mencoba memutar sebanyak mungkin instance untuk mengurangi beban, tetapi tidak ada hasilnya:

      Instance tambahan.

      Pada tahap ini, Anda dapat berhenti membakar instance, dan mengamati bagaimana sistem menurunkan skala.

Menyiapkan load balancer

Mari lihat kembali apa yang kita miliki sejauh ini:

  • Model terlatih, yang dioptimalkan dengan TensorRT5 (INT8)
  • Grup instance terkelola. Instance ini mengaktifkan penskalaan otomatis berdasarkan penggunaan GPU

Sekarang Anda dapat membuat load balancer di depan instance tersebut.

  1. Buat health check. Health check digunakan untuk menentukan apakah host tertentu di backend kita dapat menyalurkan traffic atau tidak.

    export HEALTH_CHECK_NAME="http-basic-check"

gcloud compute health-checks create http $HEALTH_CHECK_NAME \
   --request-path /v1/models/default \
   --port 8888

  2. Buat layanan backend yang mencakup grup instance dan health check.

    1. Buat health check.

      export HEALTH_CHECK_NAME="http-basic-check"
export WEB_BACKED_SERVICE_NAME="tensorflow-backend"

gcloud compute backend-services create $WEB_BACKED_SERVICE_NAME \
   --protocol HTTP \
   --health-checks $HEALTH_CHECK_NAME \
   --global

    2. Tambahkan grup instance ke layanan backend baru.

      export INSTANCE_GROUP_NAME="deeplearning-instance-group"
export WEB_BACKED_SERVICE_NAME="tensorflow-backend"

gcloud compute backend-services add-backend $WEB_BACKED_SERVICE_NAME \
   --balancing-mode UTILIZATION \
   --max-utilization 0.8 \
   --capacity-scaler 1 \
   --instance-group $INSTANCE_GROUP_NAME \
   --instance-group-region us-central1 \
   --global

  3. Siapkan URL penerusan. Load balancer perlu mengetahui URL mana yang dapat diteruskan ke layanan backend.

    export WEB_BACKED_SERVICE_NAME="tensorflow-backend"
export WEB_MAP_NAME="map-all"

gcloud compute url-maps create $WEB_MAP_NAME \
   --default-service $WEB_BACKED_SERVICE_NAME

  4. Buat load balancer.

    export WEB_MAP_NAME="map-all"
export LB_NAME="tf-lb"

gcloud compute target-http-proxies create $LB_NAME \
   --url-map $WEB_MAP_NAME

  5. Tambahkan alamat IP eksternal ke load balancer.

    export IP4_NAME="lb-ip4"

gcloud compute addresses create $IP4_NAME \
   --ip-version=IPV4 \
   --network-tier=PREMIUM \
   --global

  6. Temukan alamat IP yang dialokasikan.

    gcloud compute addresses list

  7. Siapkan aturan penerusan yang memberi tahu Google Cloud untuk meneruskan semua permintaan dari alamat IP publik ke load balancer.

    export IP=$(gcloud compute addresses list | grep ${IP4_NAME} | awk '{print $2}')
export LB_NAME="tf-lb"
export FORWARDING_RULE="lb-fwd-rule"

gcloud compute forwarding-rules create $FORWARDING_RULE \
   --address $IP \
   --global \
   --load-balancing-scheme=EXTERNAL \
   --network-tier=PREMIUM \
   --target-http-proxy $LB_NAME \
   --ports 80

    Setelah membuat aturan penerusan global, mungkin perlu beberapa menit untuk menerapkan konfigurasi Anda.

Mengaktifkan firewall

  1. Periksa apakah Anda memiliki aturan firewall yang mengizinkan koneksi dari sumber eksternal ke instance VM Anda.

    gcloud compute firewall-rules list

  2. Jika tidak memiliki aturan firewall untuk mengizinkan koneksi ini, Anda harus membuatnya. Untuk membuat aturan firewall, jalankan perintah berikut:

    gcloud compute firewall-rules create www-firewall-80 \
   --target-tags http-server --allow tcp:80

gcloud compute firewall-rules create www-firewall-8888 \
   --target-tags http-server --allow tcp:8888

Menjalankan inferensi

  1. Anda dapat menggunakan skrip Python berikut untuk mengonversi image ke dalam format yang dapat diupload ke server.

    from PIL import Image
import numpy as np
import json
import codecs

    
img = Image.open("image.jpg").resize((240, 240))
img_array=np.array(img)
result = {
      "instances":[img_array.tolist()]
       }
file_path="/tmp/out.json"
print(json.dump(result, codecs.open(file_path, 'w', encoding='utf-8'), separators=(',', ':'), sort_keys=True, indent=4))

  2. Jalankan inferensi.

    curl -X POST $IP/v1/models/default:predict -d @/tmp/out.json

Pembersihan

Agar akun Google Cloud Anda tidak dikenai biaya untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus resource satu per satu.

  1. Hapus aturan penerusan.

    gcloud compute forwarding-rules delete $FORWARDING_RULE --global

  2. Hapus alamat IPV4.

    gcloud compute addresses delete $IP4_NAME --global

  3. Hapus load balancer.

    gcloud compute target-http-proxies delete $LB_NAME

  4. Hapus URL penerusan.

    gcloud compute url-maps delete $WEB_MAP_NAME

  5. Hapus layanan backend.

    gcloud compute backend-services delete $WEB_BACKED_SERVICE_NAME --global

  6. Hapus health check.

    gcloud compute health-checks delete $HEALTH_CHECK_NAME

  7. Hapus grup instance terkelola.

    gcloud compute instance-groups managed delete $INSTANCE_GROUP_NAME --region us-central1

  8. Hapus template instance.

    gcloud beta compute --project=$PROJECT_NAME instance-templates delete $INSTANCE_TEMPLATE_NAME

  9. Hapus aturan firewall.

    gcloud compute firewall-rules delete www-firewall-80
     
    gcloud compute firewall-rules delete www-firewall-8888