TensorFlow est de retour sur Google I/O le 14 mai ! S'inscrire maintenant

Cette page a été traduite par l'API Cloud Translation.

TensorFlow Lite dans l'API Java des services Google Play

TensorFlow Lite dans les services Google Play est également accessible à l'aide des API Java, en plus de l'API native. En particulier, TensorFlow Lite dans les services Google Play est disponible via l' API TensorFlow Lite Task et l' API TensorFlow Lite Interpreter . La bibliothèque de tâches fournit des interfaces de modèles prêtes à l'emploi optimisées pour les tâches courantes d'apprentissage automatique utilisant des données visuelles, audio et textuelles. L'API TensorFlow Lite Interpreter, fournie par le runtime TensorFlow, fournit une interface plus générale pour créer et exécuter des modèles ML.

Les sections suivantes fournissent des instructions sur la façon d'utiliser les API Interpreter et Task Library avec TensorFlow Lite dans les services Google Play. Bien qu'il soit possible pour une application d'utiliser à la fois les API Interpreter et les API de la bibliothèque de tâches, la plupart des applications ne doivent utiliser qu'un seul ensemble d'API.

Utilisation des API de la bibliothèque de tâches

L'API de tâches TensorFlow Lite englobe l'API Interpreter et fournit une interface de programmation de haut niveau pour les tâches courantes d'apprentissage automatique qui utilisent des données visuelles, audio et textuelles. Vous devez utiliser l'API Task si votre application nécessite l'une des tâches prises en charge .

1. Ajouter des dépendances au projet

La dépendance de votre projet dépend de votre cas d'utilisation d'apprentissage automatique. Les API de tâches contiennent les bibliothèques suivantes :

Bibliothèque de vision : org.tensorflow:tensorflow-lite-task-vision-play-services
Bibliothèque audio : org.tensorflow:tensorflow-lite-task-audio-play-services
Bibliothèque de textes : org.tensorflow:tensorflow-lite-task-text-play-services

Ajoutez l'une des dépendances au code de votre projet d'application pour accéder à l'API des services Play pour TensorFlow Lite. Par exemple, utilisez ce qui suit pour implémenter une tâche de vision :

dependencies {
...
    implementation 'org.tensorflow:tensorflow-lite-task-vision-play-services:0.4.2'
...
}

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. L'exemple suivant initialise la bibliothèque de vision :

Kotlin

init {
  TfLiteVision.initialize(context)
}

3. Exécutez des inférences

Après avoir initialisé le composant TensorFlow Lite, appelez la méthode detect() pour générer des inférences. Le code exact de la méthode detect() varie en fonction de la bibliothèque et du cas d'utilisation. Ce qui suit concerne un cas d'utilisation simple de détection d'objets avec la bibliothèque TfLiteVision :

Kotlin

fun detect(...) {
  if (!TfLiteVision.isInitialized()) {
    Log.e(TAG, "detect: TfLiteVision is not initialized yet")
    return
  }

  if (objectDetector == null) {
    setupObjectDetector()
  }

  ...

}

Selon le format des données, vous devrez peut-être également prétraiter et convertir vos données dans la méthode detect() avant de générer des inférences. Par exemple, les données d'image d'un détecteur d'objets nécessitent les éléments suivants :

val imageProcessor = ImageProcessor.Builder().add(Rot90Op(-imageRotation / 90)).build()
val tensorImage = imageProcessor.process(TensorImage.fromBitmap(image))
val results = objectDetector?.detect(tensorImage)

Utilisation des API de l'interprète

Les API Interpreter offrent plus de contrôle et de flexibilité que les API de la bibliothèque de tâches. Vous devez utiliser les API Interpreter si votre tâche d'apprentissage automatique n'est pas prise en charge par la bibliothèque de tâches ou si vous avez besoin d'une interface plus générale pour créer et exécuter des modèles ML.

1. Ajouter des dépendances au projet

Ajoutez les dépendances suivantes au code de votre projet d'application pour accéder à l'API des services Play 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éez un interprète et définissez l'option d'exécution

Créez un interpréteur à l'aide InterpreterApi.create() et configurez-le pour utiliser 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 plus précisément 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écutez 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 unités de traitement graphique (GPU). Vous pouvez profiter de ces processeurs spécialisés à l'aide de pilotes matériels appelés délégués . Vous pouvez utiliser les délégués d'accélération matérielle suivants avec TensorFlow Lite dans les services Google Play :

