LiteRT dans les API C et C++ des services Google Play

LiteRT 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 LiteRT dans votre application. Ce guide explique comment utiliser les API C ou C++ pour les services Google Play.

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

Mettre à jour la configuration de compilation

(1) Ajoutez les dépendances suivantes au code de votre projet d'application pour accéder à l'API Play Services pour LiteRT:

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

Notez que même si le nom du package se termine par -java, ce package contient également les API C et C++.

(2) 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
}

(3) [API C++] Si vous utilisez l'API C++, copiez tflite-java-extract-cpp-sdk.gradle dans votre projet, dans votre répertoire app, puis ajoutez ce qui suit au début du script Gradle de votre application (par exemple, app/build.gradle):

apply from: 'tflite-java-extract-cpp-sdk.gradle'

Il contient du code Gradle permettant de décompresser automatiquement le SDK C++ à partir du fichier AAR pour play-services-tflite-java.

(4) [API C++ uniquement] Si vous utilisez l'API C++, recherchez le répertoire contenant le fichier de configuration CMake de votre application (normalement CMakeLists.txt). Ce répertoire est normalement votre répertoire app/src/main/cpp. Copiez ensuite Findtflite_cc_api.cmake dans votre projet, dans un nouveau sous-répertoire Modules de ce répertoire. Il contient du code qui recherche le SDK C++ décompressé par le script Gradle à l'étape précédente.

(5) Vous devez enfin ajouter le package tensorflowlite_jni_gms_client et, pour l'API C++, le package tflite_cc_api, tous deux importés depuis l'AAR, en tant que dépendances dans votre script CMake:

Initialiser l'environnement d'exécution LiteRT

Avant d'appeler l'API native LiteRT, vous devez initialiser l'environnement d'exécution TfLiteNative dans votre code Java ou 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 le code qui accède aux API LiteRT. Une fois la tâche terminée, vous pouvez appeler toutes les API natives TFLite disponibles.

Implémentation du code natif

Pour utiliser LiteRT dans les services Google Play avec votre code C/C++, vous pouvez effectuer l'une (ou les deux) des opérations suivantes:

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

Fonctions JNI

Vous pouvez déclarer de nouvelles fonctions JNI pour rendre l'environnement d'exécution LiteRT déclaré en code C/C++ accessible à votre code Java/Kotlin 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);  // For example.
}
      

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  // For example.
}
        

Correspondance avec les fonctions C ou C++ 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/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")
    // ...
}
      

LiteRT en code natif

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

Vous pouvez ensuite utiliser l'API LiteRT C ou C++ standard:

API compatibles