Delegasi LiteRT

Delegasi mengaktifkan akselerasi hardware model LiteRT dengan memanfaatkan akselerator di perangkat seperti GPU dan Prosesor Sinyal Digital (DSP).

Secara default, LiteRT menggunakan kernel CPU yang dioptimalkan untuk ARM Neon set petunjuk. Namun, CPU adalah prosesor multiguna yang tidak dioptimalkan untuk aritmatika berat yang biasa ditemukan di Machine Model pembelajaran (misalnya, matematika matriks yang terlibat dalam konvolusi dan padat lapisan berbeda).

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

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

Memilih Delegasi

LiteRT mendukung beberapa delegasi, yang masing-masing dioptimalkan untuk platform tertentu dan jenis model tertentu. Biasanya, akan ada banyak 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 Anda coba percepat.

Delegasi berdasarkan Platform

Lintas platform (Android &iOS)

• Delegasi GPU - Delegasi GPU dapat digunakan di Android dan iOS. Ini dioptimalkan untuk menjalankan model berbasis float 32-bit dan 16-bit di mana GPU yang tersedia. Vertex AI juga mendukung model terkuantisasi 8-bit dan menyediakan GPU performa yang setara dengan versi {i>float<i} mereka. Untuk mengetahui detail tentang GPU delegasi, lihat LiteRT di GPU.

iOS

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

Delegasi berdasarkan jenis model

Setiap akselerator dirancang dengan mempertimbangkan lebar bit data tertentu. Jika Anda menyediakan model floating point ke delegasi yang hanya mendukung 8-bit operasi, model akan menolak semua operasinya dan model akan berjalan sepenuhnya di CPU-nya. Untuk menghindari hal yang tidak disangka-sangka, tabel di bawah ini memberikan ikhtisar delegasikan dukungan berdasarkan jenis model:

Memvalidasi performa

Informasi di bagian ini berfungsi sebagai pedoman kasar untuk delegasi yang bisa meningkatkan aplikasi Anda. Namun, penting untuk diperhatikan setiap delegasi memiliki serangkaian operasi yang telah ditetapkan sebelumnya yang didukungnya, dan dapat bekerja secara berbeda bergantung pada model dan perangkat. Oleh karena itu, biasanya sebaiknya Anda melakukan beberapa tolok ukur untuk mengukur seberapa berguna delegasi yang sesuai dengan kebutuhan Anda. Ini juga membantu menjustifikasi peningkatan ukuran biner yang terkait dengan melampirkan delegasi ke runtime LiteRT.

LiteRT memiliki alat evaluasi akurasi dan performa ekstensif yang dapat memberdayakan developer agar percaya diri dalam menggunakan delegasi dalam aplikasi mereka. Alat-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 rata-rata inferensi latensi, overhead inisialisasi, jejak memori, dll. Alat ini mendukung beberapa penanda untuk mengetahui konfigurasi delegasi terbaik bagi model Anda. Sebagai di instance utama, --gpu_backend=gl dapat ditentukan dengan --use_gpu untuk mengukur GPU dan menjalankan keduanya dengan OpenGL. Daftar lengkap parameter delegasi yang didukung adalah didefinisikan dalam dokumentasi tambahan.

Berikut 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 versi bawaan alat ini untuk Android, ARM 64-bit arsitektur di sini (selengkapnya detail).

Akurasi & ketepatan

Delegasi biasanya melakukan komputasi pada presisi yang berbeda dari CPU mereka rekan-rekan. Akibatnya, ada imbal balik akurasi (biasanya kecil) yang terkait dengan penggunaan delegasi untuk akselerasi perangkat keras. Perhatikan bahwa tidak selalu benar; misalnya, karena GPU menggunakan presisi floating point menjalankan model terkuantisasi, mungkin ada sedikit peningkatan presisi (misalnya, <1% 5 peningkatan teratas dalam klasifikasi gambar ILSVRC).

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

Evaluasi Berbasis Tugas

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

• ILSVRC 2012 (Gambar Klasifikasi) dengan top-K akurasi

• Deteksi Objek COCO (dengan kotak pembatas) dengan rata-rata Presisi Rata-Rata (mAP)

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

• Klasifikasi Gambar ImageNet (Selengkapnya detail) * Objek COCO Deteksi (Lainnya detail)

Contoh di bawah menunjukkan klasifikasi gambar evaluasi 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

Hasil 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 Tugas-Agnostik

Untuk tugas-tugas yang tidak memiliki alat evaluasi di perangkat, atau jika Anda bereksperimen dengan model kustom, LiteRT memiliki Inferensi Perbedaan menyediakan alat command line gcloud. (Android, biner arsitektur biner ARM 64-bit di sini)

Perbedaan Inferensi membandingkan eksekusi LiteRT (dalam hal latensi & penyimpangan nilai output) di 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 - yang menjalankan kernel CPU thread tunggal, dan lainnya diparameterisasi oleh argumen pengguna.

Ini mengukur latensi dari 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 pada indeks 0, elemen dari output CPU yang berbeda dari output delegasi dengan rata-rata 1.96e-05.

Perhatikan bahwa menafsirkan angka-angka ini memerlukan pengetahuan model yang lebih dalam, dan arti dari setiap tensor output. Jika itu adalah regresi sederhana yang menentukan semacam skor atau embedding, perbedaannya akan rendah (jika tidak, itu berarti dengan delegasi). Namun, output seperti 'detection class' satu dari Model SSD sedikit lebih sulit ditafsirkan. Misalnya, {i>design sprint<i} mungkin menampilkan perbedaan menggunakan alat ini, tetapi itu mungkin bukan berarti ada yang salah dengan delegasi: pertimbangkan dua class (palsu): "TV (ID: 10)", "Monitor (ID:20)" - Jika delegasi sedikit melenceng dari kebenaran dan menampilkan monitor, bukan TV, diff output untuk tensor ini mungkin mencapai 20-10 = 10.