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 paraTfLiteVision
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 enObjectDetector
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;
eimport org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime;
a cualquier archivo fuente utilizando las clasesorg.tensorflow.lite.Interpreter
uorg.tensorflow.lite.InterpreterApi
. - Si alguna de las llamadas resultantes a
InterpreterApi.create()
tiene un solo argumento, agreguenew InterpreterApi.Options()
a la lista de argumentos. - Agregue
.setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
al último argumento de cualquier llamada aInterpreterApi.create()
. - Reemplace todas las demás apariciones de la clase
org.tensorflow.lite.Interpreter
conorg.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.