Platform For AI：Mengoptimalkan Model TensorFlow

Mengoptimalkan Model TensorFlow

Contoh ini mengoptimalkan model TensorFlow ResNet50 terbuka. Anda juga dapat mengoptimalkan model TensorFlow Anda sendiri.

1. Impor PAI-Blade dan pustaka dependensi lainnya.

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

2. Tulis kode untuk metode yang digunakan untuk mengunduh model yang akan dioptimalkan dan data uji.

   PAI-Blade mendukung optimasi model tanpa input. Namun, untuk memastikan akurasi hasil optimasi, disarankan untuk mengoptimalkan model dengan input data uji. Contoh kode berikut memberikan ilustrasi:

   def _wget_demo_tgz():
       # Unduh model TensorFlow ResNet50 terbuka. 
       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 angka 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 metode blade.optimize untuk mengoptimalkan model ResNet50. Contoh kode berikut memberikan ilustrasi cara mengoptimalkan model:

   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 ditentukan. Anda juga dapat menyetel parameter ini ke jalur tempat model yang dioptimalkan disimpan. 
       'o1',                      # Tingkat optimasi. Nilai valid: o1 dan o2. 
       device_type='gpu',         # Jenis perangkat tempat model dijalankan. Nilai valid: gpu, cpu, dan edge. 
       inputs=input_nodes,        # Node input. Parameter ini opsional. Jika Anda tidak menentukan parameter ini, PAI-Blade secara otomatis menyimpulkan node input. 
       outputs=output_nodes,      # Node output. 
       test_data=[test_data]      # Data uji. 
   )

   Metode blade.optimize mengembalikan objek berikut:

   • optimized_model: model yang telah dioptimalkan. Dalam contoh ini, objek tf.GraphDef dikembalikan.

   • opt_spec: dependensi eksternal yang diperlukan untuk mereproduksi hasil optimasi. Dependensi eksternal mencakup informasi konfigurasi, variabel lingkungan, dan file sumber daya. Anda dapat mengeksekusi pernyataan WITH dalam Python untuk membuat dependensi eksternal tersebut berlaku.

   • report: laporan optimasi, yang dapat ditampilkan langsung. Untuk informasi lebih lanjut tentang parameter dalam laporan optimasi, lihat Laporan Optimasi.

   Selama proses optimasi, proses optimasi ditampilkan, seperti yang ditunjukkan dalam contoh berikut:

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

4. Tampilkan laporan optimasi.

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

   Dalam laporan optimasi, Anda dapat melihat item optimasi yang mencapai efek optimasi, seperti yang ditunjukkan dalam contoh berikut:

   Laporan: {
     // ......
     "optimizations": [
       // ......
       {
         "name": "TfNonMaxSuppressionOpt",
         "status": "effective",
         "speedup": "1.58",        // Rasio percepatan. 
         "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 percepatan. 
     },
     // ......
   }

5. Bandingkan kinerja model 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="")
           # Pemanasan!
           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 hasil!
           print("Latensi model: {:.2f} ms.".format(rt_ms))
   
   # Uji latensi model asli. 
   benchmark(graph_def)
   
   # Uji latensi model yang dioptimalkan. 
   with opt_spec:
       benchmark(optimized_model)

   Hasil pengujian dikembalikan, seperti yang ditunjukkan dalam contoh berikut. Hasil pengujian mencerminkan informasi dalam laporan optimasi.

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

Informasi Tambahan

Apa yang Harus Dilakukan Selanjutnya

Setelah model dioptimalkan menggunakan PAI-Blade, Anda dapat menjalankan model yang dioptimalkan di Python atau menerapkan model yang dioptimalkan sebagai layanan di Elastic Algorithm Service (EAS) dari PAI. PAI-Blade juga menyediakan SDK untuk C++ untuk membantu Anda mengintegrasikan model yang dioptimalkan ke dalam aplikasi Anda sendiri.