Genera interfaces de modelo con metadatos

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

  1. 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, en New > Other > TensorFlow Lite Model

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

  3. Haz clic en Finish.

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