Écrivons brièvement un algorithme pour le filtrage coopératif en Python
Le filtrage coopératif est ce que l'on appelle le mécanisme «les gens qui voient cela voient aussi ce mécanisme».
C'est un algorithme très simple, donc ce n'est pas quelque chose que vous pouvez réellement utiliser pour quoi que ce soit, mais cela peut vous aider à comprendre facilement comment travailler un algorithme de co-filtrage.
Si vous écrivez réellement le code dans cet article, vous comprendrez que la logique de ** "Les gens qui voient cela voient aussi ceci" ** n'est pas si ésotérique dans son concept.
Le code utilisé dans cet article est basé sur ce site. Ceux qui savent lire l'anglais peuvent lire le site original.
Voici quelques autres sites utiles pour étudier le concept du système de recommandation. La conférence de Coursera est particulièrement recommandée
Pensons à un algorithme qui recommande un film recommandé pour un certain utilisateur A. Ce qui est fait par l'algorithme à ce moment est comme suit en simplification.
étape ① Cet utilisateur et d'autres utilisateurs**Degré de similitude**Calculer
↓
étape② Extrayez un ensemble de films que l'utilisateur A n'a pas encore regardés à partir des films que d'autres utilisateurs ont regardés.
↓
étape③ Renvoyez une liste de films hautement recommandés à partir de ces films.
Dans cette sélection, plus le film est visionné de manière similaire par l'utilisateur, plus le poids est élevé.
package.py
from math import sort
Les données utilisées ici contiennent les films regardés par certains cinéphiles et les résultats de leurs critiques (scores) dans un format de dictionnaire.
dataset.py
dataset={
'Lisa Rose': {
'Lady in the Water': 2.5, 'Snakes on a Plane': 3.5, 'Just My Luck': 3.0, 'Superman Returns': 3.5,'You, Me and Dupree': 2.5, 'The Night Listener': 3.0
},
'Gene Seymour': {
'Lady in the Water': 3.0, 'Snakes on a Plane': 3.5, 'Just My Luck': 1.5, 'Superman Returns': 5.0, 'The Night Listener': 3.0, 'You, Me and Dupree': 3.5
},
'Michael Phillips': {
'Lady in the Water': 2.5, 'Snakes on a Plane': 3.0, 'Superman Returns': 3.5, 'The Night Listener': 4.0
},
'Claudia Puig': {
'Snakes on a Plane': 3.5, 'Just My Luck': 3.0, 'The Night Listener': 4.5, 'Superman Returns': 4.0, 'You, Me and Dupree': 2.5
},
'Mick LaSalle': {
'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0, 'Just My Luck': 2.0, 'Superman Returns': 3.0, 'The Night Listener': 3.0, 'You, Me and Dupree': 2.0
},
'Jack Matthews': {
'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0, 'The Night Listener': 3.0, 'Superman Returns': 5.0, 'You, Me and Dupree': 3.5
},
'Toby': {
'Snakes on a Plane':4.5, 'You, Me and Dupree':1.0, 'Superman Returns':4.0
}
}
Dans le co-filtrage, la «similitude entre les utilisateurs» est d'abord calculée. Le point dans la conception de l'algorithme ici est de savoir comment définir ** "certains utilisateurs sont similaires ou différents" **.
Il existe d'innombrables définitions pour cela, selon les souhaits du concepteur. Ici, nous le définissons comme «plus les utilisateurs attribuent au même film un score similaire» et «plus la similitude est élevée».
Dans ce cas, une fonction qui calcule la similitude entre «utilisateurs (personne1, personne2)» peut être implémentée comme suit.
similarity.py
def get_similairty(person1, person2):
##Prenez une série de films que les deux ont regardés
set_person1 = set(dataset[person1].keys())
set_person2 = set(dataset[person2].keys())
set_both = set_person1.intersection(set_person2)
if len(set_both)==0: #S'il n'y a pas de film que vous avez vu en commun, définissez la similitude sur 0
return 0
list_destance = []
for item in set_both:
#Calculez le carré de la différence entre les points de revue du même film
#Plus ce nombre est élevé, plus "je n'aime pas ça"=Peut être défini comme "pas similaire"
distance = pow(dataset[person1][item]-dataset[person2][item], 2)
list_destance.append(distance)
return 1/(1+sqrt(sum(list_destance))) #Renvoie un indice inverse de l'inconfort total de chaque film
Ici, les nombres suivants sont définis comme similitude
Similitude = 1 / (1 + sqrt (sum (list_destance))) `` ... (1)
Notez que sum (list_destance) est le carré de la distance entre les utilisateurs dans l'espace de notation de la revue.
Plus cette distance est grande, plus «similaire» est exprimé, donc (1) indique le degré de «similaire». Lorsque la distance est `0, le degré de similitude est 1, et lorsque la distance est extrêmement grande, le degré de similitude s'approche de 0.
get_similairty('Lisa Rose','Jack Matthews')
0.3405424265831667
Les idées de conception et de mise en œuvre des recommandations sont écrites dans les commentaires
recomend.py
def get_recommend(person, top_N):
totals = {} ; simSums = {} #Faire une boîte pour mettre le score de recommandation
#Obtenez une liste d'utilisateurs autres que vous-même et activez l'instruction For
# ->Pour calculer la similitude avec chaque personne et le score de recommandation du film de chaque personne (pas encore vu par la personne)
list_others = dataset.keys() ; list_others.remove(person)
for other in list_others:
#Obtenez une série de films qu'il n'a pas encore vus
set_other = set(dataset[other]); set_person = set(dataset[person])
set_new_movie = set_other.difference(set_person)
#Calculer la similitude entre un utilisateur et la personne(sim est 0~Nombre de 1)
sim = get_similairty(person, other)
# (Je ne l'ai pas encore vu)Activez l'instruction For dans la liste des films
for item in set_new_movie:
# "Note d'évaluation de Similarité x"Est utilisé comme score de niveau de recommandation pour tous les utilisateurs.
totals.setdefault(item,0)
totals[item] += dataset[other][item]*sim
#Enregistrez également la valeur intégrée de la similitude utilisateur et divisez le score ci-dessus par celui-ci.
simSums.setdefault(item,0)
simSums[item] += sim
rankings = [(total/simSums[item],item) for item,total in totals.items()]
rankings.sort()
rankings.reverse()
return [i[1] for i in rankings][:top_N]
get_recommend('Toby',2)
['The Night Listener', 'Lady in the Water']
Recommended Posts