Cette page a été traduite par l'API Cloud Translation.

Optimisation des achats intégrés en temps réel sur l'appareil Codelab

1. Vue d'ensemble

Bienvenue dans l'atelier de programmation d'optimisation des achats intégrés en temps réel sur l'appareil. Dans cet atelier de programmation, vous apprendrez à utiliser TensorFlow Lite et Firebase pour entraîner et déployer un modèle de personnalisation personnalisé dans votre application.

Ce didacticiel montre comment créer un modèle d'apprentissage automatique pour la personnalisation, en particulier un modèle qui prédit l'offre d'achat in-app (IAP) 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 problème important et type de problème d'apprentissage automatique largement applicable sur lequel vous en apprendrez davantage dans cet atelier de programmation

Ce que vous apprendrez

Collectez des données d'analyse via Firebase Analytics
Prétraiter les données d'analyse à l'aide de BigQuery
Former un modèle ML simple pour l'optimisation sur appareil des achats intégrés (IAP)
Déployez des modèles TFLite sur Firebase ML et accédez-y depuis votre application
Mesurez et expérimentez différents modèles via Firebase A/B Testing
Former et déployer de nouveaux modèles en utilisant les dernières données à une cadence récurrente

Ce dont vous aurez besoin

Android Studio version 3.4+
Un appareil de test physique 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 de test physique, un câble de connexion
Connaissances novices en ML

Comment allez-vous utiliser ce tutoriel ?

Lisez-le uniquement

Lisez-le et complétez les exercices

Comment évalueriez-vous votre expérience dans la création d’applications Android ?

Novice

Intermédiaire

Compétent

2. Énoncé du problème

Supposons que vous soyez un développeur de jeux et que vous souhaitiez afficher des suggestions d'achat in-app (IAP) personnalisées à la fin de chaque niveau. Vous ne pouvez afficher qu'un nombre limité d'options IAP à chaque fois, et vous ne savez pas lesquelles auront la meilleure conversion. Étant donné que chaque utilisateur et chaque session sont différents, comment pouvons-nous trouver l'offre IAP qui offre la récompense attendue la plus élevée ?

3. Obtenez l'exemple de code

Clonez le référentiel 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 le regroupe dans un modèle TFLite
Un exemple d'application Kotlin qui utilise le modèle TFLite pour effectuer des prédictions sur l'appareil

4. Exécutez l'application avec Firebase

Dans cet atelier de programmation, nous travaillerons sur l'optimisation des IAP de notre application de jeu fictif - Flappy Sparky . Le jeu est un jeu à défilement latéral dans lequel le joueur contrôle un Sparky, tentant de voler entre des colonnes de murs sans les toucher. Au début du niveau, l'utilisateur se voit présenter une offre IAP qui lui donnera un bonus. Dans cet atelier de programmation, nous implémenterons uniquement la partie optimisation IAP de l'application.

Vous pourrez appliquer ce que vous avez appris 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 démarrer avec Firebase, veuillez consulter nos tutoriels sur ce sujet ( Android et iOS ).

5. Collectez les événements d'analyse dans votre application

Les événements d'analyse fournissent un aperçu du comportement des utilisateurs et sont utilisés pour entraîner le modèle ML. Par exemple, le modèle peut apprendre que les utilisateurs qui jouent plus longtemps sont plus susceptibles de créer un IAP pour obtenir des vies supplémentaires. Le modèle ML a besoin d'événements d'analyse comme entrée pour apprendre ces informations.

Certains événements d'analyse que nous pouvons souhaiter enregistrer incluent :

Combien de temps l'utilisateur joue au jeu
Quel niveau atteint l'utilisateur
Combien de pièces l'utilisateur dépense
Quels articles l'utilisateur achète

Télécharger des exemples de données (facultatif)

Dans les étapes suivantes, nous utiliserons Firebase Analytics pour enregistrer les événements d'analyse à utiliser dans notre modèle. Si vous disposez déjà de données d'analyse que vous souhaitez utiliser, accédez à la section "Former le modèle d'optimisation" de cet atelier de programmation et vous pourrez suivre nos exemples de données.

Collecter des données avec le SDK Firebase Analytics

Nous utiliserons Firebase Analytics pour nous aider à 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 uniques à votre application.

Installation du SDK Firebase Analytics

Vous pouvez démarrer avec Firebase Analytics dans votre application en suivant 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.

Consigner les événements personnalisés

Après avoir configuré le SDK Firebase Analytics, nous pouvons commencer à enregistrer les événements dont nous avons besoin pour entraîner notre modèle.

