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

LiteRT dans l'environnement d'exécution des services Google Play vous permet d'exécuter de ML (ML) sans avoir à regrouper statiquement des bibliothèques LiteRT dans votre application. Ce guide fournit des instructions sur l'utilisation des API C pour Google Services Play.

Avant d'utiliser LiteRT dans l'API C des services Google Play, assurez-vous vous avez installé l'outil de compilation CMake.

Mettre à jour votre configuration de compilation

Ajoutez les dépendances suivantes au code de votre projet d'application pour accéder au Play Store API Services pour LiteRT:

implementation "com.google.android.gms:play-services-tflite-java:16.2.0-beta02"

Ensuite, activez le paramètre 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 LiteRT

Avant d'appeler l'API native LiteRT, vous devez initialiser TfLiteNative dans votre code Java/Kotlin.

Task tfLiteInitializeTask = TfLiteNative.initialize(context);
      

val tfLiteInitializeTask: Task = TfLiteNative.initialize(context)
        

TfLiteNative.initialize à l'aide de l'API Task des services Google Play charge de manière asynchrone l'environnement d'exécution TFLite depuis les services Google Play dans votre le processus d'exécution de l'application. Utilisez addOnSuccessListener() pour vous assurer que La tâche TfLite.initialize() se termine avant d'exécuter du code qui accède les API LiteRT. Une fois la tâche terminée, vous pouvez appeler toutes les API natives TFLite disponibles.

Implémentation de code natif

Pour utiliser LiteRT dans les services Google Play avec votre code natif, vous pouvez : l'une des options suivantes:

• déclarer de nouvelles fonctions JNI pour appeler des fonctions natives à partir de votre code Java ;
• Appelez l'API native LiteRT à partir de votre code C natif existant.

Fonctions JNI:

Vous pouvez déclarer une nouvelle fonction JNI pour que l'environnement d'exécution LiteRT soit 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 des 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")
    // ...
}
      

Littérature en code C

Incluez le fichier d'en-tête d'API approprié pour inclure TfLite avec Google Play. API des services:

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

Vous pouvez ensuite utiliser l'API C LiteRT standard:

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

Les en-têtes de l'API native LiteRT avec les services Google Play fournissent la même API que API C LiteRT, à l'exception de de nouvelles 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 Notez que les fonctions de l'en-tête c_api_experimental.h ne sont pas acceptées.

Vous pouvez utiliser des fonctions spécifiques à LiteRT avec les services Google Play en procédant comme suit : y compris tflite.h.