Agregue recomendaciones a su aplicación con TensorFlow Lite y Firebase - Android Codelab

1. Información general

Te damos la bienvenida a las recomendaciones con el codelab de TensorFlow Lite y Firebase. En este laboratorio de código, aprenderá a usar TensorFlow Lite y Firebase para implementar un modelo de recomendación en su aplicación. Este laboratorio de programación se basa en este TensorFlow Lite ejemplo .

Las recomendaciones permiten que las aplicaciones utilicen el aprendizaje automático para ofrecer de forma inteligente el contenido más relevante para cada usuario. Tienen en cuenta el comportamiento del usuario anterior para sugerir el contenido de la aplicación con el que el usuario podría querer interactuar en el futuro mediante el uso de un modelo entrenado en el comportamiento agregado de un gran número de otros usuarios.

Este instructivo muestra cómo obtener datos de los usuarios de su aplicación con Firebase Analytics, crear un modelo de aprendizaje automático para recomendaciones de esos datos y luego usar ese modelo en una aplicación de Android para ejecutar inferencias y obtener recomendaciones. En particular, nuestras recomendaciones sugerirán qué películas probablemente vería un usuario dada la lista de películas que al usuario le han gustado anteriormente.

Lo que aprenderás

  • Integre Firebase Analytics en una aplicación de Android para recopilar datos de comportamiento del usuario
  • Exporta esos datos a Google Big Query
  • Procese previamente los datos y entrene un modelo de recomendaciones TF Lite
  • Implemente el modelo TF Lite en Firebase ML y acceda a él desde su aplicación
  • Ejecutar en la inferencia del dispositivo usando el modelo para sugerir recomendaciones a los usuarios

Lo que necesitarás

  • Android Studio versión 3.4+.
  • Código de muestra.
  • Un dispositivo de prueba con Android 2.3+ y los servicios de Google Play 9.8 o posterior, o un emulador con los servicios de Google Play 9.8 o posterior
  • Si usa un dispositivo, un cable de conexión.

¿Cómo usarás este tutorial?

Léelo solo Léelo y completa los ejercicios.

¿Cómo calificaría su experiencia con la creación de aplicaciones de Android?

Principiante Intermedio Competente

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-contentrecommendation-android.git

3. Importa la aplicación de inicio

A partir de Android Studio, seleccione el codelab-recommendations-android directorio ( android_studio_folder.png ) A partir de la descarga de código de ejemplo (Archivo> Abrir> ... / codelab-recomendaciones-android / start).

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

4. Crea un proyecto de consola de Firebase

Crea un nuevo proyecto

  1. Ir a la consola Firebase .
  2. Seleccione Agregar proyecto (o crear un proyecto si es la primera).
  3. Seleccionar o introducir un nombre de proyecto y haga clic en Continuar.
  4. Asegúrese de que "Habilitar Google Analytics para este proyecto" esté habilitado.
  5. Siga los pasos de configuración restantes en la consola de Firebase, luego haga clic en Crear proyecto (o Agregar Firebase, si está utilizando un proyecto de Google existente).

5. Agrega Firebase

  1. Desde la pantalla de descripción general de su nuevo proyecto, haga clic en el icono de Android para iniciar el flujo de trabajo de configuración.
  2. Introduzca el nombre del paquete de la codelab: com.google.firebase.codelabs.recommendations
  3. Seleccione Registro de aplicaciones.

Agregue el archivo google-services.json a su aplicación

Después de añadir el nombre del paquete y seleccionando Registro, haga clic en Descargar Google-services.json para obtener su archivo de configuración Firebase Android a continuación, copiar el archivo google-services.json en la app del directorio en su proyecto. Una vez descargado el archivo puede omitir los próximos pasos que se muestran en la consola (que ya ha sido hecho para usted en el proyecto de construcción-android-inicio).

Agregue el complemento de servicios de Google a su aplicación

