TensorFlow Lite dans l'API C des 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 d'apprentissage automatique (ML) sans regrouper statiquement les bibliothèques TensorFlow Lite dans votre application. Ce guide fournit des instructions sur la façon d'utiliser les API C pour les services Google Play.

Avant de travailler avec l'API C des services TensorFlow Lite dans les services Google Play, assurez-vous que l'outil de génération CMake est installé.

Mettez à jour votre configuration de build

Ajoutez les dépendances suivantes au code de votre projet d'application pour accéder à l'API des services Play 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 depuis 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é de 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 le runtime TensorFlow Lite

Avant d'appeler l'API TensorFlow Lite Native, vous devez initialiser le runtime TfLiteNative dans votre code Java/Kotlin.

Task tfLiteInitializeTask = TfLiteNative.initialize(context);
      

val tfLiteInitializeTask: Task = TfLiteNative.initialize(context)
        

À l'aide de l'API de tâches des services Google Play, TfLiteNative.initialize charge de manière asynchrone le runtime TFLite 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 le code qui accède aux API TensorFlow Lite. Une fois la tâche terminée avec succès, vous pouvez appeler toutes les API natives TFLite disponibles.

Implémentation du 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éclarez 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 le runtime 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
}
        

Correspondant aux 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 depuis 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 l'API des services TfLite avec Google Play :

#include "tensorflow/lite/c/c_api.h"

Vous pouvez ensuite utiliser l'API C TensorFlow Lite standard :

auto model = TfLiteModelCreate(model_asset, model_asset_length);
// ...
auto options = TfLiteInterpreterOptionsCreate();
// ...
auto interpreter = TfLiteInterpreterCreate(model, options);

Les en-têtes d'API natives des services TensorFlow Lite avec Google Play fournissent la même API que l' API C TensorFlow Lite standard, à l'exclusion des fonctionnalités obsolètes ou expérimentales. Pour l'instant, 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 prises en charge. La documentation peut être consultée en ligne .

Vous pouvez utiliser les fonctions spécifiques à TensorFlow Lite avec les services Google Play en incluant tflite.h .