Ajoutez des recommandations à votre application avec TensorFlow Lite et Firebase - Android Codelab

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

1. Vue d'ensemble

Bienvenue dans les recommandations avec TensorFlow Lite et l'atelier de programmation Firebase. Dans cet atelier de programmation, vous apprendrez à utiliser TensorFlow Lite et Firebase pour déployer un modèle de recommandation dans votre application. Cet atelier de programmation est basé sur cet exemple TensorFlow Lite .

Les recommandations permettent aux applications d'utiliser l'apprentissage automatique pour diffuser intelligemment le contenu le plus pertinent pour chaque utilisateur. Ils prennent en compte le comportement passé de l'utilisateur pour suggérer le contenu de l'application avec lequel l'utilisateur pourrait souhaiter interagir à l'avenir en utilisant un modèle formé sur le comportement global d'un grand nombre d'autres utilisateurs.

Ce didacticiel montre comment obtenir des données auprès des utilisateurs de votre application avec Firebase Analytics, créer un modèle d'apprentissage automatique pour les recommandations à partir de ces données, puis utiliser ce modèle dans une application Android pour exécuter une inférence et obtenir des recommandations. En particulier, nos recommandations suggéreront les films qu'un utilisateur regarderait très probablement compte tenu de la liste des films que l'utilisateur a aimés précédemment.

Ce que vous apprendrez

  • Intégrez Firebase Analytics dans une application Android pour collecter des données sur le comportement des utilisateurs
  • Exportez ces données dans Google Big Query
  • Pré-traiter les données et former un modèle de recommandations TF Lite
  • Déployez le modèle TF Lite sur Firebase ML et accédez-y depuis votre application
  • Exécuter sur l'inférence d'appareil en utilisant le modèle pour suggérer des recommandations aux utilisateurs

Ce dont vous aurez besoin

  • Android Studio version 3.4+.
  • Exemple de code.
  • Un appareil de test avec Android 2.3+ et les services Google Play 9.8 ou version ultérieure, ou un émulateur avec les services Google Play 9.8 ou version ultérieure
  • Si vous utilisez un appareil, un câble de connexion.

Comment allez-vous utiliser ce tutoriel ?

Lisez-le seulement Lisez-le et complétez les exercices

Comment évaluez-vous votre expérience avec la création d'applications Android ?

Novice Intermédiaire Compétent

2. Obtenez l'exemple de code

Clonez le référentiel GitHub à partir de la ligne de commande.

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

3. Importez l'application de démarrage

Depuis Android Studio, sélectionnez le codelab-recommendations-android ( android_studio_folder.png ) à partir du téléchargement de l'exemple de code ( Fichier > Ouvrir > .../codelab-recommendations-android/start).

Vous devriez maintenant avoir le projet de démarrage ouvert dans Android Studio.

4. Créer un projet de console Firebase

