API Java TensorFlow Lite dans les services Google Play

En plus de l'API native, vous pouvez accéder à TensorFlow Lite dans les services Google Play à l'aide des API Java. En particulier, TensorFlow Lite dans les services Google Play est disponible via l'API TensorFlow Lite Interpreter.

Utiliser les API Interpréteur

L'API Interpréteur TensorFlow Lite, fournie par l'environnement d'exécution TensorFlow, fournit une interface à usage général permettant de créer et d'exécuter des modèles de ML. Procédez comme suit pour exécuter des inférences avec l'API Interpréteur à l'aide de TensorFlow Lite dans l'environnement d'exécution des services Google Play.

1. Ajouter des dépendances au projet

Ajoutez les dépendances suivantes au code de votre projet d'application afin d'accéder à l'API Play Services pour TensorFlow Lite:

dependencies {
...
    // Tensorflow Lite dependencies for Google Play services
    implementation 'com.google.android.gms:play-services-tflite-java:16.0.1'
    // Optional: include Tensorflow Lite Support Library
    implementation 'com.google.android.gms:play-services-tflite-support:16.0.1'
...
}

2. Ajouter l'initialisation de TensorFlow Lite

Initialisez le composant TensorFlow Lite de l'API des services Google Play avant d'utiliser les API TensorFlow Lite:

Kotlin

val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }

Java

Task<Void> initializeTask = TfLite.initialize(context);

3. Créer un interpréteur et définir l'option d'exécution

Créez un interpréteur à l'aide de InterpreterApi.create() et configurez-le pour utiliser l'environnement d'exécution des services Google Play en appelant InterpreterApi.Options.setRuntime(), comme indiqué dans l'exemple de code suivant:

Kotlin

import org.tensorflow.lite.InterpreterApi
import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime
...
private lateinit var interpreter: InterpreterApi
...
initializeTask.addOnSuccessListener {
  val interpreterOption =
    InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  interpreter = InterpreterApi.create(
    modelBuffer,
    interpreterOption
  )}
  .addOnFailureListener { e ->
    Log.e("Interpreter", "Cannot initialize interpreter", e)
  }

Java

import org.tensorflow.lite.InterpreterApi
import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime
...
private InterpreterApi interpreter;
...
initializeTask.addOnSuccessListener(a -> {
    interpreter = InterpreterApi.create(modelBuffer,
      new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY));
  })
  .addOnFailureListener(e -> {
    Log.e("Interpreter", String.format("Cannot initialize interpreter: %s",
          e.getMessage()));
  });

Vous devez utiliser l'implémentation ci-dessus, car elle évite de bloquer le thread de l'interface utilisateur Android. Si vous devez gérer de plus près l'exécution des threads, vous pouvez ajouter un appel Tasks.await() à la création de l'interpréteur:

Kotlin

import androidx.lifecycle.lifecycleScope
...
lifecycleScope.launchWhenStarted { // uses coroutine
  initializeTask.await()
}

Java

@BackgroundThread
InterpreterApi initializeInterpreter() {
    Tasks.await(initializeTask);
    return InterpreterApi.create(...);
}

4. Exécuter des inférences

À l'aide de l'objet interpreter que vous avez créé, appelez la méthode run() pour générer une inférence.

Kotlin

interpreter.run(inputBuffer, outputBuffer)

Java

interpreter.run(inputBuffer, outputBuffer);

Accélération matérielle

TensorFlow Lite vous permet d'accélérer les performances de votre modèle à l'aide de processeurs matériels spécialisés, tels que des processeurs graphiques (GPU). Vous pouvez exploiter ces processeurs spécialisés à l'aide de pilotes matériels appelés délégués.

Le délégué de GPU est fourni via les services Google Play et est chargé de manière dynamique, tout comme les versions des services Play de l'API Interpréteur.

Vérifier la compatibilité de l'appareil

Tous les appareils ne sont pas compatibles avec l'accélération matérielle GPU avec TFLite. Pour atténuer les erreurs et les plantages potentiels, utilisez la méthode TfLiteGpu.isGpuDelegateAvailable pour vérifier si un appareil est compatible avec le délégué GPU.

