Delegasi akselerasi GPU dengan C/C++ API

Menggunakan unit pemrosesan grafis (GPU) untuk menjalankan model pembelajaran mesin (ML) dapat meningkatkan performa dan pengalaman pengguna aplikasi Anda yang mendukung ML secara signifikan. Di perangkat Android, Anda dapat mengaktifkan eksekusi model yang dipercepat GPU menggunakan delegasi dan salah satu API berikut:

  • API Juru Bahasa - panduan
  • API perpustakaan tugas - panduan
  • API Asli (C/C++) - panduan ini

Panduan ini mencakup penggunaan lanjutan delegasi GPU untuk C API, C++ API, dan penggunaan model terkuantisasi. Untuk informasi selengkapnya tentang penggunaan delegasi GPU untuk TensorFlow Lite, termasuk praktik terbaik dan teknik lanjutan, lihat halaman delegasi GPU .

Aktifkan akselerasi GPU

Gunakan delegasi GPU TensorFlow Lite untuk Android di C atau C++ dengan membuat delegasi menggunakan TfLiteGpuDelegateV2Create() dan menghancurkannya dengan TfLiteGpuDelegateV2Delete() , seperti yang ditunjukkan dalam contoh kode berikut:

// Set up interpreter.
auto model = FlatBufferModel::BuildFromFile(model_path);
if (!model) return false;
ops::builtin::BuiltinOpResolver op_resolver;
std::unique_ptr<Interpreter> interpreter;
InterpreterBuilder(*model, op_resolver)(&interpreter);

// NEW: Prepare GPU delegate.
auto* delegate = TfLiteGpuDelegateV2Create(/*default options=*/nullptr);
if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;

// Run inference.
WriteToInputTensor(interpreter->typed_input_tensor<float>(0));
if (interpreter->Invoke() != kTfLiteOk) return false;
ReadFromOutputTensor(interpreter->typed_output_tensor<float>(0));

// NEW: Clean up.
TfLiteGpuDelegateV2Delete(delegate);

Tinjau kode objek TfLiteGpuDelegateOptionsV2 untuk membuat instans delegasi dengan opsi khusus. Anda dapat menginisialisasi opsi default dengan TfLiteGpuDelegateOptionsV2Default() lalu memodifikasinya seperlunya.

Delegasi GPU TensorFlow Lite untuk Android di C atau C++ menggunakan sistem build Bazel . Anda dapat membangun delegasi menggunakan perintah berikut:

bazel build -c opt --config android_arm64 tensorflow/lite/delegates/gpu:delegate                           # for static library
bazel build -c opt --config android_arm64 tensorflow/lite/delegates/gpu:libtensorflowlite_gpu_delegate.so  # for dynamic library

Saat memanggil Interpreter::ModifyGraphWithDelegate() atau Interpreter::Invoke() , pemanggil harus memiliki EGLContext di thread saat ini dan Interpreter::Invoke() harus dipanggil dari EGLContext yang sama. Jika EGLContext tidak ada, delegasi akan membuatnya secara internal, namun Anda harus memastikan bahwa Interpreter::Invoke() selalu dipanggil dari thread yang sama dengan tempat Interpreter::ModifyGraphWithDelegate() dipanggil.

Dengan TensorFlow Lite di Layanan Google Play:

Jika Anda menggunakan TensorFlow Lite di Google Play Services C API , Anda harus menggunakan Java/Kotlin API untuk memeriksa apakah delegasi GPU tersedia untuk perangkat Anda sebelum menginisialisasi runtime TensorFlow Lite.

Tambahkan dependensi gradle delegasi GPU ke aplikasi Anda:

implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.0'

Kemudian, periksa ketersediaan GPU dan inisialisasi TfLiteNative jika pemeriksaan berhasil:

Jawa

Task tfLiteHandleTask =
TfLiteGpu.isGpuDelegateAvailable(this)
   .onSuccessTask(gpuAvailable -> {
      TfLiteInitializationOptions options =
        TfLiteInitializationOptions.builder()
          .setEnableGpuDelegateSupport(gpuAvailable).build();
        return TfLiteNative.initialize(this, options);
      }
    );

Kotlin

val tfLiteHandleTask = TfLiteGpu.isGpuDelegateAvailable(this)
    .onSuccessTask { gpuAvailable ->
        val options = TfLiteInitializationOptions.Builder()
            .setEnableGpuDelegateSupport(gpuAvailable)
            .build()
        TfLiteNative.initialize(this, options)
    }

Anda juga perlu memperbarui konfigurasi CMake untuk menyertakan tanda kompiler TFLITE_USE_OPAQUE_DELEGATE :

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

Pustaka FlatBuffers digunakan untuk mengonfigurasi plugin delegasi, jadi Anda perlu menambahkannya ke dependensi kode asli Anda. Anda dapat menggunakan konfigurasi proyek CMake resmi sebagai berikut:

target_include_directories(tflite-jni PUBLIC
        third_party/headers # flatbuffers
     ...)

Anda juga dapat menggabungkan header ke aplikasi Anda.

Terakhir untuk menggunakan inferensi GPU dalam kode C Anda, buat delegasi GPU menggunakan TFLiteSettings :

#include "flatbuffers/flatbuffers.h"
#include "tensorflow/lite/acceleration/configuration/configuration_generated.h"

flatbuffers::FlatBufferBuilder fbb;
tflite::TFLiteSettingsBuilder builder(fbb);
const tflite::TFLiteSettings* tflite_settings =
    flatbuffers::GetTemporaryPointer(fbb, builder.Finish());

const TfLiteOpaqueDelegatePlugin* pluginCApi = TfLiteGpuDelegatePluginCApi();
TfLiteOpaqueDelegate* gpu_delegate = pluginCApi->create(tflite_settings);

Model terkuantisasi

Library delegasi GPU Android mendukung model terkuantisasi secara default. Anda tidak perlu melakukan perubahan kode apa pun untuk menggunakan model terkuantisasi dengan delegasi GPU. Bagian berikut menjelaskan cara menonaktifkan dukungan terkuantisasi untuk tujuan pengujian atau eksperimental.

Nonaktifkan dukungan model terkuantisasi

Kode berikut menunjukkan cara menonaktifkan dukungan untuk model terkuantisasi.

C++

TfLiteGpuDelegateOptionsV2 options = TfLiteGpuDelegateOptionsV2Default();
options.experimental_flags = TFLITE_GPU_EXPERIMENTAL_FLAGS_NONE;

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

Untuk informasi selengkapnya tentang menjalankan model terkuantisasi dengan akselerasi GPU, lihat Ikhtisar delegasi GPU .