Kuantisasi pasca pelatihan

Kuantisasi pasca pelatihan adalah teknik konversi yang dapat mengurangi ukuran model sekaligus meningkatkan CPU dan latensi akselerator perangkat keras, dengan sedikit penurunan akurasi model. Anda dapat mengukur model TensorFlow float yang sudah terlatih saat mengonversinya menjadi format TensorFlow Lite menggunakan TensorFlow Lite Converter .

Metode Optimasi

Ada beberapa opsi kuantisasi pasca pelatihan yang dapat dipilih. Berikut adalah tabel ringkasan pilihan dan manfaat yang diberikannya:

Teknik Manfaat Perangkat keras
Kuantisasi rentang dinamis 4x lebih kecil, pemercepat 2x-3x CPU
Kuantisasi bilangan bulat penuh 4x lebih kecil, 3x + speedup CPU, Edge TPU, Mikrokontroler
Kuantisasi Float16 2x lebih kecil, akselerasi GPU CPU, GPU

Pohon keputusan berikut dapat membantu menentukan metode kuantisasi pasca-pelatihan mana yang terbaik untuk kasus penggunaan Anda:

opsi pengoptimalan pasca pelatihan

Kuantisasi rentang dinamis

Bentuk paling sederhana dari kuantisasi pasca-pelatihan secara statis hanya mengkuantisasi bobot dari floating point ke integer, yang memiliki presisi 8-bit:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant_model = converter.convert()

Pada inferensi, bobot diubah dari presisi 8-bit menjadi floating point dan dihitung menggunakan kernel floating-point. Konversi ini dilakukan sekali dan disimpan dalam cache untuk mengurangi latensi.

Untuk lebih meningkatkan latensi, operator "rentang dinamis" secara dinamis menghitung aktivasi berdasarkan rentangnya ke 8-bit dan melakukan komputasi dengan bobot dan aktivasi 8-bit. Pengoptimalan ini memberikan latensi yang mendekati inferensi titik tetap sepenuhnya. Namun, keluarannya masih disimpan menggunakan floating point sehingga percepatan dengan operasi rentang dinamis kurang dari komputasi titik tetap penuh.

Kuantisasi bilangan bulat penuh

Anda bisa mendapatkan peningkatan latensi lebih lanjut, pengurangan penggunaan memori puncak, dan kompatibilitas dengan perangkat keras atau akselerator hanya bilangan bulat dengan memastikan semua matematika model dihitung dengan bilangan bulat.

Untuk penghitungan bilangan bulat penuh, Anda perlu mengkalibrasi atau memperkirakan kisaran, yaitu (min, maks) dari semua tensor floating-point dalam model. Tidak seperti tensor konstan seperti bobot dan bias, tensor variabel seperti input model, aktivasi (keluaran lapisan perantara), dan keluaran model tidak dapat dikalibrasi kecuali kita menjalankan beberapa siklus inferensi. Akibatnya, konverter memerlukan kumpulan data representatif untuk mengkalibrasinya. Dataset ini dapat berupa subset kecil (sekitar ~ 100-500 sampel) dari data pelatihan atau validasi. Lihat fungsi representative_dataset() bawah ini.

def representative_dataset():
  for data in tf.data.Dataset.from_tensor_slices((images)).batch(1).take(100):
    yield [tf.dtypes.cast(data, tf.float32)]

Untuk tujuan pengujian, Anda dapat menggunakan kumpulan data dummy sebagai berikut:

def representative_dataset():
    for _ in range(100):
      data = np.random.rand(1, 244, 244, 3)
      yield [data.astype(np.float32)]
 

Integer dengan float fallback (menggunakan input / output float default)

Untuk sepenuhnya mengkuantisasi integer model, tetapi gunakan operator float ketika mereka tidak memiliki implementasi integer (untuk memastikan konversi terjadi dengan lancar), gunakan langkah-langkah berikut:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
tflite_quant_model = converter.convert()

Integer saja

Membuat model khusus integer adalah kasus penggunaan umum TensorFlow Lite untuk Microcontrollers dan Coral Edge TPU .

Selain itu, untuk memastikan kompatibilitas dengan perangkat khusus integer (seperti mikrokontroler 8-bit) dan akselerator (seperti Coral Edge TPU), Anda dapat menerapkan kuantisasi integer penuh untuk semua operasi termasuk input dan output, dengan menggunakan langkah-langkah berikut:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8  # or tf.uint8
converter.inference_output_type = tf.int8  # or tf.uint8
tflite_quant_model = converter.convert()

Kuantisasi Float16

Anda dapat mengurangi ukuran model floating point dengan mengukur bobot menjadi float16, standar IEEE untuk bilangan floating point 16-bit. Untuk mengaktifkan kuantisasi bobot float16, gunakan langkah-langkah berikut:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]
tflite_quant_model = converter.convert()