El complemento google-services usa el archivo google-services.json para configurar tu aplicación para que use Firebase. Las siguientes líneas ya deberían estar agregadas a los archivos build.gradle en el proyecto (verifique para confirmar):

app / build.grade

apply plugin: 'com.google.gms.google-services'

build.grade

classpath 'com.google.gms:google-services:4.3.4'

Sincroniza tu proyecto con archivos gradle

Para asegurarse de que todas las dependencias estén disponibles para su aplicación, debe sincronizar su proyecto con los archivos gradle en este momento. Seleccione Archivo> Proyecto de sincronización con Gradle de archivos de la barra de herramientas de Android Studio.

6. Ejecute la aplicación de inicio

Ahora que ha importado el proyecto en Android Studio y configurado los google-services plugin con su archivo JSON, ya está listo para ejecutar la aplicación por primera vez. Conecta tu dispositivo Android, y haga clic en Ejecutar ( ejecutar.png ) en la barra de herramientas de Android Studio.

La aplicación debería iniciarse en su dispositivo. En este punto, puede ver una aplicación en funcionamiento que muestra una pestaña con una lista de películas, una pestaña de Películas que me gustan y una pestaña de Recomendaciones. Puede hacer clic en una película de la lista de películas para agregarla a su lista de Me gusta. Después de completar los pasos restantes del laboratorio de código, podremos generar recomendaciones de películas en la pestaña Recomendaciones.

7. Agrega Firebase Analytics a la aplicación.

En este paso, agregará Firebase Analytics a la aplicación para registrar datos de comportamiento del usuario (en este caso, qué películas le gustan al usuario). Estos datos se utilizarán en conjunto en pasos futuros para entrenar el modelo de recomendaciones.

Agregar dependencia de Firebase Analytics

La siguiente dependencia es necesaria para agregar Firebase Analytics a su aplicación. Ya debería estar incluido en el archivo app / build.gradle (verificar).

app / build.grade

implementation 'com.google.firebase:firebase-analytics-ktx:17.6.0'

Configurar Firebase Analytics en la aplicación

El LikedMoviesViewModel contiene funciones para almacenar las películas que el usuario le gusta. Cada vez que al usuario le gusta una nueva película, también queremos enviar un evento de registro de análisis para registrar ese me gusta.

Agregue la función onMovieLiked con el siguiente código para registrar un evento de análisis cuando el usuario hace clic en Me gusta en una película.

LikedMoviesViewModel.kt

import com.google.firebase.analytics.FirebaseAnalytics
import com.google.firebase.analytics.ktx.analytics
import com.google.firebase.analytics.ktx.logEvent
import com.google.firebase.ktx.Firebase


class LikedMoviesViewModel internal constructor (application: Application) : AndroidViewModel(application) {

    ...

    fun onMovieLiked(movie: Movie) {
        movies.setLike(movie, true)
        logAnalyticsEvent(movie.id.toString())
    }
       
}

Agregue el siguiente campo y función para registrar un evento de Analytics cuando se agrega una película a la lista de Me gusta del usuario.

LikedMoviesViewModel.kt

import com.google.firebase.analytics.FirebaseAnalytics
import com.google.firebase.analytics.ktx.analytics
import com.google.firebase.analytics.ktx.logEvent
import com.google.firebase.ktx.Firebase


class LikedMoviesViewModel internal constructor (application: Application) : AndroidViewModel(application) {
    ...
    private val firebaseAnalytics = Firebase.analytics

    ...

