También se puede acceder a LiteRT en los Servicios de Google Play con las APIs de Java, que se pueden usar desde el código Java o Kotlin, además de la API nativa. En particular, LiteRT en los Servicios de Google Play está disponible a través de la API de LiteRT Interpreter.
Cómo usar las APIs de Interpreter
La API de LiteRT Interpreter, proporcionada por el entorno de ejecución de TensorFlow, proporciona una interfaz de uso general para compilar y ejecutar modelos de AA. Sigue estos pasos para ejecutar inferencias con la API de Interpreter mediante TensorFlow Lite en el entorno de ejecución de los Servicios de Google Play.
1. Agrega dependencias del proyecto
Agrega las siguientes dependencias al código de tu proyecto de app para acceder a la API de los Servicios de Play para LiteRT:
dependencies {
...
// LiteRT dependencies for Google Play services
implementation 'com.google.android.gms:play-services-tflite-java:16.1.0'
// Optional: include LiteRT Support Library
implementation 'com.google.android.gms:play-services-tflite-support:16.1.0'
...
}
2. Se agregó la inicialización de LiteRT.
Inicializa el componente LiteRT de la API de los Servicios de Google Play antes de usar las APIs de LiteRT:
Kotlin
val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }
Java
Task<Void> initializeTask = TfLite.initialize(context);
3. Crea un intérprete y establece la opción de entorno de ejecución
Crea un intérprete con InterpreterApi.create()
y configúralo para usar el entorno de ejecución de los Servicios de Google Play llamando a InterpreterApi.Options.setRuntime()
, como se muestra en el siguiente código de ejemplo:
Kotlin
import org.tensorflow.lite.InterpreterApi import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime ... private lateinit var interpreter: InterpreterApi ... initializeTask.addOnSuccessListener { val interpreterOption = InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) interpreter = InterpreterApi.create( modelBuffer, interpreterOption )} .addOnFailureListener { e -> Log.e("Interpreter", "Cannot initialize interpreter", e) }
Java
import org.tensorflow.lite.InterpreterApi import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime ... private InterpreterApi interpreter; ... initializeTask.addOnSuccessListener(a -> { interpreter = InterpreterApi.create(modelBuffer, new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)); }) .addOnFailureListener(e -> { Log.e("Interpreter", String.format("Cannot initialize interpreter: %s", e.getMessage())); });
Debes usar la implementación anterior porque evita bloquear el subproceso de la interfaz de usuario de Android. Si necesitas administrar la ejecución de subprocesos de forma más detallada, puedes agregar una llamada Tasks.await()
a la creación del intérprete:
Kotlin
import androidx.lifecycle.lifecycleScope ... lifecycleScope.launchWhenStarted { // uses coroutine initializeTask.await() }
Java
@BackgroundThread InterpreterApi initializeInterpreter() { Tasks.await(initializeTask); return InterpreterApi.create(...); }
4. Ejecuta inferencias
Con el objeto interpreter
que creaste, llama al método run()
para generar una inferencia.
Kotlin
interpreter.run(inputBuffer, outputBuffer)
Java
interpreter.run(inputBuffer, outputBuffer);
Aceleración de hardware
LiteRT te permite acelerar el rendimiento de tu modelo mediante procesadores de hardware especializados, como las unidades de procesamiento gráfico (GPU). Puedes aprovechar estos procesadores especializados con controladores de hardware llamados delegados.
El delegado de la GPU se proporciona a través de los Servicios de Google Play y se carga de forma dinámica, al igual que las versiones de la API de Interpreter de los Servicios de Play.
Cómo verificar la compatibilidad del dispositivo
No todos los dispositivos admiten la aceleración de hardware de la GPU con TFLite. Para mitigar errores y posibles fallas, usa el método TfLiteGpu.isGpuDelegateAvailable
para verificar si un dispositivo es compatible con el delegado de la GPU.
Usa este método para confirmar si un dispositivo es compatible con la GPU y usa la CPU como resguardo cuando la GPU no sea compatible.
useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)
Una vez que tengas una variable como useGpuTask
, puedes usarla para determinar si los dispositivos usan el delegado de la GPU.
Kotlin
val interpreterTask = useGpuTask.continueWith { task -> val interpreterOptions = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) if (task.result) { interpreterOptions.addDelegateFactory(GpuDelegateFactory()) } InterpreterApi.create(FileUtil.loadMappedFile(context, MODEL_PATH), interpreterOptions) }
Java
Task<InterpreterApi.Options> interpreterOptionsTask = useGpuTask.continueWith({ task -> InterpreterApi.Options options = new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY); if (task.getResult()) { options.addDelegateFactory(new GpuDelegateFactory()); } return options; });
GPU con APIs de intérprete
Para usar el delegado de GPU con las APIs de Interpreter, haz lo siguiente:
Actualiza las dependencias del proyecto para usar el delegado de GPU de los Servicios de Play:
implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.0'
Habilita la opción de delegado de GPU en la inicialización de TFlite:
Kotlin
TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build())
Java
TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build());
Habilita el delegado de GPU en las opciones del intérprete: llama a
addDelegateFactory() within
InterpreterApi.Options()` para establecer la fábrica de delegados en GpuDelegateFactory:Kotlin
val interpreterOption = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) .addDelegateFactory(GpuDelegateFactory())
Java
Options interpreterOption = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) .addDelegateFactory(new GpuDelegateFactory());
Cómo migrar desde LiteRT independiente
Si planeas migrar tu app de LiteRT independiente a la API de los Servicios de Play, revisa la siguiente guía adicional para actualizar el código de tu proyecto de app:
- Revisa la sección Limitaciones de esta página para asegurarte de que se admita tu caso de uso.
- Antes de actualizar el código, te recomendamos que realices verificaciones de rendimiento y precisión de los modelos, sobre todo si usas versiones de LiteRT (TF Lite) anteriores a la versión 2.1, de modo que tengas un modelo de referencia para comparar con la implementación nueva.
- Si migraste todo tu código para usar la API de Play Services para LiteRT, debes quitar las dependencias existentes de la biblioteca del entorno de ejecución de LiteRT (entradas con
org.tensorflow:tensorflow-lite:*
) de tu archivo build.gradle para reducir el tamaño de tu app. - Identifica todas las instancias de creación de objetos
new Interpreter
en tu código y modifícalas para que usen la llamadaInterpreterApi.create()
. El nuevoTfLite.initialize
es asíncrono, lo que significa que, en la mayoría de los casos, no es un reemplazo directo: debes registrar un objeto de escucha para cuando se complete la llamada. Consulta el fragmento de código en el código del paso 3. - Agrega
import org.tensorflow.lite.InterpreterApi;
yimport org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime;
a cualquier archivo fuente con las clasesorg.tensorflow.lite.Interpreter
oorg.tensorflow.lite.InterpreterApi
. - Si alguna de las llamadas resultantes a
InterpreterApi.create()
tiene solo un argumento, agreganew InterpreterApi.Options()
a la lista de argumentos. - Agrega
.setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
al último argumento de cualquier llamada aInterpreterApi.create()
. - Reemplaza todos los demás casos de la clase
org.tensorflow.lite.Interpreter
pororg.tensorflow.lite.InterpreterApi
.
Si deseas usar LiteRT independiente y la API de Play Services en paralelo, debes usar LiteRT (TF Lite) versión 2.9 o posterior. LiteRT (TF Lite) versión 2.8 y versiones anteriores no son compatibles con la versión de la API de los Servicios de Play.