Con metadatos de LiteRT, 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 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 la línea de comandos , también está disponible LiteRT Codegen.
Cómo usar la vinculación de modelos de AA de Android Studio
Para los modelos LiteRT mejorados con metadatos,
desarrolladores pueden usar ML Model Binding de Android Studio para configurar
del proyecto y generar clases de wrapper basadas en el modelo
metadatos. El código del wrapper elimina la necesidad de interactuar directamente con
ByteBuffer
En cambio, los desarrolladores pueden interactuar con el modelo LiteRT
con objetos escritos como Bitmap
y Rect
.
Cómo importar un modelo LiteRT en Android Studio
Haz clic con el botón derecho en el módulo en el que quieres usar el modelo de TFLite o en
File
; luego,New
>Other
LiteRT Model
Selecciona la ubicación de tu archivo TFLite. Ten en cuenta que las herramientas configurar la dependencia del módulo en tu nombre con la vinculación del modelo de AA y todas las dependencias insertadas automáticamente en la biblioteca
build.gradle
.Selecciona la segunda casilla de verificación para importar la GPU de TensorFlow (opcional) si quieren usar la aceleración de GPU.
Haz clic en
Finish
.La siguiente pantalla aparecerá cuando la importación se complete correctamente. Para empezar usando el modelo, selecciona Kotlin o Java, copia y pega el código debajo de
Sample Code
. Para volver a esta pantalla, haz doble clic el modelo de TFLite en el directorioml
de Android Studio.
Acelera la inferencia de modelos
La vinculación de modelos de AA proporciona una forma para que los desarrolladores aceleren su código el uso de delegados y la cantidad de conversaciones.
Paso 1: Verifica que el archivo build.gradle
del módulo contenga lo siguiente:
dependencia:
dependencies {
...
// TFLite GPU delegate 2.3.0 or above is required.
implementation 'com.google.ai.edge.litert:litert-gpu:2.3.0'
}
Paso 2: Detecta si la GPU que se ejecuta en el dispositivo es compatible con la GPU de TensorFlow delegado, si no se ejecuta el modelo con 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
Cómo generar interfaces de modelos con el generador de código LiteRT
Para el modelo LiteRT mejorado con metadatos,
los desarrolladores pueden usar el generador de códigos de wrapper LiteRT de Android
código del wrapper específico de la plataforma. El código del wrapper quita la necesidad de interactuar
directamente con ByteBuffer
. En cambio, los desarrolladores pueden interactuar con el
Modelo Lite con objetos escritos como Bitmap
y Rect
.
La utilidad del generador de código depende de la integridad de la
Entrada de metadatos del modelo LiteRT. 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 de wrapper
Deberás instalar las siguientes herramientas en tu terminal:
pip install tflite-support
Una vez completado, el generador de código se puede usar 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 eres con Google Colab u otra configuración 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')
Usa el código generado
Paso 1: Importa el código generado
Si es necesario, descomprime el código generado en una estructura de directorio. La raíz de
Se supone que el código generado es SRC_ROOT
.
Abre el proyecto de Android Studio en el que deseas usar LiteRT.
modelo e importa el módulo generado con And File -> Nuevo -> Importar módulo ->
seleccionar SRC_ROOT
En 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: Usa 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();
}
Acelera 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 conversaciones. Estos se pueden configurar cuando se inicializa el objeto del modelo, ya que tarda 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 usaron 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 el error “java.io.FileNotFoundException: This file can not be open as a descriptor de archivo; probablemente esté comprimido" inserta las siguientes líneas en la sección android del módulo de la app que usará el módulo de biblioteca:
aaptOptions {
noCompress "tflite"
}