    /**
     * Logs an event in Firebase Analytics that is used in aggregate to train the recommendations
     * model.
     */
    private fun logAnalyticsEvent(id: String) {
        firebaseAnalytics.logEvent(FirebaseAnalytics.Event.SELECT_ITEM) {
            param(FirebaseAnalytics.Param.ITEM_ID, id)
        }
    }

8. Pruebe su integración de Analytics

En este paso, generaremos eventos de Analytics en la aplicación y verificaremos que se envíen a Firebase Console.

Habilitar el registro de depuración de Analytics

Firebase Analytics está diseñado para maximizar la duración de la batería del usuario y agrupará eventos en el dispositivo y solo los enviará a Firebase ocasionalmente. Para fines de depuración, podemos deshabilitar este comportamiento para ver los eventos a medida que se registran en tiempo real ejecutando el siguiente comando en el shell.

Terminal

adb shell setprop debug.firebase.analytics.app com.google.firebase.codelabs.recommendations

Verifique que se generen los eventos de Analytics

  1. En Android Studio, abra la ventana de Logcat para examinar el registro desde su aplicación.
  2. Establezca el filtro Logcat en la cadena "Evento de registro".
  3. Verifique que se emitan eventos de análisis "select_item" cada vez que le guste una película en la aplicación.

En este punto, ha integrado correctamente Firebase Analytics en su aplicación. A medida que los usuarios usen su aplicación y les gusten las películas, sus Me gusta se registrarán en conjunto. Usaremos estos datos agregados en el resto de este codelab para entrenar nuestro modelo de recomendaciones. El siguiente es un paso opcional para ver que los mismos eventos de Analytics que vio en Logcat también se transmiten a Firebase console. No dude en pasar a la página siguiente.

Confirmar eventos Analytics en Firebase Consola: Opcional

  1. Ir a la consola Firebase .
  2. Seleccionar DebugView bajo Analytics
  3. En Android Studio, seleccione Ejecutar para iniciar la aplicación y añadir algunas películas a su lista gustado.
  4. En DebugView de la consola de Firebase, verifique que estos eventos se registren a medida que agrega películas en la aplicación.

9. Exportar datos de Analytics a Big Query

Big Query es un producto de Google Cloud que le permite examinar y procesar grandes cantidades de datos. En este paso, conectará su proyecto de Firebase Console a Big Query para que los datos de Analytics generados por su aplicación se exporten automáticamente a Big Query.

Habilitar la exportación de Big Query

  1. Ir a la consola Firebase .
  2. Seleccione el icono de rueda dentada de configuración junto a Visión general del proyecto, a continuación, seleccione Configuración del proyecto
  3. Seleccione la pestaña Integraciones.
  4. Seleccionar Enlace (o manejar) dentro del bloque de BigQuery.
  5. Seleccione Siguiente en la Firebase acerca de la vinculación a BigQuery paso.
  6. En la sección de integración Configurar, haga clic en el botón para permitir el envío de datos de Google Analytics y seleccione Enlace a BigQuery.

Ahora ha habilitado su proyecto de consola de Firebase para enviar automáticamente datos de eventos de Firebase Analytics a Big Query. Esto ocurre automáticamente sin ninguna interacción adicional; sin embargo, es posible que la primera exportación que crea el conjunto de datos de análisis en BigQuery no se realice en 24 horas. Una vez creado el conjunto de datos, Firebase exporta continuamente nuevos eventos de Analytics a Big Query en la tabla intradía y agrupa los eventos de días anteriores en la tabla de eventos.

El entrenamiento de un modelo de recomendaciones requiere una gran cantidad de datos. Dado que aún no tenemos una aplicación que genere grandes cantidades de datos, en el siguiente paso importaremos un conjunto de datos de muestra a BigQuery para usar en el resto de este instructivo.

10. Usa BigQuery para obtener datos de entrenamiento del modelo.

Ahora que hemos conectado nuestra consola de Firebase para exportar a BigQuery, los datos de eventos de análisis de nuestra aplicación aparecerán automáticamente en la consola de BigQuery después de un tiempo. Para obtener algunos datos iniciales para los propósitos de este instructivo, en este paso importaremos un conjunto de datos de muestra existente en su consola de BigQuery para usarlo para entrenar nuestro modelo de recomendaciones.

Importar un conjunto de datos de muestra a BigQuery

