Delegasi GPU untuk TensorFlow Lite

Menggunakan unit pemrosesan grafis (GPU) untuk menjalankan model pembelajaran mesin (ML) dapat meningkatkan performa model dan pengalaman pengguna aplikasi yang mendukung ML secara signifikan. TensorFlow Lite memungkinkan penggunaan GPU dan prosesor khusus lainnya melalui driver perangkat keras yang disebut delegasi . Mengaktifkan penggunaan GPU dengan aplikasi TensorFlow Lite ML Anda dapat memberikan manfaat berikut:

  • Kecepatan - GPU dibuat untuk throughput tinggi pada beban kerja paralel yang sangat besar. Desain ini membuatnya cocok untuk jaringan saraf dalam, yang terdiri dari sejumlah besar operator, masing-masing bekerja pada tensor masukan yang dapat diproses secara paralel, yang biasanya menghasilkan latensi lebih rendah. Dalam skenario terbaik, menjalankan model Anda pada GPU mungkin berjalan cukup cepat untuk mengaktifkan aplikasi real-time yang sebelumnya tidak mungkin dilakukan.
  • Efisiensi daya - GPU menjalankan komputasi ML dengan cara yang sangat efisien dan optimal, biasanya mengonsumsi lebih sedikit daya dan menghasilkan lebih sedikit panas dibandingkan tugas yang sama yang dijalankan pada CPU.

Dokumen ini memberikan ringkasan tentang dukungan GPU di TensorFlow Lite, dan beberapa penggunaan lanjutan untuk prosesor GPU. Untuk informasi lebih spesifik tentang penerapan dukungan GPU pada platform tertentu, lihat panduan berikut:

Dukungan operasi GPU ML

Ada beberapa batasan mengenai operasi atau operasi TensorFlow ML yang dapat dipercepat oleh delegasi GPU TensorFlow Lite. Delegasi mendukung operasi berikut dalam presisi float 16-bit dan 32-bit:

  • ADD
  • AVERAGE_POOL_2D
  • CONCATENATION
  • CONV_2D
  • DEPTHWISE_CONV_2D v1-2
  • EXP
  • FULLY_CONNECTED
  • LOGICAL_AND
  • LOGISTIC
  • LSTM v2 (Basic LSTM only)
  • MAX_POOL_2D
  • MAXIMUM
  • MINIMUM
  • MUL
  • PAD
  • PRELU
  • RELU
  • RELU6
  • RESHAPE
  • RESIZE_BILINEAR v1-3
  • SOFTMAX
  • STRIDED_SLICE
  • SUB
  • TRANSPOSE_CONV

Secara default, semua operasi hanya didukung pada versi 1. Mengaktifkan dukungan kuantisasi akan mengaktifkan versi yang sesuai, misalnya, ADD v2.

Memecahkan masalah dukungan GPU

Jika beberapa operasi tidak didukung oleh delegasi GPU, kerangka kerja hanya akan menjalankan sebagian grafik di GPU dan sisanya di CPU. Karena tingginya biaya sinkronisasi CPU/GPU, mode eksekusi terpisah seperti ini sering kali menghasilkan kinerja yang lebih lambat dibandingkan saat seluruh jaringan dijalankan hanya pada CPU. Dalam hal ini, aplikasi menghasilkan peringatan, seperti:

WARNING: op code #42 cannot be handled by this delegate.

Tidak ada panggilan balik untuk kegagalan jenis ini, karena ini bukan kegagalan run-time yang sebenarnya. Saat menguji eksekusi model Anda dengan delegasi GPU, Anda harus waspada terhadap peringatan ini. Banyaknya peringatan ini dapat menunjukkan bahwa model Anda tidak paling cocok untuk digunakan untuk akselerasi GPU, dan mungkin memerlukan pemfaktoran ulang model tersebut.

Contoh model

Contoh model berikut dibuat untuk memanfaatkan akselerasi GPU dengan TensorFlow Lite dan disediakan untuk referensi dan pengujian:

Mengoptimalkan untuk GPU

