Delegasi akselerasi GPU dengan C/C++ API

Menggunakan unit pemrosesan grafis (GPU) untuk menjalankan model machine learning (ML) dapat meningkatkan kinerja dan pengalaman pengguna secara signifikan aplikasi berkemampuan ML. Di perangkat Android, Anda dapat mengaktifkan akselerasi GPU eksekusi model menggunakan delegasi dan satu API berikut:

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

Panduan ini membahas penggunaan lanjutan delegasi GPU untuk C API, C++ API, dan penggunaan model terkuantisasi. Untuk informasi selengkapnya tentang menggunakan delegasi GPU untuk LiteRT, termasuk praktik terbaik dan teknik lanjutan, lihat GPU delegasi.

Aktifkan akselerasi GPU

Gunakan delegasi GPU LiteRT untuk Android di C atau C++ dengan membuat delegasi dengan TfLiteGpuDelegateV2Create() dan menghancurkannya dengan TfLiteGpuDelegateV2Delete(), seperti yang 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 membuat instance delegasi dengan opsi kustom. Anda dapat menginisialisasi opsi {i>default<i} dengan TfLiteGpuDelegateOptionsV2Default(), lalu ubah seperlunya.

Delegasi GPU LiteRT untuk Android pada C atau C++ menggunakan Bazel. Anda bisa 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 saat ini thread dan Interpreter::Invoke() harus dipanggil dari EGLContext yang sama. Jika EGLContext tidak ada, delegasi membuatnya secara internal, tetapi kemudian Anda harus memastikan bahwa Interpreter::Invoke() selalu dipanggil dari metode thread tempat Interpreter::ModifyGraphWithDelegate() dipanggil.

Dengan LiteRT di Layanan Google Play:

Jika Anda menggunakan LiteRT di C API Layanan Google Play, Anda harus menggunakan API Java/Kotlin untuk memeriksa ketersediaan delegasi GPU untuk perangkat Anda sebelum melakukan inisialisasi runtime LiteRT.

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:

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

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 delegasikan plugin, 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 harus membuat perubahan kode untuk menggunakan model terkuantisasi dengan delegasi GPU. Tujuan bagian berikut menjelaskan cara menonaktifkan dukungan terkuantisasi untuk pengujian atau tujuan eksperimental.

Menonaktifkan dukungan model terkuantisasi

Kode berikut menunjukkan cara menonaktifkan dukungan untuk model terkuantisasi.

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.