TensorFlow Lite na API C do Google Play Services (Beta)

O TensorFlow Lite no tempo de execução do Google Play Services permite que você execute modelos de aprendizado de máquina (ML) sem agrupar bibliotecas do TensorFlow Lite estaticamente em seu aplicativo. Este guia fornece instruções sobre como usar as APIs C para Google Play Services.

Antes de trabalhar com o TensorFlow Lite na API C do Google Play Services, certifique-se de ter a ferramenta de compilação CMake instalada.

Atualize sua configuração de compilação

Adicione as seguintes dependências ao código do projeto do seu aplicativo para acessar a API Play Services para TensorFlow Lite:

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

Em seguida, habilite o recurso Prefab para acessar a API C do seu script CMake atualizando o bloco android do arquivo build.gradle do seu módulo:

buildFeatures {
  prefab = true
}

Finalmente, você precisa adicionar o pacote tensorflowlite_jni_gms_client importado do AAR como uma dependência em seu 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)

Inicialize o ambiente de execução do TensorFlow Lite

Antes de chamar a API nativa do TensorFlow Lite, você deve inicializar o tempo de execução TfLiteNative em seu código Java/Kotlin.

Task tfLiteInitializeTask = TfLiteNative.initialize(context);
      

val tfLiteInitializeTask: Task = TfLiteNative.initialize(context)
        

Usando a API de tarefas do Google Play Services, TfLiteNative.initialize carrega de forma assíncrona o tempo de execução do TFLite do Google Play Services no processo de tempo de execução do seu aplicativo. Use addOnSuccessListener() para garantir que a tarefa TfLite.initialize() seja concluída antes de executar o código que acessa as APIs do TensorFlow Lite. Depois que a tarefa for concluída com êxito, você poderá invocar todas as APIs TFLite Native disponíveis.

Implementação de código nativo

Para usar o TensorFlow Lite no Google Play Services com seu código nativo, siga um destes procedimentos:

• declare novas funções JNI para chamar funções nativas do seu código Java
• Chame a API nativa do TensorFlow Lite a partir do seu código C nativo existente.

Funções JNI:

Você pode declarar uma nova função JNI para tornar o tempo de execução do TensorFlow Lite declarado em Java/Kotlin acessível ao seu código nativo da seguinte maneira:

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
}
        

Correspondendo à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

Você pode então chamar suas funções C a partir do seu 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")
    // ...
}
      

TensorFlow Lite em código C

Inclua o arquivo de cabeçalho da API apropriado para incluir o TfLite com a API do Google Play Services:

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

Você pode então usar a API normal do TensorFlow Lite C:

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

Os cabeçalhos da API nativa do TensorFlow Lite com Google Play Services fornecem a mesma API que a API C normal do TensorFlow Lite , excluindo recursos obsoletos ou experimentais. Por enquanto as funções e tipos dos cabeçalhos c_api.h , c_api_types.h e common.h estão disponíveis. Observe que as funções do cabeçalho c_api_experimental.h não são suportadas. A documentação pode ser encontrada online .

Você pode usar funções específicas do TensorFlow Lite com o Google Play Services incluindo tflite.h .