Agrega Firebase a tu app para Android con tecnología TFLite

1. Descripción general

AA de Firebase te permite implementar tu modelo de manera inalámbrica. Esto te permite mantener un tamaño pequeño de la app y solo descargar el modelo de AA cuando sea necesario, experimentar con varios modelos o actualizar tu modelo de AA sin tener que volver a publicar toda la app.

En este codelab, convertirás una app para Android con un modelo de TFLite estático en una app con un modelo entregado de forma dinámica desde Firebase.

Qué aprenderás

• Implementa modelos de TFLite en AA de Firebase y accede a ellos desde tu app
• Realiza un seguimiento de los comentarios de los usuarios para medir la precisión del modelo con Firebase Analytics
• Genera un perfil del rendimiento del modelo a través de Firebase Performance
• Selecciona cuál de los varios modelos implementados se carga a través de Remote Config.
• Experimenta con diferentes modelos mediante Firebase A/B Testing

Requisitos

• La versión más reciente de Android Studio
• Código de muestra.
• Un dispositivo de prueba con Android 5.0 o versiones posteriores y Servicios de Google Play 9.8 o versiones posteriores, o un emulador con Servicios de Google Play 9.8 o versiones posteriores
• Si usas un dispositivo, debes usar un cable de conexión.

¿Cómo usarás este instructivo?

Leer Leer y completar los ejercicios

¿Cómo calificarías tu experiencia con la compilación de apps para Android?

Principiante Intermedio Avanzado

2. Obtén el código de muestra

Clona el repositorio de GitHub a partir de la línea de comandos.

$ git clone https://github.com/FirebaseExtended/codelab-digitclassifier-android.git

Si no tienes Git instalado, también puedes descargar el proyecto de muestra desde su página de GitHub o haciendo clic en este vínculo.

El repositorio "codelab-digit-classifier-android" contiene dos carpetas:

• start: El código inicial en el que te basarás en este codelab
• final: Es el código completo de la app de ejemplo finalizada.

3. Importa la app de partida

En Android Studio, selecciona el directorio codelab-digitclassifier-android ( ) desde la descarga del código de muestra (File > Open > .../codelab-digitclassifier-android/start).

Ahora, deberías tener el proyecto de inicio abierto en Android Studio.

4. Ejecuta la app de partida

Ahora que importaste el proyecto a Android Studio, podrás ejecutar la app por primera vez. Conecta el dispositivo Android y haz clic en Run ( ) en la barra de herramientas de Android Studio.

La app debería iniciarse en el dispositivo. En este punto, si intentas dibujar un dígito, la app debería poder reconocerlo.

5. Crea un proyecto de Firebase console

Agrega Firebase al proyecto

1. Dirígete a Firebase console.
2. Selecciona Agregar proyecto.
3. Selecciona o ingresa un nombre de proyecto.
4. Sigue los pasos de configuración restantes en Firebase console y, luego, haz clic en Crear proyecto (o Agregar Firebase si usas un proyecto de Google existente).

6. Agregar Firebase

1. En la pantalla de descripción general del proyecto nuevo, haz clic en el ícono de Android para iniciar el flujo de trabajo de configuración.
2. Ingresa el nombre del paquete del codelab: org.tensorflow.lite.examples.digitclassifier

Agrega el archivo google-services.json a tu app

Después de registrar el nombre del paquete y seleccionar Siguiente, haz clic en Descargar google-services.json para obtener el archivo de configuración de Firebase para Android y, luego, copia el archivo google-services.json en el directorio app de tu proyecto. Una vez que se descargue el archivo, puedes omitir los próximos pasos que se muestran en la consola (ya se realizaron en el proyecto build-android-start).

Agrega el complemento google-services a tu app

El complemento google-services usa el archivo google-services.json para configurar tu aplicación de modo que use Firebase. Agrega la siguiente línea al bloque plugins en la parte superior del archivo build.gradle.kts en el directorio app de tu proyecto:

app/build.gradle.kts

id("com.google.gms.google-services")

Luego, agrega la siguiente línea al bloque plugins de tu archivo build.gradle.kts en el proyecto:

project/build.gradle.kts

id("com.google.gms.google-services") version "4.3.15" apply false

Sincroniza tu proyecto con archivos de Gradle

A fin de asegurarte de que todas las dependencias estén disponibles para tu app, debes sincronizar tu proyecto con archivos de Gradle en este momento. Selecciona File > Sync Project with Gradle Files en la barra de herramientas de Android Studio.

7. Ejecuta la app con Firebase

