Asista al Simposio Mujeres en ML el 7 de diciembre Regístrese ahora

TensorFlow Lite en los servicios de Google Play

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

TensorFlow Lite está disponible en el tiempo de ejecución de los servicios de Google Play para todos los dispositivos Android que ejecutan la versión actual de los servicios de Play. Este tiempo de ejecución le permite ejecutar modelos de aprendizaje automático (ML) sin agrupar estáticamente las bibliotecas de TensorFlow Lite en su aplicación.

Con la API de servicios de Google Play, puede reducir el tamaño de sus aplicaciones y obtener un rendimiento mejorado con la última versión estable de las bibliotecas. TensorFlow Lite en los servicios de Google Play es la forma recomendada de usar TensorFlow Lite en Android.

Puede comenzar con el tiempo de ejecución de los servicios de Play con el Inicio rápido , que proporciona una guía paso a paso para implementar una aplicación de muestra. Si ya usa TensorFlow Lite independiente en su aplicación, consulte la sección Migración desde TensorFlow Lite independiente para actualizar una aplicación existente para usar el tiempo de ejecución de los servicios de Play. Para obtener más información sobre los servicios de Google Play, consulte el sitio web de servicios de Google Play .

Uso del tiempo de ejecución de los servicios de Play

TensorFlow Lite en los servicios de Google Play está disponible a través de la API de tareas de TensorFlow Lite y la API de intérprete de TensorFlow Lite. La biblioteca de tareas proporciona interfaces de modelo listas para usar optimizadas 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 y las bibliotecas de soporte, proporciona una interfaz de uso más general para crear y ejecutar modelos de aprendizaje automático.

Las siguientes secciones brindan instrucciones sobre cómo implementar las API de intérprete y biblioteca de tareas en los servicios de Google Play. Si bien es posible que una aplicación use las API de intérprete y las API de 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 envuelve la API de intérprete y proporciona una interfaz de programación de alto nivel para tareas comunes de aprendizaje automático que usan 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. Agrega la 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, llama 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 de detección de objetos simple con la biblioteca TfLiteVision :

kotlin

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

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

  ...

}

Según el formato de los datos, es posible que también deba 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 de intérprete

Las API de intérprete ofrecen más control y flexibilidad que las API de la biblioteca de tareas. Debe usar las API de intérprete si su tarea de aprendizaje automático no es compatible con la biblioteca de tareas, o si necesita una interfaz 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. Agrega la 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

Crea un intérprete usando InterpreterApi.create() y configúralo para usar el tiempo 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()));
  });

Debe usar la implementación anterior porque evita bloquear el subproceso 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 te permite acelerar el rendimiento de tu modelo mediante procesadores de hardware especializados, como unidades de procesamiento de gráficos (GPU). Puede aprovechar estos procesadores especializados utilizando controladores de hardware llamados delegados . Puedes usar 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 servicios de Play de la API de tareas y la API de intérprete.

  • Delegado de 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 .

Comprobación de la compatibilidad del dispositivo

No todos los dispositivos admiten la aceleración de hardware de 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 de NNAPI como respaldo para 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 con las API de biblioteca de tareas e 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 de 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 usar el delegado de GPU con las API de tareas:

  1. 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'
    
  2. 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());
        
  3. Habilite la opción de delegado de GPU con BaseOptions :

    kotlin

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

    Java

        BaseOptions baseOptions = BaseOptions.builder().useGpu().build();
        
  4. 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 usar el delegado de GPU con las API de intérprete:

  1. 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'
    
  2. 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());
        
  3. Configure el delegado de GPU en las opciones del intérprete para usar DelegateFactory llamando a addDelegateFactory() dentro de 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 de 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:

  1. Revise la sección Limitaciones de esta página para asegurarse de que su caso de uso sea compatible.
  2. Antes de actualizar su código, realice verificaciones de rendimiento y precisión para sus modelos, especialmente si está usando versiones de TensorFlow Lite anteriores a la versión 2.1, para que tenga una línea de base para comparar con la nueva implementación.
  3. Si migró todo su código para usar la API de servicios de Play para TensorFlow Lite, debe eliminar las dependencias de la biblioteca de tiempo de ejecución de TensorFlow Lite existentes (entradas con org.tensorflow: tensorflow-lite :* ) de su archivo build.gradle para que puede reducir el tamaño de su aplicación.
  4. Identifique todas las apariciones de la creación de un new Interpreter en su código y modifíquelo para que use la llamada InterpreterApi.create(). Esta nueva API es asíncrona, lo que significa que en la mayoría de los casos no es un reemplazo directo y debe registrar un oyente para cuando se complete la llamada. Consulte el fragmento de código en el código del Paso 3 .
  5. Agregue import org.tensorflow.lite.InterpreterApi; e import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; a cualquier archivo fuente usando las clases org.tensorflow.lite.Interpreter u org.tensorflow.lite.InterpreterApi .
  6. Si alguna de las llamadas resultantes a InterpreterApi.create() tiene un solo argumento, agregue el new InterpreterApi.Options() a la lista de argumentos.
  7. .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) al último argumento de cualquier llamada a InterpreterApi.create() .
  8. Reemplace todas las demás apariciones de la clase org.tensorflow.lite.Interpreter con org.tensorflow.lite.InterpreterApi .

