Delega accelerazione GPU con API C/C++

Utilizzo delle GPU (Graphics Processing Unit) per eseguire i modelli di machine learning (ML) migliorare notevolmente le prestazioni e l'esperienza utente del tuo abilitate per ML. Sui dispositivi Android, puoi attivare l'accelerazione GPU dei modelli utilizzando un delegato e delle seguenti API:

• API Interpreter - guida
• API Native (C/C++) - Questa guida

Questa guida illustra gli utilizzi avanzati del delegato GPU per l'API C, l'API C++ e l'uso di modelli quantizzati. Per ulteriori informazioni sull'utilizzo del delegato GPU per LiteRT, che include best practice e tecniche avanzate, consulta la GPU delegata.

Attiva l'accelerazione GPU

Utilizza il delegato GPU LiteRT per Android in C o C++ creando il metodo delegare con TfLiteGpuDelegateV2Create() e distruggerlo con TfLiteGpuDelegateV2Delete(), come mostrato nel seguente codice di esempio:

// 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);

Esamina il codice dell'oggetto TfLiteGpuDelegateOptionsV2 per creare un'istanza delega con opzioni personalizzate. Puoi inizializzare le opzioni predefinite con TfLiteGpuDelegateOptionsV2Default() e poi modificali in base alle esigenze.

Il delegato LiteRT GPU per Android in C o C++ utilizza Sistema di build Bazel. Puoi creare il delegato utilizzando seguente comando:

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

Quando chiami Interpreter::ModifyGraphWithDelegate() o Interpreter::Invoke(), il chiamante deve avere un EGLContext nell'attuale il thread e Interpreter::Invoke() devono essere chiamati dallo stesso EGLContext. Se EGLContext non esiste, il delegato ne crea uno internamente, ma devi assicurarti che Interpreter::Invoke() venga sempre chiamato dalla stessa thread in cui è stato chiamato Interpreter::ModifyGraphWithDelegate().

Con LiteRT in Google Play Services:

Se utilizzi LiteRT nell'API C di Google Play Services, dovrai utilizzare l'API Java/Kotlin per verificare se è disponibile un delegato GPU del dispositivo prima di inizializzare il runtime LiteRT.

Aggiungi le dipendenze Gradle delegati della GPU alla tua applicazione:

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

Quindi, controlla la disponibilità della GPU e inizializza TfLite Native se il controllo è operazione riuscita:

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)
    }
        

Devi inoltre aggiornare la configurazione CMake per includere Flag del compilatore TFLITE_USE_OPAQUE_DELEGATE:

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

La libreria FlatBuffers viene utilizzata per configurare delegare i plug-in, quindi devi aggiungerlo alle dipendenze del codice nativo. Puoi utilizzare la configurazione ufficiale del progetto CMake nel seguente modo:

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

Puoi anche raggruppare le intestazioni nella tua app.

Infine per utilizzare l'inferenza GPU nel codice C, crea il delegato GPU utilizzando 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);

Modelli quantificati

Le librerie delegati GPU Android supportano i modelli quantizzati per impostazione predefinita. Non devi eventuali modifiche al codice per usare modelli quantizzati con il delegato GPU. La la seguente sezione spiega come disattivare il supporto quantizzato per i test o a scopi sperimentali.

Disabilita il supporto dei modelli quantiizzati

Il seguente codice mostra come disattivare il supporto per i modelli quantizzati.

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

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

Per ulteriori informazioni sull'esecuzione di modelli quantizzati con l'accelerazione GPU, consulta Panoramica dei delegati alle GPU.