Platform For AI:,

Batasan

Prosedur

Langkah 1: Persiapan

1. Jalankan perintah berikut untuk menginstal library tokenizers.

   pip3 install tokenizers

2. Unduh model dan ekstrak ke direktori tertentu.

   wget http://pai-blade.oss-cn-zhangjiakou.aliyuncs.com/tutorials/bert_example/nlu_general_news_classification_base.tar.gz
   mkdir nlu_general_news_classification_base
   tar zxvf nlu_general_news_classification_base.tar.gz -C nlu_general_news_classification_base

3. Gunakan perintah saved_model_cli yang disediakan oleh TensorFlow untuk melihat informasi dasar model.

   saved_model_cli show --dir nlu_general_news_classification_base --all

   Output berikut dikembalikan.

   MetaGraphDef with tag-set: 'serve' contains the following SignatureDefs:
   
   signature_def['serving_default']:
     The given SavedModel SignatureDef contains the following input(s):
       inputs['input_ids'] tensor_info:
           dtype: DT_INT32
           shape: (-1, -1)
           name: input_ids:0
       inputs['input_mask'] tensor_info:
           dtype: DT_INT32
           shape: (-1, -1)
           name: input_mask:0
       inputs['segment_ids'] tensor_info:
           dtype: DT_INT32
           shape: (-1, -1)
           name: segment_ids:0
     The given SavedModel SignatureDef contains the following output(s):
       outputs['logits'] tensor_info:
           dtype: DT_FLOAT
           shape: (-1, 28)
           name: app/ez_dense/BiasAdd:0
       outputs['predictions'] tensor_info:
           dtype: DT_INT32
           shape: (-1)
           name: ArgMax:0
       outputs['probabilities'] tensor_info:
           dtype: DT_FLOAT
           shape: (-1, 28)
           name: Softmax:0
     Method name is: tensorflow/serving/predict

   Output tersebut menunjukkan bahwa model klasifikasi teks berita memiliki tiga tensor input: input_ids:0, input_mask:0, dan segment_ids:0. Model ini juga memiliki tiga tensor output: logits, predictions, dan probabilities. ArgMax:0 di bawah predictions merepresentasikan kategori klasifikasi akhir, yang merupakan hasil inferensi utama.

4. Panggil tokenizers untuk menyiapkan data uji.

   from tokenizers import BertWordPieceTokenizer
   
   # Inisialisasi tokenizer dari file vocab.txt di direktori model.
   tokenizer = BertWordPieceTokenizer('./nlu_general_news_classification_base/vocab.txt')
   
   # Kelompokkan empat artikel berita menjadi satu batch untuk encoding.
   news = [
       'Mexico declares a health emergency with over 1,000 confirmed cases. Chinanews.com, March 31 - According to comprehensive reports, Mexico\'s COVID-19 cases have surpassed 1,000. On March 30, the Mexican government declared a health emergency and strengthened measures to curb the spread of the pandemic.',
       'Data from the National Bureau of Statistics shows that in August, China\'s Manufacturing Purchasing Managers\' Index (PMI) was 50.1%, remaining above the threshold but 0.3 percentage points lower than the previous month.',
       'UTC+8, August 31 - In the final round of the men\'s blind football group stage at the just-concluded Tokyo Paralympics, the Chinese team defeated host Japan 2-0 with a brace from Zhu Ruiming, advancing to the semifinals with a record of two wins and one loss.',
       'As of August 30, the "Zhurong" Mars rover has been on the surface of Mars for 100 days. In these 100 days, "Zhurong" has traveled a cumulative 1064 meters south of its landing site, carrying 6 scientific payloads and acquiring about 10 GB of raw scientific data.',
   ]
   tokenized = tokenizer.encode_batch(news)
   
   # Pad panjang sekuens menjadi 128.
   def pad(seq, seq_len, padding_val):
       return seq + [padding_val] * (seq_len - len(seq))
   
   input_ids = [pad(tok.ids, 128, 0) for tok in tokenized]
   segment_ids = [pad(tok.type_ids, 128, 0) for tok in tokenized]
   input_mask = [ pad([1] * len(tok.ids), 128, 0) for tok in tokenized ]
   
   # Data uji akhir dalam format FeedDict TensorFlow.
   test_data = {
       "input_ids:0": input_ids,
       "segment_ids:0": segment_ids,
       "input_mask:0": input_mask,
   }

5. Muat model dan gunakan data uji untuk melakukan inferensi.

   import tensorflow.compat.v1 as tf
   import json
   
   # Muat file pemetaan label untuk mendapatkan nama kategori yang sesuai dengan integer output.
   with open('./nlu_general_news_classification_base/label_mapping.json') as f:
       MAPPING = {v: k for k, v in json.load(f).items()}
   
   # Muat dan jalankan model.
   cfg = tf.ConfigProto()
   cfg.gpu_options.allow_growth = True
   with tf.Session(config=cfg) as sess:
       tf.saved_model.loader.load(sess, ['serve'], './nlu_general_news_classification_base')
       result = sess.run('ArgMax:0', test_data)
       print([MAPPING[r] for r in result])

   Hasil inferensi berikut dikembalikan seperti yang diharapkan.

   ['International', 'Finance', 'Sports', 'Science']