Teknik berikut dapat membantu Anda mendapatkan performa yang lebih baik saat menjalankan model pada hardware GPU menggunakan delegasi GPU TensorFlow Lite:

  • Membentuk ulang operasi - Beberapa operasi yang cepat pada CPU mungkin memerlukan biaya tinggi untuk GPU pada perangkat seluler. Operasi pembentukan ulang sangat mahal untuk dijalankan, termasuk BATCH_TO_SPACE , SPACE_TO_BATCH , SPACE_TO_DEPTH , dan seterusnya. Anda harus memeriksa dengan cermat penggunaan operasi pembentukan ulang, dan mempertimbangkan bahwa operasi tersebut mungkin diterapkan hanya untuk mengeksplorasi data atau untuk iterasi awal model Anda. Menghapusnya dapat meningkatkan kinerja secara signifikan.

  • Saluran data gambar - Pada GPU, data tensor dibagi menjadi 4 saluran, sehingga komputasi pada tensor dengan bentuk [B,H,W,5] memiliki kinerja yang hampir sama pada tensor berbentuk [B,H,W,8] , tetapi jauh lebih buruk daripada [B,H,W,4] . Jika perangkat keras kamera yang Anda gunakan mendukung bingkai gambar dalam RGBA, memasukkan input 4 saluran tersebut jauh lebih cepat, karena menghindari salinan memori dari RGB 3 saluran ke RGBX 4 saluran.

  • Model yang dioptimalkan untuk seluler - Untuk performa terbaik, Anda harus mempertimbangkan untuk melatih ulang pengklasifikasi Anda dengan arsitektur jaringan yang dioptimalkan untuk seluler. Pengoptimalan untuk inferensi pada perangkat dapat mengurangi latensi dan konsumsi daya secara signifikan dengan memanfaatkan fitur perangkat keras seluler.

Dukungan GPU tingkat lanjut

Anda dapat menggunakan teknik lanjutan tambahan dengan pemrosesan GPU untuk memungkinkan performa yang lebih baik lagi untuk model Anda, termasuk kuantisasi dan serialisasi. Bagian berikut menjelaskan teknik-teknik ini secara lebih rinci.

Menggunakan model terkuantisasi

Bagian ini menjelaskan bagaimana delegasi GPU mempercepat model terkuantisasi 8-bit, termasuk yang berikut:

Untuk mengoptimalkan performa, gunakan model yang memiliki tensor masukan dan keluaran titik mengambang.

Bagaimana cara kerjanya?

Karena backend GPU hanya mendukung eksekusi floating-point, kami menjalankan model terkuantisasi dengan memberikan 'tampilan floating-point' dari model aslinya. Pada tingkat tinggi, hal ini memerlukan langkah-langkah berikut:

  • Tensor konstan (seperti bobot/bias) dihilangkan kuantisasinya satu kali ke dalam memori GPU. Operasi ini terjadi ketika delegasi diaktifkan untuk TensorFlow Lite.

  • Input dan output ke program GPU, jika dikuantisasi 8-bit, didekuantisasi dan dikuantisasi (masing-masing) untuk setiap inferensi. Operasi ini dilakukan pada CPU menggunakan kernel TensorFlow Lite yang dioptimalkan.

  • Simulator kuantisasi disisipkan di antara operasi untuk meniru perilaku terkuantisasi. Pendekatan ini diperlukan untuk model di mana operasi mengharapkan aktivasi mengikuti batasan yang dipelajari selama kuantisasi.

Untuk informasi tentang mengaktifkan fitur ini dengan delegasi GPU, lihat yang berikut ini:

Mengurangi waktu inisialisasi dengan serialisasi

Fitur delegasi GPU memungkinkan Anda memuat dari kode kernel yang telah dikompilasi sebelumnya dan data model diserialkan dan disimpan di disk dari proses sebelumnya. Pendekatan ini menghindari kompilasi ulang dan dapat mengurangi waktu startup hingga 90%. Peningkatan ini dicapai dengan menukar ruang disk untuk penghematan waktu. Anda dapat mengaktifkan fitur ini dengan beberapa opsi konfigurasi, seperti yang ditunjukkan pada contoh kode berikut:

C++

    TfLiteGpuDelegateOptionsV2 options = TfLiteGpuDelegateOptionsV2Default();
    options.experimental_flags |= TFLITE_GPU_EXPERIMENTAL_FLAGS_ENABLE_SERIALIZATION;
    options.serialization_dir = kTmpDir;
    options.model_token = kModelToken;

    auto* delegate = TfLiteGpuDelegateV2Create(options);
    if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;
      

Jawa

    GpuDelegate delegate = new GpuDelegate(
      new GpuDelegate.Options().setSerializationParams(
        /* serializationDir= */ serializationDir,
        /* modelToken= */ modelToken));

    Interpreter.Options options = (new Interpreter.Options()).addDelegate(delegate);
      

Saat menggunakan fitur serialisasi, pastikan kode Anda mematuhi aturan penerapan berikut:

  • Simpan data serialisasi di direktori yang tidak dapat diakses oleh aplikasi lain. Pada perangkat Android, gunakan getCodeCacheDir() yang menunjuk ke lokasi yang bersifat pribadi untuk aplikasi saat ini.
  • Token model harus unik untuk perangkat untuk model tertentu. Anda dapat menghitung token model dengan membuat sidik jari dari data model menggunakan pustaka seperti farmhash::Fingerprint64 .