  1. Ir a la BigQuery tablero de mandos en la consola de Google nube.
  2. Seleccione el nombre de su proyecto en el menú.
  3. Seleccione el nombre de su proyecto en la parte inferior de la navegación izquierda de BigQuery para ver los detalles.
  4. Seleccione Crear conjunto de datos para abrir el panel de creación conjunto de datos.
  5. Entre 'firebase_recommendations_dataset' para el conjunto de datos de identificación y seleccione Crear conjunto de datos.
  6. El nuevo conjunto de datos aparecerá en el menú de la izquierda debajo del nombre del proyecto. Pinchalo.
  7. Seleccione Crear tabla para abrir el panel de creación de la tabla.
  8. Para Crear una tabla a partir selecciona 'Google Cloud Storage'.
  9. En el archivo Seleccione de campo Cubo de GCS, introduzca 'gs: //firebase-recommendations/recommendations-test/formatted_data_filtered.txt'.
  10. Seleccione 'JSONL' en el desplegable Formato de archivo.
  11. Entre 'recommendations_table' para el nombre de la tabla.
  12. Marque la casilla bajo el esquema> Detección automática> esquema y los parámetros de entrada
  13. Seleccione Crear una tabla

Explore el conjunto de datos de muestra

En este punto, puede explorar opcionalmente el esquema y obtener una vista previa de este conjunto de datos.

  1. Seleccione firebase-recomendaciones-conjunto de datos en el menú de la izquierda para ampliar las tablas que contiene.
  2. Seleccione la tabla de recomendaciones de la tabla para ver el esquema de la tabla.
  3. Seleccione Vista previa para ver los datos reales de eventos Analytics esta tabla contiene.

Crear credenciales de cuenta de servicio

Ahora, crearemos credenciales de cuenta de servicio en nuestro proyecto de consola de Google Cloud que podemos usar en el entorno de Colab en el siguiente paso para acceder y cargar nuestros datos de BigQuery.

  1. Asegúrese de que la facturación esté habilitada para su proyecto de Google Cloud.
  2. Habilita las API de BigQuery y BigQuery Storage. < Haga clic aquí >
  3. Ir a la página Crear clave de mantenimiento de cuentas .
  4. A partir de la lista de cuentas de servicio, seleccione Nueva cuenta de servicio.
  5. En el campo Nombre de cuenta de servicio, introduzca un nombre.
  6. En la lista de roles, seleccione Proyecto> Propietario.
  7. Haga clic en Crear. Un archivo JSON que contiene sus descargas de claves en su computadora.

En el siguiente paso, utilizaremos Google Colab para preprocesar estos datos y entrenar nuestro modelo de recomendaciones.

11. Preprocesar datos y modelo de recomendaciones de trenes.

En este paso, usaremos un cuaderno Colab para realizar los siguientes pasos:

  1. importar los datos de BigQuery al cuaderno Colab
  2. preprocesar los datos para prepararlos para el entrenamiento del modelo
  3. entrenar el modelo de recomendaciones sobre los datos analíticos
  4. exportar el modelo como modelo TF lite
  5. implementar el modelo en Firebase Console para que podamos usarlo en nuestra aplicación

Antes de lanzar el cuaderno de entrenamiento de Colab, primero habilitaremos la API de administración de modelos de Firebase para que Colab pueda implementar el modelo entrenado en nuestra consola de Firebase.

Habilita la API de administración de modelos de Firebase

Crea un depósito para almacenar tus modelos de AA

En su Firebase Console, vaya a Almacenamiento y haga clic en Comenzar. fbbea78f0eb3dc9f.png

Siga el diálogo para configurar su balde.

19517c0d6d2aa14d.png

Habilita la API de Firebase ML

Ir a la página de la API Firebase ML en Google Cloud Console y haga clic en Activar.

Use el cuaderno Colab para entrenar e implementar el modelo

Abra el cuaderno de colab usando el siguiente enlace y complete los pasos que se encuentran dentro. Después de completar los pasos en el cuaderno Colab, tendrá un archivo de modelo TF lite implementado en la consola de Firebase que podemos sincronizar con nuestra aplicación.

Abrir en Colab

12. Descarga el modelo en tu aplicación

En este paso, modificaremos nuestra aplicación para descargar el modelo que acabamos de entrenar de Firebase Machine Learning.

Agregar dependencia de Firebase ML

Se necesita la siguiente dependencia para usar los modelos de Firebase Machine Learning en su aplicación. Ya debería estar agregado (verificar).

app / build.grade

implementation 'com.google.firebase:firebase-ml-model-interpreter:22.0.4'

Descarga el modelo con la API de Firebase Model Manager

Copia el código de abajo en RecommendationClient.kt para establecer las condiciones en las que se produce modelo de descarga y crear una tarea de descarga para sincronizar el modelo de control remoto para nuestra aplicación.

RecomendaciónClient.kt