Avant de faire cela, il est important de définir un ID utilisateur dans l'événement d'analyse, afin que nous puissions associer les données d'analyse de cet utilisateur à ses données existantes dans l'application.

MainActivity.kt

firebaseAnalytics.setUserId("player1")

Ensuite, nous pouvons enregistrer les événements des joueurs. Pour l'optimisation IAP, nous souhaitons enregistrer chaque offre IAP présentée à l'utilisateur et savoir si cette offre est cliquée par l'utilisateur. Cela nous donnera deux événements d'analyse - offer_iap et offer_accepted . Nous garderons également une trace d'un offer_id unique afin de pouvoir l'utiliser plus tard pour combiner ces données afin de 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 plus d'informations sur la journalisation des événements personnalisés, consultez la documentation des événements du journal Firebase Analytics .

6. Prétraiter les données dans BigQuery

Dans la dernière étape, nous avons collecté des événements sur l'offre IAP présentée à l'utilisateur et sur l'offre IAP sur laquelle l'utilisateur clique. Dans 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 devrons commencer par exporter les événements d'analyse vers BigQuery.

Associez votre 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 Lien.

(Facultatif) Exportez vos collections Firestore vers BigQuery

Au cours de cette étape, vous avez la possibilité d'exporter des données utilisateur supplémentaires de Firestore vers BigQuery afin de les utiliser pour aider à entraîner le modèle. Si vous souhaitez ignorer cette étape pour le moment, accédez à la section "Préparation des données dans BigQuery" de cet atelier de programmation et 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 intégrés effectués, les niveaux du jeu, les pièces en solde ou tout autre attribut qui pourrait être utile pour entraîner le modèle.

Pour exporter vos collections Firestore vers BigQuery, vous pouvez installer l' extension Firestore BigQuery Export . Ensuite, joignez des tables dans BigQuery pour combiner ces données avec les données de Google Analytics à utiliser dans votre modèle de personnalisation et dans le reste de cet atelier de programmation.

Préparer des données dans BigQuery

Dans les prochaines étapes, nous utiliserons BigQuery pour transformer nos données analytiques brutes en données utilisables pour entraîner notre modèle.

Pour que notre modèle sache quelle offre IAP présenter en fonction de l'utilisateur et de l'état du jeu, nous devons organiser les données sur les éléments suivants :

l'utilisateur
l'état du jeu
l'offre présentée
si l'offre présentée est cliquée ou non

Toutes ces données devront être organisées sur une seule ligne dans un tableau pour que notre modèle puisse les traiter. Heureusement, BigQuery est conçu pour nous aider à faire exactement cela.

BigQuery permet de créer des « vues » pour garder votre requête organisée. 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 que vous interrogez une table. Grâce à cela, nous pouvons d'abord nettoyer nos données analytiques.

Pour voir si chaque offre d'achat intégrée à l'application est cliquée, nous devrons rejoindre 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 l'ensemble de données bigQuery vers Google Cloud Storage

Enfin, nous pouvons exporter l'ensemble de données bigquery vers GCS afin de pouvoir l'utiliser dans notre formation de modèle.

7. Entraîner le modèle d'optimisation

Exemples de données

Utilisez soit vos données de l'étape précédente, "Prétraiter les données dans BigQuery", soit 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.

Bandits contextuels expliqués

Au début de chaque niveau de Flappy Sparky, l'utilisateur se voit présenter une offre IAP qui lui donnera un bonus. Nous ne pouvons afficher qu'une seule option IAP à chaque fois, et nous ne savons pas lesquelles auront la meilleure conversion. Étant donné que chaque utilisateur et chaque session sont différents, comment pouvons-nous trouver l'offre IAP qui offre la récompense attendue la plus élevée ?

Dans ce cas, définissons la récompense à 0 si l'utilisateur n'accepte pas l'offre IAP, et à la valeur IAP s'il l'accepte. Pour essayer de maximiser votre récompense, nous pouvons utiliser nos données historiques pour former 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 utiliserons dans la prédiction :

État : informations sur l'utilisateur et sa session en cours
Action : offres IAP que nous pouvons choisir d'afficher
Récompense : valeur de l'offre IAP

Exploitation ou exploration

Pour tous les problèmes de bandits à plusieurs bras, l'algorithme doit trouver un équilibre entre l'exploration (obtenir plus de données pour savoir 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 pour entraîner le modèle uniquement périodiquement dans le cloud et effectuer des prédictions uniquement lors de l'utilisation du modèle sur l'appareil de l'utilisateur (par opposition à l'entraînement sur l'appareil de l'utilisateur également). Pour nous assurer que nous disposons de suffisamment de données d'entraînement après avoir utilisé le modèle, nous devrons parfois montrer des résultats aléatoires aux utilisateurs de notre application (par exemple 30 %). Cette stratégie d'équilibre entre exploration et exploitation est appelée Epsilon-greedy .

