Utiliser le machine learning sur Compute Engine pour recommander des produits

Last reviewed 2016-02-26 UTC

Google Cloud vous permet de créer un service évolutif, efficace et performant afin de proposer des recommandations de produits pertinentes aux utilisateurs d'une boutique en ligne.

La concurrence entre les sites de vente en ligne n'a jamais été aussi féroce qu'aujourd'hui. Dans ce secteur, les clients dépensent plus d’argent de manière générale, mais dépensent moins par revendeur individuel. La taille moyenne des paniers a diminué, sans doute à cause du fait que la concurrence n'est jamais qu'à un clic de là. Proposer des recommandations pertinentes aux clients potentiels peut jouer un rôle central dans la conversion des prospects en clients et l'augmentation de la taille moyenne des commandes.

Après avoir découvert la solution présentée ici, vous serez en mesure de mettre en oeuvre un environnement compatible avec un moteur de recommandations de base, que vous pourrez développer et améliorer en fonction de vos besoins opérationnels spécifiques. L'exécution d'un moteur de recommandations sur Google Cloud vous offre la flexibilité et l'évolutivité nécessaires pour les solutions que vous souhaitez mettre en place.

Dans cette solution, vous verrez comment une société de location immobilière peut identifier des recommandations pertinentes et les présenter aux clients qui naviguent sur leur site Web.

Scénario

Samantha cherche une maison à louer pour ses vacances. Elle dispose d'un profil sur un site Web de location de vacances, et a déjà loué et noté plusieurs forfaits vacances. Sam cherche des recommandations basées sur ses préférences et ses goûts. Le système devrait déjà connaître ses goûts. D'après sa page d'évaluation, elle semble aimer les hébergements de type house (maison). C'est donc un hébergement similaire que le système doit lui proposer.

Interface utilisateur permettant la location de propriétés de vacances

Présentation de la solution

Afin de fournir des recommandations, que ce soit en temps réel (lors de la navigation des clients), ou par courrier électronique, plusieurs conditions doivent être réunies. Dans un premier temps, étant donné que vous en savez peu sur les goûts et les préférences de vos utilisateurs, vous pouvez baser vos recommandations sur uniquement les caractéristiques de vos produits. Mais votre système doit être en mesure d'apprendre de vos utilisateurs, en collectant des données sur leurs goûts et leurs préférences. Au fil du temps, et après avoir collecté suffisamment de données, vous pourrez utiliser des algorithmes de machine learning pour analyser vos utilisateurs et ainsi fournir des recommandations pertinentes. Les saisies d'autres utilisateurs peuvent également améliorer les résultats, permettant au système d'être régulièrement soumis à un nouveau cycle d'entraînement. La solution présentée ici est un exemple de système de recommandations disposant d'ores et déjà de suffisamment de données pour tirer pleinement parti d'algorithmes de machine learning.

Un moteur de recommandations traite généralement les données en suivant les quatre phases suivantes :

Phases de collecte, de stockage, d'analyse et de recommandation

L'architecture d'un tel système peut être représentée par le schéma suivant :

Architecture composée de sections frontend, stockage et machine learning

Chaque partie peut être personnalisée pour répondre à vos exigences spécifiques. Le système comprend :

  1. Une interface frontend évolutive qui enregistre les interactions des utilisateurs afin de collecter des données.

  2. Un stockage permanent accessible par une plate-forme de machine learning. La transmission des données dans cet espace de stockage peut inclure plusieurs étapes, telles qu'une importation/exportation ou une transformation des données.

  3. Une plate-forme de machine learning capable d'analyser le contenu existant pour créer des recommandations pertinentes.

  4. Un stockage accessible par le frontend, en temps réel ou différé, afin de pouvoir présenter des recommandations au moment opportun.

Choisir les composants

