API C TensorFlow Lite dans les services Google Play (bêta)

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.

Task tfLiteInitializeTask = TfLiteNative.initialize(context);
      

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:

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);
}
      

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:

tfLiteHandleTask.onSuccessTask(unused -> {
    TfLiteJni jni = new TfLiteJni();
    jni.loadModel(getAssets(), "add.bin");
    //...
});
    

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.