Delegasi TensorFlow Lite

Delegasi mengaktifkan akselerasi hardware model TensorFlow Lite dengan memanfaatkan akselerator di perangkat seperti GPU dan Digital Signal Processor (DSP).

Secara default, TensorFlow Lite menggunakan kernel CPU yang dioptimalkan untuk kumpulan petunjuk ARM Neon. Namun, CPU adalah prosesor multiguna yang tidak perlu dioptimalkan untuk aritmetika berat yang biasanya ditemukan dalam model Machine Learning (misalnya, matematika matriks yang terlibat dalam lapisan konvolusi dan padat).

Di sisi lain, sebagian besar ponsel modern berisi chip yang lebih baik dalam menangani operasi berat ini. Menggunakannya untuk operasi jaringan neural memberikan manfaat besar dalam hal latensi dan efisiensi daya. Misalnya, GPU dapat memberikan latensi hingga 5x percepatan, sedangkan Qualcomm® Hexagon DSP telah menunjukkan mengurangi konsumsi daya hingga 75% dalam eksperimen kami.

Setiap akselerator ini memiliki API terkait yang memungkinkan komputasi kustom, seperti OpenCL atau OpenGL ES untuk GPU seluler. Biasanya, Anda harus menulis banyak kode kustom untuk menjalankan jaringan neural melalui antarmuka ini. Permasalahan akan menjadi lebih rumit ketika Anda mempertimbangkan bahwa setiap akselerator memiliki kelebihan & kekurangannya masing-masing, dan tidak dapat mengeksekusi setiap operasi dalam jaringan neural. Delegate API TensorFlow Lite mengatasi masalah ini dengan bertindak sebagai jembatan antara runtime TFLite dan API level lebih rendah ini.

runtime dengan delegasi

Memilih Delegasi

TensorFlow Lite mendukung beberapa delegasi, yang masing-masing dioptimalkan untuk platform tertentu dan jenis model tertentu. Biasanya, akan ada beberapa delegasi yang berlaku untuk kasus penggunaan Anda, bergantung pada dua kriteria utama: Platform (Android atau iOS?) yang Anda targetkan, dan Model-type (floating-point atau terkuantisasi?) yang ingin Anda percepat.

Delegasikan menurut Platform

Lintas platform (Android & iOS)

  • Delegasi GPU - Delegasi GPU dapat digunakan di Android dan iOS. Library ini dioptimalkan untuk menjalankan model berbasis float 32-bit dan 16-bit tempat GPU tersedia. Solusi ini juga mendukung model terkuantisasi 8 bit dan memberikan performa GPU yang setara dengan versi floatnya. Untuk detail tentang delegasi GPU, lihat TensorFlow Lite di GPU.

iOS

  • Delegasi ML inti untuk iPhone dan iPad yang lebih baru - Untuk iPhone dan iPad baru yang menyediakan Neural Engine, Anda dapat menggunakan delegasi Core ML guna mempercepat inferensi untuk model floating point 32 bit atau 16 bit. Neural Engine tersedia di perangkat seluler Apple dengan SoC A12 atau yang lebih tinggi. Untuk melihat ringkasan delegasi Core ML dan petunjuk langkah demi langkah, lihat delegasi TensorFlow Lite Core ML.

Mendelegasikan menurut jenis model

Setiap akselerator dirancang dengan mempertimbangkan lebar bit data tertentu. Jika Anda menyediakan model floating point ke delegasi yang hanya mendukung operasi terkuantisasi 8 bit, model tersebut akan menolak semua operasinya dan model akan berjalan sepenuhnya di CPU. Untuk menghindari kejutan tersebut, tabel di bawah memberikan ringkasan delegasi dukungan berdasarkan jenis model:

Jenis Model GPU NNAPI Segi Enam CoreML
Floating point (32 bit) Ya Ya Tidak Ya
Kuantisasi float16 pasca pelatihan Ya Tidak Tidak Ya
Kuantisasi rentang dinamis pascapelatihan Ya Ya Tidak Tidak
Kuantisasi bilangan bulat setelah pelatihan Ya Ya Ya Tidak
Pelatihan berbasis kuantisasi Ya Ya Ya Tidak

Memvalidasi performa

Informasi di bagian ini berfungsi sebagai panduan kasar untuk memilih delegasi yang dapat meningkatkan kualitas aplikasi Anda. Namun, penting untuk diperhatikan bahwa setiap delegasi memiliki sekumpulan operasi standar yang didukungnya, dan dapat berfungsi secara berbeda bergantung pada model dan perangkatnya. Oleh karena itu, sebaiknya Anda melakukan beberapa benchmark untuk mengukur seberapa berguna delegasi untuk kebutuhan Anda. Hal ini juga membantu mendukung peningkatan ukuran biner yang terkait dengan penyertaan delegasi ke runtime TensorFlow Lite.

TensorFlow Lite memiliki alat evaluasi performa dan akurasi yang ekstensif, yang dapat mendorong developer agar percaya diri dalam menggunakan delegasi dalam aplikasi mereka. Alat-alat ini dibahas di bagian berikutnya.

Alat untuk Evaluasi

Latensi & jejak memori

Alat tolok ukur TensorFlow Lite dapat digunakan dengan parameter yang sesuai untuk memperkirakan performa model, termasuk latensi inferensi rata-rata, overhead inisialisasi, jejak memori, dll. Alat ini mendukung beberapa flag untuk mengetahui konfigurasi delegasi terbaik untuk model Anda. Misalnya, --gpu_backend=gl dapat ditentukan dengan --use_gpu untuk mengukur eksekusi GPU dengan OpenGL. Daftar lengkap parameter delegasi yang didukung ditentukan dalam dokumentasi mendetail.

