Inicio rápido para Android

Este tutorial le muestra cómo crear una aplicación de Android usando TensorFlow Lite para analizar una transmisión de cámara en vivo e identificar objetos usando un modelo de aprendizaje automático, usando una cantidad mínima de código. Si está actualizando un proyecto existente, puede usar el ejemplo de código como referencia y pasar directamente a las instrucciones para modificar su proyecto .

Detección de objetos con aprendizaje automático

Demostración animada de detección de objetos El modelo de aprendizaje automático de este tutorial realiza la detección de objetos. Un modelo de detección de objetos toma datos de imágenes en un formato específico, los analiza e intenta categorizar elementos en la imagen como uno de un conjunto de clases conocidas que fue entrenado para reconocer. La velocidad a la que un modelo puede identificar un objeto conocido (llamada predicción o inferencia de objetos) generalmente se mide en milisegundos. En la práctica, la velocidad de inferencia varía según el hardware que aloja el modelo, el tamaño de los datos que se procesan y el tamaño del modelo de aprendizaje automático.

Ejemplo de configuración y ejecución

Para la primera parte de este tutorial, descargue la muestra de GitHub y ejecútela con Android Studio . Las siguientes secciones de este tutorial exploran las secciones relevantes del ejemplo de código, para que pueda aplicarlas a sus propias aplicaciones de Android. Necesita tener instaladas las siguientes versiones de estas herramientas:

  • Android Studio 4.2.2 o superior
  • Android SDK versión 31 o superior

Obtener el código de ejemplo

Cree una copia local del código de ejemplo. Utilizará este código para crear un proyecto en Android Studio y ejecutar la aplicación de muestra.

Para clonar y configurar el código de ejemplo:

  1. Clonar el repositorio git
    git clone https://github.com/android/camera-samples.git
    
  2. Configure su instancia de git para usar pago disperso, de modo que solo tenga los archivos para la aplicación de ejemplo de detección de objetos:

    cd camera-samples
    git sparse-checkout init --cone
    git sparse-checkout set CameraXAdvanced
    

Importar y ejecutar el proyecto

Cree un proyecto a partir del código de ejemplo descargado, compile el proyecto y luego ejecútelo.

Para importar y compilar el proyecto de código de ejemplo:

  1. Inicie Android Studio .
  2. En la página de bienvenida de Android Studio, elija Importar proyecto o seleccione Archivo > Nuevo > Importar proyecto .
  3. Navegue hasta el directorio de código de ejemplo que contiene el archivo build.gradle ( .../android/camera-samples/CameraXAdvanced/build.gradle ) y seleccione ese directorio.

Si selecciona el directorio correcto, Android Studio crea un nuevo proyecto y lo compila. Este proceso puede demorar algunos minutos, dependiendo de la velocidad de tu computadora y si has usado Android Studio para otros proyectos. Cuando se completa la compilación, Android Studio muestra un mensaje BUILD SUCCESSFUL en el panel de estado de salida de la compilación .

Opcional: para corregir errores de compilación actualizando la versión del complemento de Android:

  1. Abra el archivo build.gradle en el directorio del proyecto.
  2. Cambie la versión de las herramientas de Android de la siguiente manera:

    // from:
    classpath 'com.android.tools.build:gradle:4.2.2'
    // to:
    classpath 'com.android.tools.build:gradle:4.1.2'
    
  3. Sincronice el proyecto seleccionando: Archivo > Sincronizar proyecto con archivos Gradle .

Para ejecutar el proyecto:

  1. Desde Android Studio, ejecute el proyecto seleccionando Ejecutar > Ejecutar… y CameraActivity .
  2. Seleccione un dispositivo Android adjunto con una cámara para probar la aplicación.

Las siguientes secciones le muestran las modificaciones que debe realizar en su proyecto existente para agregar esta funcionalidad a su propia aplicación, utilizando esta aplicación de ejemplo como punto de referencia.

Agregar dependencias del proyecto

En su propia aplicación, debe agregar dependencias de proyectos específicas para ejecutar modelos de aprendizaje automático de TensorFlow Lite y acceder a funciones de utilidades que convierten datos, como imágenes, en un formato de datos de tensor que puede procesar el modelo que está utilizando.

La aplicación de ejemplo usa varias bibliotecas de TensorFlow Lite para permitir la ejecución del modelo de aprendizaje automático de detección de objetos:

  • Biblioteca principal de TensorFlow Lite : proporciona las clases de entrada de datos requeridas, la ejecución del modelo de aprendizaje automático y los resultados de salida del procesamiento del modelo.
  • Biblioteca de soporte de TensorFlow Lite : esta biblioteca proporciona una clase auxiliar para traducir imágenes de la cámara a un objeto de datos de TensorImage que puede procesar el modelo de aprendizaje automático.
  • Biblioteca de GPU TensorFlow Lite : esta biblioteca brinda soporte para acelerar la ejecución del modelo usando procesadores de GPU en el dispositivo, si están disponibles.