Keuntungan dari kuantisasi float16 adalah sebagai berikut:

  • Ini mengurangi ukuran model hingga setengah (karena semua bobot menjadi setengah dari ukuran aslinya).
  • Ini menyebabkan kerugian minimal dalam akurasi.
  • Ini mendukung beberapa delegasi (misalnya delegasi GPU) yang dapat beroperasi secara langsung pada data float16, menghasilkan eksekusi yang lebih cepat daripada komputasi float32.

Kerugian dari kuantisasi float16 adalah sebagai berikut:

  • Itu tidak mengurangi latensi sebanyak kuantisasi ke matematika titik tetap.
  • Secara default, model terkuantisasi float16 akan "mengurangi" nilai bobot menjadi float32 saat dijalankan pada CPU. (Perhatikan bahwa delegasi GPU tidak akan melakukan dequantization ini, karena dapat beroperasi pada data float16.)

Hanya bilangan bulat: aktivasi 16-bit dengan bobot 8-bit (percobaan)

Ini adalah skema kuantisasi eksperimental. Ini mirip dengan skema "hanya bilangan bulat", tetapi aktivasi dikuantisasi berdasarkan rentangnya hingga 16-bit, bobot dikuantisasi dalam bilangan bulat 8-bit dan bias dikuantisasi menjadi bilangan bulat 64-bit. Ini selanjutnya disebut sebagai kuantisasi 16x8.

Keuntungan utama dari kuantisasi ini adalah dapat meningkatkan akurasi secara signifikan, tetapi hanya sedikit meningkatkan ukuran model.

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.representative_dataset = representative_dataset
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [tf.lite.OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8]
tflite_quant_model = converter.convert()

Jika kuantisasi 16x8 tidak didukung untuk beberapa operator dalam model, maka model tersebut masih dapat dikuantisasi, tetapi operator yang tidak didukung tetap mengambang. Opsi berikut harus ditambahkan ke target_spec untuk mengizinkannya.

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.representative_dataset = representative_dataset
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [tf.lite.OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8,
tf.lite.OpsSet.TFLITE_BUILTINS]
tflite_quant_model = converter.convert()

Contoh kasus penggunaan di mana peningkatan akurasi yang diberikan oleh skema kuantisasi ini meliputi: * resolusi super, * pemrosesan sinyal audio seperti peredaman derau dan pembentukan sinar, * penghilangan derau gambar, * rekonstruksi HDR dari satu gambar.

Kerugian dari kuantisasi ini adalah:

  • Saat ini inferensi terasa lebih lambat daripada integer penuh 8-bit karena kurangnya implementasi kernel yang dioptimalkan.
  • Saat ini tidak kompatibel dengan delegasi TFLite akselerasi perangkat keras yang ada.

Tutorial untuk mode kuantisasi ini dapat ditemukan di sini .

Akurasi model

Karena bobot dihitung setelah pelatihan, mungkin ada kehilangan akurasi, terutama untuk jaringan yang lebih kecil. Model terkuantisasi penuh yang dilatih sebelumnya disediakan untuk jaringan tertentu di repositori model TensorFlow Lite . Penting untuk memeriksa keakuratan model terkuantisasi untuk memverifikasi bahwa setiap penurunan akurasi berada dalam batas yang dapat diterima. Ada beberapa fitur untuk mengevaluasi akurasi model TensorFlow Lite .

Alternatifnya, jika penurunan akurasi terlalu tinggi, pertimbangkan untuk menggunakan pelatihan sadar kuantisasi . Namun, hal tersebut memerlukan modifikasi selama pelatihan model untuk menambahkan node kuantisasi palsu, sedangkan teknik kuantisasi pasca pelatihan di halaman ini menggunakan model terlatih yang sudah ada.

Representasi untuk tensor terkuantisasi

Kuantisasi 8-bit mendekati nilai floating point menggunakan rumus berikut.

$$real\_value = (int8\_value - zero\_point) \times scale$$

Representasi memiliki dua bagian utama:

  • Bobot per sumbu (alias per saluran) atau per tensor diwakili oleh nilai komplemen int8 dua dalam rentang [-127, 127] dengan titik nol sama dengan 0.

  • Aktivasi / input per-tensor diwakili oleh nilai komplemen int8 dua dalam rentang [-128, 127], dengan titik nol dalam rentang [-128, 127].

Untuk tampilan rinci skema kuantisasi kami, silakan lihat spesifikasi kuantisasi kami. Vendor hardware yang ingin terhubung ke antarmuka delegasi TensorFlow Lite didorong untuk mengimplementasikan skema kuantisasi yang dijelaskan di sana.