Delegasi LiteRT

Delegasi memungkinkan akselerasi hardware model LiteRT dengan memanfaatkan akselerator di perangkat seperti GPU dan Digital Signal Processor (DSP).

Secara default, LiteRT menggunakan kernel CPU yang dioptimalkan untuk set instruksi ARM Neon. Namun, CPU adalah prosesor serbaguna yang tidak selalu dioptimalkan untuk aritmatika berat yang biasanya ditemukan dalam model Machine Learning (misalnya, matematika matriks yang terlibat dalam konvolusi dan lapisan padat).

Di sisi lain, sebagian besar ponsel modern berisi chip yang lebih baik dalam menangani operasi berat ini. Memanfaatkannya untuk operasi jaringan neural memberikan manfaat besar dalam hal latensi dan efisiensi daya. Misalnya, GPU dapat memberikan peningkatan kecepatan hingga 5x dalam latensi.

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. Situasinya menjadi lebih rumit jika Anda mempertimbangkan bahwa setiap akselerator memiliki kelebihan dan kekurangan serta tidak dapat menjalankan setiap operasi dalam jaringan saraf. Delegate API TensorFlow Lite memecahkan masalah ini dengan bertindak sebagai jembatan antara runtime TFLite dan API tingkat bawah ini.

runtime dengan delegasi

Memilih Delegasi

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

Delegasi 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 jika GPU tersedia. Selain itu, library ini mendukung model terkuantisasi 8-bit dan memberikan performa GPU yang setara dengan versi float-nya. Untuk mengetahui detail tentang delegasi GPU, lihat LiteRT di GPU.

iOS

  • Delegasi Core ML untuk iPhone dan iPad yang lebih baru - Untuk iPhone dan iPad yang lebih baru dengan Neural Engine, Anda dapat menggunakan delegasi Core ML untuk 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 mengetahui ringkasan delegasi Core ML dan petunjuk langkah demi langkah, lihat Delegasi Core ML LiteRT.

Delegasi menurut jenis model

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

Jenis Model GPU CoreML
Floating-point (32 bit) Ya Ya
Kuantisasi float16 pasca-pelatihan Ya Ya
Kuantisasi rentang dinamis setelah pelatihan Ya Tidak
Kuantisasi bilangan bulat pasca-pelatihan Ya Tidak
Pelatihan yang kompatibel dengan kuantisasi Ya Tidak

Memvalidasi performa

Informasi di bagian ini berfungsi sebagai panduan kasar untuk menyeleksi delegasi yang dapat meningkatkan kualitas aplikasi Anda. Namun, penting untuk diperhatikan bahwa setiap delegasi memiliki serangkaian operasi yang telah ditentukan sebelumnya yang didukungnya, dan mungkin berperforma berbeda bergantung pada model dan perangkat. Oleh karena itu, biasanya direkomendasikan agar Anda melakukan beberapa benchmark untuk mengukur seberapa berguna delegasi untuk kebutuhan Anda. Hal ini juga membantu membenarkan peningkatan ukuran biner yang terkait dengan melampirkan delegasi ke runtime LiteRT.

LiteRT memiliki alat evaluasi performa dan akurasi yang ekstensif yang dapat memungkinkan developer merasa yakin dalam menggunakan delegasi di aplikasi mereka. Alat ini akan dibahas di bagian berikutnya.

Alat untuk Evaluasi

Latensi & jejak memori

Alat tolok ukur LiteRT dapat digunakan dengan parameter yang sesuai untuk memperkirakan performa model, termasuk latensi inferensi rata-rata, overhead inisialisasi, footprint memori, dll. Alat ini mendukung beberapa tanda 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 contoh eksekusi 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 versi alat ini yang telah dibuat sebelumnya untuk Android, arsitektur ARM 64-bit di sini (detail selengkapnya).

Akurasi & kebenaran

Delegasi biasanya melakukan komputasi dengan presisi yang berbeda dari rekan CPU-nya. Akibatnya, ada kompromi akurasi (biasanya kecil) yang terkait dengan penggunaan delegasi untuk akselerasi hardware. Perhatikan 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).

LiteRT memiliki dua jenis alat untuk mengukur seberapa akurat perilaku delegasi untuk model tertentu: Berbasis Tugas dan Agnostik Tugas. Semua alat yang dijelaskan di bagian ini mendukung parameter delegasi lanjutan yang digunakan oleh alat tolok ukur dari bagian sebelumnya. Perhatikan bahwa subbagian di bawah berfokus pada evaluasi delegasi (Apakah delegasi berperforma sama dengan CPU?) daripada evaluasi model (Apakah model itu sendiri bagus untuk tugas tersebut?).

Evaluasi Berbasis Tugas

LiteRT memiliki alat untuk mengevaluasi kebenaran pada dua tugas berbasis gambar:

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

Contoh di bawah menunjukkan evaluasi klasifikasi gambar dengan GPU 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_gpu=true

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 sudah mapan, atau jika Anda bereksperimen dengan model kustom, LiteRT memiliki alat Perbedaan Inferensi. (Android, biner arsitektur ARM 64-bit di sini)

Perbedaan Inferensi membandingkan eksekusi LiteRT (dalam hal latensi & penyimpangan 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 Interpreter TFLite - satu menjalankan kernel CPU berutas tunggal, dan yang lainnya diparameterkan oleh argumen pengguna.

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

Untuk model dengan satu tensor output, outputnya 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 pada indeks 0, elemen dari output CPU berbeda dari output delegasi dengan rata-rata 1.96e-05.

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