¡TensorFlow regresa a Google I/O el 14 de mayo! Regístrate ahora

Esta página se ha traducido con Cloud Translation API.

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

También se puede acceder a TensorFlow Lite en los servicios de Google Play mediante las API de Java, además de la API nativa. En particular, TensorFlow Lite en los servicios de Google Play está disponible a través de TensorFlow Lite Task API y TensorFlow Lite Interpreter API . La biblioteca de tareas proporciona interfaces de modelo optimizadas y listas para usar para tareas comunes de aprendizaje automático que utilizan datos visuales, de audio y de texto. La API de intérprete de TensorFlow Lite, proporcionada por el tiempo de ejecución de TensorFlow, proporciona una interfaz de propósito más general para crear y ejecutar modelos de aprendizaje automático.

Las siguientes secciones brindan instrucciones sobre cómo usar las API del intérprete y la biblioteca de tareas con TensorFlow Lite en los servicios de Google Play. Si bien es posible que una aplicación use tanto las API del intérprete como las API de la biblioteca de tareas, la mayoría de las aplicaciones solo deben usar un conjunto de API.

Uso de las API de la biblioteca de tareas

La API de tareas de TensorFlow Lite incluye la API de intérprete y proporciona una interfaz de programación de alto nivel para tareas comunes de aprendizaje automático que utilizan datos visuales, de audio y de texto. Debe utilizar la API de tareas si su aplicación requiere una de las tareas admitidas .

1. Agregar dependencias del proyecto

La dependencia de su proyecto depende de su caso de uso de aprendizaje automático. Las API de tareas contienen las siguientes bibliotecas:

Biblioteca de visión: org.tensorflow:tensorflow-lite-task-vision-play-services
Biblioteca de audio: org.tensorflow:tensorflow-lite-task-audio-play-services
Biblioteca de texto: org.tensorflow:tensorflow-lite-task-text-play-services

Agregue una de las dependencias al código del proyecto de su aplicación para acceder a la API de servicios de Play para TensorFlow Lite. Por ejemplo, utilice lo siguiente para implementar una tarea de visión:

dependencies {
...
    implementation 'org.tensorflow:tensorflow-lite-task-vision-play-services:0.4.2'
...
}

2. Agregar inicialización de TensorFlow Lite

Inicialice el componente TensorFlow Lite de la API de servicios de Google Play antes de usar las API de TensorFlow Lite. El siguiente ejemplo inicializa la biblioteca de visión:

Kotlin

init {
  TfLiteVision.initialize(context)
}

3. Ejecutar inferencias

Después de inicializar el componente TensorFlow Lite, llame al método detect() para generar inferencias. El código exacto dentro del método detect() varía según la biblioteca y el caso de uso. Lo siguiente es para un caso de uso simple de detección de objetos con la biblioteca TfLiteVision :

Kotlin

fun detect(...) {
  if (!TfLiteVision.isInitialized()) {
    Log.e(TAG, "detect: TfLiteVision is not initialized yet")
    return
  }

  if (objectDetector == null) {
    setupObjectDetector()
  }

  ...

}

Dependiendo del formato de los datos, es posible que también necesite preprocesar y convertir sus datos dentro del método detect() antes de generar inferencias. Por ejemplo, los datos de imagen para un detector de objetos requieren lo siguiente:

val imageProcessor = ImageProcessor.Builder().add(Rot90Op(-imageRotation / 90)).build()
val tensorImage = imageProcessor.process(TensorImage.fromBitmap(image))
val results = objectDetector?.detect(tensorImage)

Uso de las API del intérprete

Las API de Interpreter ofrecen más control y flexibilidad que las API de la biblioteca de tareas. Debe utilizar las API de Interpreter si su tarea de aprendizaje automático no es compatible con la biblioteca de tareas o si necesita una interfaz de propósito más general para crear y ejecutar modelos de ML.

1. Agregar dependencias del proyecto

Agregue las siguientes dependencias al código del proyecto de su aplicación 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. Agregar inicialización de TensorFlow Lite

Inicialice el componente TensorFlow Lite de la API de servicios de Google Play antes de usar las API de TensorFlow Lite:

Kotlin

val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }

Java

Task<Void> initializeTask = TfLite.initialize(context);

3. Cree un intérprete y configure la opción de tiempo de ejecución.

Cree un intérprete usando InterpreterApi.create() y configúrelo para usar el tiempo de ejecución de los servicios de Google Play, llamando 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()));
  });

Debe utilizar la implementación anterior porque evita bloquear el hilo de la interfaz de usuario de Android. Si necesita administrar la ejecución de subprocesos más de cerca, puede 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

Usando el objeto interpreter que creó, llame al método run() para generar una inferencia.

Kotlin

interpreter.run(inputBuffer, outputBuffer)

Java

interpreter.run(inputBuffer, outputBuffer);

Aceleracion de hardware

TensorFlow Lite le permite acelerar el rendimiento de su modelo utilizando procesadores de hardware especializados, como unidades de procesamiento de gráficos (GPU). Puede aprovechar estos procesadores especializados utilizando controladores de hardware llamados delegados . Puede utilizar los siguientes delegados de aceleración de hardware con TensorFlow Lite en los servicios de Google Play:

Delegado de GPU (recomendado) : este delegado se proporciona a través de los servicios de Google Play y se carga dinámicamente, al igual que las versiones de los servicios de Play de Task API y Interpreter API.
Delegado NNAPI : este delegado está disponible como una dependencia de biblioteca incluida en su proyecto de desarrollo de Android y está incluido en su aplicación.

Para obtener más información sobre la aceleración de hardware con TensorFlow Lite, consulte la página de delegados de TensorFlow Lite .

Comprobando la compatibilidad del dispositivo

No todos los dispositivos admiten la aceleración de hardware GPU con TFLite. Para mitigar errores y posibles fallas, use el método TfLiteGpu.isGpuDelegateAvailable para verificar si un dispositivo es compatible con el delegado de GPU.

Utilice este método para confirmar si un dispositivo es compatible con la GPU y utilice la CPU o el delegado NNAPI como alternativa cuando la GPU no sea compatible.

useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)

Una vez que tenga una variable como useGpuTask , puede usarla para determinar si los dispositivos usan el delegado de GPU. Los siguientes ejemplos muestran cómo se puede hacer esto tanto con la biblioteca de tareas como con las API del intérprete.

Con la API de tareas

Kotlin

lateinit val optionsTask = useGpuTask.continueWith { task ->
  val baseOptionsBuilder = BaseOptions.builder()
  if (task.result) {
    baseOptionsBuilder.useGpu()
  }
 ObjectDetectorOptions.builder()
          .setBaseOptions(baseOptionsBuilder.build())
          .setMaxResults(1)
          .build()
}

Java

Task<ObjectDetectorOptions> optionsTask = useGpuTask.continueWith({ task ->
  BaseOptions baseOptionsBuilder = BaseOptions.builder();
  if (task.getResult()) {
    baseOptionsBuilder.useGpu();
  }
  return ObjectDetectorOptions.builder()
          .setBaseOptions(baseOptionsBuilder.build())
          .setMaxResults(1)
          .build()
});

Con la API intérprete

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 API de biblioteca de tareas

Para utilizar el delegado de GPU con las API de tareas:

Actualice 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'
```

Inicialice el delegado de GPU con setEnableGpuDelegateSupport . Por ejemplo, puede inicializar el delegado de GPU para TfLiteVision con lo siguiente:

Kotlin

    TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build())

Java

    TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build());

Habilite la opción de delegado de GPU con BaseOptions :

Kotlin

    val baseOptions = BaseOptions.builder().useGpu().build()

Java

    BaseOptions baseOptions = BaseOptions.builder().useGpu().build();

Configure las opciones usando .setBaseOptions . Por ejemplo, puede configurar GPU en ObjectDetector con lo siguiente:

Kotlin

    val options =
        ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build()

Java

    ObjectDetectorOptions options =
        ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build();

GPU con API de intérprete

Para utilizar el delegado de GPU con las API del intérprete:

Actualice 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'
```

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

Habilite el delegado de GPU en las opciones del intérprete: configure la fábrica de delegados en GpuDelegateFactory llamando addDelegateFactory() within InterpreterApi.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());

Migrar desde TensorFlow Lite independiente

Si planea migrar su aplicación desde TensorFlow Lite independiente a la API de servicios de Play, revise la siguiente guía adicional para actualizar el código del proyecto de su aplicación:

Revise la sección Limitaciones de esta página para asegurarse de que su caso de uso sea compatible.
Antes de actualizar su código, realice comprobaciones de rendimiento y precisión de sus modelos, especialmente si está utilizando versiones de TensorFlow Lite anteriores a la versión 2.1, de modo que tenga una base para comparar con la nueva implementación.
Si ha migrado todo su código para usar la API de servicios Play para TensorFlow Lite, debe eliminar las dependencias existentes de la biblioteca de tiempo de ejecución de TensorFlow Lite (entradas con org.tensorflow: tensorflow-lite :* ) de su archivo build.gradle para que puede reducir el tamaño de su aplicación.
Identifique todas las apariciones de creación de new Interpreter en su código y modifique cada una para que utilice 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: debe registrar un oyente para cuando se complete la llamada. Consulte el fragmento de código en el código del Paso 3 .
Agregue import org.tensorflow.lite.InterpreterApi; e import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; a cualquier archivo fuente utilizando las clases org.tensorflow.lite.Interpreter u org.tensorflow.lite.InterpreterApi .
Si alguna de las llamadas resultantes a InterpreterApi.create() tiene un solo argumento, agregue new InterpreterApi.Options() a la lista de argumentos.
Agregue .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) al último argumento de cualquier llamada a InterpreterApi.create() .
Reemplace todas las demás apariciones de la clase org.tensorflow.lite.Interpreter con org.tensorflow.lite.InterpreterApi .

Si desea utilizar TensorFlow Lite independiente y la API de servicios Play en paralelo, debe usar TensorFlow Lite 2.9 (o posterior). TensorFlow Lite 2.8 y versiones anteriores no son compatibles con la versión de la API de servicios de Play.