Créer un nouveau projet

  1. Accédez à la console Firebase .
  2. Sélectionnez Ajouter un projet (ou Créer un projet si c'est le premier).
  3. Sélectionnez ou entrez un nom de projet et cliquez sur Continuer .
  4. Assurez-vous que "Activer Google Analytics pour ce projet" est activé.
  5. Suivez les étapes de configuration restantes dans la console Firebase, puis cliquez sur Créer un projet (ou Ajouter Firebase, si vous utilisez un projet Google existant).

5. Ajouter Firebase

  1. Depuis l'écran de présentation de votre nouveau projet, cliquez sur l'icône Android pour lancer le workflow de configuration.
  2. Saisissez le nom du package de l'atelier de programmation : com.google.firebase.codelabs.recommendations
  3. Sélectionnez Enregistrer l'application .

Ajouter le fichier google-services.json à votre application

Après avoir ajouté le nom du package et sélectionné Enregistrer, cliquez sur Télécharger google-services.json pour obtenir votre fichier de configuration Firebase Android, puis copiez le fichier google-services.json dans le répertoire de l' app de votre projet. Une fois le fichier téléchargé, vous pouvez ignorer les étapes suivantes affichées dans la console (elles ont déjà été effectuées pour vous dans le projet build-android-start).

Ajoutez le plugin google-services à votre application

Le plug-in google-services utilise le fichier google-services.json pour configurer votre application afin qu'elle utilise Firebase. Les lignes suivantes doivent déjà être ajoutées aux fichiers build.gradle du projet (cochez pour confirmer) :

app/build.grade

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

build.grade

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

Synchronisez votre projet avec des fichiers graduels

Pour être sûr que toutes les dépendances sont disponibles pour votre application, vous devez synchroniser votre projet avec les fichiers gradle à ce stade. Sélectionnez Fichier > Synchroniser le projet avec les fichiers Gradle dans la barre d'outils Android Studio.

6. Exécutez l'application de démarrage

Maintenant que vous avez importé le projet dans Android Studio et configuré le plugin google-services avec votre fichier JSON, vous êtes prêt à exécuter l'application pour la première fois. Connectez votre appareil Android et cliquez sur Exécuter ( exécuter.png ) dans la barre d'outils d'Android Studio.

L'application devrait se lancer sur votre appareil. À ce stade, vous pouvez voir une application fonctionnelle qui affiche un onglet avec une liste de films, un onglet Films aimés et un onglet Recommandations. Vous pouvez cliquer sur un film dans la liste des films pour l'ajouter à votre liste de favoris. Après avoir terminé les étapes restantes de l'atelier de programmation, nous pourrons générer des recommandations de films dans l'onglet Recommandations.

7. Ajoutez Firebase Analytics à l'application

Dans cette étape, vous ajouterez Firebase Analytics à l'application pour enregistrer les données de comportement des utilisateurs (dans ce cas, quels films un utilisateur aime). Ces données seront utilisées de manière agrégée dans les étapes futures pour former le modèle de recommandations.

Ajouter une dépendance Firebase Analytics

La dépendance suivante est nécessaire pour ajouter Firebase Analytics à votre application. Il devrait déjà être inclus dans le fichier app/build.gradle (vérifier).

app/build.grade

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

Configurer Firebase Analytics dans l'application

Le LikedMoviesViewModel contient des fonctions pour stocker les films que l'utilisateur aime. Chaque fois que l'utilisateur aime un nouveau film, nous souhaitons également envoyer un événement de journal d'analyse pour enregistrer cet événement.

Ajoutez la fonction onMovieLiked avec le code ci-dessous pour enregistrer un événement d'analyse lorsque l'utilisateur clique comme sur un film.

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

Ajoutez le champ et la fonction suivants pour consigner un événement Analytics lorsqu'un film est ajouté à la liste "J'aime" de l'utilisateur.

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. Testez votre intégration Analytics

Au cours de cette étape, nous allons générer des événements Analytics dans l'application et vérifier qu'ils sont envoyés à la console Firebase.

Activer la journalisation de débogage Analytics

Firebase Analytics est conçu pour maximiser la durée de vie de la batterie de l'utilisateur et regroupera les événements sur l'appareil et ne les enverra à Firebase qu'occasionnellement. À des fins de débogage, nous pouvons désactiver ce comportement pour voir les événements tels qu'ils sont enregistrés en temps réel en exécutant la commande suivante dans le shell.

Terminal

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

Vérifier que les événements Analytics sont générés

  1. Dans le studio Android, ouvrez la fenêtre Logcat pour examiner la journalisation de votre application.
  2. Définissez le filtre Logcat sur la chaîne "Événement de journalisation".
  3. Vérifiez que les événements Analytics "select_item" sont émis chaque fois que vous aimez un film dans l'application.

À ce stade, vous avez intégré avec succès Firebase Analytics dans votre application. Au fur et à mesure que les utilisateurs utilisent votre application et aiment les films, leurs goûts seront enregistrés de manière agrégée. Nous utiliserons ces données agrégées dans le reste de cet atelier de programmation pour former notre modèle de recommandations. Ce qui suit est une étape facultative pour voir les mêmes événements Analytics que vous avez vus dans Logcat également diffusés dans la console Firebase. N'hésitez pas à passer à la page suivante.

Facultatif : Confirmer les événements Analytics dans la console Firebase

  1. Accédez à la console Firebase .
  2. Sélectionnez DebugView sous Analytics
  3. Dans Android Studio, sélectionnez Exécuter pour lancer l'application et ajouter des films à votre liste J'aime.
  4. Dans DebugView de la console Firebase, vérifiez que ces événements sont consignés lorsque vous ajoutez des films dans l'application.

9. Exporter les données Analytics vers Big Query

Big Query est un produit Google Cloud qui vous permet d'examiner et de traiter de grandes quantités de données. Au cours de cette étape, vous allez connecter votre projet Firebase Console à Big Query afin que les données Analytics générées par votre application soient automatiquement exportées vers Big Query.

Activer l'exportation Big Query

  1. Accédez à la console Firebase .
  2. Sélectionnez l'icône d'engrenage Paramètres à côté de Vue d'ensemble du projet , puis sélectionnez Paramètres du projet
  3. Sélectionnez l'onglet Intégrations .
  4. Sélectionnez Associer (ou Gérer ) dans le bloc BigQuery .
  5. Sélectionnez Suivant à l'étape À propos de l'association de Firebase à BigQuery .
  6. Dans la section Configurer l'intégration , cliquez sur le commutateur pour activer l'envoi des données Google Analytics et sélectionnez Associer à BigQuery .

Vous avez maintenant activé votre projet de console Firebase pour envoyer automatiquement les données d'événement Firebase Analytics à Big Query. Cela se produit automatiquement sans aucune autre interaction. Toutefois, la première exportation qui crée l'ensemble de données d'analyse dans BigQuery peut ne pas avoir lieu avant 24 heures. Une fois l'ensemble de données créé, Firebase exporte continuellement de nouveaux événements Analytics vers Big Query dans le tableau intrajournalier et regroupe les événements des jours précédents dans le tableau des événements.

L'entraînement d'un modèle de recommandations nécessite beaucoup de données. Étant donné que nous n'avons pas encore d'application générant de grandes quantités de données, à l'étape suivante, nous importerons un exemple d'ensemble de données dans BigQuery à utiliser pour le reste de ce didacticiel.

10. Utiliser BigQuery pour obtenir des données d'entraînement de modèle

Maintenant que nous avons connecté notre console Firebase pour exporter vers BigQuery, nos données d'événement d'analyse d'application s'afficheront automatiquement dans la console BigQuery après un certain temps. Pour obtenir des données initiales dans le cadre de ce didacticiel, au cours de cette étape, nous allons importer un exemple d'ensemble de données existant dans votre console BigQuery afin de l'utiliser pour entraîner notre modèle de recommandations.

Importer un exemple d'ensemble de données dans BigQuery

  1. Accédez au tableau de bord BigQuery dans la console cloud de Google.
  2. Sélectionnez le nom de votre projet dans le menu.
  3. Sélectionnez le nom de votre projet en bas de la navigation de gauche de BigQuery pour afficher les détails.
  4. Sélectionnez Créer un ensemble de données pour ouvrir le panneau de création d'ensemble de données.
  5. Entrez « firebase_recommendations_dataset » pour l' ID de l'ensemble de données et sélectionnez Créer un ensemble de données .
  6. Le nouveau jeu de données apparaîtra dans le menu de gauche sous le nom du projet. Cliquez dessus.
  7. Sélectionnez Créer un tableau pour ouvrir le panneau de création de tableau.
  8. Pour Créer une table à partir de , sélectionnez "Google Cloud Storage".
  9. Dans le champ Select file from GCS bucket , saisissez "gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt".
  10. Sélectionnez 'JSONL' dans la liste déroulante Format de fichier .
  11. Entrez 'recommendations_table' pour le nom de la table .
  12. Cochez la case sous Schéma > Détection automatique > Schéma et paramètres d'entrée
  13. Sélectionnez Créer un tableau

Explorer un exemple d'ensemble de données

À ce stade, vous pouvez éventuellement explorer le schéma et prévisualiser cet ensemble de données.

  1. Sélectionnez firebase-recommendations-dataset dans le menu de gauche pour développer les tables qu'il contient.
  2. Sélectionnez la table de la table des recommandations pour afficher le schéma de la table.
  3. Sélectionnez Aperçu pour afficher les données d'événement Analytics réelles contenues dans ce tableau.

Créer des identifiants de compte de service

Nous allons maintenant créer des identifiants de compte de service dans notre projet de console Google Cloud que nous pourrons utiliser dans l'environnement Colab à l'étape suivante pour accéder à nos données BigQuery et les charger.

  1. Assurez-vous que la facturation est activée pour votre projet Google Cloud.
  2. Activez les API BigQuery et BigQuery Storage API. < cliquez ici >
  3. Accédez à la page Créer une clé de compte de service .
  4. Dans la liste Compte de service , sélectionnez Nouveau compte de service .
  5. Dans le champ Nom du compte de service , saisissez un nom.
  6. Dans la liste Rôle , sélectionnez Projet > Propriétaire .
  7. Cliquez sur Créer . Un fichier JSON qui contient vos téléchargements de clés sur votre ordinateur.

Dans la prochaine étape, nous utiliserons Google Colab pour prétraiter ces données et former notre modèle de recommandations.

11. Prétraiter les données et former le modèle de recommandations

Dans cette étape, nous utiliserons un notebook Colab pour effectuer les étapes suivantes :

  1. importer les données BigQuery dans le notebook Colab
  2. prétraiter les données pour les préparer à la formation du modèle
  3. former le modèle de recommandations sur les données d'analyse
  4. exporter le modèle en tant que modèle TF lite
  5. déployer le modèle sur la console Firebase afin que nous puissions l'utiliser dans notre application

Avant de lancer le bloc-notes de formation Colab, nous allons d'abord activer l'API Firebase Model Management afin que Colab puisse déployer le modèle formé sur notre console Firebase.

Activer l'API de gestion des modèles Firebase

Créer un bucket pour stocker vos modèles de ML

Dans votre console Firebase, accédez à Stockage et cliquez sur Démarrer. fbbea78f0eb3dc9f.png

Suivez le dialogue pour configurer votre compartiment.

19517c0d6d2aa14d.png

Activer l'API Firebase ML

Accédez à la page de l'API Firebase ML sur Google Cloud Console et cliquez sur Activer.

Utiliser le notebook Colab pour entraîner et déployer le modèle

Ouvrez le bloc-notes Colab à l'aide du lien suivant et suivez les étapes qu'il contient. Après avoir terminé les étapes du notebook Colab, vous disposerez d'un fichier de modèle TF lite déployé sur la console Firebase que nous pourrons synchroniser avec notre application.

Ouvrir dans Colab

12. Téléchargez le modèle dans votre application

Dans cette étape, nous allons modifier notre application pour télécharger le modèle que nous venons de former à partir de Firebase Machine Learning.

Ajouter une dépendance Firebase ML

La dépendance suivante est nécessaire pour utiliser les modèles Firebase Machine Learning dans votre application. Il devrait déjà être ajouté (vérifier).

app/build.grade

implementation 'com.google.firebase:firebase-ml-modeldownloader:24.0.4'

Télécharger le modèle avec l'API Firebase Model Manager

Copiez le code ci-dessous dans RecommendationClient.kt pour configurer les conditions dans lesquelles le téléchargement du modèle se produit et créez une tâche de téléchargement pour synchroniser le modèle distant avec notre application.

RecommendationClient.kt

    private fun downloadModel(modelName: String) {
        val conditions = CustomModelDownloadConditions.Builder()
            .requireWifi()
            .build()
        FirebaseModelDownloader.getInstance()
            .getModel(modelName, DownloadType.LOCAL_MODEL, conditions)
            .addOnCompleteListener {
                if (!it.isSuccessful) {
                    showToast(context, "Failed to get model file.")
                } else {
                    showToast(context, "Downloaded remote model: $modelName")
                    GlobalScope.launch { initializeInterpreter(it.result) }
                }
            }
            .addOnFailureListener {
                showToast(context, "Model download failed for recommendations, please check your connection.")
            }
    }

13. Intégrez le modèle de recommandation Tensorflow Lite dans votre application

L'environnement d'exécution Tensorflow Lite vous permettra d'utiliser votre modèle dans l'application pour générer des recommandations. Dans l'étape précédente, nous avons initialisé un interpréteur TFlite avec le fichier de modèle que nous avons téléchargé. Dans cette étape, nous allons d'abord charger un dictionnaire et des étiquettes pour accompagner notre modèle dans l'étape d'inférence, puis nous ajouterons un pré-traitement pour générer les entrées de notre modèle et un post-traitement où nous extrairons les résultats de notre inférence .

Charger le dictionnaire et les étiquettes

Les étiquettes utilisées pour générer les candidats de recommandation par le modèle de recommandations sont répertoriées dans le fichier sorted_movie_vocab.json dans le dossier res/assets. Copiez le code suivant pour charger ces candidats.

RecommendationClient.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.")
        }
    }

