Qu’est-ce qu’un système de recommandation ?
Un système de recommandation est un moteur logiciel développé pour suggérer des produits et des services à un ensemble donné de clients. Bien qu’il existe plusieurs façons par lesquelles ces systèmes recommandent des produits, la plus courante consiste à analyser les habitudes d’achat précédentes d’un client en stockant des données relatives aux achats précédents, aux avis positifs et négatifs, aux sauvegardes/ajouts aux listes, aux vues, etc.
Alors pourquoi des entreprises comme Amazon et Netflix dépensent-elles de petites fortunes pour construire et améliorer ces systèmes ? Parce que les systèmes de recommandation augmentent considérablement les ventes. En agissant comme l’équipe de vente personnelle de chaque client, les systèmes de recommandation offrent à chaque utilisateur une expérience unique et personnalisée. Ces systèmes peuvent aider les clients à identifier leurs films, livres, émissions, articles préférés, etc., sans avoir à parcourir les millions de choix.
TensorFlow et l’outil de recommandation TensorFlow
Créé par le framework Tensor bien connu, le TensorFlow Recommender (ou TFRS) est une bibliothèque créée spécifiquement pour créer des modèles de système de recommandation. En plus d’être modérément facile à apprendre, le framework TensorFlow Recommender aide à l’ensemble du processus de création du système de recommandation, de la collecte et de l’évaluation des données au déploiement.
Dans notre court tutoriel, nous allons intégrer le système TensorFlow Recommender dans notre modèle de système de recommandation. Nous expliquerons également la structure de notre modèle, avec une brève explication de chaque étape du code.
L’objectif de notre système de recommandation
Nous allons construire un système de recommandation qui prend en compte une liste de produits électroniques (fournie par Amazon) ainsi qu’une liste d’évaluations de chaque article donnée par différents utilisateurs comme données d’entrée. Le système fournira d’autres suggestions pour des produits similaires avec les notes les plus élevées que chaque client pourrait être intéressé à acheter.
Pour trouver l’ensemble de données utilisé dans notre exemple de didacticiel, veuillez consulter le lien suivant : Ensemble de données Amazon Product Review. L’ensemble de données contient quatre colonnes ; le ID utilisateur, ID produit, évaluation du produitet le horodatage de chaque note. En utilisant les valeurs suivantes, nous allons construire le système de recommandation requis.
Tutoriel des recommandations TensorFlow
Notez que vous pouvez tester votre code sur Kaggle ou Google Colab.
Étape 1 : Importation des bibliothèques requises
<span>import numpy as np</span> <span>import pandas as pd</span> <span>from datetime import datetime,timedelta</span>
Nous allons également importer les bibliothèques de tracé. Ce sont des bibliothèques qui nous permettent de dessiner et de tracer des figures, des graphiques, etc. Ces figures seront principalement utilisées à des fins d’explication et n’auront aucun effet sur le résultat final de notre modèle.
<span>import matplotlib.pyplot as plt</span>
<span>from matplotlib.patches import Patch</span>
<span>from matplotlib.ticker import MaxNLocator</span>
<span>from learntools.time_series.utils import plot_periodogram, seasonal_plot</span>
<span>from learntools.time_series.style import *</span>
<span>import seaborn as sns</span>
<span>from IPython.display import Markdown, display</span>
<span>def printmd(string):</span>
<span>display(Markdown(string))<br><br></span><span>from pathlib import Path</span>
<span>comp_dir = Path('../input/amazon-product-reviews')</span>
Étape 2 : Importation de l’ensemble de données Amazon Reviews
Dans cette étape, nous importerons et lirons l’ensemble de données de notation électronique d’Amazon.
<span>electronics_data=pd.read_csv(comp_dir / "ratings_Electronics (1).csv", dtype={'rating': 'int8'},</span>
<span>names=['userId', 'productId','rating','timestamp'], index_col=None, header=0)</span>
<span>#electronics_data.drop("timestamp",axis=1, inplace=True)</span>
Étape 3 : Impression des informations sur l’ensemble de données
Dans cette partie, nous imprimerons des informations sur l’ensemble de données donné, telles que le nombre de lignes (notes) disponibles, les colonnes utilisées (userID, productID, note et horodatage), le nombre d’utilisateurs uniques et enfin le nombre de produits uniques.
<span>printmd("Number of Rating: {:,}".format(electronics_data.shape[0]) )</span>
<span>printmd("Columns: {}".format( np.array2string(electronics_data.columns.values)) )</span>
<span>printmd("Number of Users: {:,}".format(len(electronics_data.userId.unique()) ) )</span>
<span>printmd("Number of Products: {:,}".format(len(electronics_data.productId.unique()) ) )</span>
<span>electronics_data.describe()['rating'].reset_index()</span>
Sortir:
Number of Rating: 7,824,481 Columns: ['userId' 'productId' 'rating' 'timestamp'] Number of Users: 4,201,696 Number of Products: 476,001
Étape 4 : Vérification des valeurs manquantes
<span>printmd('**Number of missing values**:')</span>
<span>pd.DataFrame(electronics_data.isnull().sum().reset_index()).rename( columns={0:"Total missing","index":"Columns"})</span>
Heureusement pour nous, l’ensemble de données utilisé ne contient aucune valeur manquante. La raison pour laquelle nous vérifions les valeurs manquantes est de les supprimer. Comme dans notre cas, les valeurs manquantes affecteront négativement la précision de notre modèle final.
Étape 5 : impression du nombre d’évaluations par jour
<span>data_by_date = electronics_data.copy()</span>
<span>data_by_date.timestamp = pd.to_datetime(electronics_data.timestamp, unit="s")#.dt.date</span>
<span>data_by_date = data_by_date.sort_values(by="timestamp", ascending=False).reset_index(drop=True)</span>
<span>printmd("Number of Ratings each day:")</span>
<span>data_by_date.groupby("timestamp")["rating"].count().tail(10).reset_index()</span>
Étape 6 : Tracer le nombre de notes au fil des ans
<span>data_by_date["year"] = data_by_date.timestamp.dt.year</span>
<span>data_by_date["month"] = data_by_date.timestamp.dt.month</span>
<span>rating_by_year = data_by_date.groupby(["year","month"])["rating"].count().reset_index()</span>
<span>rating_by_year["date"] = pd.to_datetime(rating_by_year["year"].astype("str") +"-"+rating_by_year["month"].astype("str") +"-1")</span>
<span>rating_by_year.plot(x="date", y="rating")</span>
<span>plt.title("Number of Rating over years")</span>
<span>plt.show()</span>
Étape 7 : Trier les produits par nombre de notes
<span>#rating_by_product = electronics_data.groupby(by='productId')['Rating'].count().sort_values(ascending=False).reset_index()</span>
<span>rating_by_product = electronics_data.groupby("productId").agg({"userId":"count","rating":"mean"}).rename(columns={"userId":"Number of Ratings", "rating":"Average Rating"}).reset_index()</span>
Nous définirons alors le seuil à une valeur de 50. Seuls les produits dont le nombre de notes est supérieur au seuil seront comptabilisés. Cela signifie que les produits dont le nombre d’évaluations est inférieur au nombre limite seront exclus du tri.
<span>cutoff = 50</span> <span>top_rated = rating_by_product.loc[rating_by_product["Number of Ratings"]>cutoff].sort_values(by="Average Rating",ascending=False).reset_index(drop=True)</span>
Étape 8 : Installation des recommandations TensorFlow (TFSR)
Pour commencer, nous mettrons à jour pépin à la dernière version disponible. Si pépin n’est pas trouvé, il sera installé. Après cela, nous installerons le framework de recommandations TensorFlow en utilisant pépin.
<span>!/opt/conda/bin/python3.7 -m pip install --upgrade pip</span> <span>!pip install -q tensorflow-recommenders</span>
Étape 9 : Importer la bibliothèque de recommandations TensorFlow et TensorFlow
Nous utiliserons les deux bibliothèques ci-dessous afin d’importer les deux modèles de réseau de neurones utilisés dans ce didacticiel.
<span>import tensorflow as tf</span> <span>import tensorflow_recommenders as tfrs</span>
Étape 10 : Importation de nos modèles
Le Modèle de classement méthode prend comme seul et unique paramètre tf. keras. Modèle, qui est le modèle de réseau de neurones parent importé de la bibliothèque TensorFlow. En continuant, nous passerons alors une valeur de 32 au intégration_dimensionqui est un hyperparamètre de la couche d’intégration qui spécifie la taille du vecteur d’intégration.
Ensuite, à l’intérieur du Modèle de classement, nous effectuerons une intégration de mots sur les ensembles de données produit et utilisateur. Étant donné que notre modèle ne peut pas comprendre les données textuelles, nous devrons transformer les données textuelles en valeurs entières pouvant être traitées par celui-ci.
L’incorporation de mots est le processus de transformation de chaque mot d’un ensemble de données donné en une valeur entière. Cette valeur représentera l’importance du mot donné dans le réseau neuronal utilisé pour atteindre l’objectif recherché.
Enfin, pour les évaluations, nous allons construire 3 couches denses (entièrement connectées) qui effectueront une régression normale. La première couche contient 256 neurones, la seconde 64 et la dernière couche n’en a qu’un, ce qui signifie que notre valeur finale est soit vrai/faux (oui/non).
<span>class RankingModel(tf.keras.Model):</span> <span>def init(self):</span> <span>super().init()</span> <span>embedding_dimension = 32</span> <span>self.user_embeddings = tf.keras.Sequential([</span> <span>tf.keras.layers.experimental.preprocessing.StringLookup(vocabulary=unique_userIds, mask_token=None),</span> <span># add additional embedding to account for unknown tokens</span> <span>tf.keras.layers.Embedding(len(unique_userIds)+1, embedding_dimension)</span> <span>])</span> <span>self.product_embeddings = tf.keras.Sequential([</span> <span>tf.keras.layers.experimental.preprocessing.StringLookup(vocabulary=unique_productIds, mask_token=None),</span> <span># add additional embedding to account for unknown tokens</span> <span>tf.keras.layers.Embedding(len(unique_productIds)+1, embedding_dimension)</span> <span>])</span> <span># Set up a retrieval task and evaluation metrics over the</span> <span># entire dataset of candidates.</span> <span>self.ratings = tf.keras.Sequential([</span> <span>tf.keras.layers.Dense(256, activation="relu"),</span> <span>tf.keras.layers.Dense(64, activation="relu"),</span> <span>tf.keras.layers.Dense(1)</span> <span>])</span> <span>def call(self, userId, productId):</span> <span>user_embeddings = self.user_embeddings (userId)</span> <span>product_embeddings = self.product_embeddings(productId)</span> <span>return self.ratings(tf.concat([user_embeddings,product_embeddings], axis=1))</span>
Le amazonModèle quel est le modèle final…