Délégué de l'accélération du GPU avec API C/C++

L'utilisation de processeurs graphiques (GPU) pour exécuter vos modèles de machine learning (ML) peut considérablement améliorer les performances et l'expérience utilisateur de vos applications compatibles avec le ML. Sur les appareils Android, vous pouvez activer l'exécution de vos modèles avec accélération par GPU à l'aide d'un délégué et de l'une des API suivantes:

API Interpréteur - guide
API native (C/C++) – ce guide

Ce guide aborde les utilisations avancées du délégué GPU pour l'API C et l'API C++, ainsi que l'utilisation de modèles quantifiés. Pour en savoir plus sur l'utilisation du délégué de GPU pour TensorFlow Lite, y compris sur les bonnes pratiques et les techniques avancées, consultez la page Délégués de GPU.

Activer l'accélération du GPU

Utilisez le délégué de GPU TensorFlow Lite pour Android en C ou C++ en créant le délégué avec TfLiteGpuDelegateV2Create() et en le détruisant avec TfLiteGpuDelegateV2Delete(), comme illustré dans l'exemple de code suivant:

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

Examinez le code d'objet TfLiteGpuDelegateOptionsV2 pour créer une instance déléguée avec des options personnalisées. Vous pouvez initialiser les options par défaut avec TfLiteGpuDelegateOptionsV2Default(), puis les modifier si nécessaire.

Le délégué de GPU TensorFlow Lite pour Android en C ou C++ utilise le système de compilation Bazel. Vous pouvez créer le délégué à l'aide de la commande suivante:

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

Lors de l'appel de Interpreter::ModifyGraphWithDelegate() ou Interpreter::Invoke(), l'appelant doit disposer d'un EGLContext dans le thread actuel et Interpreter::Invoke() doit être appelé à partir du même EGLContext. Si aucun élément EGLContext n'existe, le délégué en crée un en interne, mais vous devez ensuite vous assurer que Interpreter::Invoke() est toujours appelé à partir du même thread que celui dans lequel Interpreter::ModifyGraphWithDelegate() a été appelé.

Avec TensorFlow Lite dans les services Google Play:

Si vous utilisez TensorFlow Lite dans l'API C des services Google Play, vous devez utiliser l'API Java/Kotlin pour vérifier si un délégué de GPU est disponible pour votre appareil avant d'initialiser l'environnement d'exécution TensorFlow Lite.

Ajoutez les dépendances Gradle de GPU à votre application:

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

Vérifiez ensuite la disponibilité du GPU et initialisez TfLiteNative si la vérification aboutit:

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

Vous devez également mettre à jour votre configuration CMake pour inclure l'indicateur de compilation TFLITE_USE_OPAQUE_DELEGATE:

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

La bibliothèque FlatBuffers permet de configurer les plug-ins délégués. Vous devez donc l'ajouter aux dépendances de votre code natif. Vous pouvez utiliser la configuration officielle du projet CMake comme suit:

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

Vous pouvez également simplement regrouper les en-têtes dans votre application.

Enfin, pour utiliser l'inférence GPU dans votre code C, créez le délégué GPU à l'aide de 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);

Modèles quantifiés

Par défaut, les bibliothèques de délégués de GPU Android sont compatibles avec les modèles quantifiés. Vous n'avez pas besoin de modifier le code pour utiliser des modèles quantifiés avec le délégué GPU. La section suivante explique comment désactiver la compatibilité quantifiée à des fins de test ou d'expérimentation.

Désactiver la prise en charge des modèles quantifiés

Le code suivant montre comment désactiver la prise en charge des modèles quantifiés.

C++

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

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

Pour en savoir plus sur l'exécution de modèles quantifiés avec l'accélération GPU, consultez la section Délégué de GPU.