Genera interfaces de modelo con metadatos

Con LiteRT Metadata, 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 Android Studio ML Model Binding es la más fácil de usar. Si necesitas más personalización o usas herramientas de línea de comandos, también está disponible LiteRT Codegen.

Cómo usar la vinculación de modelos de AA de Android Studio

En el caso de los modelos de LiteRT mejorados con metadatos, los desarrolladores pueden usar la vinculación de modelos de AA de Android Studio para configurar automáticamente los parámetros del proyecto y generar clases de wrapper basadas en los metadatos del modelo. El código de wrapper elimina la necesidad de interactuar directamente con ByteBuffer. En cambio, los desarrolladores pueden interactuar con el modelo de LiteRT con objetos escritos, como Bitmap y Rect.

Cómo importar un modelo de LiteRT en Android Studio

  1. Haz clic con el botón derecho en el módulo en el que deseas usar el modelo de TFLite o haz clic en File, luego en New > Other > LiteRT Model.

  2. Selecciona la ubicación de tu archivo .tflite. Ten en cuenta que las herramientas configurarán la dependencia del módulo en tu nombre con la vinculación de modelos de AA y todas las dependencias se insertarán 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.

  3. Haz clic en Finish.

  4. Aparecerá la siguiente pantalla después de que la importación se realice 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 directorio ml de Android Studio.

Cómo acelerar la inferencia de modelos

La vinculación de modelos de AA proporciona una forma para que los desarrolladores aceleren su código a través del uso de delegados y la cantidad de subprocesos.

Paso 1: Verifica que el archivo build.gradle del módulo contenga la siguiente dependencia:

    dependencies {
        ...
        // For the LiteRT GPU delegate, we need
        // 'com.google.ai.edge.litert:litert-gpu' version 1.*.
        implementation 'com.google.ai.edge.litert:litert-gpu:1.4.1'
    }

Paso 2: Detecta si la GPU que se ejecuta en el dispositivo es compatible con el delegado de GPU de TensorFlow. Si no lo es, 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

Genera interfaces de modelos con el generador de código de LiteRT

En el caso del modelo de LiteRT mejorado con metadatos, los desarrolladores pueden usar el generador de código del wrapper de LiteRT para Android para crear código del wrapper específico de la plataforma. El código del wrapper elimina la necesidad de interactuar directamente con ByteBuffer. En cambio, los desarrolladores pueden interactuar con el modelo de TensorFlow 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 de LiteRT. Consulta la sección <Codegen usage> en los campos pertinentes de metadata_schema.fbs para ver cómo la herramienta de generación de código analiza cada campo.

Genera código de wrapper

Deberás instalar las siguientes herramientas en tu terminal:

pip install tflite-support

Una vez que se complete, se podrá 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 LiteRT y, luego, importa el módulo generado de la siguiente manera: File -> New -> Import Module -> selecciona SRC_ROOT.

Con 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: Cómo 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();
}

Cómo acelerar la inferencia de modelos

El código generado proporciona una forma para que los desarrolladores aceleren su código a través del 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: Es el delegado de aceleración de TFLite. Por ejemplo, GPUDelegate
  • (Opcional) numThreads: Es la 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 recibes el error "java.io.FileNotFoundException: This file can not be opened as a file descriptor; it is probably compressed", inserta las siguientes líneas en la sección android del módulo de la app que usará el módulo de la biblioteca:

aaptOptions {
   noCompress "tflite"
}