Utiliser le machine learning sur Compute Engine pour recommander des produits

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. Pour découvrir un exemple d'analyse implicite des données utilisant des entrées de journaux, consultez la section Analyser des journaux en temps réel à l'aide de Fluentd et BigQuery.

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, en 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.

for cRank, cRegul, cIter in itertools.product(ranks, reguls, iters):

  model = ALS.train(rddTraining, cRank, cIter, float(cRegul))
  dist = howFarAreWe(model, rddValidating, nbValidating)
  if dist < finalDist:
    print("Best so far:%f" % dist)
    finalModel = model
    finalRank  = cRank
    finalRegul = cRegul
    finalIter  = cIter
    finalDist  = dist
def howFarAreWe(model, against, sizeAgainst):
  # Ignore the rating column
  againstNoRatings = against.map(lambda x: (int(x[0]), int(x[1])) )

  # Keep the rating to compare against
  againstWiRatings = against.map(lambda x: ((int(x[0]),int(x[1])), int(x[2])) )

  # Make a prediction and map it for later comparison
  # The map has to be ((user,product), rating) not ((product,user), rating)
  predictions = model.predictAll(againstNoRatings).map(lambda p: ( (p[0],p[1]), p[2]) )

  # Returns the pairs (prediction, rating)
  predictionsAndRatings = predictions.join(againstWiRatings).values()

  # Returns the variance
  return sqrt(predictionsAndRatings.map(lambda s: (s[0] - s[1]) ** 2).reduce(add) / float(sizeAgainst))

Calculer les meilleures prévisions pour l'utilisateur

Maintenant que vous disposez d'un modèle à même de fournir une prédiction raisonnablement précise, vous pouvez l'utiliser pour voir ce qui est le plus susceptible d'intéresser l'utilisateur, en fonction de ses goûts et des évaluations d'autres personnes ayant des goûts similaires. Le mappage matriciel décrit précédemment rentre en jeu dans cette étape.

# Build our model with the best found values
# Rating, Rank, Iteration, Regulation
model = ALS.train(rddTraining, BEST_RANK, BEST_ITERATION, BEST_REGULATION)

# Calculate all predictions
predictions = model.predictAll(pairsPotential).map(lambda p: (str(p[0]), str(p[1]), float(p[2])))

# Take the top 5 ones
topPredictions = predictions.takeOrdered(5, key=lambda x: -x[2])
print(topPredictions)

schema = StructType([StructField("userId", StringType(), True), StructField("accoId", StringType(), True), StructField("prediction", FloatType(), True)])

dfToSave = sqlContext.createDataFrame(topPredictions, schema)
dfToSave.write.jdbc(url=jdbcUrl, table=TABLE_RECOMMENDATIONS, mode='overwrite')

Enregistrer les meilleures prédictions

Maintenant que vous avez la liste de toutes les prédictions, vous pouvez enregistrer les dix meilleures dans Cloud SQL, afin que le système puisse proposer ces recommandations à l'utilisateur. Par exemple, un bon moment pour utiliser ces prédictions peut être lors de la prochaine connexion de l'utilisateur au site Web.

dfToSave = sqlContext.createDataFrame(topPredictions, schema)
dfToSave.write.jdbc(url=jdbcUrl, table=TABLE_RECOMMENDATIONS, mode='overwrite')

Lancer la solution

Pour exécuter cette solution, suivez les instructions pas à pas disponible sur la page GitHub. Vous y découvrirez comment calculer des recommandations et les présenter à l'utilisateur.

Le code SQL final récupère la recommandation principale de la base de données et l'affiche sur la page d'accueil de Samantha.

La requête, lorsqu'elle est exécutée dans Cloud Console ou un client MySQL, renvoie un résultat semblable à l'exemple suivant :

Résultats de la requête SQL pour cinq utilisateurs

À partir d'un site Web, la même requête peut améliorer la page d'accueil et augmenter la probabilité de conversion d'un prospect en client, comme illustré ci-dessous :

Interface utilisateur avec résultats

Ces recommandations semblent assez similaires aux goûts de Sam, en se basant sur ce que le système savait déjà sur elle, comme nous l'avons vu dans la description du scénario.

Tutoriel

Le contenu complet du tutoriel, y compris les instructions et le code source, est disponible sur GitHub.