Ahora que configuraste el complemento google-services con el archivo JSON, estás listo para ejecutar la app con Firebase. Conecta el dispositivo Android y haz clic en Run ( ) en la barra de herramientas de Android Studio.

La app debería iniciarse en el dispositivo. En este punto, tu app debería compilarse correctamente.

8. Implementa un modelo en AA de Firebase

La implementación de un modelo en el AA de Firebase es útil por dos razones principales:

1. Podemos mantener un tamaño de instalación de la app pequeño y solo descargar el modelo si es necesario.
2. El modelo se puede actualizar con regularidad y con un ciclo de lanzamiento diferente al de toda la app.

Antes de que podamos reemplazar el modelo estático de nuestra app por un modelo descargado dinámicamente desde Firebase, debemos implementarlo en el AA de Firebase. El modelo se puede implementar a través de la consola o de manera programática con el SDK de Firebase Admin. En este paso, realizaremos la implementación a través de la consola.

Para simplificarlo, usaremos el modelo de TensorFlow Lite que ya está en nuestra app. Primero, abre Firebase console y haz clic en Aprendizaje automático en el panel de navegación izquierdo. Haz clic en "Comenzar" si lo abres por primera vez. Luego, navega a "Personalizado" y haz clic en el botón "Agregar modelo personalizado".

Cuando se te solicite, asigna un nombre descriptivo al modelo, como mnist_v1, y sube el archivo desde el directorio del proyecto del codelab en start/app/src/main/assets/mnist.tflite. Luego, puedes borrar este archivo de modelo de TF Lite del proyecto de Android.

Nota: Si tienes una canalización para volver a entrenar tu modelo de forma continua, puedes automatizar el proceso de carga a Firebase con la API de Firebase ML Model Management.

9. Descarga el modelo de AA de Firebase

Elegir cuándo descargar el modelo remoto de Firebase a tu app puede ser complicado, ya que los modelos de TFLite pueden crecer relativamente grandes. Lo ideal es evitar cargar el modelo de inmediato cuando se inicia la app, ya que si nuestro modelo se usa para una sola función y el usuario nunca usa esa función, habremos descargado una cantidad significativa de datos sin motivo. También podemos configurar opciones de descarga, como recuperar solo los modelos cuando hay una conexión a Wi-Fi. Si quieres asegurarte de que el modelo esté disponible incluso sin una conexión de red, es importante empaquetarlo sin la app como copia de seguridad.

Para hacerlo más simple, quitaremos el modelo empaquetado predeterminado y siempre descargaremos un modelo de Firebase cuando se inicie la app. De esta manera, cuando ejecutas el reconocimiento de dígitos, puedes estar seguro de que la inferencia se ejecuta con el modelo proporcionado desde Firebase.

En el archivo app/build.gradle.kts, agrega la dependencia de aprendizaje automático de Firebase.

app/build.gradle.kts

implementation("com.google.firebase:firebase-ml-modeldownloader:24.1.2")

Luego, agrega lógica para descargar el modelo desde Firebase.

Reemplazaremos digitClassifier.initialize(loadModelFile()) por downloadModel("mnist_v1") y, luego, implementaremos este método.

MainActivity.kt

  private fun downloadModel(modelName: String): Task<CustomModel> {
    val conditions = CustomModelDownloadConditions.Builder()
    .requireWifi()
    .build()
    return FirebaseModelDownloader.getInstance()
        .getModel(modelName, DownloadType.LOCAL_MODEL, conditions)
        .addOnCompleteListener {
          val model = it.result
          if (model == null) {
            showToast("Failed to get model file.")
          } else {
            showToast("Downloaded remote model: $modelName")
            digitClassifier.initialize(model)
          }
        }
      .addOnFailureListener {
        showToast("Model download failed for $modelName, please check your connection.")
      }
  }

Vuelve a ejecutar tu app y dibuja un dígito en el clasificador de dígitos. Una vez finalizada la descarga, deberías ver un mensaje de aviso que indica que se descargó el modelo remoto y un registro que indica que se está usando el modelo nuevo.

10. Haz un seguimiento de los comentarios y las conversiones de los usuarios para medir la precisión del modelo

Google Analytics para Firebase te permite comprender la forma en que los usuarios se mueven por tu aplicación, dónde tienen éxito y en qué puntos se quedan atascados y regresan. También se puede usar para comprender las partes más usadas de tu aplicación.

Mediremos la exactitud del modelo a través del seguimiento de los comentarios de los usuarios sobre las predicciones del modelo. Si un usuario hace clic en "SÍ", indicará que la predicción fue precisa.