Las siguientes instrucciones explican cómo agregar las dependencias requeridas del proyecto y del módulo a su propio proyecto de aplicación de Android.

Para agregar dependencias de módulo:

  1. En el módulo que usa TensorFlow Lite, actualice el archivo build.gradle del módulo para incluir las siguientes dependencias. En el código de ejemplo, este archivo se encuentra aquí: .../android/camera-samples/CameraXAdvanced/tflite/build.gradle ( referencia de código )

    ...
    dependencies {
    ...
        // Tensorflow lite dependencies
        implementation 'org.tensorflow:tensorflow-lite:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-gpu:2.8.0'
        implementation 'org.tensorflow:tensorflow-lite-support:2.8.0'
    ...
    }
    
  2. En Android Studio, sincronice las dependencias del proyecto seleccionando: Archivo > Sincronizar proyecto con archivos Gradle .

Inicializar el intérprete del modelo ML

En su aplicación de Android, debe inicializar el intérprete del modelo de aprendizaje automático de TensorFlow Lite con parámetros antes de ejecutar predicciones con el modelo. Estos parámetros de inicialización dependen del modelo que esté utilizando y pueden incluir configuraciones como umbrales mínimos de precisión para predicciones y etiquetas para clases de objetos identificados.

Un modelo de TensorFlow Lite incluye un archivo .tflite que contiene el código del modelo y, con frecuencia, incluye un archivo de etiquetas que contiene los nombres de las clases predichas por el modelo. En el caso de la detección de objetos, las clases son objetos como una persona, un perro, un gato o un automóvil. Los modelos generalmente se almacenan en el directorio src/main/assets del módulo principal, como en el ejemplo de código:

  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_quant.tflite
  • CameraXAdvanced/tflite/src/main/assets/coco_ssd_mobilenet_v1_1.0_labels.txt

Para mayor comodidad y legibilidad del código, el ejemplo declara un objeto complementario que define la configuración del modelo.

Para inicializar el modelo en su aplicación:

  1. Cree un objeto complementario para definir la configuración del modelo: ( referencia de código )

    companion object {
       private val TAG = CameraActivity::class.java.simpleName
    
       private const val ACCURACY_THRESHOLD = 0.5f
       private const val MODEL_PATH = "coco_ssd_mobilenet_v1_1.0_quant.tflite"
       private const val LABELS_PATH = "coco_ssd_mobilenet_v1_1.0_labels.txt"
    }
    
  2. Use la configuración de este objeto para construir un objeto TensorFlow Lite Interpreter que contenga el modelo: ( referencia de código )

    private val tflite by lazy {
       Interpreter(
           FileUtil.loadMappedFile(this, MODEL_PATH),
           Interpreter.Options().addDelegate(nnApiDelegate))
    }
    

Configurar acelerador de hardware

Al inicializar un modelo de TensorFlow Lite en su aplicación, puede usar funciones de aceleración de hardware para acelerar los cálculos de predicción del modelo. El ejemplo de código anterior usa NNAPI Delegate para manejar la aceleración de hardware de la ejecución del modelo:

Interpreter.Options().addDelegate(nnApiDelegate)

Los delegados de TensorFlow Lite son módulos de software que aceleran la ejecución de modelos de aprendizaje automático mediante hardware de procesamiento especializado en un dispositivo móvil, como GPU, TPU o DSP. Se recomienda usar delegados para ejecutar modelos de TensorFlow Lite, pero no es obligatorio.

Para obtener más información sobre el uso de delegados con TensorFlow Lite, consulte Delegados de TensorFlow Lite .

Proporcionar datos al modelo.

En su aplicación de Android, su código proporciona datos al modelo para su interpretación mediante la transformación de datos existentes, como imágenes, en un formato de datos Tensor que puede procesar su modelo. Los datos de un tensor deben tener dimensiones o formas específicas que coincidan con el formato de los datos utilizados para entrenar el modelo.

Para determinar la forma de tensor necesaria para un modelo:

  • Utilice el objeto Intérprete inicializado para determinar la forma del tensor utilizado por su modelo, como se muestra en el fragmento de código a continuación: ( referencia de código )

    private val tfInputSize by lazy {
       val inputIndex = 0
       val inputShape = tflite.getInputTensor(inputIndex).shape()
       Size(inputShape[2], inputShape[1]) // Order of axis is: {1, height, width, 3}
    }
    

El modelo de detección de objetos utilizado en el código de ejemplo espera imágenes cuadradas con un tamaño de 300 por 300 píxeles.

Antes de que pueda proporcionar imágenes desde la cámara, su aplicación debe tomar la imagen, hacer que se ajuste al tamaño esperado, ajustar su rotación y normalizar los datos de la imagen. Al procesar imágenes con un modelo de TensorFlow Lite, puede usar la clase ImageProcessor de la biblioteca de soporte de TensorFlow Lite para manejar este preprocesamiento de datos, como se muestra a continuación.