Entraîner le modèle

Vous pouvez utiliser le script de formation ( training.ipynb ) fourni avec l'atelier de programmation pour commencer. Notre objectif est de former un modèle qui prédit les récompenses attendues pour chaque action étant donné un état, puis nous trouvons l'action qui nous donne les récompenses attendues les plus élevées.

Formation localement

Le moyen le plus simple de commencer à entraîner votre propre modèle consiste à faire une copie du notebook dans l'exemple de code de cet atelier de programmation.

Vous n'avez pas besoin d'un GPU pour cet atelier de programmation, mais 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 de formation fourni, nous avons créé un itérateur qui génère des données de formation à partir des fichiers CSV que nous avons exportés depuis BigQuery. Ensuite, nous avons utilisé les données pour commencer à entraîner notre modèle avec Keras. Des détails sur la façon de former le modèle peuvent être trouvés dans les commentaires du notebook Python.

Mesurer les performances du modèle

Lors de la formation du modèle, nous le comparerons à un agent aléatoire qui sélectionne les offres IAP au hasard pour voir si notre modèle est réellement en train d'apprendre. Cette logique réside sous ValidationCallback .

A la fin de la formation, 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û à un surajustement . Dans ce cas, le modèle est 28 % plus performant que l’agent aléatoire.

Exporter le modèle TFLite

Nous disposons désormais d'un modèle entraîné prêt à l'emploi, sauf qu'il est actuellement au format TensorFlow. Nous devrons exporter le modèle au format TFLite afin 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)

À partir de là, vous pouvez télécharger le modèle et le regrouper avec votre application.

Eventuellement, pour une application de production, nous vous recommandons de déployer le modèle sur Firebase ML et de demander à Firebase d'héberger votre modèle. Ceci est utile pour deux raisons principales :

Nous pouvons garder la taille d'installation de l'application petite et télécharger le modèle uniquement 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 avez la possibilité de déployer à l'aide de la console Firebase ou de l'API Python.

8. Faire des prédictions sur l'appareil

L'étape suivante consiste à faire des prédictions à l'aide du modèle intégré à l'appareil. Vous pouvez trouver un exemple d'application qui télécharge un modèle à partir de Firebase ML dans le dossier app de l'exemple de code que vous avez téléchargé et l'utiliser pour effectuer une inférence avec certaines données côté client.

Étant donné que nous avons appliqué un prétraitement lors de la formation 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. Un moyen simple de procéder consiste à utiliser un format indépendant de la plate-forme et du langage, tel qu'un fichier JSON contenant une carte de chaque fonctionnalité avec des métadonnées sur la façon dont le prétraitement est effectué. Vous pouvez trouver plus de détails sur la façon dont cela est effectué dans l'exemple d'application.

Ensuite, nous donnons 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 la meilleure mise sous tension IAP pour cet utilisateur particulier.

Mesurer la précision du modèle

Pour mesurer la précision de notre modèle, nous pouvons simplement suivre les offres IAP prédites par notre modèle et savoir si elles sont cliquées à l'aide de Firebase Analytics. Vous pouvez l'utiliser avec les tests Firebase A/B pour mesurer les performances réelles du modèle. Pour aller plus loin, vous pouvez également effectuer des tests A/B sur différentes itérations du modèle. Vous pouvez en savoir plus sur les tests A/B avec Firebase dans la documentation Créer des expériences de configuration à distance Firebase avec des tests A/B .

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 arrivent, vous pouvez configurer un pipeline pour recycler votre modèle de manière récurrente. Pour ce faire, vous devez d'abord vous assurer que vous disposez de nouvelles données à utiliser pour la formation en utilisant la stratégie epsilon-greedy que nous avons mentionnée ci-dessus. (Par exemple, utiliser le résultat de la prédiction du modèle 70 % du temps et utiliser des résultats aléatoires 30 % du temps).

La configuration d'un pipeline pour la formation et le déploiement avec de nouvelles données dépassent le cadre de cet atelier de programmation. Vous pouvez consulter Google Cloud AI Platform et TFX pour commencer.

10. Félicitations !

Dans cet atelier de programmation, vous avez appris à entraîner et à déployer un modèle TFLite sur appareil pour optimiser les achats intégrés à l'aide de Firebase. Pour en savoir plus sur TFLite et Firebase, consultez d'autres exemples TFLite et les guides de démarrage de Firebase.

Si vous avez des questions, vous pouvez les laisser sur Stack Overflow #firebase-machine-learning .