Étapes suivantes

  • Testez d'autres fonctionnalités de Google Cloud. Découvrez nos tutoriels.
  • Découvrez comment utiliser les produits Google Cloud pour créer des solutions de bout en bout.
  • Pour en savoir plus sur la surveillance, consultez la documentation de Cloud Dataproc sur les résultats ou les interfaces Web.

Annexe

Filtrage croisé

Bien que vous ayez vu comment créer une solution de filtrage collaboratif efficace et évolutive, croiser les résultats obtenus avec d'autres types de filtrage peut encore davantage améliorer les recommandations. Comme nous l'avons vu, deux autres types principaux de filtrage existent : basé sur le contenu et sur les clusters. Combiner ces différentes approches peut aboutir à une recommandation plus précise pour l'utilisateur.

Types de filtrage

Filtrage basé sur le contenu

Le filtrage basé sur le contenu se base sur les attributs des éléments et prend en compte leurs similarités, ce qui facilite la création de recommandations pour les éléments disposant d'attributs mais de peu d'évaluations d'utilisateurs. À mesure que la base d'utilisateurs augmente, ce type de filtrage reste gérable, même avec un grand nombre d'utilisateurs.

Afin de mettre en oeuvre un filtrage basé sur le contenu, utilisez les évaluations précédentes d'autres utilisateurs pour les éléments de votre catalogue. Sur la base de ces évaluations, vous pourrez trouver les produits les plus similaires au produit actuel.

Une méthode courante pour calculer la similarité entre deux produits consiste à utiliser la formule de similarité cosinus suivante et à rechercher les valeurs les plus proches :

Formule de similarité cosinus

Diagramme de similarité cosinus

Le résultat de la similarité sera compris entre 0 et 1. Plus elle se rapproche de 1, plus les produits sont similaires.

Spectre de similarité cosinus

Considérons la matrice suivante :

Formule de similarité cosinus

Dans cette matrice, la similarité entre P1 et P2 peut être calculée comme suit :

Formule de similarité cosinus avec résultat

Divers outils peuvent vous permettre de réaliser un filtrage basé sur le contenu. Si vous voulez en savoir plus, consultez les rubriques suivantes :

  • Similarité Twitter sur toutes les paires. La fonction CosineSimilarities Scala ajoutée à MLlib peut être exécutée dans l'environnement Spark.

  • Mahout. Si vous souhaitez accéder à davantage de bibliothèques pour compléter ou remplacer un algorithme MLlib, vous pouvez installer Mahout sur le nœud (maître) du contrôleur Dataproc en utilisant ssh pour vous connecter à l'instance ou en effectuant une action d'initialisation, comme suit :

    sudo apt-get update
    sudo apt-get install mahout -y
    

Filtrage par cluster

Il est également important de comprendre le contexte de navigation et ce que l'utilisateur regarde actuellement. La même personne, à différents moments, peut être intéressée par deux produits complètement différents, ou acheter un cadeau pour quelqu'un d'autre. Être capable de comprendre quels éléments sont similaires à celui actuellement affiché est essentiel. L'utilisation d'un clustering en K-moyennes permet au système de regrouper des éléments similaires dans des buckets, en fonction de leurs attributs principaux.

Pour la solution présentée ici, une personne cherchant à louer une maison à Londres ne souhaite probablement pas, pour le moment, louer une propriété à Auckland. Le système devrait donc filtrer ces éléments lors de la formulation d'une recommandation.

from pyspark.mllib.clustering import KMeans, KMeansModel
clusters = KMeans.train(parsedData, 2,
                        maxIterations=10,
                        runs=10,
                        initializationMode="random")

Vue à 360 degrés

Vous pouvez améliorer encore davantage vos recommandations en prenant en compte d'autres données client, telles que les commandes passées, les demandes d'assistance et les attributs personnels, comme l'âge, le lieu de résidence ou le sexe. Ces caractéristiques, qui sont souvent déjà disponibles dans les systèmes de gestion de la relation client (CRM) ou de planification des ressources d'entreprise (ERP), aideront à préciser les résultats.

Mais on peut aller plus loin. Les données internes du système ne sont pas les seules à avoir un impact sur le comportement et les choix des utilisateurs. Les facteurs externes sont tout aussi importants. Dans le cas d'utilisation présenté ici, on peut imaginer que la qualité de l'air soit un critère de choix important pour une famille avec de jeunes enfants. L'intégration d'un moteur de recommandations basé sur Google Cloud à une autre API, telle que Breezometer, pourrait donc constituer un avantage concurrentiel.