Mettre en œuvre le prétraitement

Dans l'étape de prétraitement, nous modifions la forme des données d'entrée pour qu'elles correspondent à ce que notre modèle attend. Ici, nous remplissons la longueur d'entrée avec une valeur d'espace réservé si nous n'avons pas déjà généré beaucoup d'utilisateurs. Copiez le code ci-dessous :

RecommendationClient.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
        }
    }


Exécuter l'interpréteur pour générer des recommandations

Ici, nous utilisons le modèle que nous avons téléchargé à une étape précédente pour exécuter l'inférence sur notre entrée prétraitée. Nous définissons le type d'entrée et de sortie pour notre modèle et exécutons l'inférence pour générer nos recommandations de films. Copiez le code suivant dans votre application.

RecommendationClient.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()
            }
        }
    }



Mettre en œuvre le post-traitement

Enfin, dans cette étape, nous post-traitons la sortie de notre modèle, en sélectionnant les résultats avec la plus grande confiance et en supprimant les valeurs contenues (films que l'utilisateur a déjà aimés). Copiez le code suivant dans votre application.

RecommendationClient.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
        }
    }


Testez votre application !

Réexécutez votre application. Lorsque vous sélectionnez quelques films, il devrait automatiquement télécharger le nouveau modèle et commencer à générer des recommandations !

14. Félicitations !

Vous avez intégré une fonctionnalité de recommandations dans votre application à l'aide de TensorFlow Lite et de Firebase. Notez que les techniques et le pipeline présentés dans cet atelier de programmation peuvent être généralisés et utilisés pour servir également d'autres types de recommandations.

Ce que nous avons couvert

  • Firebase ML
  • Analyse Firebase
  • Exporter des événements d'analyse vers BigQuery
  • Prétraiter les événements d'analyse
  • Recommandations d'entraînement du modèle TensorFlow
  • Exporter le modèle et le déployer sur la console Firebase
  • Proposer des recommandations de films dans une application

Prochaines étapes

  • Mettez en œuvre les recommandations Firebase ML dans votre application.

Apprendre encore plus

Avoir une question?

Signaler des problèmes