Podemos registrar un evento de Analytics para hacer un seguimiento de la precisión de nuestro modelo. En primer lugar, debemos agregar Analytics a la dependencia antes de poder usarla en el proyecto:

Agrega una dependencia de Firebase Analytics

app/build.gradle.kts

implementation(platform("com.google.firebase:firebase-bom:32.0.0"))
implementation("com.google.firebase:firebase-analytics-ktx")

Registra eventos

Luego, en la función onCreate, configuraremos el objeto de escucha click para registrar el evento correct_inference en Firebase.

MainActivity.kt (onCreate)

// Setup YES button
yesButton?.setOnClickListener {
  Firebase.analytics.logEvent("correct_inference", null)
}

Vuelve a ejecutar la app y dibuja un dígito. Presiona el botón “Yes” un par de veces para enviar comentarios que indiquen que la inferencia fue precisa.

NOTA: Los informes de Firebase Analytics están disponibles para su análisis en Firebase console aproximadamente 24 horas después de que se suben.

Análisis de depuración

Por lo general, los eventos que registra la app se agrupan en lotes durante un período de aproximadamente una hora y se suben juntos. Con este enfoque, se conserva la batería de los dispositivos de los usuarios finales y se reduce el uso de datos de la red. Sin embargo, para validar tu implementación de estadísticas (y para ver tus estadísticas en el informe de DebugView), puedes habilitar el modo de depuración en tu dispositivo de desarrollo para subir eventos con un retraso mínimo.

Para habilitar el modo de depuración de Analytics en un dispositivo Android, ejecuta los siguientes comandos:

adb shell setprop debug.firebase.analytics.app org.tensorflow.lite.examples.digitclassifier

Vuelve a ejecutar la app y dibuja un dígito. Presiona el botón “Yes” un par de veces para enviar comentarios que indiquen que la inferencia fue precisa. Ahora puedes ver los eventos de registro casi en tiempo real a través de la vista de depuración en Firebase console. Haz clic en Analytics > DebugView en la barra de navegación izquierda.

11. Analizar el rendimiento del modelo

Firebase Performance Monitoring es un servicio que te permite obtener información valiosa sobre las características de rendimiento de tus apps web, para iOS y Android.

Usa el SDK de Performance Monitoring para recopilar datos de rendimiento de tu app y, luego, revisa y analiza esos datos en Firebase console. Performance Monitoring te ayuda a comprender dónde y cuándo se puede mejorar el rendimiento de tu app, de modo que puedas usar esa información para solucionar problemas de rendimiento.

Aquí agregamos seguimientos de rendimiento en torno a la inferencia y la descarga

Esto es importante porque los modelos más grandes que se usan en el aprendizaje profundo tienen el potencial de ser más precisos, pero también pueden tardar más tiempo en devolver una respuesta. En nuestro experimento, intentamos encontrar el equilibrio adecuado entre precisión y velocidad.

Cómo agregar una dependencia de Firebase Performance

project/build.gradle.kts

plugins {
  // ...

  // Add the dependency for the Performance Monitoring plugin
  id("com.google.firebase.firebase-perf") version "1.4.2" apply false
}

app/build.gradle.kts

plugins {
  // ...

  // Add the Performance Monitoring plugin
  id("com.google.firebase.firebase-perf")
}

// ...

dependencies {
  // ...

  // Add the dependency for the Performance Monitoring library
  implementation("com.google.firebase:firebase-perf")
}

Cómo agregar seguimientos personalizados

En la función setupDigitClassifier(), crea un nuevo DownloadTrace y, luego, inícialo justo antes de descargar el modelo. Luego, agrega un objeto de escucha onsuccess que detenga el registro.

En la función classifyDrawing(), crea un nuevo classifyTrace y, luego, inícialo justo antes de la clasificación. Luego, detén el seguimiento en el objeto de escucha onsuccess.

MainActivity.kt

class MainActivity : AppCompatActivity() {
  // ...
  
  private val firebasePerformance = FirebasePerformance.getInstance()
  
  // ...

  private fun setupDigitClassifier() {
    // Add these lines to create and start the trace
    val downloadTrace = firebasePerformance.newTrace("download_model")
    downloadTrace.start()
    downloadModel("mnist_v1")
      // Add these lines to stop the trace on success
      .addOnSuccessListener {
        downloadTrace.stop()
      }
  }

// ...

