Genere interfaces modelo usando metadatos

Con los metadatos de TensorFlow Lite , los desarrolladores pueden generar código contenedor para permitir 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 necesita más personalización o está utilizando herramientas de línea de comandos, TensorFlow Lite Codegen también está disponible.

Usar el enlace de modelos de Android Studio ML

Para los modelos de TensorFlow Lite mejorados con metadatos , los desarrolladores pueden usar el enlace de modelos de Android Studio ML para configurar automáticamente la configuración del proyecto y generar clases contenedoras basadas en los metadatos del modelo. El código contenedor 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 .

Importar un modelo de TensorFlow Lite en Android Studio

  1. Haga clic con el botón derecho en el módulo en el que le gustaría usar el modelo TFLite o haga clic en File , luego New > Other > TensorFlow Lite Model Menús del botón derecho para acceder a la funcionalidad de importación de TensorFlow Lite

  2. Seleccione la ubicación de su archivo TFLite. Tenga en cuenta que las herramientas configurarán la dependencia del módulo en su nombre con el enlace del modelo ML y todas las dependencias se insertarán automáticamente en el archivo build.gradle su módulo de build.gradle .

    Opcional: seleccione la segunda casilla de verificación para importar TensorFlow GPU si desea usar la aceleración de GPU.Diálogo de importación para el modelo TFLite

  3. Haga clic en Finish .

  4. La siguiente pantalla aparecerá después de que la importación sea exitosa. Para comenzar a usar el modelo, seleccione Kotlin o Java, copie y pegue el código en la sección Sample Code . Puede volver a esta pantalla haciendo doble clic en el modelo TFLite debajo del directorio ml en Android Studio. Página de detalles del modelo en Android Studio

Acelerar la inferencia del modelo

ML Model Binding proporciona una forma para que los desarrolladores aceleren su código mediante el uso de delegados y el número de subprocesos.

Paso 1. Verifique 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 GPU de TensorFlow; si no, 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
      

Genere interfaces de modelo con el generador de código TensorFlow Lite

Para el modelo de TensorFlow Lite mejorado con metadatos , los desarrolladores pueden usar el generador de código de envoltura de Android TensorFlow Lite para crear un código de envoltura específico de la plataforma. El código contenedor 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 TensorFlow Lite. Consulte la sección <Codegen usage> en los campos relevantes en metadata_schema.fbs , para ver cómo la herramienta Codegen analiza cada campo.

Generar código contenedor

Deberá instalar las siguientes herramientas en su terminal:

pip install tflite-support

Una vez completado, el generador de código se puede utilizar 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 está utilizando Google Colab u otro entorno remoto, tal vez sea más fácil comprimir el resultado en un archivo zip y descargarlo en su 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')

Usando el código generado

Paso 1: Importa el código generado

Descomprima el código generado si es necesario en una estructura de directorio. Se supone que la raíz del código generado es SRC_ROOT .

Abra el proyecto de Android Studio donde le gustaría usar el modelo TensorFlow lite e importe el módulo generado por: Y Archivo -> Nuevo -> Módulo de importación -> seleccione SRC_ROOT

Usando el ejemplo anterior, el directorio y el módulo importados se llamarían classify_wrapper .

Paso 2: actualiza el archivo build.gradle la aplicación

En el módulo de la aplicación que consumirá el módulo de biblioteca generado:

En la sección de Android, agregue lo siguiente:

aaptOptions {
   noCompress "tflite"
}

En la sección de dependencias, agregue 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();
}

Acelerar la inferencia del modelo

El código generado proporciona una forma para que los desarrolladores aceleren su código mediante el uso de delegados y el número de subprocesos. Estos se pueden configurar al iniciar el objeto modelo, ya que toma tres parámetros:

  • Context : contexto de la actividad o servicio de Android
  • (Opcional) Device : Delegado de aceleración TFLite, por ejemplo GPUDelegate o NNAPIDelegate
  • (Opcional) numThreads : número de subprocesos utilizados para ejecutar el modelo; el valor predeterminado es uno.

Por ejemplo, para usar un delegado NNAPI y hasta tres subprocesos, puede inicializar el modelo de esta manera:

try {
    myImageClassifier = new MyClassifierModel(this, Model.Device.NNAPI, 3);
} catch (IOException io){
    // Error reading the model
}

Solución de problemas

Si obtiene una 'java.io.FileNotFoundException: este archivo no se puede abrir como un descriptor de archivo; probablemente esté comprimido, inserte las siguientes líneas debajo de la sección de Android del módulo de la aplicación que usará el módulo de la biblioteca:

aaptOptions {
   noCompress "tflite"
}