Berikut adalah contoh yang dijalankan untuk model terkuantisasi dengan GPU melalui adb:

adb shell /data/local/tmp/benchmark_model \
  --graph=/data/local/tmp/mobilenet_v1_224_quant.tflite \
  --use_gpu=true

Anda dapat mendownload alat versi siap pakai ini untuk Android, arsitektur ARM 64-bit di sini (detail selengkapnya).

Akurasi & ketepatan

Delegasi biasanya melakukan komputasi dengan presisi yang berbeda dari partner CPU-nya. Akibatnya, ada kompromi akurasi (biasanya kecil) yang terkait dengan penggunaan delegasi untuk akselerasi hardware. Perlu diperhatikan bahwa hal ini tidak selalu benar; misalnya, karena GPU menggunakan presisi floating point untuk menjalankan model terkuantisasi, mungkin ada sedikit peningkatan presisi (misalnya, <1% peningkatan 5 teratas dalam klasifikasi gambar ILSVRC).

TensorFlow Lite memiliki dua jenis alat untuk mengukur seberapa akurat delegasi berperilaku untuk model tertentu: Berbasis Tugas dan Task-Agnostic. Semua alat yang dijelaskan di bagian ini mendukung parameter delegasi lanjutan yang digunakan oleh alat benchmark dari bagian sebelumnya. Perlu diperhatikan bahwa sub-bagian di bawah ini berfokus pada evaluasi delegasi (Apakah delegasi melakukan hal yang sama seperti CPU?), bukan evaluasi model (Apakah model itu sendiri bagus untuk tugas tersebut?).

Evaluasi Berbasis Tugas

TensorFlow Lite memiliki alat untuk mengevaluasi ketepatan pada dua tugas berbasis gambar:

Biner bawaan dari alat ini (Android, arsitektur ARM 64-bit), beserta dokumentasi dapat ditemukan di sini:

Contoh di bawah menunjukkan evaluasi klasifikasi gambar dengan NNAPI yang menggunakan Edge-TPU Google di Pixel 4:

adb shell /data/local/tmp/run_eval \
  --model_file=/data/local/tmp/mobilenet_quant_v1_224.tflite \
  --ground_truth_images_path=/data/local/tmp/ilsvrc_images \
  --ground_truth_labels=/data/local/tmp/ilsvrc_validation_labels.txt \
  --model_output_labels=/data/local/tmp/model_output_labels.txt \
  --output_file_path=/data/local/tmp/accuracy_output.txt \
  --num_images=0 # Run on all images. \
  --use_nnapi=true \
  --nnapi_accelerator_name=google-edgetpu

Output yang diharapkan adalah daftar metrik Top-K dari 1 hingga 10:

Top-1 Accuracy: 0.733333
Top-2 Accuracy: 0.826667
Top-3 Accuracy: 0.856667
Top-4 Accuracy: 0.87
Top-5 Accuracy: 0.89
Top-6 Accuracy: 0.903333
Top-7 Accuracy: 0.906667
Top-8 Accuracy: 0.913333
Top-9 Accuracy: 0.92
Top-10 Accuracy: 0.923333

Evaluasi Agnostik Tugas

Untuk tugas yang tidak memiliki alat evaluasi di perangkat yang ditetapkan, atau jika Anda bereksperimen dengan model kustom, TensorFlow Lite memiliki alat Inference Diff. (Android, biner arsitektur biner ARM 64-bit di sini)

Inference Diff membandingkan eksekusi TensorFlow Lite (dalam hal latensi & deviasi nilai output) dalam dua setelan:

  • Inferensi CPU thread tunggal
  • Inferensi yang ditentukan pengguna - ditentukan oleh parameter ini

Untuk melakukannya, alat ini menghasilkan data Gaussian acak dan meneruskannya melalui dua Penafsir TFLite, satu menjalankan kernel CPU thread tunggal, dan satu lagi diparameterisasi oleh argumen pengguna.

Interpreter mengukur latensi keduanya, serta perbedaan absolut antara tensor output dari setiap Interpreter, per elemen.

Untuk model dengan tensor output tunggal, output-nya mungkin terlihat seperti ini:

Num evaluation runs: 50
Reference run latency: avg=84364.2(us), std_dev=12525(us)
Test run latency: avg=7281.64(us), std_dev=2089(us)
OutputDiff[0]: avg_error=1.96277e-05, std_dev=6.95767e-06

Artinya, untuk tensor output di indeks 0, elemen dari output CPU berbeda dengan output delegasi dengan rata-rata 1.96e-05.

Perhatikan bahwa menafsirkan angka-angka ini memerlukan pengetahuan yang lebih mendalam tentang model, dan apa yang ditunjukkan oleh setiap tensor output. Jika berupa regresi sederhana yang menentukan semacam skor atau embedding, perbedaannya harus rendah (jika tidak, error pada delegasi). Namun, output seperti 'class deteksi' dari model SSD sedikit lebih sulit untuk ditafsirkan. Misalnya, tampilan mungkin menunjukkan perbedaan dengan menggunakan alat ini, tetapi itu mungkin tidak berarti ada yang salah dengan delegasi: pertimbangkan dua class (palsu): "TV (ID: 10)", "Monitor (ID:20)" - Jika delegasi sedikit keluar dari kebenaran emas dan menampilkan monitor, bukan TV, perbedaan output untuk tensor ini mungkin setinggi 20-10 = 10.