Delegasi GPU untuk LiteRT

Menggunakan unit pemrosesan grafis (GPU) untuk menjalankan model machine learning (ML) dapat meningkatkan performa model dan pengalaman pengguna aplikasi yang mendukung ML secara signifikan. LiteRT memungkinkan penggunaan GPU dan prosesor khusus lainnya melalui driver hardware yang disebut delegasi. Mengaktifkan penggunaan GPU dengan aplikasi ML LiteRT dapat memberikan manfaat berikut:

  • Kecepatan - GPU dibuat untuk throughput tinggi dari workload paralel masif. Desain ini membuatnya sangat cocok untuk jaringan saraf dalam (DNN), yang terdiri dari sejumlah besar operator, yang masing-masing bekerja pada tensor input yang dapat diproses secara paralel, yang biasanya menghasilkan latensi yang lebih rendah. Dalam skenario terbaik, menjalankan model Anda di GPU mungkin cukup cepat untuk memungkinkan aplikasi real-time yang sebelumnya tidak mungkin dilakukan.
  • Efisiensi daya - GPU melakukan komputasi ML dengan cara yang sangat efisien dan dioptimalkan, biasanya mengonsumsi lebih sedikit daya dan menghasilkan lebih sedikit panas daripada tugas yang sama yang berjalan di CPU.

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

Dukungan operasi ML GPU

Ada beberapa batasan terkait operasi ML TensorFlow, atau ops, yang dapat dipercepat oleh delegasi GPU LiteRT. 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 di versi 1. Mengaktifkan dukungan kuantisasi memungkinkan versi yang sesuai, misalnya, ADD v2.

Memecahkan masalah dukungan GPU

Jika beberapa operasi tidak didukung oleh delegasi GPU, framework hanya akan menjalankan sebagian grafik di GPU dan bagian lainnya di CPU. Karena biaya sinkronisasi CPU/GPU yang tinggi, mode eksekusi terpisah seperti ini sering kali menghasilkan performa yang lebih lambat daripada saat seluruh jaringan dijalankan di CPU saja. Dalam hal ini, aplikasi akan menghasilkan peringatan, seperti:

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

Tidak ada callback untuk kegagalan jenis ini, karena ini bukan kegagalan runtime yang sebenarnya. Saat menguji eksekusi model dengan delegasi GPU, Anda harus mewaspadai peringatan ini. Banyaknya peringatan ini dapat menunjukkan bahwa model Anda tidak cocok untuk digunakan dengan akselerasi GPU, dan mungkin memerlukan refaktorisasi model.

Contoh model

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

Mengoptimalkan untuk GPU

Teknik berikut dapat membantu Anda mendapatkan performa yang lebih baik saat menjalankan model di hardware GPU menggunakan delegasi GPU LiteRT:

  • Operasi mengubah bentuk - Beberapa operasi yang cepat di CPU mungkin memiliki biaya tinggi untuk GPU di perangkat seluler. Operasi pembentukan ulang sangat mahal untuk dijalankan, termasuk BATCH_TO_SPACE, SPACE_TO_BATCH, SPACE_TO_DEPTH, dan sebagainya. Anda harus memeriksa penggunaan operasi reshape dengan cermat, dan mempertimbangkan bahwa operasi tersebut mungkin hanya diterapkan untuk menjelajahi data atau untuk iterasi awal model Anda. Menghapusnya dapat meningkatkan performa secara signifikan.

  • Saluran data gambar - Di GPU, data tensor diiris menjadi 4 saluran, dan sehingga komputasi pada tensor dengan bentuk [B,H,W,5] berperforma hampir sama dengan tensor berbentuk [B,H,W,8], tetapi jauh lebih buruk daripada [B,H,W,4]. Jika hardware kamera yang Anda gunakan mendukung frame gambar dalam RGBA, memasukkan input 4 saluran tersebut akan jauh lebih cepat, karena menghindari penyalinan memori dari RGB 3 saluran ke RGBX 4 saluran.

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

Dukungan GPU lanjutan

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

Menggunakan model terkuantisasi

Bagian ini menjelaskan cara GPU delegate mempercepat model terkuantisasi 8-bit, termasuk hal berikut:

Untuk mengoptimalkan performa, gunakan model yang memiliki tensor input dan output floating point.

Bagaimana cara kerjanya?

Karena backend GPU hanya mendukung eksekusi floating point, kita menjalankan model yang dikuantisasi dengan memberikan ‘tampilan floating point’ dari model asli. Secara umum, hal ini memerlukan langkah-langkah berikut:

  • Tensor konstanta (seperti bobot/bias) di-dekuantisasi sekali ke dalam memori GPU. Operasi ini terjadi saat delegasi diaktifkan untuk LiteRT.

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

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

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

Mengurangi waktu inisialisasi dengan serialisasi

Fitur delegasi GPU memungkinkan Anda memuat dari kode kernel yang telah dikompilasi sebelumnya dan data model yang diserialisasi 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 menghemat waktu. Anda dapat mengaktifkan fitur ini dengan beberapa opsi konfigurasi, seperti yang ditunjukkan dalam 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;

Java

    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. Di perangkat Android, gunakan getCodeCacheDir() yang mengarah ke lokasi yang bersifat pribadi untuk aplikasi saat ini.
  • Token model harus unik untuk perangkat dan model tertentu. Anda dapat menghitung token model dengan membuat sidik jari dari data model menggunakan library seperti farmhash::Fingerprint64.