Que sont les systèmes de recommandation et comment les utiliser

Un système de recommandation, ou système de recommandation, est un algorithme utilisé pour filtrer les informations. La collecte d'informations fournit des suggestions les plus pertinentes pour un utilisateur particulier. Ceci est utile lorsque quelqu'un doit choisir une plate-forme où se trouve une quantité écrasante d'informations.

Filtrage collaboratif

Le filtrage collaboratif crée un modèle utilisant les décisions passées de l'utilisateur, telles que les montres ou les évaluations passées sur un certain produit, et les comportements similaires d'autres utilisateurs pour prédire ce que l'utilisateur pourrait apprécier. Il utilise une matrice d'évaluation des utilisateurs et ne nécessite aucune autre information utilisateur telle que des données démographiques ou d'autres informations en plus des évaluations. Il s'agit d'un atout majeur du filtrage collaboratif car il repose sur un minimum d'informations et peut recommander des éléments sans comprendre leur contenu.

Last.fm recommande des chansons en observant les groupes et les morceaux individuels que l'utilisateur a écoutés régulièrement et en les comparant au comportement d'écoute des autres utilisateurs. Last.fm jouera des morceaux qui n'apparaissent pas dans la bibliothèque de l'utilisateur mais qui sont souvent lus par d'autres utilisateurs partageant les mêmes intérêts. Comme cette approche exploite le comportement des utilisateurs, il s’agit d’un exemple de technique de filtrage collaboratif. Last.fm nécessite de nombreuses informations sur un utilisateur pour faire des recommandations précises. Ceci est un exemple du problème de démarrage à froid, courant dans les systèmes de filtrage collaboratifs. (source : WiKipedia, https://en.wikipedia.org/wiki/Recommemender_system)

Le filtrage collaboratif suppose que les personnes qui étaient d'accord dans le passé seront d'accord à l'avenir. Il identifie un autre utilisateur avec un historique similaire à l'utilisateur actuel et génère des prédictions en utilisant ce quartier. Ces méthodes sont considérées comme des approches basées sur la mémoire et sur des modèles.

Certains problèmes pouvant interférer avec les algorithmes de filtrage collaboratif sont le démarrage à froid, l'évolutivité et la parcimonie. Les Démarrages à froid font référence au manque de données permettant de faire des recommandations précises. Il existe également un besoin en puissance de calcul important, qui est souvent nécessaire pour calculer des recommandations, ce qui rend l'algorithme moins évolutif. De plus, il existe une énorme quantité de produits et d'articles sur Internet, ce qui signifie que les notes sont plutôt rares.

Implémenter le filtrage collaboratif en Python

Nous utiliserons un ensemble de données contenant les meilleures marques et critiques de cosmétiques. Cet ensemble de données est disponible sur le site Web de Kaggle : https://www.kaggle.com/datasets/jithinanievarghese/cosmetics-and-beauty-products-reviews-top-brands

rating_list = pd.read_csv('top_brands_cosmetics_product_reviews.csv', sep=',', usecols=['author', 'product_title', 'product_rating', 'review_date'])

items = pd.read_csv('top_brands_cosmetics_product_reviews.csv', 
                    usecols=['product_title', 'product_url', 'brand_name'], encoding='latin-1')

print(f'Number of ratings: {rating_list.author.nunique()} | Number of items: {items.product_title.nunique()}')

Pivotez la formation à l'aide de la matrice d'éléments utilisateur.

X_train, X_test, y_train, y_test = train_test_split(rating_list, rating_list.product_rating, test_size=0.1, random_state=42)

ratings = X_train.pivot_table(index=['author'], columns=['product_title'], values='product_rating').fillna(0)
mean_ratings = ratings.mean(axis=1)
print(f'Number of users: {ratings.shape[0]} | Number of items: {ratings.shape[1]}')

Calculer la similarité.

