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. Cet atelier de programmation est basé sur cet exemple TensorFlow Lite .
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é 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 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 iOS pour exécuter des inférences et obtenir des recommandations. En particulier, nos recommandations suggéreront les films qu'un utilisateur serait le plus susceptible de regarder compte tenu de la liste des films qu'il a déjà aimés.
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étraitez les données et entraînez 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 l'inférence sur l'appareil à l'aide du modèle pour suggérer des recommandations aux utilisateurs
Ce dont vous aurez besoin
- Xcode 11 (ou supérieur)
- CocoaPods 1.9.1 (ou supérieur)
Comment allez-vous utiliser ce tutoriel ?
Comment évalueriez-vous votre expérience dans la création d’applications iOS ?
2. Créer un projet de console Firebase
Ajouter Firebase au projet
- Accédez à la console Firebase .
- Sélectionnez Créer un nouveau projet et nommez votre projet « Firebase ML iOS Codelab ».
3. Obtenez l'exemple de projet
Téléchargez le code
Commencez par cloner l'exemple de projet et exécutez pod update dans le répertoire du projet :
git clone https://github.com/FirebaseExtended/codelab-contentrecommendation-ios.git cd codelab-contentrecommendation-ios/start pod install --repo-update
Si git n'est pas installé, vous pouvez également télécharger l'exemple de projet depuis sa page GitHub ou en cliquant sur ce lien . Une fois que vous avez téléchargé le projet, exécutez-le dans Xcode et jouez avec la recommandation pour avoir une idée de son fonctionnement.
Configurer Firebase
Suivez la documentation pour créer un nouveau projet Firebase. Une fois que vous avez votre projet, téléchargez le fichier GoogleService-Info.plist de votre projet depuis la console Firebase et faites-le glisser vers la racine du projet Xcode.
Ajoutez Firebase à votre Podfile et exécutez l'installation du pod.
pod 'FirebaseAnalytics' pod 'FirebaseMLModelDownloader', '9.3.0-beta' pod 'TensorFlowLiteSwift'
Dans la méthode didFinishLaunchingWithOptions de votre AppDelegate , importez Firebase en haut du fichier
import FirebaseCore
Et ajoutez un appel pour configurer Firebase.
FirebaseApp.configure()
Exécutez à nouveau le projet pour vous assurer que l'application est correctement configurée et ne plante pas au lancement.
- Assurez-vous que « Activer Google Analytics pour ce projet » est activé.
- 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).
4. Ajoutez Firebase Analytics à l'application
Au cours de cette étape, vous ajouterez Firebase Analytics à l'application pour enregistrer les données de comportement des utilisateurs (dans ce cas, les films qu'un utilisateur aime). Ces données seront utilisées globalement dans les étapes futures pour entraîner le modèle de recommandations.
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 le code ci-dessous pour enregistrer un événement d'analyse lorsque l'utilisateur clique comme sur un film.
AllMoviesCollectionViewController.swift
import FirebaseAnalytics
//
override func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
//
if movie.liked == nil {
movie.liked = true
Analytics.logEvent(AnalyticsEventSelectItem, parameters: [AnalyticsParameterItemID: movie.id])
} else {
movie.liked?.toggle()
}
}
5. Testez votre intégration Analytics
Au cours de cette étape, nous générerons des événements Analytics dans l'application et vérifierons qu'ils sont envoyés à la console Firebase.
Activer la journalisation du débogage Analytics
Généralement, les événements enregistrés par votre application sont regroupés sur une période d'environ une heure et téléchargés ensemble. Cette approche préserve la batterie des appareils des utilisateurs finaux et réduit l'utilisation des données du réseau. Cependant, dans le but de valider la mise en œuvre de votre analyse (et afin d'afficher vos analyses dans le rapport DebugView), vous pouvez activer le mode Débogage sur votre appareil de développement pour télécharger les événements dans un délai minimal.
Pour activer le mode Analytics Debug sur votre appareil de développement, spécifiez l'argument de ligne de commande suivant dans Xcode :
-FIRDebugEnabled
À 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 des films, leurs préférences seront enregistrées globalement. 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.
Facultatif : Confirmez les événements Analytics dans la console Firebase
- Accédez à la console Firebase .
- Sélectionnez DebugView sous Analytics
- Dans Xcode, sélectionnez Exécuter pour lancer l'application et ajouter des films à votre liste "J'aime".
- Dans DebugView de la console Firebase, vérifiez que ces événements sont enregistrés lorsque vous ajoutez des films dans l'application.
6. 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 connecterez 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
- Accédez à la console Firebase .
- Sélectionnez l'icône d'engrenage Paramètres en regard de Présentation du projet , puis sélectionnez Paramètres du projet.
- Sélectionnez l'onglet Intégrations .
- Sélectionnez Lien (ou Gérer ) dans le bloc BigQuery .
- Sélectionnez Suivant à l'étape À propos de la liaison de Firebase à BigQuery .
- Dans la section Configurer l'intégration , cliquez sur le commutateur 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 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 les nouveaux événements Analytics vers Big Query dans la table intrajournalière et regroupe les événements des jours passés dans la table des événements.
La formation d'un modèle de recommandations nécessite beaucoup de données. Comme nous ne disposons pas encore d'une 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.
7. Utilisez BigQuery pour obtenir des données de formation de modèle
Maintenant que nous avons connecté notre console Firebase pour exporter vers BigQuery, nos données d'événements d'analyse d'application s'afficheront automatiquement dans la console BigQuery après un certain temps. Pour obtenir des données initiales pour les besoins de ce didacticiel, au cours de cette étape, nous importerons 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
- Accédez au tableau de bord BigQuery dans la console cloud de Google.
- Sélectionnez le nom de votre projet dans le menu.
- Sélectionnez le nom de votre projet en bas de la navigation de gauche de BigQuery pour voir les détails.
- Sélectionnez Créer un ensemble de données pour ouvrir le panneau de création d'ensemble de données.
- Saisissez « firebase_recommendations_dataset » pour l' ID de l'ensemble de données et sélectionnez Créer un ensemble de données .
- Le nouvel ensemble de données apparaîtra dans le menu de gauche sous le nom du projet. Cliquez dessus.
- Sélectionnez Créer une table pour ouvrir le panneau de création de table.
- Pour Créer une table à partir de, sélectionnez « Google Cloud Storage ».
- Dans le champ Sélectionner un fichier dans le compartiment GCS , saisissez « gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt ».
- Sélectionnez « JSONL » dans la liste déroulante Format de fichier .
- Saisissez « recommendations_table » pour le nom de la table .
- Cochez la case sous Schéma > Détection automatique > Schéma et paramètres d'entrée
- 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.
- Sélectionnez Firebase-recommendations-dataset dans le menu de gauche pour développer les tables qu'il contient.
- Sélectionnez la table de recommandations pour afficher le schéma de la table.
- Sélectionnez Aperçu pour voir les données réelles des événements Analytics que contient ce tableau.
Créer les informations d'identification du compte de service
Nous allons maintenant créer les informations d'identification du compte de service dans notre projet de console Google Cloud que nous pourrons utiliser dans l'environnement Colab à l'étape suivante pour accéder et charger nos données BigQuery.
- Assurez-vous que la facturation est activée pour votre projet Google Cloud.
- Activez les API des API BigQuery et BigQuery Storage. < cliquez ici >
- Accédez à la page Créer une clé de compte de service .
- Dans la liste Compte de service , sélectionnez Nouveau compte de service .
- Dans le champ Nom du compte de service , saisissez un nom.
- Dans la liste Rôle , sélectionnez Projet > Propriétaire .
- 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 entraîner notre modèle de recommandations.
8. 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 :
- importer les données BigQuery dans le notebook Colab
- prétraiter les données pour les préparer à la formation du modèle
- entraîner le modèle de recommandations sur les données analytiques
- exporter le modèle en tant que modèle TF Lite
- 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 entraîné sur notre console Firebase.
Activer l'API de gestion des modèles Firebase
Créez un bucket pour stocker vos modèles ML
Dans votre console Firebase, accédez à Stockage et cliquez sur Commencer. 
Suivez la boîte de dialogue pour configurer votre bucket.
Activer l'API Firebase ML
Accédez à 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 en utilisant le lien suivant et suivez les étapes indiquées. Après avoir terminé les étapes dans le bloc-notes 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
9. 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).
Fichier de pod
import FirebaseCore
import FirebaseMLModelDownloader
Téléchargez le modèle avec l'API Firebase Model Manager
Copiez le code ci-dessous dans ModelLoader.swift 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.
ModelLoader.swift
static func downloadModel(named name: String,
completion: @escaping (CustomModel?, DownloadError?) -> Void) {
guard FirebaseApp.app() != nil else {
completion(nil, .firebaseNotInitialized)
return
}
guard success == nil && failure == nil else {
completion(nil, .downloadInProgress)
return
}
let conditions = ModelDownloadConditions(allowsCellularAccess: false)
ModelDownloader.modelDownloader().getModel(name: name, downloadType: .localModelUpdateInBackground, conditions: conditions) { result in
switch (result) {
case .success(let customModel):
// Download complete.
// The CustomModel object contains the local path of the model file,
// which you can use to instantiate a TensorFlow Lite classifier.
return completion(customModel, nil)
case .failure(let error):
// Download was unsuccessful. Notify error message.
completion(nil, .downloadFailed(underlyingError: error))
}
}
}
10. Intégrez le modèle de recommandation Tensorflow Lite dans votre application
Le runtime 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 à la recommandation par le modèle de recommandations sont répertoriées dans le fichier sorted_movie_vocab.json dans le dossier des ressources. Copiez le code suivant pour charger ces candidats.
RecommandationsViewController.swift
func getMovies() -> [MovieItem] {
let barController = self.tabBarController as! TabBarController
return barController.movies
}
Implémenter le prétraitement
Lors de 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 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 d'utilisateurs. Copiez le code ci-dessous :
RecommandationsViewController.swift
// Given a list of selected items, preprocess to get tflite input.
func preProcess() -> Data {
let likedMovies = getLikedMovies().map { (MovieItem) -> Int32 in
return MovieItem.id
}
var inputData = Data(copyingBufferOf: Array(likedMovies.prefix(10)))
// Pad input data to have a minimum of 10 context items (4 bytes each)
while inputData.count < 10*4 {
inputData.append(0)
}
return inputData
}
Exécuter un interprète 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 l'inférence sur notre entrée prétraitée. Nous définissons le type d'entrée et de sortie de notre modèle et effectuons l'inférence pour générer nos recommandations de films. Copiez le code suivant dans votre application.
RecommandationsViewController.swift
import TensorFlowLite
RecommandationsViewController.swift
private var interpreter: Interpreter?
func loadModel() {
// Download the model from Firebase
print("Fetching recommendations model...")
ModelDownloader.fetchModel(named: "recommendations") { (filePath, error) in
guard let path = filePath else {
if let error = error {
print(error)
}
return
}
print("Recommendations model download complete")
self.loadInterpreter(path: path)
}
}
func loadInterpreter(path: String) {
do {
interpreter = try Interpreter(modelPath: path)
// Allocate memory for the model's input `Tensor`s.
try interpreter?.allocateTensors()
let inputData = preProcess()
// Copy the input data to the input `Tensor`.
try self.interpreter?.copy(inputData, toInputAt: 0)
// Run inference by invoking the `Interpreter`.
try self.interpreter?.invoke()
// Get the output `Tensor`
let confidenceOutputTensor = try self.interpreter?.output(at: 0)
let idOutputTensor = try self.interpreter?.output(at: 1)
// Copy output to `Data` to process the inference results.
let confidenceOutputSize = confidenceOutputTensor?.shape.dimensions.reduce(1, {x, y in x * y})
let idOutputSize = idOutputTensor?.shape.dimensions.reduce(1, {x, y in x * y})
let confidenceResults =
UnsafeMutableBufferPointer<Float32>.allocate(capacity: confidenceOutputSize!)
let idResults =
UnsafeMutableBufferPointer<Int32>.allocate(capacity: idOutputSize!)
_ = confidenceOutputTensor?.data.copyBytes(to: confidenceResults)
_ = idOutputTensor?.data.copyBytes(to: idResults)
postProcess(idResults, confidenceResults)
print("Successfully ran inference")
DispatchQueue.main.async {
self.tableView.reloadData()
}
} catch {
print("Error occurred creating model interpreter: \(error)")
}
}
Implémenter 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 (les films que l'utilisateur a déjà aimés). Copiez le code suivant dans votre application.
RecommandationsViewController.swift
// Postprocess to get results from tflite inference.
func postProcess(_ idResults: UnsafeMutableBufferPointer<Int32>, _ confidenceResults: UnsafeMutableBufferPointer<Float32>) {
for i in 0..<10 {
let id = idResults[i]
let movieIdx = getMovies().firstIndex { $0.id == id }
let title = getMovies()[movieIdx!].title
recommendations.append(Recommendation(title: title, confidence: confidenceResults[i]))
}
}
Testez votre application !
Réexécutez votre application. Au fur et à mesure que vous sélectionnez quelques films, il devrait automatiquement télécharger le nouveau modèle et commencer à générer des recommandations !
11. 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 également être généralisés et utilisés pour servir d'autres types de recommandations.
Ce que nous avons couvert
- Firebase ML
- Analyse Firebase
- Exporter des événements d'analyse vers BigQuery
- Événements d’analyse de prétraitement
- Recommandations d'entraînement Modèle TensorFlow
- Exporter le modèle et déployer sur la console Firebase
- Servir 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