LiteRT en la API de Java (y Kotlin) de los Servicios de Google Play

También se puede acceder a LiteRT en los Servicios de Google Play con las APIs de Java, que se pueden usar desde 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.

Usa las APIs de Interpreter

La API del intérprete de LiteRT, proporcionada por el tiempo de ejecución de TensorFlow, ofrece una interfaz de uso general para compilar y ejecutar modelos de AA. Sigue estos pasos para ejecutar inferencias con la API de Interpreter usando el tiempo de ejecución de TensorFlow Lite en los Servicios de Google Play.

1. Agrega dependencias del proyecto

Agrega las siguientes dependencias al código del proyecto de tu app para acceder a la API de Play services 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. Agrega 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 configura la opción de tiempo de ejecución

Crea un intérprete con InterpreterApi.create() y configúralo para que use 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 precisa, puedes agregar una llamada a Tasks.await() para 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 con procesadores de hardware especializados, como las unidades de procesamiento de gráficos (GPU). Puedes aprovechar estos procesadores especializados con controladores de hardware llamados delegados.

El delegado de 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 los Servicios de Play de la API de Interpreter.

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 GPU.

Usa este método para confirmar si un dispositivo es compatible con la GPU y usa la CPU como alternativa cuando no se admite la GPU.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Una vez que tengas una variable como useGpuTask, puedes usarla para determinar si los dispositivos usan el delegado de 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 Interpreter

Para usar el delegado de GPU con las APIs de Interpreter, haz lo siguiente:

  1. Actualiza las dependencias del proyecto para usar el delegado de la GPU de los Servicios de Play:

    implementation 'com.google.android.gms:play-services-tflite-gpu:16.2.0'

  2. Habilita la opción del 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());

  3. Habilita el delegado de GPU en las opciones del intérprete: configura la fábrica de delegados en GpuDelegateFactory llamando a addDelegateFactory() withinInterpreterApi.Options()`:

    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());

Migración desde LiteRT independiente

Si planeas migrar tu app de LiteRT independiente a la API de Play services, revisa la siguiente guía adicional para actualizar el código del proyecto de tu app:

  1. Revisa la sección Limitaciones para asegurarte de que se admita tu caso de uso.
  2. Antes de actualizar tu código, te recomendamos que realices verificaciones de rendimiento y precisión para tus modelos, en especial si usas versiones de LiteRT (TF Lite) anteriores a la versión 2.1, de modo que tengas un valor de referencia para comparar con la nueva implementación.
  3. Si migraste todo tu código para usar la API de Play services para LiteRT, debes quitar las dependencias existentes de la biblioteca de tiempo de ejecución de LiteRT (entradas con org.tensorflow:tensorflow-lite:*) de tu archivo build.gradle para reducir el tamaño de tu app.
  4. Identifica todas las ocurrencias de la creación de objetos new Interpreter en tu código y modifica cada una para que use la llamada InterpreterApi.create(). El nuevo TfLite.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.
  5. Agrega import org.tensorflow.lite.InterpreterApi; y import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; a cualquier archivo fuente con las clases org.tensorflow.lite.Interpreter o org.tensorflow.lite.InterpreterApi.
  6. Si alguna de las llamadas resultantes a InterpreterApi.create() tiene solo un argumento, agrega new InterpreterApi.Options() a la lista de argumentos.
  7. Agrega .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) al último argumento de cualquier llamada a InterpreterApi.create().
  8. Reemplaza todas las demás ocurrencias de la clase org.tensorflow.lite.Interpreter por org.tensorflow.lite.InterpreterApi.

Si deseas usar LiteRT independiente y la API de Play services de forma paralela, debes usar la versión 2.9 o posterior de LiteRT (TF Lite). La versión 2.8 y las versiones anteriores de LiteRT (TF Lite) no son compatibles con la versión de la API de los Servicios de Play.