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

L'utilisation d'unités de traitement graphique (GPU) pour exécuter vos modèles d'apprentissage automatique (ML) peut améliorer considérablement les performances et l'expérience utilisateur de vos applications compatibles ML. Sur les appareils Android, vous pouvez activer l'exécution accélérée par GPU de vos modèles à l'aide d'un délégué et de l'une des API suivantes :

  • API de l'interprète - guide
  • API de la bibliothèque de tâches - guide
  • API native (C/C++) - ce guide

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

Activer l'accélération GPU

Utilisez le délégué 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 indiqué 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);

Passez en revue le code objet TfLiteGpuDelegateOptionsV2 pour créer une instance de délégué 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é GPU TensorFlow Lite pour Android en C ou C++ utilise le système de build 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 Interpreter::ModifyGraphWithDelegate() ou Interpreter::Invoke() , l'appelant doit avoir un EGLContext dans le thread actuel et Interpreter::Invoke() doit être appelé à partir du même EGLContext . Si un EGLContext n'existe pas, le délégué en crée un en interne, mais vous devez alors vous assurer Interpreter::Invoke() est toujours appelé à partir du même thread 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 devrez utiliser l'API Java/Kotlin pour vérifier si un délégué GPU est disponible pour votre appareil avant d'initialiser le runtime TensorFlow Lite.

Ajoutez les dépendances de niveau du délégué GPU à votre application :

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

Ensuite, vérifiez la disponibilité du GPU et initialisez TfLiteNative si la vérification réussit :

Java

Task 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 du compilateur TFLITE_USE_OPAQUE_DELEGATE :

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

La bibliothèque FlatBuffers est utilisée pour configurer les plugins 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

Les bibliothèques déléguées GPU Android prennent en charge les modèles quantifiés par défaut. Vous n'avez pas besoin d'apporter de modifications au code pour utiliser des modèles quantifiés avec le délégué GPU. La section suivante explique comment désactiver la prise en charge quantifiée à des fins de test ou d'expérimentation.

Désactiver la prise en charge du modèle quantifié

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 plus d’informations sur l’exécution de modèles quantifiés avec l’accélération GPU, consultez Présentation des délégués GPU .