  private fun classifyDrawing() {
    val bitmap = drawView?.getBitmap()

    if ((bitmap != null) && (digitClassifier.isInitialized)) {
      // Add these lines to create and start the trace
      val classifyTrace = firebasePerformance.newTrace("classify")
      classifyTrace.start()
      digitClassifier
        .classifyAsync(bitmap)
        .addOnSuccessListener { resultText -> 
          // Add this line to stop the trace on success
          classifyTrace.stop()
          predictedTextView?.text = resultText
        }
        .addOnFailureListener { e ->
          predictedTextView?.text = getString(
            R.string.tfe_dc_classification_error_message,
            e.localizedMessage
          )
          Log.e(TAG, "Error classifying drawing.", e)
        }
    }
  }

Consulta los mensajes de registro de los eventos de rendimiento

1. Agrega un elemento <meta-data> al archivo AndroidManifest.xml de tu app para habilitar el registro de depuración de Performance Monitoring en el tiempo de compilación, como en el siguiente ejemplo:

AndroidManifest.xml

<application>
    <meta-data
      android:name="firebase_performance_logcat_enabled"
      android:value="true" />
</application>

2. Revisa si hay mensajes de error en los mensajes de registro.
3. Performance Monitoring etiqueta sus mensajes de registro con FirebasePerformance. Con el filtrado de logcat, puedes ver específicamente el seguimiento de duración y el registro de solicitudes de red HTTP/S mediante la ejecución del siguiente comando:

adb logcat -s FirebasePerformance

4. Verifica los siguientes tipos de registros que indican que Performance Monitoring registra eventos de rendimiento:

• Logging TraceMetric
• Logging NetworkRequestMetric

12. Implementa un segundo modelo en el AA de Firebase

Cuando se te ocurra una nueva versión de tu modelo, como una con una mejor arquitectura de modelo o una entrenado con un conjunto de datos más grande o actualizado, podemos sentir la tentación de reemplazar nuestro modelo actual por la nueva versión. Sin embargo, un modelo que funciona bien en las pruebas no necesariamente tiene el mismo rendimiento en producción. Por lo tanto, hagamos pruebas A/B en producción para comparar nuestro modelo original y el nuevo.

Habilitar la API de Firebase Model Management

En este paso, habilitaremos la API de Firebase Model Management para implementar una versión nueva de nuestro modelo de TensorFlow Lite con código de Python.

Crea un bucket para almacenar tus modelos de AA

En Firebase console, ve a Storage y haz clic en Comenzar.

Sigue el diálogo para configurar tu bucket.

Habilitar la API de AA de Firebase

Ve a la página de la API de AA de Firebase en la consola de Google Cloud y haz clic en Habilitar.

Selecciona la app de Digit Classifier cuando se te solicite.

Entrena un modelo nuevo y publícalo en AA de Firebase

Ahora entrenaremos una nueva versión del modelo con un conjunto de datos más grande y, luego, la implementaremos de manera programática directamente desde el notebook de entrenamiento con el SDK de Firebase Admin.

Descarga la clave privada de la cuenta de servicio

Antes de poder usar el SDK de Firebase Admin, tendremos que crear una cuenta de servicio. Abre el panel de cuentas de servicio de Firebase console. Para ello, haz clic en este vínculo y, luego, en el botón a fin de crear una cuenta de servicio nueva para el SDK de Firebase Admin. Cuando se te solicite, haz clic en el botón Generate New Private Key. Usaremos la clave de la cuenta de servicio para autenticar nuestras solicitudes desde el notebook de Colab.

Ahora podemos entrenar e implementar el modelo nuevo.

1. Abre este notebook de Colab y haz una copia de él en tu propia Drive.
2. Ejecuta la primera celda “Entrenar un modelo mejorado de TensorFlow Lite” haciendo clic en el botón de reproducción a la izquierda. Se entrenará un modelo nuevo, lo que puede tardar un poco.
3. Si ejecutas la segunda celda, se creará una solicitud de carga de archivos. Sube el archivo JSON que descargaste de Firebase console cuando creaste tu cuenta de servicio.

4. Ejecuta las dos últimas celdas.

Después de ejecutar el notebook de Colab, deberías ver un segundo modelo en Firebase console. Asegúrate de que el segundo modelo se llame mnist_v2.

13. Selecciona un modelo a través de Remote Config.

Ahora que tenemos dos modelos separados, agregaremos un parámetro para seleccionar el modelo que se descargará en el tiempo de ejecución. El valor del parámetro que reciba el cliente determinará qué modelo descargará.

Agrega reglas de configuración en Firebase console

Primero, abre Firebase console y haz clic en el botón Remote Config en el menú de navegación izquierdo. Luego, haz clic en el botón "Agregar parámetro".

Asígnale el nombre model_name al parámetro nuevo y asígnale un valor predeterminado de "mnist_v1". Al poner el nombre del modelo en el parámetro de Remote Config, podemos probar varios modelos sin agregar un parámetro nuevo para cada modelo que queramos probar. Haz clic en Publicar cambios para aplicar las actualizaciones.

Agrega la dependencia de Firebase RemoteConfig

app/build.gradle.kts

implementation("com.google.firebase:firebase-config-ktx")

Configura Firebase Remote Config

MainActivity.kt

