Genera interfaces de modelo con metadatos

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

  1. 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

  2. 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.

  3. Haz clic en Finish.

  4. 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 directorio ml 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"
}