L'utilizzo di GPU (Graphics Processing Unit) per l'esecuzione dei modelli di machine learning (ML) può migliorare notevolmente le prestazioni e l'esperienza utente delle applicazioni abilitate per ML. Sui dispositivi Android, puoi attivare l'esecuzione con accelerazione GPU dei tuoi modelli utilizzando un delegato e una delle seguenti API:
- API Interpreter - guida
- API nativa (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 quantiizzati. Per ulteriori informazioni sull'utilizzo del delegato GPU per TensorFlow Lite, tra cui best practice e tecniche avanzate, consulta la pagina relativa ai delegati GPU.
Attiva l'accelerazione GPU
Utilizza il delegato GPU TensorFlow Lite per Android in C o C++ creando il
delegato con TfLiteGpuDelegateV2Create()
ed eliminandolo 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 delegata con opzioni personalizzate. Puoi inizializzare le opzioni predefinite con TfLiteGpuDelegateOptionsV2Default()
e quindi modificarle in base alle tue esigenze.
Il delegato GPU TensorFlow Lite per Android in C o C++ utilizza il sistema di build Bazel. Puoi creare il delegato utilizzando il 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
nel thread attuale
e Interpreter::Invoke()
deve essere chiamato dallo stesso EGLContext
. Se EGLContext
non esiste, il delegato ne crea uno internamente, ma devi assicurarti che Interpreter::Invoke()
venga sempre chiamato dallo stesso thread in cui è stato chiamato Interpreter::ModifyGraphWithDelegate()
.
Con TensorFlow Lite in Google Play Services:
Se usi TensorFlow Lite nell'API C di Google Play Services, devi utilizzare l'API Java/Kotlin per verificare se è disponibile un delegato GPU per il tuo dispositivo prima di inizializzare il runtime TensorFlow Lite.
Aggiungi le dipendenze graduali del delegato GPU all'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 ha esito positivo:
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) }
Devi anche aggiornare la configurazione di CMake per includere il flag di compilazione TFLITE_USE_OPAQUE_DELEGATE
:
add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)
La libreria FlatBuffers viene utilizzata per configurare i plug-in di delega, quindi devi aggiungerla alle dipendenze del tuo 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 quantizzati
Le librerie delegate di GPU Android supportano i modelli quantizzati per impostazione predefinita. Non è necessario apportare modifiche al codice per utilizzare i modelli quantizzati con il delegato GPU. La sezione seguente spiega come disattivare il supporto quantizzato per scopi di test o sperimentali.
Disabilita il supporto del modello quantizzato
Il seguente codice mostra come disabilitare il supporto per i modelli quantiizzati.
C++
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 la panoramica relativa al delegato GPU.