Pour obtenir un bon compromis entre rapidité, simplicité, contrôle des coûts et précision, cette solution utilise App Engine, Cloud SQL et Apache Spark exécuté sur App Engine à l'aide de Cloud Dataproc.

App Engine peut traiter plusieurs dizaines de milliers de requêtes par seconde, tout en nécessitant un minimum de gestion. Qu'il s'agisse de créer un site Web ou d'enregistrer des données sur votre espace de stockage backend, App Engine vous permet d'écrire votre code et de le déployer en production en quelques secondes.

Cloud SQL offre également un déploiement d'une grande simplicité. Cloud SQL peut héberger des machines virtuelles jusqu'à 32 cœurs et 208 Go de RAM, et augmenter votre espace de stockage à la demande jusqu'à 10 To, 30 IOPS par Go et des milliers de connexions simultanées. Ces caractéristiques sont largement suffisantes pour l'exemple présenté ici, et pour un grand nombre de moteurs de recommandations réels. Cloud SQL a également l’avantage d'être directement accessible depuis Spark.

Spark offre de bien meilleures performances qu'une configuration Hadoop classique, entre 10 et 100 fois plus rapide. Avec Spark MLlib, vous pouvez analyser plusieurs centaines de millions de commentaires client en quelques minutes, ce qui augmente l'agilité des recommandations, permettant ainsi à l'administrateur d'exécuter l'algorithme plus souvent. Spark exploite autant que possible la mémoire des machines virtuelles dans ses calculs, afin de réduire le plus possible les allers-retours sur disque. Il essaie également de minimiser les E/S. Dans cet exemple, nous utilisons Compute Engine pour héberger l'infrastructure d'analyse. Compute Engine aide à maintenir les coûts liés aux analyses aussi faibles que possible, grâce à une tarification à la demande et par seconde.

Le schéma suivant reprend le diagramme d'architecture précédent, mais met en évidence la technologie utilisée pour chaque étape :

Architecture utilisant App Engine, Cloud SQL, Spark et Compute Engine

Collecter les données

Un moteur de recommandations peut collecter des données sur les utilisateurs en fonction de leur comportement implicite ou de leur saisie explicite.

Les données de comportement sont faciles à collecter, car il suffit de conserver des journaux relatifs aux activités des utilisateurs. Ce processus est d'autant plus simple qu'il ne nécessite aucune action supplémentaire de la part de l'utilisateur. En effet, ils utilisent déjà l'application. L'inconvénient de cette approche, c'est que les données collectées sont plus difficiles à analyser. Il peut par exemple s'avérer fastidieux de distinguer les journaux intéressants de ceux qui le sont moins.

Les données de saisie peuvent être plus difficiles à collecter, car les utilisateurs doivent effectuer des actions supplémentaires, telles que la rédaction d'un commentaire. Les utilisateurs peuvent ne pas vouloir fournir ces données pour toutes sortes de raisons. Mais lorsqu'il s'agit de comprendre les préférences des utilisateurs, ces résultats se révèlent bien plus précis.

Stocker les données

Plus vous mettrez de données à la disposition de vos algorithmes, meilleures seront les recommandations. La conséquence directe, c'est que tout projet de moteur de recommandations peut rapidement devenir un projet big data.

Le type de données que vous utilisez pour créer des recommandations peut vous aider à déterminer le type de stockage le plus approprié. Vous pouvez choisir d'utiliser une base de données NoSQL, une base de données SQL standard ou même un type de stockage d'objets. Chacune de ces options est viable, selon que vous collectez les saisies ou le comportement des utilisateurs, ou selon des facteurs tels que la facilité de mise en œuvre, la quantité de données que le stockage peut gérer, l'intégration au reste de l'environnement et la portabilité.

Lors de l'enregistrement des évaluations ou des événements des utilisateurs, une base de données évolutive et gérée minimise le nombre de tâches opérationnelles nécessaires et permet au système de se concentrer sur la création de recommandations. Cloud SQL répond à ces deux besoins et facilite également le chargement des données, directement à partir de Spark.

