Con los metadatos de TensorFlow Lite, los desarrolladores pueden generar código de wrapper para habilitar la integración en Android. Para la mayoría de los desarrolladores, la interfaz gráfica de la vinculación de modelos de AA de Android Studio es la más fácil de usar. Si necesitas más personalización o usas las herramientas de la línea de comandos, TensorFlow Lite Codegen también está disponible.
Cómo usar la vinculación de modelos de AA de Android Studio
En el caso de los modelos de TensorFlow Lite mejorados con metadatos, los desarrolladores pueden usar la vinculación de modelos de AA de Android Studio para establecer automáticamente la configuración del proyecto y generar clases de wrapper basadas en los metadatos del modelo. El código del wrapper quita la necesidad de interactuar directamente con ByteBuffer
. En su lugar, los desarrolladores pueden interactuar con el modelo de TensorFlow Lite
mediante objetos escritos como Bitmap
y Rect
.
Cómo importar un modelo de TensorFlow Lite en Android Studio
Haz clic con el botón derecho en el módulo que quieres usar el modelo de TFLite o haz clic en
File
y, luego, enNew
>Other
>TensorFlow Lite Model
Selecciona la ubicación del archivo TFLite. Ten en cuenta que las herramientas configurarán por ti la dependencia del módulo con la vinculación del modelo de AA y todas las dependencias insertadas automáticamente en el archivo
build.gradle
de tu módulo de Android.Opcional: Selecciona la segunda casilla de verificación para importar la GPU de TensorFlow si deseas usar la aceleración de GPU.
Haz clic en
Finish
.Aparecerá la siguiente pantalla cuando la importación se haya realizado correctamente. Para comenzar a usar el modelo, selecciona Kotlin o Java, y copia y pega el código en la sección
Sample Code
. Para volver a esta pantalla, haz doble clic en el modelo de TFLite en el directorioml
de Android Studio.
Aceleración de la inferencia de modelos
La vinculación de modelos de AA proporciona una forma para que los desarrolladores aceleren su código mediante el uso de delegados y la cantidad de subprocesos.
Paso 1: Verifica que el archivo build.gradle
del módulo contenga la siguiente dependencia:
dependencies {
...
// TFLite GPU delegate 2.3.0 or above is required.
implementation 'org.tensorflow:tensorflow-lite-gpu:2.3.0'
}
Paso 2. Detecta si la GPU que se ejecuta en el dispositivo es compatible con el delegado de la GPU de TensorFlow en caso de que no ejecute el modelo usando varios subprocesos de CPU:
Kotlin
import org.tensorflow.lite.gpu.CompatibilityList import org.tensorflow.lite.gpu.GpuDelegate val compatList = CompatibilityList() val options = if(compatList.isDelegateSupportedOnThisDevice) { // if the device has a supported GPU, add the GPU delegate Model.Options.Builder().setDevice(Model.Device.GPU).build() } else { // if the GPU is not supported, run on 4 threads Model.Options.Builder().setNumThreads(4).build() } // Initialize the model as usual feeding in the options object val myModel = MyModel.newInstance(context, options) // Run inference per sample code
Java
import org.tensorflow.lite.support.model.Model import org.tensorflow.lite.gpu.CompatibilityList; import org.tensorflow.lite.gpu.GpuDelegate; // Initialize interpreter with GPU delegate Model.Options options; CompatibilityList compatList = CompatibilityList(); if(compatList.isDelegateSupportedOnThisDevice()){ // if the device has a supported GPU, add the GPU delegate options = Model.Options.Builder().setDevice(Model.Device.GPU).build(); } else { // if the GPU is not supported, run on 4 threads options = Model.Options.Builder().setNumThreads(4).build(); } MyModel myModel = new MyModel.newInstance(context, options); // Run inference per sample code
Genera interfaces de modelos con el generador de código de TensorFlow Lite
En el caso del modelo de TensorFlow Lite mejorado con metadatos, los desarrolladores pueden usar el generador de código wrapper de Android para TensorFlow Lite a fin de crear un código de wrapper específico para la plataforma. El código del wrapper quita la necesidad de interactuar directamente con ByteBuffer
. En su lugar, los desarrolladores pueden interactuar con el modelo de TensorFlow Lite mediante objetos escritos, como Bitmap
y Rect
.
La utilidad del generador de código depende de la integridad de la
entrada de los metadatos del modelo de TensorFlow Lite. Consulta la sección <Codegen usage>
en los campos relevantes de metadata_schema.fbs para ver cómo la herramienta codegen analiza cada campo.
Generar código del wrapper
Deberás instalar las siguientes herramientas en la terminal:
pip install tflite-support
Cuando termines, puedes usar el generador de código con la siguiente sintaxis:
tflite_codegen --model=./model_with_metadata/mobilenet_v1_0.75_160_quantized.tflite \
--package_name=org.tensorflow.lite.classify \
--model_class_name=MyClassifierModel \
--destination=./classify_wrapper
El código resultante se ubicará en el directorio de destino. Si usas Google Colab o algún otro entorno remoto, tal vez sea más fácil comprimir el resultado en un archivo ZIP y descargarlo en tu proyecto de Android Studio:
# Zip up the generated code
!zip -r classify_wrapper.zip classify_wrapper/
# Download the archive
from google.colab import files
files.download('classify_wrapper.zip')
Cómo usar el código generado
Paso 1: Importa el código generado
Si es necesario, descomprime el código generado en una estructura de directorio. Se supone que la raíz del código generado es SRC_ROOT
.
Abre el proyecto de Android Studio en el que deseas usar el modelo de TensorFlow Lite y, luego, importa el módulo generado con And File -> New -> Import Module -> selecciona SRC_ROOT
.
Si usamos el ejemplo anterior, el directorio y el módulo importado se llamarían classify_wrapper
.
Paso 2: Actualiza el archivo build.gradle
de la app
En el módulo de la app que consumirá el módulo de biblioteca generado, haz lo siguiente:
En la sección Android, agrega lo siguiente:
aaptOptions {
noCompress "tflite"
}
En la sección de dependencias, agrega lo siguiente:
implementation project(":classify_wrapper")
Paso 3: Usar el modelo
// 1. Initialize the model
MyClassifierModel myImageClassifier = null;
try {
myImageClassifier = new MyClassifierModel(this);
} catch (IOException io){
// Error reading the model
}
if(null != myImageClassifier) {
// 2. Set the input with a Bitmap called inputBitmap
MyClassifierModel.Inputs inputs = myImageClassifier.createInputs();
inputs.loadImage(inputBitmap));
// 3. Run the model
MyClassifierModel.Outputs outputs = myImageClassifier.run(inputs);
// 4. Retrieve the result
Map<String, Float> labeledProbability = outputs.getProbability();
}
Aceleración de la inferencia de modelos
El código generado proporciona una forma para que los desarrolladores aceleren su código mediante el uso de delegados y la cantidad de subprocesos. Estos se pueden configurar cuando se inicializa el objeto del modelo, ya que toma tres parámetros:
Context
: Contexto de la actividad o el servicio de Android- (Opcional)
Device
: Delegado de aceleración de TFLite. Por ejemplo: GPUDelegate - (Opcional)
numThreads
: Cantidad de subprocesos que se usan para ejecutar el modelo; el valor predeterminado es uno.
Por ejemplo, para usar un delegado de GPU y hasta tres subprocesos, puedes inicializar el modelo de la siguiente manera:
try {
myImageClassifier = new MyClassifierModel(this, Model.Device.GPU, 3);
} catch (IOException io){
// Error reading the model
}
Solución de problemas
Si obtienes un error "java.io.FileNotFoundException: Este archivo no se puede abrir como descriptor de archivo; es probable que esté comprimido", inserta las siguientes líneas en la sección de Android del módulo de la app que usará el módulo de biblioteca:
aaptOptions {
noCompress "tflite"
}