Para transformar datos de imagen para un modelo:

  1. Utilice el procesador de imágenes de la biblioteca de soporte para crear un objeto para transformar datos de imagen en un formato que su modelo pueda usar para ejecutar predicciones: ( referencia de código )

    private val tfImageProcessor by lazy {
       val cropSize = minOf(bitmapBuffer.width, bitmapBuffer.height)
       ImageProcessor.Builder()
           .add(ResizeWithCropOrPadOp(cropSize, cropSize))
           .add(ResizeOp(
               tfInputSize.height, tfInputSize.width, ResizeOp.ResizeMethod.NEAREST_NEIGHBOR))
           .add(Rot90Op(-imageRotationDegrees / 90))
           .add(NormalizeOp(0f, 1f))
           .build()
    }
    
  2. Copie los datos de la imagen del sistema de cámara de Android y prepárelos para el análisis con su objeto ImageProcessor : ( referencia de código )

    // Copy out RGB bits to the shared buffer
    image.use { bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer)  }
    
    // Process the image in Tensorflow
    val tfImage =  tfImageProcessor.process(tfImageBuffer.apply { load(bitmapBuffer) })
    

Ejecutar predicciones

En su aplicación de Android, una vez que crea un objeto TensorImage con datos de imagen en el formato correcto, puede ejecutar el modelo contra esos datos para producir una predicción o inferencia . El código de ejemplo de este tutorial usa una clase ObjectDetectionHelper que encapsula este código en un método predict() .

Para ejecutar una predicción en un conjunto de datos de imagen:

  1. Ejecute la predicción pasando los datos de la imagen a su función de predicción: ( referencia de código )

    // Perform the object detection for the current frame
    val predictions = detector.predict(tfImage)
    
  2. Llame al método de ejecución en su instancia de objeto tflite con los datos de la imagen para generar predicciones: ( referencia de código )

    fun predict(image: TensorImage): List<ObjectPrediction> {
       tflite.runForMultipleInputsOutputs(arrayOf(image.buffer), outputBuffer)
       return predictions
    }
    

El objeto TensorFlow Lite Interpreter recibe estos datos, los compara con el modelo y produce una lista de predicciones. Para el procesamiento continuo de datos por parte del modelo, use el método runForMultipleInputsOutputs() para que el sistema no cree y luego elimine objetos de intérprete para cada ejecución de predicción.

Manejar la salida del modelo

En su aplicación de Android, después de ejecutar datos de imagen contra el modelo de detección de objetos, genera una lista de predicciones que el código de su aplicación debe manejar mediante la ejecución de lógica comercial adicional, la visualización de resultados al usuario o la realización de otras acciones.

El resultado de cualquier modelo de TensorFlow Lite dado varía en términos de la cantidad de predicciones que produce (una o varias) y la información descriptiva de cada predicción. En el caso de un modelo de detección de objetos, las predicciones suelen incluir datos para un cuadro delimitador que indica dónde se detecta un objeto en la imagen. En el código de ejemplo, los datos devueltos tienen el formato de una lista de objetos ObjectPrediction , como se muestra a continuación: ( referencia de código )

val predictions get() = (0 until OBJECT_COUNT).map {
   ObjectPrediction(

       // The locations are an array of [0, 1] floats for [top, left, bottom, right]
       location = locations[0][it].let {
           RectF(it[1], it[0], it[3], it[2])
       },

       // SSD Mobilenet V1 Model assumes class 0 is background class
       // in label file and class labels start from 1 to number_of_classes + 1,
       // while outputClasses correspond to class index from 0 to number_of_classes
       label = labels[1 + labelIndices[0][it].toInt()],

       // Score is a single value of [0, 1]
       score = scores[0][it]
   )
}

Captura de pantalla de detección de objetos Para el modelo utilizado en este ejemplo, cada predicción incluye una ubicación de cuadro delimitador para el objeto, una etiqueta para el objeto y una puntuación de predicción entre 0 y 1 como Flotante que representa la confianza de la predicción, siendo 1 la calificación de confianza más alta. . En general, las predicciones con una puntuación inferior al 50 % (0,5) se consideran no concluyentes. Sin embargo, la forma en que maneja los resultados de predicción de bajo valor depende de usted y de las necesidades de su aplicación.

Una vez que el modelo ha devuelto un resultado de predicción, su aplicación puede actuar sobre esa predicción presentando el resultado a su usuario o ejecutando lógica adicional. En el caso del código de ejemplo, la aplicación dibuja un cuadro delimitador alrededor del objeto identificado y muestra el nombre de la clase en la pantalla. Revise la función CameraActivity.reportPrediction() en el código de ejemplo para obtener más información.

Próximos pasos

  • Explore varios usos de TensorFlow Lite en los ejemplos .
  • Obtenga más información sobre el uso de modelos de aprendizaje automático con TensorFlow Lite en la sección Modelos .
  • Obtén más información sobre cómo implementar el aprendizaje automático en tu aplicación móvil en la Guía para desarrolladores de TensorFlow Lite .