Ajouter des recommandations à votre application avec TensorFlow Lite et Firebase – Android Codelab

1. Vue d'ensemble

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

Les recommandations permettent aux applications d'utiliser l'apprentissage automatique pour proposer intelligemment le contenu le plus pertinent pour chaque utilisateur. Ils prennent en compte le comportement passé des utilisateurs pour suggérer le contenu de l'application avec lequel l'utilisateur pourrait aimer 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 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 des inférences et obtenir des recommandations. En particulier, nos recommandations suggéreront quels films un utilisateur regarderait le plus probablement compte tenu de la liste des films que l'utilisateur a aimés précédemment.

Ce que vous apprendrez

  • Intégrer 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 de l'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 évalueriez-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

De Android Studio, sélectionnez le codelab-recommendations-android annuaire ( android_studio_folder.png ) À partir du code exemple téléchargement (Fichier> Ouvrir> ... / codelab-recommandations-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. Allez à la console Firebase .
  2. Sélectionnez Ajouter un projet (ou créer un projet si ce dernier 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 une base de feu

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

Ajoutez le fichier google-services.json à votre application

Après avoir ajouté le nom du package et en sélectionnant 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 l' app dans votre projet. Une fois le fichier téléchargé , vous pouvez sauter les prochaines étapes indiquées dans la console (ils ont déjà été fait pour vous dans le projet de construction-android-start).

Ajouter le plug-in 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 (vérifiez pour confirmer) :

app/build.grade

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

build.grade

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

Synchronisez votre projet avec les fichiers gradle

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> Project Sync avec Gradle fichiers de la barre d' outils studio Android.

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

Maintenant que vous avez importé le projet dans Android Studio configuré les google-services plugin avec votre fichier JSON, vous êtes prêt à exécuter l'application pour la première fois. Connectez votre appareil Android, puis cliquez sur Exécuter ( exécuter.png ) dans la barre d'outils 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 de l'utilisateur (dans ce cas, les films qu'un utilisateur aime). Ces données seront utilisées de manière agrégée dans les prochaines étapes pour entraîner 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:17.6.0'

Configurer Firebase Analytics dans l'application

Le LikedMoviesViewModel contient des fonctions pour stocker les films à 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 ce type de film.

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

J'ai aiméFilmsViewModel.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 des "Aimés" de l'utilisateur.

J'ai aiméFilmsViewModel.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

Dans 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 du débogage d'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 Android studio, ouvrez la fenêtre Logcat pour examiner la journalisation à partir 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 globale. Nous utiliserons ces données agrégées dans le reste de cet atelier de programmation pour entraîner 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.

En option: Confirmer les événements Analytics dans Firebase Console

  1. Allez à 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 n'a pas aimé.
  4. Dans DebugView de la console Firebase, vérifiez que ces événements sont enregistré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 de console Firebase à 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. Allez à la console Firebase .
  2. Sélectionnez l'icône d'engrenage Paramètres en regard du projet Vue d' ensemble, puis sélectionnez Paramètres du projet
  3. Sélectionnez l'onglet Intégrations.
  4. Sélectionnez Lier (ou gérer) à l' intérieur du bloc BigQuery.
  5. Sélectionnez Suivant dans la A propos des liens Firebase à l' étape BigQuery.
  6. Dans la section d'intégration Configurer, cliquez sur le bouton pour activer l' envoi des données Google Analytics et sélectionnez Lien vers 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. Cependant, 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 la table intrajournalière et regroupe les événements des jours précédents dans la table des événements.

La formation 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, dans 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 BigQuery tableau de bord dans la console nuage 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 jeu de données pour ouvrir le panneau de création de données.
  5. Entrez « firebase_recommendations_dataset » pour l'ID Dataset 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 table pour ouvrir le panneau de création de la table.
  8. Pour créer la table de sélectionnez "Google Cloud Storage.
  9. Dans Sélectionner le fichier à partir du champ de seau GCS, entrez « gs: //firebase-recommendations/recommendations-test/formatted_data_filtered.txt ».
  10. Sélectionnez « JSONL » drop dans le format de fichier vers le bas.
  11. Entrez « recommendations_table » pour le nom du tableau.
  12. Cochez la case sous schéma> Détection automatique> Paramètres du schéma et d' entrée
  13. Sélectionnez Créer la table

Explorer un exemple de jeu de données

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

  1. Parmi les recommandations de Firebase-jeu de données-dans le menu de gauche pour étendre les tables qu'il contient.
  2. Sélectionnez la table recommandations table pour afficher le schéma de la table.
  3. Sélectionnez Aperçu pour afficher les données d'événement Analytics réel ce tableau contient.

Créer des identifiants de compte de service

À présent, nous allons créer des identifiants de compte de service dans notre projet de console Google Cloud que nous pouvons utiliser dans l'environnement Colab à l'étape suivante pour accéder et charger nos données BigQuery.

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

Dans l'étape suivante, nous utiliserons Google Colab pour prétraiter ces données et entraîner 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 à l'apprentissage du modèle
  3. entraîner le modèle de recommandations sur les données analytiques
  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 notebook 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 Firebase Model Management

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

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

Suivez le dialogue pour configurer votre seau.

19517c0d6d2aa14d.png

Activer l'API Firebase ML

Aller à la page 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 ci-dessous. Après avoir terminé les étapes du bloc-notes Colab, vous disposerez d'un fichier de modèle TF lite déployé sur la console Firebase que nous pouvons 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-model-interpreter:22.0.4'

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

Copiez le code ci - dessous dans RecommendationClient.kt pour mettre en place les conditions dans lesquelles le téléchargement du modèle se produit et créer une tâche de téléchargement pour synchroniser le modèle à distance à notre application.

RecommandationClient.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. 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. À l'étape précédente, nous avons initialisé un interpréteur TFlite avec le fichier 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 du modèle recommandations sont répertoriées dans le fichier sorted_movie_vocab.json dans les res / dossier actif. Copiez le code suivant pour charger ces candidats.

RecommandationClient.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 correspondre à ce que notre modèle attend. Ici, nous complétons la longueur d'entrée avec une valeur d'espace réservé si nous n'avons pas déjà généré beaucoup de likes de l'utilisateur. Copiez le code ci-dessous :

RecommandationClient.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é lors d'une étape précédente pour exécuter une 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 film. Copiez le code suivant dans votre application.

RecommandationClient.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 confiance la plus élevée et en supprimant les valeurs contenues (films que l'utilisateur a déjà aimés). Copiez le code suivant dans votre application.

RecommandationClient.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 télécharger automatiquement 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 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 Modèle TensorFlow
  • Exporter le modèle et déployer vers la console Firebase
  • Proposez des recommandations de films dans une application

Prochaines étapes

  • Implémentez les recommandations Firebase ML dans votre application.

Apprendre encore plus

Avoir une question?

Signaler des problèmes