def get_all_recommendations(user_id, model, use_means=True):
    distance, knn = model.kneighbors(ratings.fillna(0)) # nearest neighbors
    knn = pd.DataFrame(knn + 1, index=ratings.index)
    sim = pd.DataFrame(1 - distance, index=ratings.index) # invert the distance
    neighbors = knn.loc[user_id, 1:]
    similarities = sim.loc[user_id, 1:]
    similarities.index = ratings.loc[neighbors].index

    if use_means:
        return pd.Series(mean_ratings.loc[user_id] + ratings.loc[neighbors].subtract(mean_ratings.loc[neighbors], axis='index').mul(similarities, axis='index').sum(axis='index') / similarities.sum(), name='recommendation')
    else:
        return pd.Series(ratings.loc[neighbors].mul(similarities, axis='index').sum(axis='index') / similarities.sum(), name='recommendation')

Calculer une seule recommandation pour un utilisateur, un produit et un modèle donnés

def get_recommendations (user_id, product_id, model, use_means=True):
    if product_id not in ratings.columns:
        return 2.5
    recommendations = get_all_recommendations(user_id, model, use_means=use_means)
    return recommendations.loc[product_id]

Calculez l'erreur quadratique moyenne (RMSE) à évaluer afin de prédire les notes de tous les produits pour chaque utilisateur de l'ensemble de données. Ensuite, alignez les notes prévues avec les notes réelles dans l'ensemble de test et calculez le RMSE.7.

model = NearestNeighbors(n_neighbors=40, metric='cosine')
model.fit(ratings.fillna(0))

def get_RMSE(X_test, model, use_means=True):
    group = X_test[['product_title', 'product_rating']].groupby(X_test.author)
    mse = []
    i = 0
    for key in group.groups:
        if key not in rating_list['author']:
            continue  # Skip users not in the dataset
        predictions = get_all_recommendations(key, model=model, use_means=use_means)
        rated_products = group.get_group(key).set_index('product_title')
        df = rated_products.join(predictions).dropna().reset_index()
        mse.append(df)
        if i % 100 == 0:
            score = np.sqrt(mean_squared_error(df.product_rating, df.recommendation))
            print(f'{i}/{X_test.author.nunique()} - RMSE: {score:.4f}')
        i += 1
    mse = pd.concat(mse).reset_index(drop=True)
    score = np.sqrt(mean_squared_error(mse.product_rating, mse.recommendation))
    print(f'{X_test.author.nunique()}/{X_test.author.nunique()} - RMSE: {score:.4f}')

get_RMSE(X_test, model)

ratings_dict = {
    "item": [1, 2, 1, 2, 1, 2, 1, 2, 1],
    "user": ['A', 'A', 'B', 'B', 'C', 'C', 'D', 'D', 'E'],
    "rating": [1, 2, 2, 4, 2.5, 4, 4.5, 5, 3],
}

df = pd.DataFrame(ratings_dict)
reader = Reader(rating_scale=(1, 5))

data = Dataset.load_from_df(df[["user", "item", "rating"]], reader)

movielens = Dataset.load_builtin('ml-100k') 
trainingSet = movielens.build_full_trainset()
algo.fit(trainingSet)

def get_recommendation(id_user, id_movie, ratings):
    #cosine similarity of the ratings
    similarity_matrix = cosine_similarity(ratings.fillna(0), ratings.fillna(0))
    similarity_matrix_df = pd.DataFrame(similarity_matrix, index=ratings.index, columns=ratings.index)

    cosine_scores = similarity_matrix_df[id_user]
    ratings_scores = ratings[id_movie]
    ratings_scores.dropna().dot(cosine_scores[~ratings_scores.isna()]) / cosine_scores[~ratings_scores.isna()].sum()
    return np.dot(ratings_scores.dropna(), cosine_scores[~ratings_scores.isna()]) / cosine_scores[
        ~ratings_scores.isna()].sum()

get_recommendation(196, 8, ratings) # get recommandations for user 196 for movie 8 

Filtrage basé sur le contenu

