LiteRT en la API de Google Play Services para Java

También se puede acceder a LiteRT en los servicios de Google Play a través de las APIs de Java, en además de la API nativa. Específicamente, LiteRT en Google Play. están disponibles a través del Intérprete de LiteRT de la API de Google Ads.

Usa 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. Usa el sigue los 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 app de Play de Google Services para LiteRT:

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

2. Cómo agregar la inicialización de LiteRT

Cómo inicializar el componente LiteRT de la API de 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 del entorno de ejecución

Crea un intérprete con InterpreterApi.create() y configúralo para que use 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, ya que evita que se bloquee el código de Android de la interfaz de usuario. Si necesitas administrar más de cerca la ejecución del subproceso, Puedes agregar una llamada Tasks.await() a la creación de un 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 las 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 y procesadores de hardware especializados, como unidades de procesamiento gráfico (GPU). Tú puede 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, tal como las versiones de Servicios de Play de la Interpreter de Google Cloud.

Cómo comprobar la compatibilidad con un dispositivo

No todos los dispositivos admiten la aceleración de hardware de GPU con TFLite. Con el fin de mitigar errores y posibles fallas, usa el TfLiteGpu.isGpuDelegateAvailable para comprobar si un dispositivo 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 no se admite GPU.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Una vez que tengas una variable como useGpuTask, puedes usarla para determinar si 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 Interpreter, haz lo siguiente:

  1. Actualiza las dependencias del proyecto para usar el delegado de la GPU desde 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 de intérprete y establece la fábrica del delegado 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());

Cómo migrar desde LiteRT independiente

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

  1. Revisa la sección Limitaciones de esta página para asegurarte de que tu el caso de uso de Google Cloud.
  2. Antes de actualizar el código, verifica el rendimiento y la precisión de tus sobre todo si usas versiones anteriores de LiteRT que la versión 2.1, así que hay un modelo de referencia para comparar para implementarlos.
  3. Si migraste todo tu código para usar la API de Play Services en LiteRT, debes quitar el entorno de ejecución de LiteRT existente biblioteca (entradas con org.tensorflow:tensorflow-lite:*) de tu build.gradle de modo que puedas reducir el tamaño de tu app.
  4. Identifica todos los casos de creación del objeto new Interpreter en tu código. y modificar cada una para que use la llamada InterpreterApi.create(). El el nuevo TfLite.inicializa 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 la llamada de datos completados. 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 fuente. con el comando org.tensorflow.lite.Interpreter o org.tensorflow.lite.InterpreterApi.
  6. Si alguna de las llamadas resultantes a InterpreterApi.create() tiene solo un 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 con org.tensorflow.lite.InterpreterApi.

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