    private fun downloadModel(modelName: String) {
        val remoteModel = FirebaseCustomRemoteModel.Builder(modelName).build()
        val firebaseModelManager = FirebaseModelManager.getInstance()
        firebaseModelManager
            .isModelDownloaded(remoteModel)
            .continueWithTask { task ->
                // Create update condition if model is already downloaded, otherwise create download
                // condition.
                val conditions = if (task.result != null && task.result == true) {
                    FirebaseModelDownloadConditions.Builder()
                        .requireWifi()
                        .build() // Update condition that requires wifi.
                } else {
                    FirebaseModelDownloadConditions.Builder().build(); // Download condition.
                }
                firebaseModelManager.download(remoteModel, conditions)
            }
            .addOnSuccessListener {
                firebaseModelManager.getLatestModelFile(remoteModel)
                    .addOnCompleteListener {
                        val model = it.result
                        if (model == null) {
                            showToast(context, "Failed to get model file.")
                        } else {
                            showToast(context, "Downloaded remote model")
                            GlobalScope.launch { initializeInterpreter(model) }
                        }
                    }
            }
            .addOnFailureListener {
                showToast(context, "Model download failed for recommendations, please check your connection.")
            }
    }



13. Integra el modelo de recomendación de Tensorflow Lite en tu aplicación.

El tiempo de ejecución de Tensorflow Lite te permitirá usar tu modelo en la aplicación para generar recomendaciones. En el paso anterior, inicializamos un intérprete TFlite con el archivo de modelo que descargamos. En este paso, primero cargaremos un diccionario y etiquetas para acompañar nuestro modelo en el paso de inferencia, luego agregaremos preprocesamiento para generar las entradas a nuestro modelo y postprocesamiento donde extraeremos los resultados de nuestra inferencia. .

Cargar diccionario y etiquetas

Las etiquetas utilizadas para generar los candidatos recomendación del modelo de recomendaciones se enumeran en la sorted_movie_vocab.json archivo en la res / carpeta de activos. Copie el siguiente código para cargar estos candidatos.

RecomendaciónClient.kt

    /** Load recommendation candidate list.  */
    private suspend fun loadCandidateList() {
        return withContext(Dispatchers.IO) {
            val collection = MovieRepository.getInstance(context).getContent()
            for (item in collection) {
                candidates[item.id] = item
            }
            Log.v(TAG, "Candidate list loaded.")
        }
    }

Implementar preprocesamiento

En el paso de preprocesamiento, cambiamos la forma de los datos de entrada para que coincidan con lo que espera nuestro modelo. Aquí, rellenamos la longitud de entrada con un valor de marcador de posición si aún no hemos generado muchos Me gusta a los usuarios. Copie el siguiente código:

RecomendaciónClient.kt

