LiteRT dans l'API Java des services Google Play

Vous pouvez également accéder à LiteRT dans les services Google Play à l'aide des API Java, en plus de l'API native. En particulier, LiteRT sur Google Play sont disponibles via l'interprète LiteRT. API.

Utiliser les API Interpreter

L'API LiteRT Interpreter, fournie par l'environnement d'exécution TensorFlow, fournit une interface à usage général pour créer et exécuter des modèles de ML. Utilisez le pour exécuter des inférences avec l'API Interpreter à l'aide de TensorFlow Lite dans l'environnement d'exécution des 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 au Play Store API Services pour LiteRT:

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

2. Ajouter l'initialisation de LiteRT

Initialiser 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éer un interpréteur à l'aide de InterpreterApi.create() et le configurer pour qu'il utilise 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 Android thread d'interface utilisateur. Si vous devez gérer l'exécution des threads de plus près, 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 des processeurs matériels spécialisés, tels que des processeurs graphiques (GPU). Toi peut 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 qu'il est chargé de manière dynamique, comme les versions Interpreter API.

Vérification de la compatibilité de l'appareil

Tous les appareils ne sont pas compatibles avec l'accélération matérielle GPU avec TFLite. Afin de pour limiter les erreurs et les plantages potentiels, TfLiteGpu.isGpuDelegateAvailable pour vérifier si un appareil est compatible avec le délégué de GPU.

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

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Une fois que vous disposez d'une variable comme useGpuTask, vous pouvez l'utiliser pour déterminer si utilisent le délégué de 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 Interpreter

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

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

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

  2. Activez l'option "Délégué de GPU" lors de l'initialisation de TFlite:

    Kotlin

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

    Java

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

  3. Activer le délégué de GPU dans les options de l'interpréteur: définissez la fabrique déléguée 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 la version autonome de LiteRT

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

  1. Consultez la section Limites de cette page pour vous assurer que est pris en charge.
  2. Avant de mettre à jour votre code, vérifiez les performances et l'exactitude de votre en particulier si vous utilisez des versions de LiteRT par rapport à la version 2.1. Vous disposez donc d'une référence à comparer la mise en œuvre.
  3. Si vous avez migré l'ensemble de votre code afin d'utiliser l'API des services Play pour LiteRT, vous devez supprimer l'environnement d'exécution LiteRT existant. les dépendances de bibliothèque (entrées avec org.tensorflow:tensorflow-lite:*) à partir de votre fichier build.gradle afin de réduire la taille de votre application.
  4. Identifier toutes les occurrences de création d'objet new Interpreter dans votre code et modifier chacun d'entre eux pour qu'il utilise l'appel InterpreterApi.create(). La TfLite.Initialize est asynchrone, ce qui signifie que dans la plupart des cas, il ne s'agit pas Remplacement par dépôt direct: vous devez enregistrer un écouteur lorsque l'appel terminé. Reportez-vous à l'extrait de code de l'étape 3.
  5. Ajouter import org.tensorflow.lite.InterpreterApi; et import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; à n'importe quelle source à l'aide des commandes org.tensorflow.lite.Interpreter ou org.tensorflow.lite.InterpreterApi.
  6. Si l'un des appels obtenus à InterpreterApi.create() ne comporte qu'un argument unique, ajoutez new InterpreterApi.Options() à la liste d'arguments.
  7. Ajouter .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) au dernier argument de les appels à InterpreterApi.create().
  8. Remplacer toutes les autres occurrences de la classe org.tensorflow.lite.Interpreter avec org.tensorflow.lite.InterpreterApi.

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