Utilisez cette méthode pour vérifier si un appareil est compatible avec le GPU, et utilisez le processeur comme solution de secours lorsque le GPU n'est pas pris en charge.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Une fois que vous disposez d'une variable telle que useGpuTask, vous pouvez l'utiliser pour déterminer si les appareils utilisent le délégué GPU.

Kotlin

val interpreterTask = useGpuTask.continueWith { task ->
  val interpreterOptions = InterpreterApi.Options()
      .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
  if (task.result) {
      interpreterOptions.addDelegateFactory(GpuDelegateFactory())
  }
  InterpreterApi.create(FileUtil.loadMappedFile(context, MODEL_PATH), interpreterOptions)
}

Java

Task<InterpreterApi.Options> interpreterOptionsTask = useGpuTask.continueWith({ task ->
  InterpreterApi.Options options =
      new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY);
  if (task.getResult()) {
     options.addDelegateFactory(new GpuDelegateFactory());
  }
  return options;
});

GPU avec API Interpréteur

Pour utiliser le délégué GPU avec les API Interpréteur:

  1. Mettez à jour les dépendances du projet pour utiliser le délégué GPU des services Play:

    implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'

  2. Activez l'option de délégué de GPU dans l'initialisation de TFlite:

    Kotlin

        TfLite.initialize(context,
      TfLiteInitializationOptions.builder()
       .setEnableGpuDelegateSupport(true)
       .build())

    Java

        TfLite.initialize(context,
      TfLiteInitializationOptions.builder()
       .setEnableGpuDelegateSupport(true)
       .build());

  3. Activez le délégué GPU dans les options de l'interpréteur: définissez la fabrique déléguée sur GpuDelegateFactory en appelant addDelegateFactory() withinSignificationerApi.Options()`:

    Kotlin

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

    Java

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

Migrer depuis la version autonome de TensorFlow Lite

Si vous prévoyez de migrer votre application de la version autonome de TensorFlow Lite vers l'API des services Play, consultez les conseils supplémentaires suivants pour mettre à jour le code de votre projet d'application:

  1. Consultez la section Limites de cette page pour vous assurer que votre cas d'utilisation est pris en charge.
  2. Avant de mettre à jour votre code, vérifiez les performances et la justesse de vos modèles, en particulier si vous utilisez des versions de TensorFlow Lite antérieures à la version 2.1. Vous disposerez ainsi d'une référence pour la comparer à la nouvelle implémentation.
  3. Si vous avez migré tout votre code pour utiliser l'API des services Play pour TensorFlow Lite, vous devez supprimer les dépendances existantes de la bibliothèque d'exécution TensorFlow Lite (entrées associées à org.tensorflow:tensorflow-lite:*) du fichier build.gradle, afin de pouvoir réduire la taille de votre application.
  4. Identifiez toutes les occurrences de création d'objet new Interpreter dans votre code et modifiez chacune d'elles afin qu'elle utilise l'appel InterpreterApi.create(). Le nouveau TfLite.divers est asynchrone, ce qui signifie qu'il ne s'agit pas dans la plupart des cas d'un remplacement ponctuel: vous devez enregistrer un écouteur à la fin de l'appel. Reportez-vous à l'extrait de code de l'étape 3.
  5. Ajoutez import org.tensorflow.lite.InterpreterApi; et import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; à tous les fichiers sources à l'aide des classes org.tensorflow.lite.Interpreter ou org.tensorflow.lite.InterpreterApi.
  6. Si l'un des appels obtenus à InterpreterApi.create() ne comporte qu'un seul argument, ajoutez new InterpreterApi.Options() à la liste d'arguments.
  7. Ajoutez .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) au dernier argument de tous les appels à InterpreterApi.create().
  8. Remplacez toutes les autres occurrences de la classe org.tensorflow.lite.Interpreter par org.tensorflow.lite.InterpreterApi.

Si vous souhaitez utiliser la version autonome de TensorFlow Lite et l'API des services Play côte à côte, vous devez utiliser TensorFlow Lite 2.9 (ou une version ultérieure). TensorFlow Lite 2.8 et les versions antérieures ne sont pas compatibles avec la version de l'API des services Play.