Platform For AI:Optimalkan model TensorFlow

Prosedur

Topik ini menunjukkan cara mengoptimalkan model TensorFlow menggunakan model ResNet50 publik. Sesuaikan langkah-langkah berikut untuk model TensorFlow Anda sendiri.

1. Impor PAI-Blade dan dependensinya.

   import os
   import numpy as np
   import tensorflow.compat.v1 as tf
   import blade

2. Tulis fungsi untuk mengunduh model dan data uji.

   PAI-Blade mendukung optimasi tanpa data uji (zero-input optimization), tetapi hasilnya lebih akurat dengan data input nyata. Sediakan data uji bila memungkinkan. Kode contoh berikut mengunduh model dan data uji.

   def _wget_demo_tgz():
       # Unduh model ResNet50 publik.
       url = 'http://pai-blade.oss-cn-zhangjiakou.aliyuncs.com/demo/mask_rcnn_resnet50_atrous_coco_2018_01_28.tar.gz'
       local_tgz = os.path.basename(url)
       local_dir = local_tgz.split('.')[0]
       if not os.path.exists(local_dir):
           blade.util.wget_url(url, local_tgz)
           blade.util.unpack(local_tgz)
       model_path = os.path.abspath(os.path.join(local_dir, "frozen_inference_graph.pb"))
       graph_def = tf.GraphDef()
       with open(model_path, 'rb') as f:
           graph_def.ParseFromString(f.read())
       # Gunakan bilangan acak sebagai data uji.
       test_data = np.random.rand(1, 800,1000, 3)
       return graph_def, {'image_tensor:0': test_data}
   
   graph_def, test_data = _wget_demo_tgz()

3. Panggil blade.optimize untuk mengoptimalkan model. Untuk detail parameter, lihat Referensi API Python.

   input_nodes=['image_tensor']
   output_nodes = ['detection_boxes', 'detection_scores', 'detection_classes', 'num_detections', 'detection_masks']
   
   optimized_model, opt_spec, report = blade.optimize(
       graph_def,                 # Model yang akan dioptimalkan. Dalam contoh ini, objek tf.GraphDef. Bisa juga berupa path SavedModel.
       'o1',                      # Tingkat optimasi. Nilai yang valid: o1 dan o2.
       device_type='gpu',         # Perangkat target. Nilai yang valid: gpu, cpu, dan edge.
       inputs=input_nodes,        # Node input. Opsional. PAI-Blade secara otomatis melakukan inferensi jika tidak ditentukan.
       outputs=output_nodes,      # Node output.
       test_data=[test_data]      # Data uji.
   )

   blade.optimize mengembalikan tiga objek:

   • optimized_model: Model yang telah dioptimalkan. Dalam contoh ini berupa objek tf.GraphDef.

   • opt_spec: Informasi konfigurasi, variabel lingkungan, dan file resource yang diperlukan untuk mereproduksi hasil optimasi. Terapkan menggunakan pernyataan with.

   • report: Laporan optimasi. Cetak langsung untuk melihatnya. Untuk detail parameter, lihat Laporan optimasi.

   Informasi progres selama optimasi:

   [Progress] 5%, phase: user_test_data_validation.
   [Progress] 10%, phase: test_data_deduction.
   [Progress] 15%, phase: CombinedSwitch_1.
   [Progress] 24%, phase: TfStripUnusedNodes_22.
   [Progress] 33%, phase: TfStripDebugOps_23.
   [Progress] 42%, phase: TfFoldConstants_24.
   [Progress] 51%, phase: CombinedSequence_7.
   [Progress] 59%, phase: TfCudnnrnnBilstm_25.
   [Progress] 68%, phase: TfFoldBatchNorms_26.
   [Progress] 77%, phase: TfNonMaxSuppressionOpt_27.
   [Progress] 86%, phase: CombinedSwitch_20.
   [Progress] 95%, phase: model_collecting.
   [Progress] 100%, Finished!

4. Cetak laporan optimasi.

   print("Report: {}".format(report))

   Laporan tersebut menunjukkan item optimasi mana yang paling berkontribusi terhadap peningkatan performa.

   Report: {
     // ......
     "optimizations": [
       // ......
       {
         "name": "TfNonMaxSuppressionOpt",
         "status": "effective",
         "speedup": "1.58",        // Rasio akselerasi.
         "pre_run": "522.74 ms",   // Latensi sebelum optimasi.
         "post_run": "331.45 ms"   // Latensi setelah optimasi.
       },
       {
         "name": "TfAutoMixedPrecisionGpu",
         "status": "effective",
         "speedup": "2.43",
         "pre_run": "333.30 ms",
         "post_run": "136.97 ms"
       }
       // ......
     ],
     // Hasil optimasi end-to-end.
     "overall": {
       "baseline": "505.91 ms",    // Latensi model asli.
       "optimized": "136.83 ms",   // Latensi model yang dioptimalkan.
       "speedup": "3.70"           // Rasio akselerasi.
     },
     // ......
   }

5. Bandingkan performa sebelum dan sesudah optimasi.

   import time
   
   def benchmark(model):
       tf.reset_default_graph()
       with tf.Session() as sess:
           sess.graph.as_default()
           tf.import_graph_def(model, name="")
           # Warmup!
           for i in range(0, 1000):
               sess.run(['image_tensor:0'], test_data)
           # Benchmark!
           num_runs = 1000
           start = time.time()
           for i in range(0, num_runs):
               sess.run(['image_tensor:0'], test_data)
           elapsed = time.time() - start
           rt_ms = elapsed / num_runs * 1000.0
           # Tampilkan hasilnya!
           print("Latensi model: {:.2f} ms.".format(rt_ms))
   
   # Uji kecepatan model asli.
   benchmark(graph_def)
   
   # Uji kecepatan model yang dioptimalkan.
   with opt_spec:
       benchmark(optimized_model)

   Hasil pengujian performa sesuai dengan nilai dalam laporan optimasi.

   Latensi model: 530.26 ms.
   Latensi model: 148.40 ms.

Ekstensi

Langkah selanjutnya

Setelah mengoptimalkan model, eksekusi langsung dalam Python atau deploy sebagai layanan EAS. PAI-Blade juga menyediakan SDK C++ untuk mengintegrasikan model yang telah dioptimalkan ke dalam aplikasi. Untuk informasi selengkapnya, lihat Gunakan SDK untuk deploy model TensorFlow untuk inferensi.