Asista al Simposio Mujeres en ML el 7 de diciembre Regístrese ahora

Genere interfaces de modelo usando metadatos

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Con los metadatos de TensorFlow Lite , los desarrolladores pueden generar un código contenedor 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 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 de Android Studio ML

Para los modelos de TensorFlow Lite mejorados con metadatos , los desarrolladores pueden usar Model Binding de Android Studio ML 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 su lugar, 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 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 Haga clic con el botón derecho en los menús 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 de su módulo de Android.

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

  3. Haga clic 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. Página de detalles del modelo en Android Studio

Acelerando 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 del módulo build.gradle 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; si no, ejecute 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 TensorFlow Lite mejorado con metadatos , los desarrolladores pueden usar el generador de código contenedor de TensorFlow Lite Android para crear un código contenedor específico de la plataforma. El código contenedor elimina la necesidad de interactuar directamente con ByteBuffer . En su lugar, 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

Deberá 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: 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 en el que le gustaría usar el modelo TensorFlow lite e importe el módulo generado: 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 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: Usando 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();
}

Acelerando 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 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 excepción 'java.io.FileNotFoundException: este archivo no se puede abrir como un descriptor de archivo; probablemente sea un error comprimido, inserte las siguientes líneas en la sección de Android del módulo de la aplicación que usará el módulo de la biblioteca:

aaptOptions {
   noCompress "tflite"
}