L'exemple de code suivant montre les schémas des tables Cloud SQL. La table Accommodation représente le bien en location, et la table Rating représente la note d'un utilisateur pour un bien spécifique.

CREATE TABLE Accommodation
(
  id varchar(255),
  title varchar(255),
  location varchar(255),
  price int,
  rooms int,
  rating float,
  type varchar(255),
  PRIMARY KEY (ID)
);

CREATE TABLE Rating
(
  userId varchar(255),
  accoId varchar(255),
  rating int,
  PRIMARY KEY(accoId, userId),
  FOREIGN KEY (accoId)
    REFERENCES Accommodation(id)
);

Spark peut recevoir des données issues de différentes sources, telles que Hadoop HDFS ou Cloud Storage. Cette solution reçoit les données directement à partir de Cloud SQL à l'aide du connecteur Java Database Connectivity (JDBC) Spark. Étant donné que les tâches Spark s'exécutent en parallèle, le connecteur doit être disponible sur toutes les instances de cluster.

Analyser les données

La conception de la phase d'analyse nécessite une compréhension des exigences spécifiques de l'application. Voici les éléments à déterminer :

  • La fourniture en temps opportun des recommandations. À quel moment l'application doit-elle présenter des recommandations ?

  • L'approche de filtrage des données. L'application fondera-t-elle sa recommandation sur les seuls goûts de l'utilisateur, en fonction de ce que les autres utilisateurs pensent, ou selon les produits qui ont une correspondance logique entre eux ?

Fournir des recommandations en temps opportun

Le premier facteur à déterminer dans l'analyse des données est le moment où présenter des recommandations à l'utilisateur. Si vous souhaitez présenter des recommandations immédiatement, par exemple dès que l'utilisateur visualise un produit, vous aurez besoin d'un type d'analyse plus agile que si, par exemple, vous souhaitez lui envoyer, à une date ultérieure, un e-mail contenant des recommandations.

  • Les systèmes en temps réel peuvent traiter les données au fur et à mesure de leur création. Ce type de système implique généralement des outils permettant de traiter et d'analyser des flux d'événements. Un système en temps réel est approprié pour fournir des recommandations dans l'instant.

  • L'analyse par lots implique un traitement périodique des données. Un volume suffisant de données, par exemple, les ventes du jour, doit être collecté afin de rendre l'analyse pertinente. Un système de traitement par lots est approprié si vous souhaitez envoyer à vos clients un e-mail à une date ultérieure.

  • L'analyse en quasi-temps réel vous permet de rassembler des données rapidement afin d'actualiser les analyses dans des intervalles de quelques minutes ou de quelques secondes. Un système en quasi-temps réel est adapté si vous souhaitez fournir des recommandations au cours d'une même session de navigation.

Une recommandation peut appartenir à n'importe laquelle de ces trois catégories, mais pour un outil de vente en ligne, vous pourriez opter pour un traitement en quasi-temps réel ou un traitement par lots, en fonction du trafic et des saisies des utilisateurs dans votre application. La plate-forme exécutant l'analyse peut travailler directement à partir d'une base de données où les données collectées sont enregistrées, ou bien à partir d'un fichier de vidage enregistré périodiquement dans un espace de stockage persistant.

Filtrer les données

Le filtrage est un élément essentiel de la création d'un moteur de recommandations. Les approches du filtrage les plus courantes comprennent :

  • Basé sur le contenu : recommande les produits populaires ayant des attributs similaires à ceux que l'utilisateur aime ou est en train de consulter.

  • Cluster : recommande des produits par catégorie, sans prise en compte des saisies des autres utilisateurs.

  • Collaboratif : recommande les produits que d'autres utilisateurs, qui aiment les produits que l'utilisateur consulte ou aime actuellement, ont également aimés.

