Déléguer l'accélération du GPU avec l'API Interpréteur

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 un délégué et l'une des API suivantes:

• API Interprète – ce guide
• API native (C/C++) : guide

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

Utiliser un GPU avec TensorFlow Lite avec les services Google Play

L'API Interpréteur TensorFlow Lite fournit un ensemble d'API à usage général pour la création d'applications de machine learning. Cette section explique comment utiliser le délégué d'accélérateur GPU avec ces API avec TensorFlow Lite avec les services Google Play.

Pour utiliser TensorFlow Lite sur Android, nous vous recommandons d'utiliser TensorFlow Lite avec les services Google Play. Si votre application cible les appareils qui n'exécutent pas Google Play, consultez la section GPU avec l'API Interpréteur et la version autonome de TensorFlow Lite.

Ajouter des dépendances de projet (avec le catalogue de versions .toml)

1. Mettre à jour le fichier libs.versions.toml de votre projet

[libraries]
...
tflite-gpu = { module = "org.tensorflow:tensorflow-lite-gpu", version = "2.X.Y" }
tflite-gpu-api = { module = "org.tensorflow:tensorflow-lite-gpu-api", version = "2.X.Y" }
...

1. Ajouter des dépendances de projet dans le fichier build.gradle.kts de l'application

dependencies {
  ...
  implementation(libraries.tflite.gpu)
  implementation(libraries.tflite.gpu.api)
  ...
}

Ajouter des dépendances au projet

Pour activer l'accès au délégué GPU, ajoutez com.google.android.gms:play-services-tflite-gpu au fichier build.gradle de votre application:

dependencies {
    ...
    implementation 'com.google.android.gms:play-services-tflite-java:16.0.1'
    implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
}

Activer l'accélération du GPU

Ensuite, initialisez TensorFlow Lite avec les services Google Play compatibles avec les GPU:

val useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

val interpreterTask = useGpuTask.continueWith { useGpuTask ->
  TfLite.initialize(context,
      TfLiteInitializationOptions.builder()
      .setEnableGpuDelegateSupport(useGpuTask.result)
      .build())
  }
        

Task<boolean> useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context);

Task<Options> interpreterOptionsTask = useGpuTask.continueWith({ task ->
  TfLite.initialize(context,
  TfLiteInitializationOptions.builder()
    .setEnableGpuDelegateSupport(true)
    .build());
});
        

Vous pouvez enfin initialiser l'interpréteur en transmettant un GpuDelegateFactory via InterpreterApi.Options:

    val options = InterpreterApi.Options()
      .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
      .addDelegateFactory(GpuDelegateFactory())

    val interpreter = InterpreterApi(model, options)

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

    Options options = InterpreterApi.Options()
      .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
      .addDelegateFactory(new GpuDelegateFactory());

    Interpreter interpreter = new InterpreterApi(model, options);

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

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

Utiliser un GPU avec la version autonome de TensorFlow Lite

Si votre application cible des appareils qui n'exécutent pas Google Play, il est possible de regrouper le délégué GPU à votre application et de l'utiliser avec la version autonome de TensorFlow Lite.

Ajouter des dépendances au projet

Pour activer l'accès au délégué GPU, ajoutez org.tensorflow:tensorflow-lite-gpu-delegate-plugin au fichier build.gradle de votre application:

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

Activer l'accélération du GPU

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

      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)
      

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

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.

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

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

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.