    /** Given a list of selected items, preprocess to get tflite input.  */
    @Synchronized
    private suspend fun preprocess(selectedMovies: List<Movie>): IntArray {
        return withContext(Dispatchers.Default) {
            val inputContext = IntArray(config.inputLength)
            for (i in 0 until config.inputLength) {
                if (i < selectedMovies.size) {
                    val (id) = selectedMovies[i]
                    inputContext[i] = id
                } else {
                    // Padding input.
                    inputContext[i] = config.pad
                }
            }
            inputContext
        }
    }


Ejecutar intérprete para generar recomendaciones

Aquí usamos el modelo que descargamos en un paso anterior para ejecutar la inferencia en nuestra entrada preprocesada. Establecemos el tipo de entrada y salida para nuestro modelo y ejecutamos la inferencia para generar nuestras recomendaciones de películas. Copie el siguiente código en su aplicación.

RecomendaciónClient.kt

    /** Given a list of selected items, and returns the recommendation results.  */
    @Synchronized
    suspend fun recommend(selectedMovies: List<Movie>): List<Result> {
        return withContext(Dispatchers.Default) {
            val inputs = arrayOf<Any>(preprocess(selectedMovies))

            // Run inference.
            val outputIds = IntArray(config.outputLength)
            val confidences = FloatArray(config.outputLength)
            val outputs: MutableMap<Int, Any> = HashMap()
            outputs[config.outputIdsIndex] = outputIds
            outputs[config.outputScoresIndex] = confidences
            tflite?.let {
                it.runForMultipleInputsOutputs(inputs, outputs)
                postprocess(outputIds, confidences, selectedMovies)
            } ?: run {
                Log.e(TAG, "No tflite interpreter loaded")
                emptyList()
            }
        }
    }



Implementar posprocesamiento

Finalmente, en este paso posprocesamos la salida de nuestro modelo, seleccionando los resultados con la mayor confianza y eliminando los valores contenidos (películas que al usuario ya le han gustado). Copie el siguiente código en su aplicación.

RecomendaciónClient.kt

    /** Postprocess to gets results from tflite inference.  */
    @Synchronized
    private suspend fun postprocess(
        outputIds: IntArray, confidences: FloatArray, selectedMovies: List<Movie>
    ): List<Result> {
        return withContext(Dispatchers.Default) {
            val results = ArrayList<Result>()

            // Add recommendation results. Filter null or contained items.
            for (i in outputIds.indices) {
                if (results.size >= config.topK) {
                    Log.v(TAG, String.format("Selected top K: %d. Ignore the rest.", config.topK))
                    break
                }
                val id = outputIds[i]
                val item = candidates[id]
                if (item == null) {
                    Log.v(TAG, String.format("Inference output[%d]. Id: %s is null", i, id))
                    continue
                }
                if (selectedMovies.contains(item)) {
                    Log.v(TAG, String.format("Inference output[%d]. Id: %s is contained", i, id))
                    continue
                }
                val result = Result(
                    id, item,
                    confidences[i]
                )
                results.add(result)
                Log.v(TAG, String.format("Inference output[%d]. Result: %s", i, result))
            }
            results
        }
    }


¡Prueba tu aplicación!

Vuelva a ejecutar su aplicación. Al seleccionar algunas películas, debería descargar automáticamente el nuevo modelo y comenzar a generar recomendaciones.

14. ¡Felicitaciones!

Ha creado una función de recomendaciones en su aplicación con TensorFlow Lite y Firebase. Tenga en cuenta que las técnicas y la canalización que se muestran en este laboratorio de código se pueden generalizar y utilizar para servir también a otros tipos de recomendaciones.

Lo que hemos cubierto

  • Firebase ML
  • Firebase Analytics
  • Exportar eventos de análisis a BigQuery
  • Eventos analíticos previos al proceso
  • Recomendaciones de tren del modelo de TensorFlow
  • Exportar modelo e implementarlo en Firebase Console
  • Ofrecer recomendaciones de películas en una aplicación

Próximos pasos

  • Implementa las recomendaciones de Firebase ML en tu aplicación.

Aprende más

¿Tengo una pregunta?

Informar problemas