TensorFlow Lite dans l'environnement d'exécution des services Google Play vous permet d'exécuter des modèles de machine learning (ML) sans regrouper de manière statique les bibliothèques TensorFlow Lite dans votre application. Ce guide explique comment utiliser les API C pour les services Google Play.
Avant d'utiliser TensorFlow Lite dans l'API C des services Google Play, assurez-vous que l'outil de compilation CMake est installé.
Mettre à jour votre configuration de compilation
Ajoutez les dépendances suivantes au code de votre projet d'application afin d'accéder à l'API Play Services pour TensorFlow Lite:
implementation "com.google.android.gms:play-services-tflite-java:16.2.0-beta02"
Ensuite, activez la fonctionnalité Prefab pour accéder à l'API C à partir de votre script CMake en mettant à jour le bloc Android du fichier build.gradle de votre module:
buildFeatures {
prefab = true
}
Vous devez enfin ajouter le package tensorflowlite_jni_gms_client
importé depuis l'AAR en tant que dépendance dans votre script CMake:
find_package(tensorflowlite_jni_gms_client REQUIRED CONFIG)
target_link_libraries(tflite-jni # your JNI lib target
tensorflowlite_jni_gms_client::tensorflowlite_jni_gms_client
android # other deps for your target
log)
# Also add -DTFLITE_IN_GMSCORE -DTFLITE_WITH_STABLE_ABI
# to the C/C++ compiler flags.
add_compile_definitions(TFLITE_IN_GMSCORE)
add_compile_definitions(TFLITE_WITH_STABLE_ABI)
Initialiser l'environnement d'exécution TensorFlow Lite
Avant d'appeler l'API native TensorFlow Lite, vous devez initialiser l'environnement d'exécution TfLiteNative
dans votre code Java/Kotlin.
Java
Task tfLiteInitializeTask = TfLiteNative.initialize(context);
Kotlin
val tfLiteInitializeTask: Task= TfLiteNative.initialize(context)
À l'aide de l'API Task des services Google Play, TfLiteNative.initialize
charge de manière asynchrone l'environnement d'exécution TFLite à partir des services Google Play dans le processus d'exécution de votre application. Utilisez addOnSuccessListener()
pour vous assurer que la tâche TfLite.initialize()
se termine avant d'exécuter du code qui accède aux API TensorFlow Lite. Une fois la tâche terminée, vous pouvez appeler toutes les API TFLite Native disponibles.
Intégration de code natif
Pour utiliser TensorFlow Lite dans les services Google Play avec votre code natif, vous pouvez effectuer l'une des opérations suivantes:
- Déclarer de nouvelles fonctions JNI pour appeler des fonctions natives à partir de votre code Java
- Appelez l'API native TensorFlow Lite à partir de votre code C natif existant.
Fonctions JNI:
Vous pouvez déclarer une nouvelle fonction JNI pour rendre l'environnement d'exécution TensorFlow Lite déclaré en Java/Kotlin accessible à votre code natif, comme suit:
Java
package com.google.samples.gms.tflite.c; public class TfLiteJni { static { System.loadLibrary("tflite-jni"); } public TfLiteJni() { /**/ }; public native void loadModel(AssetManager assetManager, String assetName); public native float[] runInference(float[] input); }
Kotlin
package com.google.samples.gms.tflite.c class TfLiteJni() { companion object { init { System.loadLibrary("tflite-jni") } } external fun loadModel(assetManager: AssetManager, assetName: String) external fun runInference(input: FloatArray): FloatArray }
Correspondance avec les fonctions natives loadModel
et runInference
suivantes:
#ifdef __cplusplus
extern "C" {
#endif
void Java_com_google_samples_gms_tflite_c_loadModel(
JNIEnv *env, jobject tflite_jni, jobject asset_manager, jstring asset_name){
//...
}
jfloatArray Java_com_google_samples_gms_tflite_c_TfLiteJni_runInference(
JNIEnv* env, jobject tfliteJni, jfloatArray input) {
//...
}
#ifdef __cplusplus
} // extern "C".
#endif
Vous pouvez ensuite appeler vos fonctions C à partir de votre code Java/Kotlin:
Java
tfLiteHandleTask.onSuccessTask(unused -> { TfLiteJni jni = new TfLiteJni(); jni.loadModel(getAssets(), "add.bin"); //... });
Kotlin
tfLiteHandleTask.onSuccessTask { val jni = TfLiteJni() jni.loadModel(assets, "add.bin") // ... }
TensorFlow Lite en code C
Incluez le fichier d'en-tête d'API approprié pour inclure TfLite avec l'API des services Google Play:
#include "tensorflow/lite/c/c_api.h"
Vous pouvez ensuite utiliser l'API TensorFlow Lite C standard:
auto model = TfLiteModelCreate(model_asset, model_asset_length);
// ...
auto options = TfLiteInterpreterOptionsCreate();
// ...
auto interpreter = TfLiteInterpreterCreate(model, options);
Les en-têtes d'API natives de TensorFlow Lite avec les services Google Play fournissent la même API que l'API TensorFlow Lite C standard, à l'exception des fonctionnalités obsolètes ou expérimentales. Pour le moment, les fonctions et les types des en-têtes c_api.h
, c_api_types.h
et common.h
sont disponibles. Veuillez noter que les fonctions de l'en-tête c_api_experimental.h
ne sont pas compatibles.
Vous pouvez utiliser des fonctions spécifiques à TensorFlow Lite avec les services Google Play en incluant tflite.h
.