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

Utiliser des 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 les applications compatibles avec le ML. Sur les appareils Android, vous pouvez activer l'exécution de vos modèles à l'aide d'un délégué et d'un autre des API suivantes:

• API Interpreter – Guide
• API native (C/C++) : ce guide

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

Activer l'accélération GPU

Utilisez le délégué de GPU LiteRT pour Android en C ou C++ en créant le délégué avec TfLiteGpuDelegateV2Create() et le détruire 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);

Examiner 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 modifiez-les si nécessaire.

Le délégué de GPU LiteRT pour Android en C ou C++ utilise le Système de compilation Bazel Vous pouvez créer le délégué à l'aide du 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

Lorsque vous appelez Interpreter::ModifyGraphWithDelegate() ou Interpreter::Invoke(), l'appelant doit avoir un EGLContext dans la Le thread et Interpreter::Invoke() doivent être appelés à partir du même EGLContext. Si EGLContext n'existe pas, le délégué en crée un en interne, mais vous devez vous assurer que Interpreter::Invoke() est toujours appelé à partir du même thread dans lequel Interpreter::ModifyGraphWithDelegate() a été appelé.

Avec LiteRT dans les services Google Play:

Si vous utilisez LiteRT 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 LiteRT.

Ajoutez les dépendances Gradle déléguées par le 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 est réussi:

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

Vous devez également mettre à jour votre configuration CMake pour y inclure le Indicateur de compilation TFLITE_USE_OPAQUE_DELEGATE:

add_compile_definitions(TFLITE_USE_OPAQUE_DELEGATE)

La bibliothèque FlatBuffers permet de configurer délégué. Vous devez donc l'ajouter aux dépendances de votre code natif. Vous pouvez utiliser la configuration de projet CMake officielle 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é de 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 déléguées de GPU Android sont compatibles avec les modèles quantifiés. Vous ne devez pas n'avez pas besoin de modifier le code pour utiliser des modèles quantifiés avec le délégué de GPU. La La section suivante explique comment désactiver la prise en charge quantifiée pour les tests ou à des fins expérimentales.

Désactiver la compatibilité avec les modèles quantifiés

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

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 Présentation de la délégué de GPU.