LiteRT na API C do Google Play Services (Beta)

O LiteRT no ambiente de execução do Google Play Services permite executar de machine learning (ML) sem agrupar estaticamente as bibliotecas LiteRT em seu app. Este guia fornece instruções sobre como usar as APIs C para o Google Google Play Services.

Antes de usar a LiteRT na API C do Google Play Services, verifique se a ferramenta de build CMake está instalada;

Atualizar a configuração da compilação

Adicione as seguintes dependências ao código do projeto do app para acessar a biblioteca Play API de serviços para LiteRT:

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

Em seguida, ative Prefab (link em inglês) para acessar a API C pelo script do CMake atualizando o bloco do Android do arquivo build.gradle do seu módulo:

buildFeatures {
  prefab = true
}

Por fim, é necessário adicionar o pacote tensorflowlite_jni_gms_client importado do AAR como uma dependência no script do 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)

Inicializar o ambiente de execução LiteRT

Antes de chamar a API LiteRT nativa, você precisa inicializar o TfLiteNative ambiente de execução no seu código Java/Kotlin.

Task tfLiteInitializeTask = TfLiteNative.initialize(context);
      

val tfLiteInitializeTask: Task = TfLiteNative.initialize(context)
        

Usando a API Task do Google Play Services, TfLiteNative.initialize carrega de forma assíncrona o tempo de execução do TFLite a partir do Google Play Services no seu do ambiente de execução do aplicativo. Use addOnSuccessListener() para garantir que o A tarefa TfLite.initialize() é concluída antes da execução do código que acessa APIs LiteRT. Depois que a tarefa for concluída com êxito, será possível invocar todas as APIs nativas do TFLite disponíveis.

Implementação de código nativo

Para usar o LiteRT no Google Play Services com seu código nativo, faça o seguinte: uma das seguintes opções:

• declarar novas funções JNI para chamar funções nativas do código Java
• Chame a API LiteRT nativa do seu código C nativo.

Funções JNI:

É possível declarar uma nova função JNI para declarar o ambiente de execução LiteRT em Java/Kotlin acessíveis ao código nativo da seguinte forma:

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
}
        

Corresponde às seguintes funções nativas loadModel e runInference:

#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

Em seguida, você pode chamar as funções C usando o código 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 em código C

Inclua o arquivo principal da API adequado para incluir o TfLite com o Google Play API de serviços:

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

Depois, você pode usar a API LiteRT C normal:

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

O LiteRT com cabeçalhos da API nativa do Google Play Services oferece a a mesma API que a API API LiteRT C, exceto recursos que foram descontinuados ou experimentais. Por enquanto, as funções e os tipos dos cabeçalhos c_api.h, c_api_types.h e common.h estão disponíveis. Não se esqueça Não há suporte para as funções do cabeçalho c_api_experimental.h.

Para usar funções específicas da LiteRT com o Google Play Services, incluindo tflite.h.