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

TensorFlow Lite dans les services Google Play

TensorFlow Lite est disponible dans l'environnement d'exécution des services Google Play pour tous les appareils Android exécutant la version actuelle des services Play. Cet environnement d'exécution vous permet d'exécuter des modèles d'apprentissage automatique (ML) sans regrouper de manière statique les bibliothèques TensorFlow Lite dans votre application.

Avec l'API des services Google Play, vous pouvez réduire la taille de vos applications et améliorer les performances de la dernière version stable des bibliothèques. TensorFlow Lite dans les services Google Play est la méthode recommandée pour utiliser TensorFlow Lite sur Android.

Vous pouvez démarrer avec l'environnement d'exécution des services Play avec le Quickstart , qui fournit un guide étape par étape pour implémenter un exemple d'application. Si vous utilisez déjà TensorFlow Lite autonome dans votre application, reportez-vous à la section Migrer depuis TensorFlow Lite autonome pour mettre à jour une application existante afin d'utiliser l'environnement d'exécution des services Play. Pour plus d'informations sur les services Google Play, consultez le site Web des services Google Play .

Utilisation de l'environnement d'exécution des services Play

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èle 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 les bibliothèques d'exécution et de support 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'implémenter les API Interpreter et Task Library 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 TensorFlow Lite Task encapsule 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 de tâche si votre application nécessite l'une des tâches prises en charge .

1. Ajouter des dépendances de projet

La dépendance de votre projet dépend de votre cas d'utilisation de machine learning. Les API de tâche contiennent les bibliothèques suivantes :

Bibliothèque Vision : org.tensorflow:tensorflow-lite-task-vision-play-services
Bibliothèque audio : org.tensorflow:tensorflow-lite-task-audio-play-services
Bibliothèque de texte : 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 dans 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'objet 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'objet 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 d'interpréteur

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

Ajoutez les dépendances suivantes au code de projet de votre 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éteur et définissez 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 illustré 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 d'interface utilisateur Android. Si vous avez besoin de gérer plus étroitement 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 tirer parti 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 de tâche et de l'API d'interprète.
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 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 processeur 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 avez une variable comme 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 fait avec les API de la bibliothèque de tâches et de l'interpréteur.

Avec l'API de tâche

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 interprète

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âche :

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 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 .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 GPU délégué dans l'initialisation de TFlite :

Kotlin

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

Java

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

Définissez le délégué GPU dans les options de l'interpréteur pour utiliser DelegateFactory en appelant addDelegateFactory() dans 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());

Migrer depuis TensorFlow Lite autonome

Si vous envisagez de migrer votre application de TensorFlow Lite autonome vers l'API des services Play, consultez les instructions supplémentaires suivantes 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 référence à comparer à 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 peut réduire la taille de votre application.
Identifiez toutes les occurrences de la création d'un new Interpreter dans votre code et modifiez-le afin qu'il utilise l'appel InterpreterApi.create(). Cette nouvelle API est asynchrone, ce qui signifie que dans la plupart des cas, il ne s'agit pas d'un remplacement instantané, et vous devez enregistrer un écouteur pour la fin de l'appel. Reportez-vous à l'extrait de code dans le code de l' étape 3 .
Ajouter import org.tensorflow.lite.InterpreterApi; et import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; à tous les fichiers 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 des 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.

Limites

TensorFlow Lite dans les services Google Play présente les limitations suivantes :

La prise en charge des délégués d'accélération matérielle est limitée aux délégués répertoriés dans la section Accélération matérielle . Aucun autre délégué d'accélération n'est pris en charge.
L'accès à TensorFlow Lite via des API natives n'est pas pris en charge. Seules les API Java TensorFlow Lite sont disponibles via les services Google Play.
Les API TensorFlow Lite expérimentales ou obsolètes, y compris les opérations personnalisées, ne sont pas prises en charge.

Soutien et commentaires

Vous pouvez fournir des commentaires et obtenir de l'aide via l'outil de suivi des problèmes TensorFlow. Veuillez signaler les problèmes et les demandes d'assistance à l'aide du modèle de problème pour TensorFlow Lite dans les services Google Play.

Conditions d'utilisation

L'utilisation de TensorFlow Lite dans les API des services Google Play est soumise aux conditions d'utilisation des API Google .

Confidentialité et collecte de données

Lorsque vous utilisez TensorFlow Lite dans les API des services Google Play, le traitement des données d'entrée, telles que les images, les vidéos et le texte, s'effectue entièrement sur l'appareil, et TensorFlow Lite dans les API des services Google Play n'envoie pas ces données aux serveurs Google. Par conséquent, vous pouvez utiliser nos API pour traiter des données qui ne doivent pas quitter l'appareil.

Les API des services TensorFlow Lite dans Google Play peuvent contacter les serveurs Google de temps à autre afin de recevoir des éléments tels que des correctifs de bogues, des modèles mis à jour et des informations de compatibilité des accélérateurs matériels. Les API des services TensorFlow Lite dans Google Play envoient également à Google des métriques sur les performances et l'utilisation des API dans votre application. Google utilise ces données de métrique pour mesurer les performances, déboguer, maintenir et améliorer les API, et détecter les abus ou les abus, comme décrit plus en détail dans notre Politique de confidentialité .

Il vous incombe d'informer les utilisateurs de votre application du traitement par Google des données de métriques des API des services TensorFlow Lite dans Google Play, conformément à la loi en vigueur.

Les données que nous collectons incluent les éléments suivants :

Informations sur l'appareil (telles que le fabricant, le modèle, la version et la version du système d'exploitation) et les accélérateurs matériels ML disponibles (GPU et DSP). Utilisé pour les diagnostics et l'analyse de l'utilisation.
Identifiant de l'appareil utilisé pour les diagnostics et l'analyse de l'utilisation.
Informations sur l'application (nom du package, version de l'application). Utilisé pour les diagnostics et l'analyse de l'utilisation.
Configuration de l'API (par exemple, quels délégués sont utilisés). Utilisé pour les diagnostics et l'analyse de l'utilisation.
Type d'événement (comme la création d'un interpréteur, l'inférence). Utilisé pour les diagnostics et l'analyse de l'utilisation.
Codes d'erreur. Utilisé pour le diagnostic.
Indicateurs de performance. Utilisé pour le diagnostic.

Prochaines étapes

Pour plus d'informations sur la mise en œuvre du machine learning dans votre application mobile avec TensorFlow Lite, consultez le Guide du développeur TensorFlow Lite . Vous pouvez trouver d'autres modèles TensorFlow Lite pour la classification d'images, la détection d'objets et d'autres applications sur le TensorFlow Hub .