1. Présentation
Bienvenue dans l'atelier de programmation sur l'optimisation en temps réel des achats via l'application sur l'appareil. Dans cet atelier de programmation, vous allez apprendre à utiliser TensorFlow Lite et Firebase pour entraîner et déployer un modèle de personnalisation personnalisé dans votre application.
Ce tutoriel explique comment créer un modèle de machine learning pour la personnalisation, en particulier un modèle qui prédit l'offre d'achat via l'application (IAP, in-app purchase) optimale en fonction de l'état dans lequel se trouve l'utilisateur actuel. Il s'agit d'un exemple de problème de bandit contextuel, un type de problème de machine learning important et largement applicable que vous découvrirez plus en détail dans cet atelier de programmation.
Points abordés
- Collecter des données analytiques via Firebase Analytics
- Prétraiter les données analytiques à l'aide de BigQuery
- Entraîner un modèle de ML simple pour l'optimisation sur l'appareil des achats via l'application
- Déployer des modèles TFLite sur Firebase ML et y accéder depuis votre application
- Mesurer et tester différents modèles avec Firebase A/B Testing
- Entraîner et déployer de nouveaux modèles à l'aide des dernières données à une fréquence récurrente
Prérequis
- Android Studio version 3.4 ou ultérieure
- Un appareil de test physique équipé d'Android 2.3 ou version ultérieure et des services Google Play 9.8 ou version ultérieure, ou un émulateur équipé des services Google Play 9.8 ou version ultérieure
- Si vous utilisez un appareil de test physique, un câble de connexion
- Connaissances de base en ML
Comment allez-vous utiliser ce tutoriel ?
Comment évalueriez-vous votre niveau d'expérience en matière de création d'applications Android ?
2. Description du problème
Imaginons que vous soyez un développeur de jeux et que vous souhaitiez afficher des suggestions d'achats via l'application (IAP) personnalisées à la fin de chaque niveau. Vous ne pouvez afficher qu'un nombre limité d'options d'achats via l'application à chaque fois, et vous ne savez pas lesquelles auront le meilleur taux de conversion. Étant donné que chaque utilisateur et chaque session sont différents, comment trouver l'offre d'achat via l'application qui offre la récompense attendue la plus élevée ?
3. Obtenir l'exemple de code
Clonez le dépôt GitHub à partir de la ligne de commande.
git clone https://github.com/googlecodelabs/firebase-iap-optimization.git
Ce dépôt contient :
- Un notebook Jupyter (.ipynb) qui entraîne le modèle de personnalisation et l'intègre à un modèle TFLite
- Exemple d'application Kotlin qui utilise le modèle TFLite pour effectuer des prédictions sur l'appareil
4. Exécuter l'application avec Firebase
Dans cet atelier de programmation, nous allons optimiser les achats via l'application de notre jeu fictif, Flappy Sparky. Il s'agit d'un jeu de plateforme à défilement horizontal dans lequel le joueur contrôle un Sparky et tente de voler entre des colonnes de murs sans les heurter. Au début du niveau, l'utilisateur reçoit une offre d'achat via l'application qui lui permettra d'obtenir un bonus. Dans cet atelier de programmation, nous n'implémenterons que la partie de l'application concernant l'optimisation des achats via l'application.
Vous pourrez appliquer ce que vous apprendrez ici à votre propre application connectée à un projet Firebase. Vous pouvez également créer un projet Firebase pour cet atelier de programmation. Si vous avez besoin d'aide pour vous lancer avec Firebase, veuillez consulter nos tutoriels sur ce sujet ( Android et iOS).
5. Collecter des événements Analytics dans votre application
Les événements Analytics fournissent des informations sur le comportement des utilisateurs et sont utilisés pour entraîner le modèle de ML. Par exemple, le modèle peut apprendre que les utilisateurs qui jouent plus longtemps sont plus susceptibles d'effectuer un achat via l'application pour obtenir des vies supplémentaires. Le modèle de ML a besoin d'événements Analytics comme entrée pour apprendre ces informations.
Voici quelques exemples d'événements analytiques que nous pouvons enregistrer :
- Durée pendant laquelle l'utilisateur joue au jeu
- le niveau atteint par l'utilisateur.
- Nombre de pièces dépensées par l'utilisateur
- les articles achetés par l'utilisateur ;
Télécharger des exemples de données (facultatif)
Dans les étapes suivantes, nous utiliserons Firebase Analytics pour consigner les événements analytiques à utiliser dans notre modèle. Si vous disposez déjà de données analytiques que vous souhaitez utiliser, passez à la section "Entraîner le modèle d'optimisation" de cet atelier de programmation. Vous pourrez suivre les instructions avec nos exemples de données.
Collecter des données avec le SDK Firebase Analytics
Nous utiliserons Firebase Analytics pour collecter ces événements d'analyse. Le SDK Firebase Analytics capture automatiquement un certain nombre d'événements et de propriétés utilisateur. Il vous permet également de définir vos propres événements personnalisés pour mesurer les événements propres à votre application.
Installer le SDK Firebase Analytics
Pour commencer à utiliser Firebase Analytics dans votre application, suivez la documentation Premiers pas avec Google Analytics. Le dépôt firebase-iap-optimization cloné au début de cet atelier de programmation inclut déjà le SDK Firebase Analytics.
Enregistrer des événements personnalisés
Une fois le SDK Firebase Analytics configuré, nous pouvons commencer à enregistrer les événements dont nous avons besoin pour entraîner notre modèle.
Avant cela, il est important de définir un ID utilisateur dans l'événement Analytics. Nous pourrons ainsi associer les données Analytics de cet utilisateur à ses données existantes dans l'application.
MainActivity.kt
firebaseAnalytics.setUserId("player1")
Nous pouvons ensuite enregistrer les événements du lecteur. Pour optimiser les achats via l'application, nous souhaitons enregistrer chaque offre d'achat via l'application présentée à l'utilisateur et indiquer si l'utilisateur a cliqué sur cette offre. Nous obtiendrons ainsi deux événements Analytics : offer_iap et offer_accepted. Nous allons également suivre un offer_id unique afin de pouvoir l'utiliser ultérieurement pour combiner ces données et voir si une offre est acceptée.
MainActivity.kt
predictButton?.setOnClickListener {
predictionResult = iapOptimizer.predict()
firebaseAnalytics.logEvent("offer_iap"){
param("offer_type", predictionResult)
param("offer_id", sessionId)
}
}
acceptButton?.setOnClickListener {
firebaseAnalytics.logEvent("offer_accepted") {
param("offer_type", predictionResult)
param("offer_id", sessionId)
}
}
Pour en savoir plus sur la consignation d'événements personnalisés, consultez la documentation Firebase Analytics sur la consignation d'événements.
6. Prétraiter les données dans BigQuery
Lors de la dernière étape, nous avons collecté des événements concernant l'offre d'achat via l'application présentée à l'utilisateur et celle sur laquelle il a cliqué. Au cours de cette étape, nous combinerons ces données d'événement avec les données utilisateur afin que notre modèle puisse apprendre à partir d'une image complète.
Pour ce faire, nous devons commencer par exporter les événements Analytics vers BigQuery.
Associer le projet Firebase à BigQuery
Pour associer votre projet Firebase et ses applications à BigQuery :
- Connectez-vous à Firebase.
- Cliquez sur
, puis sélectionnez "Paramètres du projet". - Sur la page "Paramètres du projet", cliquez sur l'onglet "Intégrations".
- Sur la fiche BigQuery, cliquez sur "Associer".
(Facultatif) Exporter vos collections Firestore vers BigQuery
Lors de cette étape, vous avez la possibilité d'exporter des données utilisateur supplémentaires de Firestore vers BigQuery pour vous aider à entraîner le modèle. Si vous souhaitez ignorer cette étape pour le moment, passez à la section "Préparer les données dans BigQuery" de cet atelier de programmation. Vous pourrez suivre les événements Firebase Analytics enregistrés lors de la dernière étape.
Firestore peut être l'endroit où vous avez stocké la date d'inscription des utilisateurs, les achats effectués dans l'application, les niveaux atteints dans le jeu, les pièces disponibles ou tout autre attribut pouvant être utile pour entraîner le modèle.
Pour exporter vos collections Firestore vers BigQuery, vous pouvez installer l'extension Firestore BigQuery Export. Ensuite, associez les tables dans BigQuery pour combiner ces données avec celles de Google Analytics. Vous pourrez ainsi les utiliser dans votre modèle de personnalisation et tout au long de cet atelier de programmation.
Préparer les données dans BigQuery
Dans les prochaines étapes, nous allons utiliser BigQuery pour transformer nos données brutes d'analyse en données utilisables pour l'entraînement de notre modèle.
Pour que notre modèle puisse apprendre quelle offre d'achat via l'application présenter en fonction de l'utilisateur et de l'état du jeu, nous devons organiser les données concernant les éléments suivants :
- l'utilisateur
- l'état du jeu
- l'offre présentée
- si l'utilisateur a cliqué ou non sur l'offre présentée ;
Toutes ces données devront être organisées dans une seule ligne d'un tableau pour que notre modèle puisse les traiter. Heureusement, BigQuery est conçu pour nous aider à le faire.
BigQuery vous permet de créer des "vues" pour organiser vos requêtes. Une vue est une table virtuelle définie par une requête SQL. Lorsque vous créez une vue, vous l'interrogez de la même manière qu'une table. Nous pouvons ainsi commencer par nettoyer nos données analytiques.
Pour savoir si chaque offre d'achat via l'application a fait l'objet d'un clic, nous devons joindre les événements offer_iap et offer_accepted que nous avons enregistrés à l'étape précédente.
all_offers_joined : vue BigQuery
SELECT
iap_offers.*,
CASE
WHEN accepted_offers.accepted IS NULL THEN FALSE ELSE TRUE
END
is_clicked,
FROM
`iap-optimization.ml_sample.accepted_offers` AS accepted_offers
RIGHT JOIN
`iap-optimization.ml_sample.iap_offers` AS iap_offers
ON
accepted_offers.offer_id =iap_offers.offer_id;
all_offers_with_user_data : vue BigQuery
SELECT
offers.is_clicked,
offers.presented_powerup,
offers.last_run_end_reason,
offers.event_timestamp,
users.*
FROM
`iap-optimization.ml_sample.all_offers_joined` AS offers
LEFT JOIN
`iap-optimization.ml_sample.all_users` AS users
ON
users.user_id = offers.user_id;
Exporter un ensemble de données BigQuery vers Google Cloud Storage
Enfin, nous pouvons exporter l'ensemble de données BigQuery vers GCS afin de l'utiliser pour entraîner notre modèle.
7. Entraîner le modèle d'optimisation
Exemple de données
Utilisez vos données de l'étape précédente, "Prétraiter les données dans BigQuery", ou les exemples de données téléchargeables fournis ici pour suivre le reste de cet atelier de programmation.
Définition du problème
Avant de commencer à entraîner le modèle, prenons le temps de définir notre problème de bandits contextuels.
Présentation des bandits contextuels
Au début de chaque niveau de Flappy Sparky, l'utilisateur se voit proposer un achat via l'application qui lui permettra d'obtenir un bonus. Nous ne pouvons afficher qu'une seule option d'achat via l'application à la fois, et nous ne savons pas lesquelles généreront le plus de conversions. Étant donné que chaque utilisateur et chaque session sont différents, comment trouver l'offre d'achat via l'application qui offre la récompense attendue la plus élevée ?
Dans ce cas, définissons la récompense sur 0 si l'utilisateur n'accepte pas l'offre d'achat via l'application, et sur la valeur de l'achat via l'application s'il l'accepte. Pour essayer de maximiser votre récompense, nous pouvons utiliser nos données historiques pour entraîner un modèle qui prédit la récompense attendue pour chaque action donnée à un utilisateur, et trouver l'action avec la récompense la plus élevée.
Voici ce que nous allons utiliser dans la prédiction :
- État : informations sur l'utilisateur et sa session actuelle
- Action : offres d'achats via l'application que nous pouvons choisir d'afficher
- Récompense : valeur de l'offre d'achat via une application
Exploitation vs exploration
Pour tous les problèmes de bandits manchots, l'algorithme doit trouver un équilibre entre l'exploration (obtenir plus de données pour déterminer quelle action donne le résultat optimal) et l'exploitation (utiliser le résultat optimal pour obtenir la récompense la plus élevée).
Dans notre version du problème, nous allons simplifier cela en n'entraînant le modèle que périodiquement dans le cloud et en n'effectuant des prédictions que lorsque le modèle est utilisé sur l'appareil de l'utilisateur (par opposition à l'entraînement sur l'appareil de l'utilisateur également). Pour nous assurer de disposer de suffisamment de données d'entraînement après avoir utilisé le modèle, nous devrons parfois afficher des résultats aléatoires aux utilisateurs de notre application (par exemple, 30 % du temps). Cette stratégie d'équilibrage entre exploration et exploitation est appelée epsilon-greedy.
Entraîner le modèle
Pour commencer, vous pouvez utiliser le script d'entraînement (training.ipynb) fourni avec l'atelier de programmation. Notre objectif est d'entraîner un modèle qui prédit les récompenses attendues pour chaque action en fonction d'un état. Nous trouvons ensuite l'action qui nous donne les récompenses attendues les plus élevées.
Entraînement en local
Le moyen le plus simple de commencer à entraîner votre propre modèle est de copier le notebook dans l'exemple de code de cet atelier de programmation.
Vous n'avez pas besoin de GPU pour cet atelier de programmation. Toutefois, si vous avez besoin d'une machine plus puissante pour explorer vos propres données et entraîner votre propre modèle, vous pouvez obtenir une instance AI Platform Notebook pour accélérer votre entraînement.
Dans le script d'entraînement fourni, nous avons créé un itérateur qui génère des données d'entraînement à partir des fichiers CSV que nous avons exportés depuis BigQuery. Nous avons ensuite utilisé les données pour commencer à entraîner notre modèle avec Keras. Pour savoir comment entraîner le modèle, consultez les commentaires du notebook Python.
Mesurer les performances du modèle
Lors de l'entraînement du modèle, nous le comparerons à un agent aléatoire qui sélectionne des offres d'achats via l'application de manière aléatoire pour voir si notre modèle apprend réellement. Cette logique se trouve sous ValidationCallback..
À la fin de l'entraînement, nous utilisons les données de test.csv pour tester à nouveau notre modèle. Le modèle n'a jamais vu ces données auparavant. Nous pouvons donc être sûrs que le résultat n'est pas dû au surapprentissage. Dans ce cas, le modèle est 28 % plus performant que l'agent aléatoire.
Exporter le modèle TFLite
Nous disposons maintenant d'un modèle entraîné prêt à l'emploi, mais il est actuellement au format TensorFlow. Nous devrons exporter le modèle au format TFLite pour qu'il puisse être exécuté sur des appareils mobiles.
train.ipynb
converter = tflite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
with tf.io.gfile.GFile('iap-optimizer.tflite', 'wb') as f:
f.write(tflite_model)
De là, vous pouvez télécharger le modèle et le regrouper avec votre application.
Si vous le souhaitez, pour une application de production, nous vous recommandons de déployer le modèle sur Firebase ML et de le faire héberger par Firebase. Cela est utile pour deux raisons principales :
- Nous pouvons réduire la taille d'installation de l'application et ne télécharger le modèle que si nécessaire.
- Le modèle peut être mis à jour régulièrement et avec un cycle de publication différent de celui de l'ensemble de l'application.
Pour savoir comment déployer le modèle sur Firebase ML, vous pouvez suivre l'atelier de programmation Ajouter Firebase à votre application Android basée sur TFLite. Vous pouvez effectuer le déploiement à l'aide de la console Firebase ou de l'API Python.
8. Effectuer des prédictions sur l'appareil
L'étape suivante consiste à effectuer des prédictions à l'aide du modèle sur l'appareil. Vous trouverez un exemple d'application qui télécharge un modèle depuis Firebase ML dans le dossier app de l'exemple de code que vous avez téléchargé. Vous pouvez l'utiliser pour effectuer une inférence avec des données côté client.
Comme nous avons appliqué un prétraitement lors de l'entraînement du modèle, nous devrons appliquer le même prétraitement à l'entrée du modèle lors de l'exécution sur l'appareil. Pour ce faire, vous pouvez utiliser un format indépendant de la plate-forme et du langage, tel qu'un fichier JSON contenant un mappage de chaque caractéristique aux métadonnées sur la façon dont le prétraitement est effectué. Pour en savoir plus sur la façon de procéder, consultez l'exemple d'application.
Ensuite, nous fournissons au modèle une entrée de test comme suit :
IapOptimzer.kt
val testInput = mapOf(
"coins_spent" to 2048f,
"distance_avg" to 1234f,
"device_os" to "ANDROID",
"game_day" to 10f,
"geo_country" to "Canada",
"last_run_end_reason" to "laser"
)
Le modèle suggère que sparky_armor est le meilleur power-up d'achat via l'application pour cet utilisateur en particulier.
Mesurer la précision du modèle
Pour mesurer la précision de notre modèle, nous pouvons simplement suivre les offres d'achats via l'application prédites par notre modèle et déterminer si les utilisateurs ont cliqué dessus à l'aide de Firebase Analytics. Vous pouvez l'utiliser avec Firebase A/B Testing pour mesurer les performances réelles du modèle. Vous pouvez également effectuer des tests A/B sur différentes itérations du modèle. Pour en savoir plus sur les tests A/B avec Firebase, consultez la documentation Créer des tests Firebase Remote Config avec A/B Testing.
9. (Facultatif) : Mettre à jour régulièrement le modèle avec de nouvelles données
Si vous devez mettre à jour votre modèle à mesure que de nouvelles données sont disponibles, vous pouvez configurer un pipeline pour réentraîner votre modèle de manière récurrente. Pour ce faire, vous devez d'abord vous assurer de disposer de nouvelles données à utiliser pour l'entraînement à l'aide de la stratégie epsilon-greedy que nous avons mentionnée ci-dessus. (par exemple, en utilisant le résultat de la prédiction du modèle 70 % du temps et des résultats aléatoires 30 % du temps).
La configuration d'un pipeline pour l'entraînement et le déploiement avec de nouvelles données ne fait pas partie de cet atelier de programmation. Pour commencer, vous pouvez consulter Google Cloud AI Platform et TFX.
10. Félicitations !
Dans cet atelier de programmation, vous avez appris à entraîner et à déployer un modèle TFLite sur l'appareil pour optimiser les achats via l'application à l'aide de Firebase. Pour en savoir plus sur TFLite et Firebase, consultez les autres exemples TFLite et les guides de démarrage Firebase.
Si vous avez des questions, vous pouvez les poser sur Stack Overflow #firebase-machine-learning.
Points abordés
- TensorFlow Lite
- Firebase ML
- Firebase Analytics
- BigQuery
Étapes suivantes
- Entraînez et déployez un modèle d'optimiseur pour votre application.