Langkah 2: Panggil Blade untuk mengoptimalkan model

1. Panggil antarmuka blade.optimize untuk mengoptimalkan model, seperti pada contoh berikut. Untuk informasi selengkapnya tentang antarmuka ini, lihat dokumentasi antarmuka Python.

   import blade
   
   saved_model_dir = 'nlu_general_news_classification_base'
   optimized_model, _, report = blade.optimize(
       saved_model_dir,       # Path model.
       'o1',                  # Optimasi lossless O1.
       device_type='gpu',     # Optimalkan untuk perangkat GPU.
       test_data=[test_data]  # Data uji.
   )

   Saat mengoptimalkan model, pertimbangkan hal berikut:

   • Nilai kembali pertama dari blade.optimize adalah model yang telah dioptimalkan. Tipe datanya sama dengan model input. Dalam contoh ini, input berupa path ke SavedModel, dan nilai kembalinya adalah path ke SavedModel yang telah dioptimalkan.

   • Jangan memberikan parameter inputs dan outputs. Blade secara otomatis menginferensi node input dan output.

2. Setelah optimasi selesai, cetak laporan optimasi.

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

   Laporan optimasi mirip dengan output berikut.

   Report: {
     "software_context": [
       {
         "software": "tensorflow",
         "version": "1.15.0"
       },
       {
         "software": "cuda",
         "version": "10.0.0"
       }
     ],
     "hardware_context": {
       "device_type": "gpu",
       "microarchitecture": "T4"
     },
     "user_config": "",
     "diagnosis": {
       "model": "nlu_general_news_classification_base",
       "test_data_source": "user provided",
       "shape_variation": "dynamic",
       "message": "",
       "test_data_info": "input_ids:0 shape: (4, 128) data type: int64\nsegment_ids:0 shape: (4, 128) data type: int64\ninput_mask:0 shape: (4, 128) data type: int64"
     },
     "optimizations": [
       {
         "name": "TfStripUnusedNodes",
         "status": "effective",
         "speedup": "na",
         "pre_run": "na",
         "post_run": "na"
       },
       {
         "name": "TfStripDebugOps",
         "status": "effective",
         "speedup": "na",
         "pre_run": "na",
         "post_run": "na"
       },
       {
         "name": "TfAutoMixedPrecisionGpu",
         "status": "effective",
         "speedup": "1.46",
         "pre_run": "35.04 ms",
         "post_run": "24.02 ms"
       },
       {
         "name": "TfAicompilerGpu",
         "status": "effective",
         "speedup": "2.43",
         "pre_run": "23.99 ms",
         "post_run": "9.87 ms"
       }
     ],
     "overall": {
       "baseline": "35.01 ms",
       "optimized": "9.90 ms",
       "speedup": "3.54"
     },
     "model_info": {
       "input_format": "saved_model"
     },
     "compatibility_list": [
       {
         "device_type": "gpu",
         "microarchitecture": "T4"
       }
     ],
     "model_sdk": {}
   }

   Laporan optimasi menunjukkan bahwa dalam contoh ini, optimasi TfAutoMixedPrecisionGpu dan TfAicompilerGpu diterapkan. Keduanya memberikan percepatan 3,54×, mengurangi waktu inferensi model dari 35 ms menjadi 9,9 ms. Hasil ini hanya berlaku untuk contoh ini. Efek optimasi aktual Anda mungkin berbeda. Untuk informasi selengkapnya tentang bidang dalam laporan optimasi, lihat Laporan optimasi.

3. Cetak path optimized_model.

   print("Optimized model: {}".format(optimized_model))

   Sistem mengembalikan output yang mirip dengan berikut.

   Optimized model: /root/nlu_general_news_classification_base_blade_opt_20210901141823/nlu_general_news_classification_base

   Output tersebut menunjukkan bahwa model yang telah dioptimalkan disimpan di path baru.

Langkah 3: Verifikasi kinerja dan kebenaran

Setelah optimasi, Anda dapat memverifikasi informasi dalam laporan optimasi menggunakan skrip Python.