  private fun configureRemoteConfig() {
    remoteConfig = Firebase.remoteConfig
    val configSettings = remoteConfigSettings {
      minimumFetchIntervalInSeconds = 3600
    }
    remoteConfig.setConfigSettingsAsync(configSettings)
  }

Solicitar y usar la configuración

Crea una solicitud de recuperación para la configuración y agrega un controlador de finalización para recoger y usar los parámetros de configuración.

MainActivity.kt

 private fun setupDigitClassifier() {
    configureRemoteConfig()
    remoteConfig.fetchAndActivate()
      .addOnCompleteListener { task ->
        if (task.isSuccessful) {
          val modelName = remoteConfig.getString("model_name")
          val downloadTrace = firebasePerformance.newTrace("download_model")
          downloadTrace.start()
          downloadModel(modelName)
            .addOnSuccessListener {
              downloadTrace.stop()
            }
        } else {
          showToast("Failed to fetch model name.")
        }
      }
  }

Prueba Remote Config

1. Haz clic en el botón Run.
2. Verifica que veas el mensaje Toast que indica que se descargó el modelo mnist_v1.
3. Regresa a Firebase console, cambia el valor predeterminado a mnist_v2 y selecciona Publicar cambios para aplicar las actualizaciones.
4. Reinicia la app y comprueba que aparezca el mensaje de aviso de que el modelo mnist_v2 se descargó esta vez.

14. Efectividad del modelo de prueba A/B

Firebase A/B Testing te ayuda a optimizar la experiencia de tu app, ya que facilita la ejecución, el análisis y el escalamiento del producto y los experimentos de marketing. Por último, podemos usar el comportamiento integrado de A/B Testing de Firebase para ver cuál de los dos modelos tiene el mejor rendimiento.

Ve a Analytics -> Eventos en Firebase console. Si se muestra el evento correct_inference, márcalo como "Evento de conversión". De lo contrario, ve a Analytics -> Eventos de conversión y haz clic en "Crear un evento de conversión nuevo" y selecciona correct_inference..

Ahora ve a “Remote Config” en Firebase console y selecciona el botón “Prueba A/B” del menú de más opciones en el parámetro “model_name” que acabamos de agregar.

En el menú que aparece a continuación, acepta el nombre predeterminado.

Selecciona tu app en el menú desplegable y cambia los criterios de segmentación al 50% de los usuarios activos.

Si anteriormente pudiste establecer el evento correct_inference como una conversión, utiliza este evento como la métrica principal de seguimiento. De lo contrario, si no deseas esperar a que el evento aparezca en Analytics, puedes agregar correct_inference manually.

Por último, en la pantalla Variantes, configura la variante del grupo de control para que use mnist_v1 y el grupo Variante A para usar mnist_v2.

Haz clic en el botón Revisar ubicado en la esquina inferior derecha.

Felicitaciones, creaste con éxito una prueba A/B para tus dos modelos independientes. Actualmente, la prueba A/B se encuentra en estado de borrador y puede iniciarse en cualquier momento haciendo clic en el botón "Iniciar experimento".

Para obtener información más detallada sobre las pruebas A/B, consulta la documentación sobre A/B Testing.

15. ¡Felicitaciones!

En este codelab, aprendiste a reemplazar un recurso de tflite empaquetado de forma estática en tu app por un modelo TFLite cargado de forma dinámica desde Firebase. Para obtener más información sobre TFLite y Firebase, consulta otras muestras de TFLite y las guías de introducción de Firebase.

Temas abordados

• TensorFlow Lite
• AA de Firebase
• Firebase Analytics
• Firebase Performance Monitoring
• Firebase Remote Config
• Firebase A/B Testing

Próximos pasos

• Implementar la implementación del AA de Firebase en tu app

Más información

• Documentación sobre el aprendizaje automático de Firebase
• Documentación de TensorFlow Lite
• Modelos de A/B Testing con Firebase

¿Tienes alguna pregunta?

• Stack Overflow “firebase-machine-learning”

Informar problemas

• Problemas de GitHub