TensorFlow Lite en la API de Java de los Servicios de Google Play

Además de la API nativa, también se puede acceder a TensorFlow Lite en los Servicios de Google Play con las APIs de Java. En particular, TensorFlow Lite en los Servicios de Google Play está disponible a través de la API de intérprete de TensorFlow Lite.

Cómo usar las APIs de intérprete

La API de intérprete de TensorFlow Lite, que proporciona el entorno de ejecución de TensorFlow, proporciona una interfaz de uso general para compilar y ejecutar modelos de AA. Usa los siguientes pasos para ejecutar inferencias con la API de intérprete 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 del proyecto de tu app para acceder a la API de Servicios de Play para TensorFlow Lite:

dependencies {
...
    // Tensorflow Lite dependencies for Google Play services
    implementation 'com.google.android.gms:play-services-tflite-java:16.0.1'
    // Optional: include Tensorflow Lite Support Library
    implementation 'com.google.android.gms:play-services-tflite-support:16.0.1'
...
}

2. Agrega inicialización de TensorFlow Lite

Inicializa el componente de TensorFlow Lite de la API de los Servicios de Google Play antes de usar las APIs de TensorFlow Lite:

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. Para ello, llama 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 interfaz de usuario de Android. Si necesitas administrar mejor la ejecución de subprocesos, 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. Ejecutar 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

TensorFlow Lite te permite acelerar el rendimiento de tu modelo con procesadores de hardware especializados, como unidades de procesamiento gráfico (GPU). Puedes aprovechar estos procesadores especializados mediante 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 Servicios de Play de la API de intérprete.

Cómo comprobar la compatibilidad del dispositivo

No todos los dispositivos admiten la aceleración de hardware de GPU con TFLite. Para mitigar errores y posibles fallas, usa el método TfLiteGpu.isGpuDelegateAvailable a fin de 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 la GPU con las APIs de intérprete, haz lo siguiente:

  1. 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.1.0'

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

  3. Habilita el delegado de GPU en las opciones del intérprete. Para establecer la fábrica de delegados en GpuDelegateFactory, llama 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());

Migra desde TensorFlow Lite independiente

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

  1. Revisa la sección Limitaciones de esta página para asegurarte de que se admita tu caso de uso.
  2. Antes de actualizar el código, realiza verificaciones de rendimiento y precisión de tus modelos, en especial si usas versiones de TensorFlow Lite anteriores a la 2.1, de modo que tengas un modelo de referencia para compararlo con la implementación nueva.
  3. Si migraste todo el código para usar la API de Servicios de Play para TensorFlow Lite, debes quitar las dependencias existentes de la biblioteca del entorno de ejecución de TensorFlow Lite (entradas con org.tensorflow:tensorflow-lite:*) del archivo build.gradle para reducir el tamaño de la app.
  4. Identifica todos los casos de creación del objeto new Interpreter en tu código y modifica cada uno 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 del Paso 3.
  5. Agrega import org.tensorflow.lite.InterpreterApi; y import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; a cualquier archivo de origen con las clases org.tensorflow.lite.Interpreter o org.tensorflow.lite.InterpreterApi.
  6. Si alguna de las llamadas resultantes a InterpreterApi.create() tiene un solo 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 todos los demás casos de la clase org.tensorflow.lite.Interpreter por org.tensorflow.lite.InterpreterApi.

Si quieres usar TensorFlow Lite independiente y la API de los Servicios de Play en paralelo, debes usar TensorFlow Lite 2.9 (o una versión posterior). TensorFlow Lite 2.8 y las versiones anteriores no son compatibles con la versión de la API de los Servicios de Play.