1. Definisikan metode benchmark. Metode ini melakukan pemanasan model sebanyak 10 kali, menjalankannya 1.000 kali, lalu menghitung rata-rata waktu inferensi.

   import time
   
   def benchmark(model, test_data):
       tf.reset_default_graph()
       with tf.Session() as sess:
           sess.graph.as_default()
           tf.saved_model.loader.load(sess, ['serve'], model)
           # Pemanasan.
           for i in range(0, 10):
               result = sess.run('ArgMax:0', test_data)
           # Benchmark.
           num_runs = 1000
           start = time.time()
           for i in range(0, num_runs):
               result = sess.run('ArgMax:0', test_data)
           elapsed = time.time() - start
           rt_ms = elapsed / num_runs * 1000.0
           # Tampilkan hasil.
           print("Latency of model: {:.2f} ms.".format(rt_ms))
           print("Predict result: {}".format([MAPPING[r] for r in result]))

2. Panggil metode benchmark untuk memverifikasi model asli.

   benchmark('nlu_general_news_classification_base', test_data)

   Sistem mengembalikan output yang mirip dengan berikut.

   Latency of model: 36.20 ms.
   Predict result: ['International', 'Finance', 'Sports', 'Science']

   Hasil tersebut menunjukkan bahwa waktu inferensi 36,20 ms konsisten dengan "baseline": "35.01 ms" di bagian "overall" laporan optimasi. Hasil prediksi ['International', 'Finance', 'Sports', 'Science'] sesuai harapan. Waktu inferensi di sini hanya berlaku untuk studi kasus ini. Waktu inferensi aktual model Anda mungkin berbeda.

3. Panggil metode benchmark untuk memverifikasi model yang telah dioptimalkan.

   import os
   os.environ['TAO_COMPILATION_MODE_ASYNC'] = '0'
   
   benchmark(optimized_model, test_data)

   Laporan optimasi menunjukkan bahwa AICompiler digunakan untuk mengoptimalkan model. AICompiler melakukan kompilasi secara asinkron, artinya model asli masih digunakan untuk inferensi selama proses kompilasi. Untuk mendapatkan data uji yang akurat, atur variabel lingkungan TAO_COMPILATION_MODE_ASYNC=0 agar memaksa kompilasi sinkron sebelum memanggil benchmark.

   Sistem mengembalikan output yang mirip dengan berikut.

   Latency of model: 9.87 ms.
   Predict result: ['International', 'Finance', 'Sports', 'Science']

   Hasil tersebut menunjukkan bahwa waktu inferensi 9,87 ms konsisten dengan "optimized": "9.90 ms" di bagian "overall" laporan optimasi. Hasil prediksi ['International', 'Finance', 'Sports', 'Science'] sesuai harapan. Waktu inferensi di sini hanya berlaku untuk studi kasus ini. Waktu inferensi aktual model Anda mungkin berbeda.

Langkah 4: Muat dan jalankan model yang telah dioptimalkan

Setelah memverifikasi model, Anda dapat menerapkannya. Blade menyediakan SDK runtime untuk Python dan C++ guna integrasi. Untuk informasi tentang penggunaan SDK C++, lihat Gunakan SDK untuk menerapkan model TensorFlow untuk inferensi. Bagian ini menjelaskan cara menggunakan SDK Python untuk menerapkan model.

1. Opsional: Selama masa percobaan, tambahkan pengaturan variabel lingkungan berikut untuk mencegah program keluar secara tak terduga akibat kegagalan autentikasi:

   export BLADE_AUTH_USE_COUNTING=1

2. Lakukan autentikasi untuk menggunakan PAI-Blade.

   export BLADE_REGION=<region>
   export BLADE_TOKEN=<token>

   Konfigurasikan parameter berikut sesuai kebutuhan bisnis Anda:

   • <region>: wilayah tempat Anda menggunakan PAI-Blade. Anda dapat bergabung dengan grup DingTalk pengguna PAI-Blade untuk mendapatkan wilayah yang didukung PAI-Blade. Untuk informasi tentang kode QR grup DingTalk, lihat Instal PAI-Blade.

   • <token>: token autentikasi yang diperlukan untuk menggunakan PAI-Blade. Anda dapat bergabung dengan grup DingTalk pengguna PAI-Blade untuk mendapatkan token autentikasi. Untuk informasi tentang kode QR grup DingTalk, lihat Instal PAI-Blade.

3. Muat dan jalankan model yang telah dioptimalkan.

   Tambahkan baris import blade.runtime.tensorflow. Tidak diperlukan perubahan kode lain untuk mengintegrasikan Blade. Kode inferensi asli tidak perlu dimodifikasi.

   import tensorflow.compat.v1 as tf
   import blade.runtime.tensorflow
   # Ganti <your_optimized_model_path> dengan path model yang telah dioptimalkan.
   savedmodel_dir = <your_optimized_model_path>
   # Ganti <your_infer_data> dengan data untuk inferensi.
   infer_data = <your_infer_data>
   
   with tf.Session() as sess:
       sess.graph.as_default()
       tf.saved_model.loader.load(sess, ['serve'], savedmodel_dir)
       result = sess.run('ArgMax:0', infer_data)