Bien que Google Cloud soit compatible avec n'importe laquelle de ces approches, la solution présentée ici est axée sur le filtrage collaboratif, mis en œuvre à l’aide d’Apache Spark. Pour plus d'informations sur le filtrage basé sur le contenu ou le filtrage par cluster, reportez-vous à l'annexe.

Le filtrage collaboratif vous permet d'extraire des attributs de produit et d'effectuer des prédictions en fonction des goûts des utilisateurs. Les résultats de ce filtrage sont basés sur l'hypothèse que deux utilisateurs différents, ayant par le passé aimé les mêmes produits, aimeront probablement les mêmes maintenant.

Vous pouvez représenter les données sur les évaluations ou les interactions sous la forme d'un ensemble de matrices, avec les produits et les utilisateurs comme dimensions. Le filtrage collaboratif tente de prédire les cellules manquantes pour une paire utilisateur-produit spécifique. Les deux matrices suivantes sont similaires, mais la seconde est déduite de la première en remplaçant les notations existantes par le chiffre un et les notations manquantes par le chiffre zéro. La matrice résultante est une table de vérité où le chiffre 1 représente une interaction des utilisateurs avec un produit.

Matrice d'évaluation Matrice d'interaction
Matrice d'évaluation Matrice d'évaluation

Le filtrage collaboratif peut être utilisé en se basant sur deux approches distinctes :

  • Le filtrage basé sur la mémoire calcule les similitudes entre les produits ou les utilisateurs.

  • Le filtrage basé sur des modèles tente d'apprendre le modèle sous-jacent qui détermine comment les utilisateurs évaluent les produits, ou interagissent avec eux.

La solution présentée ici utilise l'approche basée sur des modèles, s'appuyant sur les évaluations laissées par les utilisateurs.

Toutes les fonctionnalités d'analyse requises par cette solution sont disponibles via PySpark, qui fournit une interface Python au langage de programmation Spark. D'autres options sont disponibles avec Scala ou Java. Pour plus d'informations, consultez la documentation Spark.

Entraîner des modèles

Spark MLlib met en œuvre l'algorithme ALS (moindres carrés alternatifs) pour entraîner les modèles. Vous devrez utiliser différentes combinaisons des paramètres suivants afin obtenir le meilleur compromis entre variance et biais :

  • Rang : nombre de facteurs inconnus qui ont amené un utilisateur à donner une note. Ceux-ci pourraient inclure l'âge, le sexe ou le lieu de résidence de l'utilisateur. Plus le rang est élevé, plus il est probable que la recommandation soit précise. Nous conseillons, nonobstant toute limitation de mémoire ou de processeur, de commencer à 5 et d'augmenter de 5 jusqu'à ce que le taux d'amélioration des recommandations après chaque incrément ralentisse.

  • Lambda : paramètre de régularisation destiné à empêcher le surapprentissage, représenté par une variance élevée et un biais faible. La variance représente la fluctuation des prédictions, à un moment donné et sur plusieurs exécutions, par rapport à la valeur théoriquement correcte pour ce point. Le biais représente la distance qui sépare les prédictions générées de la valeur réelle que vous essayez de prédire. Le surapprentissage survient lorsque le modèle fonctionne bien sur les données d'apprentissage mais ne donne pas de résultats concluants sur les données de test réelles. Plus la valeur de lambda est élevée, plus le phénomène de surapprentissage est limité, mais plus le biais est important. Nous recommandons de tester les valeurs 0,01, 1 et 10.

    Le schéma suivant illustre la relation entre la variance et le biais. Le centre de la cible représente la valeur que l'algorithme tente de prédire.

    Variance versus biais (le scénario idéal se trouve en haut à gauche)
    Variance et biais
  • Itération : nombre de fois que l’entraînement sera exécuté. Dans cet exemple, vous ferez 5, 10 et 20 itérations pour différentes combinaisons de rang et de lambda.

