Délégué d'accélération GPU pour Android

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 de votre modèle et l'expérience utilisateur de vos applications compatibles ML. Sur les appareils Android, vous pouvez activer l'utilisation de l'exécution accélérée par GPU de vos modèles à l'aide d'un délégué . Les délégués agissent en tant que pilotes matériels pour TensorFlow Lite, vous permettant d'exécuter le code de votre modèle sur des processeurs GPU.

Cette page explique comment activer l'accélération GPU pour les modèles TensorFlow Lite dans les applications Android. 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 .

Utiliser le GPU avec les API de la bibliothèque de tâches

Les bibliothèques de tâches TensorFlow Lite fournissent un ensemble d'API spécifiques aux tâches pour créer des applications de machine learning. Cette section décrit comment utiliser le délégué de l'accélérateur GPU avec ces API.

Ajouter des dépendances de projet

Activez l'accès aux API déléguées GPU avec les bibliothèques de tâches TensorFlow Lite en ajoutant les dépendances suivantes. Mettez à jour le fichier build.gradle de vos projets de développement pour inclure le tensorflow-lite-gpu-delegate-plugin , comme illustré dans l'exemple de code suivant :

dependencies {
  ...
  implementation 'org.tensorflow:tensorflow-lite-gpu-delegate-plugin'
}

Activer l'accélération GPU

Activez l'option de délégué GPU pour votre classe de modèle d'API de tâche avec la classe BaseOptions . Par exemple, vous pouvez configurer le GPU dans ObjectDetector comme indiqué dans les exemples de code suivants :

Kotlin

    import org.tensorflow.lite.task.core.BaseOptions
    import org.tensorflow.lite.task.gms.vision.detector.ObjectDetector

    val baseOptions = BaseOptions.builder().useGpu().build()

    val options =
        ObjectDetector.ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build()

    val objectDetector = ObjectDetector.createFromFileAndOptions(
      context, model, options)

      

Java

    import org.tensorflow.lite.task.core.BaseOptions
    import org.tensorflow.lite.task.gms.vision.detector.ObjectDetector

    BaseOptions baseOptions = BaseOptions.builder().useGpu().build();

    ObjectDetectorOptions options =
        ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build();

    val objectDetector = ObjectDetector.createFromFileAndOptions(
      context, model, options);
      

Utiliser le GPU avec l'API Interpreter

L' API TensorFlow Lite Interpreter fournit un ensemble d'API à usage général pour créer des applications d'apprentissage automatique. Cette section décrit comment utiliser le délégué de l'accélérateur GPU avec ces API.

Ajouter des dépendances de projet

Activez l'accès aux API déléguées GPU en ajoutant les dépendances suivantes, mettez à jour le fichier build.gradle de vos projets de développement pour inclure le org.tensorflow:tensorflow-lite-gpu , comme illustré dans l'exemple de code suivant :

dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite'
    implementation 'org.tensorflow:tensorflow-lite-gpu'
}

Activer l'accélération GPU

Exécutez ensuite TensorFlow Lite sur GPU avec TfLiteDelegate . En Java, vous pouvez spécifier le GpuDelegate via Interpreter.Options .

Kotlin

    import org.tensorflow.lite.Interpreter
    import org.tensorflow.lite.gpu.CompatibilityList
    import org.tensorflow.lite.gpu.GpuDelegate

    val compatList = CompatibilityList()

    val options = Interpreter.Options().apply{
        if(compatList.isDelegateSupportedOnThisDevice){
            // if the device has a supported GPU, add the GPU delegate
            val delegateOptions = compatList.bestOptionsForThisDevice
            this.addDelegate(GpuDelegate(delegateOptions))
        } else {
            // if the GPU is not supported, run on 4 threads
            this.setNumThreads(4)
        }
    }

    val interpreter = Interpreter(model, options)

    // Run inference
    writeToInput(input)
    interpreter.run(input, output)
    readFromOutput(output)
      

Java

    import org.tensorflow.lite.Interpreter;
    import org.tensorflow.lite.gpu.CompatibilityList;
    import org.tensorflow.lite.gpu.GpuDelegate;

    // Initialize interpreter with GPU delegate
    Interpreter.Options options = new Interpreter.Options();
    CompatibilityList compatList = CompatibilityList();

    if(compatList.isDelegateSupportedOnThisDevice()){
        // if the device has a supported GPU, add the GPU delegate
        GpuDelegate.Options delegateOptions = compatList.getBestOptionsForThisDevice();
        GpuDelegate gpuDelegate = new GpuDelegate(delegateOptions);
        options.addDelegate(gpuDelegate);
    } else {
        // if the GPU is not supported, run on 4 threads
        options.setNumThreads(4);
    }

    Interpreter interpreter = new Interpreter(model, options);

    // Run inference
    writeToInput(input);
    interpreter.run(input, output);
    readFromOutput(output);
      

Remarque : Le délégué GPU doit être créé sur le même thread qui l'exécute. Sinon, vous pouvez voir l'erreur suivante, TfLiteGpuDelegate Invoke: GpuDelegate must run on the same thread where it was initialized.

Le délégué GPU peut également être utilisé avec la liaison de modèle ML dans Android Studio. Pour plus d'informations, consultez Générer des interfaces de modèle à l'aide de métadonnées .

Prise en charge avancée du processeur graphique

Cette section couvre les utilisations avancées du délégué GPU pour Android, y compris l'API C, l'API C++ et l'utilisation de modèles quantifiés.

API C/C++ pour Android

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

Passez en revue le code 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é GPU TensorFlow Lite pour Android en C ou C++ utilise le système de génération 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 que Interpreter::Invoke() est toujours appelé à partir du même thread dans lequel Interpreter::ModifyGraphWithDelegate() a été appelé.

Modèles quantifiés

Les bibliothèques déléguées de 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.

Java

GpuDelegate delegate = new GpuDelegate(new GpuDelegate.Options().setQuantizedModelsAllowed(false));

Interpreter.Options options = (new Interpreter.Options()).addDelegate(delegate);
      

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 du délégué GPU .