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

1. Descripción general

cd824ecfd05a2822.png

El AA de Firebase te permite implementar tu modelo de manera inalámbrica. Esto te permite mantener el tamaño de la app pequeño 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 la app completa.

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

Qué aprenderás

  • Implementa modelos de TFLite en el 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
  • Cómo generar perfiles del rendimiento del modelo a través de Firebase Performance
  • Selecciona cuál de los múltiples modelos implementados se carga a través de Remote Config
  • Experimenta con diferentes modelos con 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 los 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, 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 desde 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.

3. Importa la app de partida

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

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

4. Ejecuta la app de inicio

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

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

6e36e1b947b395f2.png

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 para el 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. Desde la pantalla de informació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 siguientes pasos que aparecen en la consola (ya se realizaron automáticamente en el proyecto build-android-start).

Agrega el complemento de Servicios de Google a tu app

El complemento google-services usa el archivo google-services.json para configurar tu aplicación de modo que utilice 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

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

7. Ejecuta la app con Firebase

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

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

8. Implementa un modelo en el AA de Firebase

Implementar un modelo en el AA de Firebase es útil por dos motivos 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 poder reemplazar el modelo estático en nuestra app por un modelo descargado de forma dinámica desde Firebase, debemos implementarlo en 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 simplificar el proceso, 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 de la izquierda. Haz clic en "Comenzar". si es la primera vez que lo abres. Luego, navega a "Personalizado" y haz clic en “Agregar modelo personalizado” .

Cuando se te solicite, asígnale un nombre descriptivo al modelo, como mnist_v1, y sube el archivo del 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.

3c3c50e6ef12b3b.png

9. Descarga el modelo desde el 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 grande. Lo ideal sería evitar cargar el modelo de inmediato cuando se inicie la app, ya que si nuestro modelo se usa solo para una función y el usuario nunca usa esa función, se descargará una cantidad significativa de datos sin motivo. También podemos configurar opciones de descarga, como recuperar modelos solo cuando haya conexión a Wi-Fi. Si quieres asegurarte de que el modelo esté disponible incluso sin conexión de red, es importante empaquetarlo sin la app como copia de seguridad.

Para simplificar, quitaremos el modelo empaquetado predeterminado y siempre descargaremos un modelo de Firebase cuando se inicie la app. De esta manera, cuando se ejecuta el reconocimiento de dígitos, puedes estar seguro de que la inferencia se ejecuta con el modelo proporcionado por 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 de 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 tu modelo nuevo se está usando.

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 avanzan en tu aplicación, en qué punto tienen éxito y en qué puntos se atascan y retroceden. También se puede usar para comprender las partes más usadas de tu aplicación.

Mediremos la precisión 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. Primero, debemos agregar Analytics a la dependencia antes de que se pueda usar 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 de clic 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" varias veces para enviar comentarios que indiquen que la inferencia fue correcta.

Estadísticas de depuración

Por lo general, los eventos que registra tu app se agrupan en lotes durante un período de aproximadamente una hora y se suben juntos. Con este enfoque, se ahorra batería de las cargas de trabajo de los usuarios finales y 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" varias veces para enviar comentarios que indiquen que la inferencia fue correcta. Ahora podrás 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.

5276199a086721fd.png

11. Analiza 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 manera que puedas usar esa información para solucionar problemas de rendimiento.

Aquí, agregamos seguimientos de rendimiento sobre inferencia y 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 en devolver una respuesta. En nuestro experimento, intentamos encontrar el equilibrio correcto entre exactitud y velocidad.

Agrega la 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")
}

Agregar seguimientos personalizados

En la función setupDigitClassifier(), crea un downloadTrace nuevo y, luego, inícialo 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 registro 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. Para habilitar el registro de depuración de Performance Monitoring en el tiempo de compilación, agrega un elemento <meta-data> al archivo AndroidManifest.xml de tu app, de la siguiente manera:

AndroidManifest.xml

<application>
    <meta-data
      android:name="firebase_performance_logcat_enabled"
      android:value="true" />
</application>
  1. Revisa si hay mensajes de error en los mensajes de registro.
  2. 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 ejecutando el siguiente comando:
adb logcat -s FirebasePerformance
  1. 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 creamos una nueva versión de tu modelo, por ejemplo, una con una mejor arquitectura de modelo o una entrenado con un conjunto de datos más grande o actualizado, es posible que nos sientamos tentados a reemplazar el modelo actual por la nueva versión. Sin embargo, un modelo que funciona bien en pruebas no necesariamente tendrá el mismo rendimiento en producción. Por lo tanto, realicemos pruebas A/B en producción para comparar nuestro modelo original y el nuevo.

Habilita 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. fbbea78f0eb3dc9f.png

Sigue el diálogo para configurar tu bucket.

19517c0d6d2aa14d.png

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.

2414fd5cced6c984.pngSelecciona la app de Digit Classifier cuando se te solicite.

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

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

Descarga la clave privada para la cuenta de servicio

Antes de poder usar el SDK de Firebase Admin, necesitaremos crear una cuenta de servicio. Haz clic en este vínculo para abrir el panel Cuentas de servicio de Firebase console y, luego, en el botón para crear una cuenta de servicio nueva para el SDK de Firebase Admin. Cuando se te solicite, haz clic en el botón Generar nueva clave privada. Usaremos la clave de la cuenta de servicio para autenticar nuestras solicitudes desde el notebook de Colab.

c3b95de1e5508516.png

Ahora podemos entrenar y, luego, implementar el modelo nuevo.

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

71e847c6a85423b3.png

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

c316683bb4d75d57.png

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

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

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 "Agregar parámetro" .

Asigna el nombre model_name al nuevo parámetro 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 nuevo parámetro para cada modelo que queremos probar. Haz clic en Publicar cambios para aplicar las actualizaciones.

2949cb95c7214ca4.png

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)
  }

Solicita y usa 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 98205811bbed9d74.pngRun.
  2. Verifica que ves el mensaje de aviso 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 verifica el mensaje de aviso que indica que esta vez se descargó el modelo mnist_v2.

14. Eficacia del modelo de pruebas 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 nuestros 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, puedes ir a Analytics -> Eventos de conversión y haz clic en "Crear un evento de conversión nuevo" y suelta correct_inference.

Ahora, ve a “Remote Config en Firebase console, selecciona “Prueba A/B” en el menú Más opciones de “model_name” que acabamos de agregar.

fad5ea36969d2aeb.png

En el siguiente menú, acepta el nombre predeterminado.

d7c006669ace6e40.png

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

cb72dcc7d2666bd3.png

Si antes pudo establecer el evento correct_inference como una conversión, utilice este evento como la métrica principal de la que desea hacer un seguimiento. De lo contrario, si no quieres esperar a que el evento aparezca en Analytics, puedes agregar correct_inference manually.

1ac9c94fb3159271.png

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.

e4510434f8da31b6.png

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 separados. La prueba A/B se encuentra actualmente en estado de borrador y se puede iniciar en cualquier momento haciendo clic en "Iniciar experimento". .

Para conocer más detalles sobre las pruebas A/B, consulta la documentación de 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 de TFLite cargado de forma dinámica desde Firebase. Para obtener más información sobre TFLite y Firebase, consulta otros ejemplos 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

¿Tienes alguna pregunta?

Informar problemas