Les approches de filtrage basées sur le contenu utilisent une série de caractéristiques discrètes et pré-étiquetées d'un élément pour recommander des éléments supplémentaires ayant des propriétés similaires. Il utilise les fonctionnalités des éléments pour sélectionner et renvoyer des éléments pertinents par rapport à ce que recherche l'utilisateur. Certains algorithmes de recommandation basés sur le contenu font correspondre les éléments en fonction de leur description plutôt que du contenu réel.

Pandora utilise les propriétés d'une chanson ou d'un artiste pour créer une file d'attente qui joue de la musique avec des propriétés similaires. Les commentaires des utilisateurs sont utilisés pour affiner les résultats de la station, en atténuant certains attributs lorsqu'un utilisateur « n'aime pas » une chanson particulière et en mettant l'accent sur d'autres attributs lorsqu'un utilisateur « aime » une chanson. Ceci est un exemple d’approche basée sur le contenu. Pandora a besoin de très peu d'informations pour démarrer, sa portée est beaucoup plus limitée (par exemple, elle ne peut faire que des recommandations similaires à la graine d'origine). (source : Wikipédia, https://en.wikipedia.org/wiki/Recommemender_system)

La méthode utilise la description du produit et le profil de l'utilisateur, ce qui la rend adaptée aux situations où il existe des données connues sur un article mais pas sur l'utilisateur. Les recommandateurs basés sur le contenu traitent la recommandation comme un problème de classification spécifique à l'utilisateur et apprennent un classificateur pour les goûts et les aversions de l'utilisateur en fonction des fonctionnalités d'un élément. Des mots clés sont utilisés pour décrire les éléments et un profil utilisateur est créé pour répertorier les goûts et les aversions de l'utilisateur. Divers éléments candidats sont comparés aux éléments précédemment évalués par l'utilisateur, et les éléments les mieux correspondants sont recommandés. Un algorithme largement utilisé est la représentation TF-IDF. Il existe des techniques d'apprentissage automatique telles que les classificateurs bayésiens, l'analyse groupée, les arbres de décision et les réseaux de neurones artificiels pour estimer la probabilité que l'utilisateur aime l'élément.

Cependant, le filtrage basé sur le contenu peut souvent suggérer des éléments très similaires à ce qu'un utilisateur aime déjà, limitant ainsi la variété et rendant plus difficile la découverte de nouvelles choses. Cela peut créer une « bulle » dans laquelle les utilisateurs ne voient que certains types de contenu. Cela dépend également de la façon dont les éléments sont étiquetés ou décrits, ce qui peut poser problème s'il n'y a pas suffisamment d'informations ou si l'utilisateur est nouveau et n'a pas encore interagi avec beaucoup de contenu.

Implémentation du filtrage basé sur le contenu en Python (à l'aide de BOW)

rating_list = pd.read_csv('top_brands_cosmetics_product_reviews.csv', sep=',', usecols=['author', 'product_title', 'product_rating', 'review_date'])

items = pd.read_csv('top_brands_cosmetics_product_reviews.csv', 
                    usecols=['product_title', 'product_url', 'brand_name'], encoding='latin-1')

print(f'Number of ratings: {rating_list.author.nunique()} | Number of items: {items.product_title.nunique()}')

Transformez les résumés d'intrigue en représentations vectorielles pour pouvoir appliquer des algorithmes d'apprentissage automatique numérique.

X_train, X_test, y_train, y_test = train_test_split(rating_list, rating_list.product_rating, test_size=0.1, random_state=42)

ratings = X_train.pivot_table(index=['author'], columns=['product_title'], values='product_rating').fillna(0)
mean_ratings = ratings.mean(axis=1)
print(f'Number of users: {ratings.shape[0]} | Number of items: {ratings.shape[1]}')

Chaque résumé de l'intrigue sera transformé en une séquence de mots pour pointer vers un espace sémantique de grande dimension (le modèle TF-IDF est utilisé ici). Cela compte le nombre de fois qu'un mot apparaît dans le document pour décider de l'importance du mot dans le document.

print(f'Matrix contient {tfidf_model.shape[0]} lignes et {tfidf_model.shape[1]} colonnes')

Le modèle BOW (Bag of Words) compte le nombre de fois qu'un mot apparaît dans un document (rare, la plupart des entrées dans le vecteur sont 0)

Le modèle

TF-IDF (Term Frequency — Inverse Document Frequency) compte le nombre de fois qu'un mot apparaît dans un document mais prend également en compte la fréquence à laquelle le mot apparaît dans tous les documents. Il allège les mots qui apparaissent fréquemment dans les documents, les rendant moins informatifs que ceux qui apparaissent rarement. Chaque résumé d'intrigue est codé comme un vecteur unique dont la longueur est égale à la taille du vocabulaire de tous les résumés d'intrigue, TD-IDF transforme les résumés d'intrigue en une matrice. Il ignore les mots qui apparaissent dans plus de 80% des avis et ceux qui apparaissent dans moins de 2 → le bruit est réduit.

Inspectez le modèle TF-IDF en utilisant le vocabulaire de maquillage populaire.

def get_all_recommendations(user_id, model, use_means=True):
    distance, knn = model.kneighbors(ratings.fillna(0)) # nearest neighbors
    knn = pd.DataFrame(knn + 1, index=ratings.index)
    sim = pd.DataFrame(1 - distance, index=ratings.index) # invert the distance
    neighbors = knn.loc[user_id, 1:]
    similarities = sim.loc[user_id, 1:]
    similarities.index = ratings.loc[neighbors].index

    if use_means:
        return pd.Series(mean_ratings.loc[user_id] + ratings.loc[neighbors].subtract(mean_ratings.loc[neighbors], axis='index').mul(similarities, axis='index').sum(axis='index') / similarities.sum(), name='recommendation')
    else:
        return pd.Series(ratings.loc[neighbors].mul(similarities, axis='index').sum(axis='index') / similarities.sum(), name='recommendation')

Appliquer la similarité cosinus entre différents produits en fonction de leur signature d'occurrence de fréquence de terme de résumé d'intrigue.

def get_recommendations (user_id, product_id, model, use_means=True):
    if product_id not in ratings.columns:
        return 2.5
    recommendations = get_all_recommendations(user_id, model, use_means=use_means)
    return recommendations.loc[product_id]

Appliquez la fonction à n'importe quel produit de l'ensemble de données.

model = NearestNeighbors(n_neighbors=40, metric='cosine')
model.fit(ratings.fillna(0))

def get_RMSE(X_test, model, use_means=True):
    group = X_test[['product_title', 'product_rating']].groupby(X_test.author)
    mse = []
    i = 0
    for key in group.groups:
        if key not in rating_list['author']:
            continue  # Skip users not in the dataset
        predictions = get_all_recommendations(key, model=model, use_means=use_means)
        rated_products = group.get_group(key).set_index('product_title')
        df = rated_products.join(predictions).dropna().reset_index()
        mse.append(df)
        if i % 100 == 0:
            score = np.sqrt(mean_squared_error(df.product_rating, df.recommendation))
            print(f'{i}/{X_test.author.nunique()} - RMSE: {score:.4f}')
        i += 1
    mse = pd.concat(mse).reset_index(drop=True)
    score = np.sqrt(mean_squared_error(mse.product_rating, mse.recommendation))
    print(f'{X_test.author.nunique()}/{X_test.author.nunique()} - RMSE: {score:.4f}')

get_RMSE(X_test, model)

Systèmes hybrides

Vous pouvez également combiner les deux algorithmes pour proposer une recommandation plus affinée. Les systèmes de recommandation aident les utilisateurs à découvrir des éléments qu'ils n'auraient peut-être pas trouvés autrement. Les systèmes de recommandation sont souvent mis en œuvre à l'aide de moteurs de recherche indexant des données non traditionnelles.

Conclusion

En conclusion, les systèmes de recommandation jouent un rôle clé en aidant les utilisateurs à découvrir du contenu et des produits pertinents en fournissant des suggestions personnalisées. Ils améliorent l'expérience en réduisant le temps et les efforts nécessaires pour trouver ce qui les intéresse.

** Consultez le code complet sur GitHub : https://github.com/alexiacismaru/recommender-systems

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!