LiteRT dans l'API Java (et Kotlin) des services Google Play

LiteRT dans les services Google Play est également accessible à l'aide d'API Java, qui peuvent être utilisées à partir de code Java ou Kotlin, en plus de l'API Native. Plus précisément, LiteRT dans les services Google Play est disponible via l'API LiteRT Interpreter.

Utiliser les API Interpreter

L'API LiteRT Interpreter, fournie par l'exécution TensorFlow, fournit une interface à usage général pour créer et exécuter des modèles de ML. Suivez les étapes ci-dessous pour exécuter des inférences avec l'API Interpreter à l'aide du runtime TensorFlow Lite dans les services Google Play.

1. Ajouter des dépendances de projet

Ajoutez les dépendances suivantes au code de votre projet d'application pour accéder à l'API des services Play pour LiteRT :

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

2. Ajouter l'initialisation de LiteRT

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

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 une option d'exécution

Créez un interpréteur à l'aide de InterpreterApi.create() et configurez-le pour qu'il utilise le runtime 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 avez besoin de gérer l'exécution des threads de manière plus précise, 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

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

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

Vérifier la compatibilité de l'appareil

Tous les appareils ne sont pas compatibles avec l'accélération matérielle du GPU avec TFLite. Pour éviter 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 confirmer si un appareil est compatible avec le GPU et utilisez le CPU 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 les API Interpreter

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

  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.2.0'

  2. Activez l'option de délégué GPU dans l'initialisation 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 de délégués sur GpuDelegateFactory en appelant addDelegateFactory() withinInterpreterApi.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 LiteRT autonome

Si vous prévoyez de migrer votre application de LiteRT autonome vers l'API Play Services, consultez les conseils supplémentaires suivants pour mettre à jour le code du projet de votre application :

  1. Consultez la section Limites pour vous assurer que votre cas d'utilisation est pris en charge.
  2. Avant de mettre à jour votre code, nous vous recommandons de vérifier les performances et la précision de vos modèles, en particulier si vous utilisez des versions de LiteRT (TF Lite) antérieures à la version 2.1. Vous disposerez ainsi d'une référence à comparer à la nouvelle implémentation.
  3. Si vous avez migré tout votre code pour utiliser l'API des services Play pour LiteRT, vous devez supprimer les dépendances de la bibliothèque d'exécution LiteRT existantes (entrées avec org.tensorflow:tensorflow-lite:*) de votre fichier build.gradle afin de 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 pour qu'elle utilise l'appel InterpreterApi.create(). Le nouveau TfLite.initialize est asynchrone, ce qui signifie que, dans la plupart des cas, il ne s'agit pas d'un remplacement direct : vous devez enregistrer un écouteur pour savoir quand l'appel se termine. 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 à InterpreterApi.create() résultants ne comporte qu'un seul argument, ajoutez new InterpreterApi.Options() à la liste des 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 LiteRT autonome et l'API des services Play côte à côte, vous devez utiliser LiteRT (TF Lite) version 2.9 ou ultérieure. LiteRT (TF Lite) version 2.8 et les versions antérieures ne sont pas compatibles avec la version de l'API des services Play.