L'exemple de code suivant montre comment démarrer l'entraînement d'un modèle ALS dans Spark.

from pyspark.mllib.recommendation import ALS
model = ALS.train(training, rank = 10, iterations = 5, lambda_=0.01)

Trouver le bon modèle

Le filtrage collaboratif basé sur l'algorithme ALS repose sur trois ensembles de données différents :

  • Ensemble d'apprentissage : contient des données avec une sortie connue. Cet ensemble correspond à ce que serait un résultat parfait. Ici, il s'agit des évaluations laissées par les utilisateurs eux-mêmes.

  • Ensemble de validation : contient des données qui aideront à ajuster l’entraînement afin de choisir la bonne combinaison de paramètres et d'opter pour le meilleur modèle.

  • Ensemble de test : contient les données qui seront utilisées pour évaluer les performances du modèle le mieux entraîné. Cela équivaudrait à exécuter l'analyse dans un exemple réel.

Pour trouver le meilleur modèle, vous devez calculer la racine carrée de l'erreur quadratique moyenne (root mean squared error, ou RMSE) en fonction du modèle calculé, de l'ensemble de validation et de sa taille. Plus la RMSE est basse, meilleur est le modèle.

Fournir les recommandations

Pour rendre les résultats accessibles à l'utilisateur aussi rapidement que facilement, vous devez les charger dans une base de données pouvant être interrogée à la demande. Cloud SQL est, encore une fois, une excellente option pour cela. Depuis Spark 1.4, vous pouvez écrire les résultats de la prédiction directement dans la base de données, à l'aide de PySpark.

Le schéma de la table Recommendation ressemble à ceci :

CREATE TABLE Recommendation
(
  userId varchar(255),
  accoId varchar(255),
  prediction float,
  PRIMARY KEY(userId, accoId),
  FOREIGN KEY (accoId)
    REFERENCES Accommodation(id)
);

Tutoriel du code

Cette section présente le code utilisé pour l'entraînement des modèles.

Obtenir les données de Cloud SQL

Le contexte Spark SQL vous permet de vous connecter facilement à une instance Cloud SQL via le connecteur JDBC. Les données chargées sont au format DataFrame.

jdbcUrl    = 'jdbc:mysql://%s:3306/%s?user=%s&password=%s' % (CLOUDSQL_INSTANCE_IP, CLOUDSQL_DB_NAME, CLOUDSQL_USER, CLOUDSQL_PWD)
dfAccos = sqlContext.read.jdbc(url=jdbcUrl, table=TABLE_ITEMS)
dfRates = sqlContext.read.jdbc(url=jdbcUrl, table=TABLE_RATINGS)

Convertir le DataFrame en RDD et créer les différents ensembles de données

Spark utilise un concept appelé ensemble de données distribué résilient (Resilient Distributed Dataset, ou RDD) qui facilite les traitements en parallèle. Les RDD sont des collections en lecture seule créées à partir d'espaces de stockage persistant. Ils peuvent être traités en mémoire, et sont donc bien adaptés aux traitements itératifs.

Rappelez-vous que pour obtenir le meilleur modèle pour effectuer vos prédictions, vous devez diviser vos ensembles de données en trois ensembles différents. Le code suivant utilise une fonction d'assistance qui fractionne de manière aléatoire les valeurs ne se chevauchant pas sur une base 60/20/20 :

rddTraining, rddValidating, rddTesting = dfRates.rdd.randomSplit([6,2,2])

Entraîner des modèles en fonction de divers paramètres

Lorsque vous utilisez la méthode ALS, le système se base sur les paramètres indiqués de rang, de régularisation et d'itération pour trouver le modèle le plus performant. Mais n'oubliez pas l'existence des évaluations utilisateurs : les résultats de la fonction train doivent être comparés à l'ensemble de validation. Assurez-vous que les goûts de l'utilisateur sont également inclus dans l'ensemble de données d'entraînement.