Genere interfaces de 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.

Utilice el enlace de modelo Android Studio ML

Para los modelos de TensorFlow Lite mejorados con metadatos , los desarrolladores pueden usar Android Studio ML Model Binding para configurar automáticamente los ajustes 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 TensorFlow Lite con objetos escritos como Bitmap y Rect .

Importar un modelo de TensorFlow Lite en Android Studio

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

  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 de su módulo de Android.

    Opcional: seleccione la segunda casilla para importar TensorFlow GPU si desea utilizar la aceleración de GPU.

  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 en el directorio ml 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 la cantidad 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. Detecte si la GPU que se ejecuta en el dispositivo es compatible con el delegado de GPU de TensorFlow; de lo contrario, ejecute el modelo utilizando múltiples 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 TensorFlow Lite mejorado con metadatos , los desarrolladores pueden usar el generador de código contenedor de Android TensorFlow Lite para crear código contenedor 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 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 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

Necesitará instalar las siguientes herramientas en su terminal:

pip install tflite-support

Una vez completado, el generador de código se puede utilizar utilizando 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: importar 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 mediante: Y Archivo -> Nuevo -> Importar módulo -> seleccione SRC_ROOT

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

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

En el módulo de 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 la cantidad de subprocesos. Estos se pueden configurar al inicializar el objeto modelo, ya que requiere 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 utilizar 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 excepción 'java.io.FileNotFoundException: este archivo no se puede abrir como descriptor de archivo; Probablemente esté comprimido, inserte las siguientes líneas en la sección de Android del módulo de la aplicación que utilizará el módulo de biblioteca:

aaptOptions {
   noCompress "tflite"
}