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 pourTfLiteVision
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 dansObjectDetector
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;
etimport org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime;
à n'importe quel fichier source à l'aide des classesorg.tensorflow.lite.Interpreter
ouorg.tensorflow.lite.InterpreterApi
. - Si l'un des appels résultants à
InterpreterApi.create()
n'a qu'un seul argument, ajouteznew 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
parorg.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.