Délégué GPU (recommandé) : ce délégué est fourni via les services Google Play et est chargé dynamiquement, tout comme les versions des services Play de l'API Task et de l'API Interpreter.
Délégué NNAPI : ce délégué est disponible en tant que dépendance de bibliothèque incluse dans votre projet de développement Android et est intégré à votre application.

Pour plus d'informations sur l'accélération matérielle avec TensorFlow Lite, consultez la page Délégués TensorFlow Lite .

Vérification de la compatibilité des appareils

Tous les appareils ne prennent pas en charge l'accélération matérielle GPU avec TFLite. Afin d'atténuer les erreurs et les plantages potentiels, utilisez la méthode TfLiteGpu.isGpuDelegateAvailable pour vérifier si un périphérique 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 ou le délégué NNAPI 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. Les exemples suivants montrent comment cela peut être réalisé avec les API de la bibliothèque de tâches et de l'interprète.

Avec l'API de tâches

Kotlin

lateinit val optionsTask = useGpuTask.continueWith { task ->
  val baseOptionsBuilder = BaseOptions.builder()
  if (task.result) {
    baseOptionsBuilder.useGpu()
  }
 ObjectDetectorOptions.builder()
          .setBaseOptions(baseOptionsBuilder.build())
          .setMaxResults(1)
          .build()
}

Java

Task<ObjectDetectorOptions> optionsTask = useGpuTask.continueWith({ task ->
  BaseOptions baseOptionsBuilder = BaseOptions.builder();
  if (task.getResult()) {
    baseOptionsBuilder.useGpu();
  }
  return ObjectDetectorOptions.builder()
          .setBaseOptions(baseOptionsBuilder.build())
          .setMaxResults(1)
          .build()
});

Avec l’API Interpreter

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 de bibliothèque de tâches

Pour utiliser le délégué GPU avec les API de tâches :

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'
```

Initialisez le délégué GPU avec setEnableGpuDelegateSupport . Par exemple, vous pouvez initialiser le délégué GPU pour TfLiteVision avec ce qui suit :

Kotlin

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

Java

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

Activez l'option de délégué GPU avec BaseOptions :

Kotlin

    val baseOptions = BaseOptions.builder().useGpu().build()

Java

    BaseOptions baseOptions = BaseOptions.builder().useGpu().build();

Configurez les options à l'aide de .setBaseOptions . Par exemple, vous pouvez configurer le GPU dans ObjectDetector avec les éléments suivants :

Kotlin

    val options =
        ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build()

Java

    ObjectDetectorOptions options =
        ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build();

GPU avec API d'interprétation

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

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'
```

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

Kotlin

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

Java

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

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() within InterpreterApi.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());

Migration depuis TensorFlow Lite autonome

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

Consultez la section Limitations de cette page pour vous assurer que votre cas d'utilisation est pris en charge.
Avant de mettre à jour votre code, effectuez des vérifications des performances et de la précision de vos modèles, en particulier si vous utilisez des versions de TensorFlow Lite antérieures à la version 2.1, afin de disposer d'une base de référence à comparer avec la nouvelle implémentation.
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 avec org.tensorflow: tensorflow-lite :* ) de votre fichier build.gradle afin que vous puissiez peut réduire la taille de votre application.
Identifiez toutes les occurrences de création 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 immédiat : vous devez enregistrer un écouteur lorsque l'appel est terminé. Reportez-vous à l'extrait de code du code de l'étape 3 .
Ajouter import org.tensorflow.lite.InterpreterApi; et import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; à n'importe quel fichier source à l'aide des classes org.tensorflow.lite.Interpreter ou org.tensorflow.lite.InterpreterApi .
Si l'un des appels résultants à InterpreterApi.create() n'a qu'un seul argument, ajoutez new InterpreterApi.Options() à la liste d'arguments.
Ajoutez .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) au dernier argument de tout appel à InterpreterApi.create() .
Remplacez toutes les autres occurrences de la classe org.tensorflow.lite.Interpreter par org.tensorflow.lite.InterpreterApi .

Si vous souhaitez utiliser TensorFlow Lite autonome et l'API des services Play côte à côte, vous devez utiliser TensorFlow Lite 2.9 (ou 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.