Délégué d'accélération GPU avec API Interpreter

L'utilisation d'unités de traitement graphique (GPU) pour exécuter vos modèles d'apprentissage automatique (ML) peut considérablement améliorer les performances et l'expérience utilisateur de vos applications compatibles ML. Sur les appareils Android, vous pouvez activer

délégué et l'une des API suivantes :

• API d'interpréteur - ce guide
• API de bibliothèque de tâches - guide
• API native (C/C++) - guide

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

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 avec TensorFlow Lite avec les services Google Play.

TensorFlow Lite avec les services Google Play est le chemin recommandé pour utiliser TensorFlow Lite sur Android. Si votre application cible des appareils qui n'exécutent pas Google Play, consultez la section GPU avec API Interpreter et TensorFlow Lite autonome .

Ajouter des dépendances de 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 GPU

Ensuite, initialisez TensorFlow Lite avec les services Google Play avec la prise en charge du GPU :

    val useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

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

    Task useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context);

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

Vous pouvez enfin initialiser l'interpréteur en passant 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èle ML dans Android Studio. Pour plus d'informations, consultez Générer des interfaces de modèle à l'aide de métadonnées .

Utiliser le GPU avec TensorFlow Lite autonome

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 de 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 GPU

Exécutez ensuite TensorFlow Lite sur GPU avec TfLiteDelegate . En Java, vous pouvez spécifier le GpuDelegate via 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

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.

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

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

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 .