Delegasi akselerasi GPU dengan C/C++ API

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

Interpreter API - panduan
API Native (C/C++) - panduan ini

Panduan ini membahas 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.

Mengaktifkan akselerasi GPU

Gunakan delegasi GPU TensorFlow Lite untuk Android di C atau C++ dengan membuat delegasi dengan TfLiteGpuDelegateV2Create() dan menghancurkannya dengan TfLiteGpuDelegateV2Delete(), seperti ditunjukkan dalam kode contoh 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 mem-build instance delegasi dengan opsi kustom. Anda dapat menginisialisasi opsi default dengan TfLiteGpuDelegateOptionsV2Default(), lalu mengubahnya sesuai kebutuhan.

Delegasi GPU TensorFlow Lite untuk Android di C atau C++ menggunakan sistem build Bazel. Anda dapat mem-build 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 dalam 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 tempat Interpreter::ModifyGraphWithDelegate() dipanggil.

Dengan TensorFlow Lite di Layanan Google Play:

Jika menggunakan TensorFlow Lite di C API Layanan Google Play, Anda harus menggunakan Java/Kotlin API untuk memeriksa apakah delegasi GPU tersedia untuk perangkat Anda sebelum melakukan inisialisasi 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 lakukan inisialisasi TfLiteNative jika pemeriksaan berhasil:

Java

Task<Void> 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 compiler TFLITE_USE_OPAQUE_DELEGATE:

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

Library FlatBuffers digunakan untuk mengonfigurasi plugin delegasi sehingga Anda perlu menambahkannya ke dependensi kode native. Anda dapat menggunakan konfigurasi project CMake resmi sebagai berikut:

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

Anda juga dapat memaketkan 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 membuat perubahan kode untuk menggunakan model terkuantisasi dengan delegasi GPU. Bagian berikut menjelaskan cara menonaktifkan dukungan terkuantisasi untuk tujuan pengujian atau eksperimental.

Menonaktifkan 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 mengetahui informasi selengkapnya tentang menjalankan model terkuantisasi dengan akselerasi GPU, lihat ringkasan delegasi GPU.