Delegasi GPU untuk LiteRT

Menggunakan unit pemrosesan grafis (GPU) untuk menjalankan model machine learning (ML) bisa meningkatkan performa model dan pengalaman pengguna secara signifikan aplikasi berkemampuan ML. LiteRT memungkinkan penggunaan GPU dan prosesor khusus lainnya melalui {i>driver<i} perangkat keras yang disebut delegasi. Mengaktifkan penggunaan GPU dengan LiteRT ML Anda dapat memberikan manfaat berikut:

  • Kecepatan - GPU dibangun untuk throughput tinggi paralel secara besar-besaran sebagian besar workload standar dan berbasis cloud. Desain ini membuatnya cocok untuk jaringan neural dalam, yang terdiri dari sejumlah besar operator, masing-masing mengerjakan tensor input dapat diproses secara paralel, yang biasanya menghasilkan latensi yang lebih rendah. Di beberapa skenario terbaiknya, menjalankan model Anda pada GPU bisa berjalan cukup cepat untuk mengaktifkan aplikasi {i>real-time<i} yang sebelumnya tidak mungkin dilakukan.
  • Efisiensi daya - GPU melakukan komputasi ML dengan cara yang sangat efisien dan optimal, biasanya mengonsumsi lebih sedikit daya dan menghasilkan lebih sedikit panas dari tugas yang sama yang berjalan pada CPU.

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

Dukungan operasi ML GPU

Ada beberapa batasan terkait operasi ML TensorFlow, atau operasi, yang dapat yang dipercepat oleh delegasi GPU LiteRT. Delegasi tersebut 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. Memungkinkan proses kuantisasi dukungan akan mengaktifkan versi yang sesuai, misalnya, ADD v2.

Pemecahan masalah dukungan GPU

Jika beberapa operasi tidak didukung oleh delegasi GPU, kerangka kerja akan hanya menjalankan sebagian grafik di GPU dan sebagian lainnya di CPU. Tenggat tingginya biaya sinkronisasi CPU/GPU, mode eksekusi terpisah seperti ini sering menyebabkan kinerja yang lebih lambat dibandingkan bila seluruh jaringan dijalankan pada 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 kesalahan sebenarnya kegagalan runtime. Saat menguji eksekusi model dengan delegasi GPU, Anda harus waspada terhadap peringatan ini. Sejumlah besar peringatan ini dapat menunjukkan bahwa model Anda tidak cocok untuk digunakan dalam akselerasi GPU, dan mungkin memerlukan pemfaktoran ulang model.

Contoh model

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

Mengoptimalkan GPU

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

  • Operasi bentuk ulang - Beberapa operasi yang cepat pada CPU dapat memiliki biaya GPU yang tinggi pada perangkat seluler. Operasi {i>reshape<i} sangat mahal untuk dijalankan, termasuk BATCH_TO_SPACE, SPACE_TO_BATCH, SPACE_TO_DEPTH, dan sebagainya. Anda harus dengan cermat memeriksa penggunaan operasi, dan mempertimbangkan bahwa hal itu mungkin telah diterapkan hanya untuk mengeksplorasi data atau untuk iterasi awal model. Jika Anda menghapusnya, meningkatkan performa.

  • Saluran data gambar - Di GPU, data tensor dibagi menjadi 4 saluran, dan jadi perhitungan pada tensor dengan bentuk [B,H,W,5] yang bekerja sama pada tensor bentuk [B,H,W,8], tetapi jauh lebih buruk daripada [B,H,W,4]. Jika perangkat keras kamera yang Anda gunakan mendukung {i>frame<i} gambar dalam RGBA, memberikan input 4-saluran secara signifikan lebih cepat, karena menghindari salinan memori dari RGB 3-saluran ke RGBX 4-saluran.

  • Model yang dioptimalkan untuk seluler - Untuk mendapatkan performa terbaik, sebaiknya pertimbangkan melatih ulang pengklasifikasi Anda dengan arsitektur jaringan yang dioptimalkan untuk seluler. Pengoptimalan untuk inferensi di perangkat dapat mengurangi latensi dan konsumsi daya dengan memanfaatkan fitur perangkat keras seluler.

Dukungan GPU lanjutan

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

Menggunakan model terkuantisasi

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

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

Bagaimana cara kerjanya?

Karena backend GPU hanya mendukung eksekusi floating point, kami menjalankan komputasi dengan memberinya ‘tampilan mengambang’ dari model asli. Di tingkat tinggi, memerlukan langkah-langkah berikut:

  • Tensor konstanta (seperti bobot/bias) didekuantisasi sekali ke dalam Memori GPU. Operasi ini terjadi jika delegasi diaktifkan untuk LiteRT.

  • Input dan output ke program GPU, jika dikuantisasi 8-bit, didekuantisasi dan dikuantisasi (masing-masing) untuk setiap inferensi. Operasi ini dilakukan pada CPU menggunakan {i> kernel<i} LiteRT yang dioptimalkan.

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

Untuk 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 {i>disk<i} dari proses sebelumnya. Pendekatan ini menghindari kompilasi ulang dan dapat mengurangi waktu startup hingga 90%. Peningkatan ini dicapai dengan menukar kapasitas {i>disk<i} 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 mematuhi aturan penerapan:

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