Atelier de programmation sur l'optimisation des achats via une application en temps réel sur l'appareil

1. Présentation

1cbf855eda62c306.png

Bienvenue dans l'atelier de programmation sur l'optimisation des achats via une application en temps réel sur l'appareil. Dans cet atelier de programmation, vous allez découvrir comment 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 une application (IAP) optimale en fonction de l'état de 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 d'analyse via Firebase Analytics
  • Prétraiter les données d'analyse à l'aide de BigQuery
  • Entraîner un modèle de ML simple pour l'optimisation sur l'appareil des achats intégrés
  • Déployer des modèles TFLite sur Firebase ML et y accéder depuis votre application
  • Mesurer et tester différents modèles via Firebase A/B Testing
  • Entraîner et déployer de nouveaux modèles à l'aide des dernières données à intervalles réguliers

Ce dont vous avez besoin

  • Android Studio, version 3.4 ou ultérieure
  • Un appareil de test physique avec Android 2.3 ou version ultérieure 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 de base en ML

Comment allez-vous utiliser ce tutoriel ?

Je vais le lire uniquement Je vais le lire et effectuer les exercices

Comment évalueriez-vous votre niveau d'expérience en matière de création d'applications Android ?

Débutant Intermédiaire Expert

2. Description du problème

Supposons que vous soyez un développeur de jeux qui souhaite afficher des suggestions d'achat via une application personnalisées à la fin de chaque niveau. Vous ne pouvez afficher qu'un nombre limité d'options d'achat intégré à la fois, et vous ne savez 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 intégré qui génère 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 les éléments suivants :

  1. Un notebook Jupyter (.ipynb) qui entraîne le modèle de personnalisation et le regroupe dans un modèle TFLite
  2. Un 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 intégrés de notre application de jeu fictive, Flappy Sparky. Le jeu est un jeu de plateforme à défilement latéral dans lequel le joueur contrôle un Sparky, qui tente de voler entre des colonnes de murs sans les toucher. Au début du niveau, l'utilisateur reçoit une offre d'achat intégré qui lui donne un bonus. Dans cet atelier de programmation, nous n'implémenterons que la partie de l'application concernant l'optimisation des achats intégrés.

Vous pourrez appliquer ce que vous apprenez 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 commencer à utiliser Firebase, veuillez consulter nos tutoriels sur ce sujet ( Android et iOS).

5. Collecter des événements d'analyse dans votre application

Les événements d'analyse 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 intégré pour obtenir des vies supplémentaires. Le modèle de ML a besoin d'événements d'analyse comme entrée pour apprendre ces informations.

Voici quelques événements d'analyse que nous pouvons enregistrer :

  • Durée de jeu de l'utilisateur
  • Niveau atteint par l'utilisateur
  • Nombre de pièces dépensées par l'utilisateur
  • Articles achetés par l'utilisateur

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

Au cours des étapes suivantes, nous allons utiliser Firebase Analytics pour enregistrer des événements d'analyse à utiliser dans notre modèle. Si vous disposez déjà de données d'analyse que vous souhaitez utiliser, passez à la section "Entraîner le modèle d'optimisation" de cet atelier de programmation. Vous pourrez suivre nos exemples de données.

Collecter des données avec le SDK Firebase Analytics

Nous allons utiliser 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

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 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")

Nous pouvons ensuite enregistrer les événements du joueur. Pour l'optimisation des achats intégrés, nous voulons enregistrer chaque offre d'achat intégré présentée à l'utilisateur et si l'utilisateur clique sur cette offre. Cela nous donnera deux événements d'analyse : 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 l'enregistrement d'événements personnalisés, consultez la documentation Firebase Analytics Log Events.

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 intégré présentée à l'utilisateur et sur laquelle il a cliqué. Au cours de cette étape, nous allons combiner 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 d'analyse vers BigQuery.

Pour associer votre projet Firebase et ses applications à BigQuery :

  1. Connectez-vous à Firebase.
  2. Cliquez sur l'icône Paramètres, puis sélectionnez Paramètres du projet.
  3. Sur la page "Paramètres du projet", cliquez sur l'onglet Intégrations.
  4. Sur la fiche BigQuery, cliquez sur Associer.

(Facultatif) Exporter 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 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 intégrés effectués, les niveaux du 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, 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 tout au long de cet atelier de programmation.

Préparer les données dans BigQuery

Au cours des prochaines étapes, nous allons utiliser BigQuery pour transformer nos données d'analyse brutes en données utilisables pour entraîner notre modèle.

Pour que notre modèle puisse apprendre quelle offre d'achat intégré 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é sur l'offre présentée ou non

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

BigQuery permet de créer des "vues" pour organiser votre requête. 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 nettoyer nos données d'analyse.

Pour voir si l'utilisateur a cliqué sur chaque offre d'achat intégré, nous devons joindre les événements offer_iap et offer_accepted que nous avons enregistrés lors de 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 l'entraînement de notre modèle.

888daa7ba4db8e44.png14d22bf474fae455.png

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 reçoit une offre d'achat intégré qui lui donne un bonus. Nous ne pouvons afficher qu'une seule option d'achat intégré à 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 intégré qui génère 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 intégré, et sur la valeur de l'achat intégré 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 en fonction d'un utilisateur, et trouver l'action avec la récompense la plus élevée.

e7d3264141498bff.jpeg

Voici ce que nous allons utiliser dans la prédiction :

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

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 en n'entraînant le modèle que périodiquement dans le cloud et en n'effectuant des prédictions que lorsque nous utilisons le modèle sur l'appareil de l'utilisateur (au lieu de l'entraîner également sur l'appareil de l'utilisateur). Pour nous assurer que nous disposons de suffisamment de données d'entraînement après avoir utilisé le modèle, nous devons parfois afficher des résultats aléatoires aux utilisateurs de notre application (par exemple, 30 % du temps). Cette stratégie d'équilibre entre exploration et exploitation est appelée Epsilon-greedy.

Entraîner le modèle

Vous pouvez utiliser le script d'entraînement (training.ipynb) fourni avec l'atelier de programmation pour commencer. Notre objectif est d'entraîner un modèle qui prédit les récompenses attendues pour chaque action en fonction d'un état, puis de trouver l'action qui nous donne les récompenses attendues les plus élevées.

Entraînement local

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

Vous n'avez pas besoin de 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 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. Vous trouverez des informations sur l'entraînement du modèle dans 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'achat intégré 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û à un 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 devons 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)

Vous pouvez ensuite 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 :

  1. Nous pouvons réduire la taille d'installation de l'application et ne télécharger le modèle que si nécessaire.
  2. Le modèle peut être mis à jour régulièrement et avec un cycle de publication différent de celui de l'application entière.

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é, et l'utilisez 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 devons 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 une carte de chaque caractéristique vers des métadonnées sur la façon dont le prétraitement est effectué. Vous trouverez plus d'informations sur cette procédure dans 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 bonus d'achat intégré pour cet utilisateur particulier.

a3381dbcdbdf811e.png

Mesurer la précision du modèle

Pour mesurer la justesse de notre modèle, nous pouvons simplement suivre les offres d'achat via une application prédites par notre modèle et si l'utilisateur clique dessus à l'aide de Firebase Analytics. Vous pouvez utiliser cette fonctionnalité 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 arrivent, 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 que vous disposez 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, 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 l'entraînement et le déploiement avec de nouvelles données ne fait pas partie 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 l'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.

Points abordés

  • TensorFlow Lite
  • Firebase ML
  • Firebase Analytics
  • BigQuery

Étapes suivantes

  • Entraîner et déployer un modèle d'optimisation pour votre application.

En savoir plus