Si desea usar TensorFlow Lite independiente y la API de servicios de 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 los servicios de Play.

Limitaciones

TensorFlow Lite en los servicios de Google Play tiene las siguientes limitaciones:

  • La compatibilidad con los delegados de aceleración de hardware se limita a los delegados enumerados en la sección Aceleración de hardware . No se admiten otros delegados de aceleración.
  • No se admite el acceso a TensorFlow Lite a través de API nativas . Solo las API de Java de TensorFlow Lite están disponibles a través de los servicios de Google Play.
  • No se admiten las API experimentales o obsoletas de TensorFlow Lite, incluidas las operaciones personalizadas.

Soporte y retroalimentación

Puede proporcionar comentarios y obtener soporte a través del Rastreador de problemas de TensorFlow. Informe los problemas y las solicitudes de asistencia mediante la plantilla de problemas para TensorFlow Lite en los servicios de Google Play.

Términos de servicio

El uso de TensorFlow Lite en las API de los servicios de Google Play está sujeto a los Términos de servicio de las API de Google .

Privacidad y recopilación de datos

Cuando usa TensorFlow Lite en las API de los servicios de Google Play, el procesamiento de los datos de entrada, como imágenes, video, texto, ocurre completamente en el dispositivo, y TensorFlow Lite en las API de los servicios de Google Play no envía esos datos a los servidores de Google. Como resultado, puede usar nuestras API para procesar datos que no deberían salir del dispositivo.

TensorFlow Lite en las API de los servicios de Google Play puede ponerse en contacto con los servidores de Google de vez en cuando para recibir cosas como correcciones de errores, modelos actualizados e información de compatibilidad del acelerador de hardware. TensorFlow Lite en las API de servicios de Google Play también envía métricas sobre el rendimiento y la utilización de las API en su aplicación a Google. Google utiliza estos datos de métricas para medir el rendimiento, depurar, mantener y mejorar las API y detectar el uso indebido o el abuso, como se describe más detalladamente en nuestra Política de privacidad .

Usted es responsable de informar a los usuarios de su aplicación sobre el procesamiento de Google de TensorFlow Lite en los datos de métricas de las API de los servicios de Google Play, según lo exige la ley aplicable.

Los datos que recopilamos incluyen lo siguiente:

  • Información del dispositivo (como fabricante, modelo, versión del sistema operativo y compilación) y aceleradores de hardware ML disponibles (GPU y DSP). Se utiliza para diagnósticos y análisis de uso.
  • Identificador de dispositivo utilizado para diagnósticos y análisis de uso.
  • Información de la aplicación (nombre del paquete, versión de la aplicación). Se utiliza para diagnósticos y análisis de uso.
  • Configuración de la API (como qué delegados se están utilizando). Se utiliza para diagnósticos y análisis de uso.
  • Tipo de evento (como creación de intérprete, inferencia). Se utiliza para diagnósticos y análisis de uso.
  • Códigos de error. Se utiliza para diagnósticos.
  • Métricas de rendimiento. Se utiliza para diagnósticos.

Próximos pasos

Para obtener más información sobre cómo implementar el aprendizaje automático en su aplicación móvil con TensorFlow Lite, consulte la Guía para desarrolladores de TensorFlow Lite . Puede encontrar modelos adicionales de TensorFlow Lite para clasificación de imágenes, detección de objetos y otras aplicaciones en TensorFlow Hub .