LiteRT en el entorno de ejecución de los Servicios de Google Play modelos de aprendizaje automático (AA) sin agrupar estáticamente las bibliotecas LiteRT tu app. En esta guía, se proporcionan instrucciones para usar las APIs de C para Google Servicios de Play
Antes de trabajar con LiteRT en la API C de los Servicios de Google Play, asegúrate de que Tener instalada la herramienta de compilación CMake
Cómo actualizar la configuración de tu compilación
Agrega las siguientes dependencias al código de tu proyecto de app para acceder a la app de Play de Google Services para LiteRT:
implementation "com.google.android.gms:play-services-tflite-java:16.2.0-beta02"
Luego, habilita el Prefab para acceder a la API de C desde tu secuencia de comandos de CMake actualizando el bloque Android del archivo build.gradle de tu módulo:
buildFeatures {
prefab = true
}
Por último, debes agregar el paquete tensorflowlite_jni_gms_client
importado.
del AAR como una dependencia en tu secuencia de comandos de 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)
Cómo inicializar el entorno de ejecución de LiteRT
Antes de llamar a la LiteRT Native API, debes inicializar el
TfLiteNative
en tu código Java/Kotlin.
Java
Task tfLiteInitializeTask = TfLiteNative.initialize(context);
Kotlin
val tfLiteInitializeTask: Task= TfLiteNative.initialize(context)
Con la API de Google Play Services Task, TfLiteNative.initialize
Carga de forma asíncrona el entorno de ejecución de TFLite desde los Servicios de Google Play en tu
el proceso de tiempo de ejecución de tu aplicación. Usa addOnSuccessListener()
para asegurarte de que el elemento
Se completa TfLite.initialize()
tarea antes de ejecutar un código que accede
APIs de LiteRT. Una vez que la tarea se complete correctamente, puedes invocar
todas las APIs nativas de TFLite disponibles.
Implementación de código nativo
Para usar LiteRT en Servicios de Google Play con tu código nativo, puedes hacer lo siguiente: una de las siguientes opciones:
- Declara nuevas funciones de JNI para llamar a funciones nativas desde tu código Java
- Llama a la API nativa de LiteRT desde tu código C nativo existente.
Funciones de JNI:
Puedes declarar una nueva función JNI para declarar el tiempo de ejecución de LiteRT. en Java/Kotlin accesible para tu código nativo de la siguiente manera:
Java
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); }
Kotlin
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 }
Haz coincidir las siguientes funciones nativas loadModel
y 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
Luego, puedes llamar a las funciones de C desde el código Java o Kotlin:
Java
tfLiteHandleTask.onSuccessTask(unused -> { TfLiteJni jni = new TfLiteJni(); jni.loadModel(getAssets(), "add.bin"); //... });
Kotlin
tfLiteHandleTask.onSuccessTask { val jni = TfLiteJni() jni.loadModel(assets, "add.bin") // ... }
LiteRT en código C
Incluye el archivo de encabezado de la API adecuado para incluir TfLite con Google Play Services de Google:
#include "tensorflow/lite/c/c_api.h"
Luego, puedes usar la API de LiteRT C normal:
auto model = TfLiteModelCreate(model_asset, model_asset_length);
// ...
auto options = TfLiteInterpreterOptionsCreate();
// ...
auto interpreter = TfLiteInterpreterCreate(model, options);
Los encabezados de la API nativa de LiteRT de Servicios de Google Play proporcionan la
misma API que la normal
API de LiteRT C, sin incluir
funciones obsoletas o experimentales. Por ahora, las funciones y los tipos
de los encabezados c_api.h
, c_api_types.h
y common.h
. Por favor,
Ten en cuenta que no se admiten las funciones del encabezado c_api_experimental.h
.
Puedes usar funciones específicas de LiteRT con los Servicios de Google Play:
incluido tflite.h
.