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

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 delegate et l'une des API suivantes:

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

Cette page explique comment activer l'accélération GPU pour les modèles LiteRT dans Applications Android utilisant l'API Interpreter Pour en savoir plus sur l'utilisation du GPU pour LiteRT, y compris les bonnes pratiques et les techniques avancées, consultez la page Délégués de GPU.

Utiliser le GPU avec LiteRT avec les services Google Play

L'interprète LiteRT de l'API Google fournit un ensemble des API à usage général pour créer des applications de machine learning. Cette section explique comment utiliser le délégué de l'accélérateur GPU avec ces API avec avec les services Google Play.

Nous vous recommandons d'utiliser LiteRT avec les services Google Play. pour utiliser LiteRT sur Android. Si votre application cible les appareils qui n'est pas exécutée sur Google Play, consultez l'article GPU avec API Interpreter et LiteRT.

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 = "com.google.ai.edge.litert:litert-gpu", version = "2.X.Y" }
tflite-gpu-api = { module = "com.google.ai.edge.litert:litert-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 de projet

Pour activer l'accès au délégué de GPU, ajoutez com.google.android.gms:play-services-tflite-gpu à la 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 GPU

Ensuite, initialisez LiteRT 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 à 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é de GPU peut également être utilisé avec la liaison de modèle 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 le GPU avec la version LiteRT autonome

Si votre application cible des appareils qui n'exécutent pas Google Play, elle est de grouper le délégué GPU avec votre application et de l'utiliser avec le la version autonome de LiteRT.

Ajouter des dépendances de projet

Pour activer l'accès au délégué de GPU, ajoutez com.google.ai.edge.litert:litert-gpu-delegate-plugin à votre Fichier build.gradle:

dependencies {
    ...
    implementation 'com.google.ai.edge.litert:litert'
    implementation 'com.google.ai.edge.litert:litert-gpu'
    implementation 'com.google.ai.edge.litert:litert-gpu-api'
}

Activer l'accélération GPU

Exécutez ensuite LiteRT 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 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.

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