Système de recommandation avec filtrage basé sur le contenu

Jan 23 2023

Photo de Tamas Pap sur Unsplash

Le système de recommandation ou système de recommandation est un système qui aide les utilisateurs à découvrir les choses qu'ils aiment. Il peut être utilisé pour recommander des produits, des films ou de la musique. Le système utilise les préférences et les taux pour faire des prédictions sur le choix d'un utilisateur individuel.

Un système de recommandation peut utiliser un filtrage basé sur le contenu, un filtrage collaboratif ou des techniques hybrides pour générer des recommandations pour les nouveaux utilisateurs en fonction des comportements observés des autres utilisateurs.

Un système de filtrage basé sur le contenu est utilisé pour faire des recommandations basées sur la similitude entre l'article que vous avez noté et d'autres articles de notre catalogue.

Le filtrage collaboratif utilise les similitudes entre les utilisateurs, comme les articles qu'ils ont achetés ou regardés. Plus un article est similaire à un autre, plus il est susceptible d'être recommandé

Dans cet article, nous allons construire un système de recommandation de films basé sur le contenu recherché par les utilisateurs.

Conditions préalables

Assurez-vous que les bibliothèques requises sont installées sur votre appareil. Si ce n'est pas le cas, vous pouvez d'abord l'installer en consultant la documentation sur le site de chaque bibliothèque.

Bibliothèques

Importez toutes les bibliothèques requises.

import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics.pairwise import cosine_similarity

Chargez le jeu de données.

movie_rating_df = pd.read_csv('https://dqlab-dataset.s3-ap-southeast-1.amazonaws.com/movie_rating_df.csv')

cast_df = pd.read_csv('https://dqlab-dataset.s3-ap-southeast-1.amazonaws.com/actor_name.csv')

      
                
                    
                    
                
            
director_writer_df = pd.read_csv('https://dqlab-dataset.s3-ap-southeast-1.amazonaws.com/directors_writers.csv')

Convertissez le nom des réalisateurs et des scénaristes en type de données de liste car certains films ont plus d'un réalisateur ou scénariste.

director_writer_df['director_name'] = director_writer_df['director_name'].apply(lambda row: row.split(','))
director_writer_df['writer_name'] = director_writer_df['writer_name'].apply(lambda row: row.split(','))

cast_df = cast_df[['nconst','primaryName','knownForTitles']]
cast_df.head()

cast_df['knownForTitles'].apply(lambda x: len(x.split(','))).unique()

cast_df['knownForTitles'] = cast_df['knownForTitles'].apply(lambda x: x.split(','))
cast_df.head()

df_uni = []
for x in ['knownForTitles']:
  idx = cast_df.index.repeat(cast_df['knownForTitles'].str.len())
  df1 = pd.DataFrame({
      x: np.concatenate(cast_df[x].values)
  })
  df1.index = idx
  df_uni.append(df1)
df_concat = pd.concat(df_uni, axis=1)
unnested_df = df_concat.join(cast_df.drop(['knownForTitles'], 1), how='left')
unnested_df = unnested_df[cast_df.columns.tolist()]
unnested_df.head()

unnested_drop = unnested_df.drop(['nconst'], axis=1)
df_uni = []
for col in ['primaryName']:
  dfi = unnested_drop.groupby(['knownForTitles'])[col].apply(list)
  df_uni.append(dfi)
df_grouped = pd.concat(df_uni, axis=1).reset_index()
df_grouped.columns = ['knownForTitles','cast_name']
df_grouped.head()

base_df = pd.merge(df_grouped, movie_rating_df, left_on='knownForTitles', right_on='tconst', how='inner')
base_df = pd.merge(base_df, director_writer_df, left_on='tconst', right_on='tconst', how='left')
base_df.head()

base_drop = base_df.drop(['knownForTitles'], axis=1)
base_drop.info()
base_drop['genres'] = base_drop['genres'].fillna('Unknown')
base_drop.isnull().sum()
base_drop[['director_name','writer_name']] = base_drop[['director_name','writer_name']].fillna('Unknown')

base_drop['genres'] = base_drop['genres'].apply(lambda x: x.split(','))

base_drop2 = base_drop.drop(['tconst','isAdult','endYear','originalTitle'], axis=1)
base_drop2 = base_drop2[['primaryTitle','titleType','startYear','runtimeMinutes','genres','averageRating','numVotes','cast_name','director_name','writer_name']]
base_drop2.columns = ['title','type','start','duration','genres','rating','votes','cast_name','director_name','writer_name']
base_drop2.head()

feature_df = base_drop2[['title','cast_name','genres','director_name','writer_name']]
feature_df.head()

Créez une fonction pour supprimer les espaces de chaque ligne et de chacun de ses éléments.

def sanitize(x):
  try:
    if isinstance(x, list):
      return [i.replace(' ','').lower() for i in x]
    else:
      return [x.replace(' ','').lower()]
  except:
    print(x)
feature_cols = ['cast_name','genres','writer_name','director_name']
for col in feature_cols:
  feature_df[col] = feature_df[col].apply(sanitize)

def soup_feature(x):
  return ' '.join(x['cast_name']) + ' ' + ' '.join(x['genres']) + ' ' + ' '.join(x['director_name']) + ' ' + ' '.join(x['writer_name'])
feature_df['soup'] = feature_df.apply(soup_feature, axis=1)

count = CountVectorizer(stop_words='english')
count_matrix = count.fit_transform(feature_df['soup'])
print(count)
count_matrix.shape

cosine_sim = cosine_similarity(count_matrix, count_matrix)
cosine_sim

indices = pd.Series(feature_df.index, index=feature_df['title']).drop_duplicates()
def content_recommender(title):
  idx = indices[title]
  sim_scores = list(enumerate(cosine_sim[idx]))
  sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
  sim_scores = sim_scores[1:11]
  movie_indices = [i[0] for i in sim_scores]
  return base_df.iloc[movie_indices]

content_recommender('The Lion King')

Le système de recommandation est un élément essentiel de l'Internet d'aujourd'hui. Il peut être mis en œuvre sous la forme d'un service en ligne, utilisé par les clients pour sélectionner des produits ou d'autres services. Ce système aide les entreprises à améliorer leurs ventes et la satisfaction de leurs clients en suggérant des produits susceptibles de les intéresser.