Lassen Sie uns kurz einen Algorithmus für die "kooperative Filterung" in Python schreiben Die kooperative Filterung ist ein sogenannter "Menschen, die dies sehen, sehen auch diesen" -Mechanismus.
Es ist ein sehr einfacher Algorithmus, den Sie also nicht für irgendetwas verwenden können, aber es kann Ihnen helfen, leicht zu verstehen, wie ein Co-Filter-Algorithmus funktioniert.
Wenn Sie den Code in diesem Artikel tatsächlich schreiben, werden Sie verstehen, dass die Logik von ** "Menschen, die dies sehen, sehen dies auch" ** nicht so esoterisch im Konzept ist.
Der in diesem Artikel verwendete Code basiert auf dieser Site. Diejenigen, die gerne Englisch lesen, können die ursprüngliche Website lesen.
Hier sind einige andere Websites, die nützlich sind, um das Konzept des Empfehlungssystems zu untersuchen. Besonders Courseras Vortrag wird empfohlen
Lassen Sie uns über einen Algorithmus nachdenken, der einen empfohlenen Film für einen bestimmten Benutzer A empfiehlt. Was der Algorithmus zu diesem Zeitpunkt tut, ist zur Vereinfachung wie folgt.
Schritt ① Dieser Benutzer und andere Benutzer**Ähnlichkeitsgrad**Berechnen
↓
Schritt ② Extrahieren Sie eine Reihe von Filmen, die Benutzer A noch nicht gesehen hat, aus den Filmen, die andere Benutzer gesehen haben.
↓
Schritt ③ Geben Sie eine Liste der empfohlenen Filme aus diesen Filmen zurück.
In dieser Auswahl ist das Gewicht umso höher, je ähnlicher der Film vom Benutzer angesehen wird.
package.py
from math import sort
Die hier verwendeten Daten enthalten die von einigen Filmliebhabern angesehenen Filme und die Ergebnisse ihrer Rezensionen (Partituren) im Wörterbuchformat.
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
}
}
Bei der Co-Filterung wird zunächst die "Ähnlichkeit zwischen Benutzern" berechnet. Der Punkt beim Entwerfen des Algorithmus ist hier, wie ** "einige Benutzer sind ähnlich oder unähnlich" ** definiert werden.
Es gibt unzählige Definitionen dafür, abhängig von den Wünschen des Designers. Hier definieren wir es als "je mehr Benutzer dem gleichen Film eine ähnliche Punktzahl geben" und "je höher die Ähnlichkeit".
In diesem Fall kann eine Funktion, die die Ähnlichkeit zwischen "Benutzern (Person1, Person2)" berechnet, wie folgt implementiert werden.
similarity.py
def get_similairty(person1, person2):
##Nehmen Sie eine Reihe von Filmen, die beide gesehen haben
set_person1 = set(dataset[person1].keys())
set_person2 = set(dataset[person2].keys())
set_both = set_person1.intersection(set_person2)
if len(set_both)==0: #Wenn Sie keinen gemeinsamen Film gesehen haben, setzen Sie die Ähnlichkeit auf 0
return 0
list_destance = []
for item in set_both:
#Berechnen Sie das Quadrat der Differenz zwischen den Überprüfungspunkten desselben Films
#Je größer diese Zahl, desto mehr "Ich mag es nicht"=Kann als "nicht ähnlich" definiert werden
distance = pow(dataset[person1][item]-dataset[person2][item], 2)
list_destance.append(distance)
return 1/(1+sqrt(sum(list_destance))) #Gibt einen inversen Index der Gesamtbeschwerden jedes Films zurück
Hier werden die folgenden Zahlen als Ähnlichkeit definiert
Ähnlichkeit = `1 / (1 + sqrt (sum (list_destance)))` ... (1)
Beachten Sie, dass "sum (list_destance)" das Quadrat der Entfernung zwischen Benutzern im Bewertungsbereich ist. Je größer dieser Abstand ist, desto ähnlicher wird "ähnlich" ausgedrückt, so dass (1) den Grad von "ähnlich" angibt. Wenn der Abstand "0" ist, ist der Ähnlichkeitsgrad 1, und wenn der Abstand extrem groß ist, nähert sich der Ähnlichkeitsgrad 0.
get_similairty('Lisa Rose','Jack Matthews')
0.3405424265831667
Empfehlungsdesign und Implementierungsideen sind in den Kommentaren geschrieben
recomend.py
def get_recommend(person, top_N):
totals = {} ; simSums = {} #Machen Sie ein Kästchen, um die Empfehlungsbewertung zu setzen
#Holen Sie sich eine Liste anderer Benutzer als Sie selbst und drehen Sie die For-Anweisung
# ->Berechnung der Ähnlichkeit mit jeder Person und der Empfehlungsbewertung des Films von jeder Person (noch nicht von der Person gesehen)
list_others = dataset.keys() ; list_others.remove(person)
for other in list_others:
#Holen Sie sich eine Reihe von Filmen, die er noch nicht gesehen hat
set_other = set(dataset[other]); set_person = set(dataset[person])
set_new_movie = set_other.difference(set_person)
#Berechnen Sie die Ähnlichkeit zwischen einem Benutzer und der Person(sim ist 0~Nummer 1)
sim = get_similairty(person, other)
# (Ich habe es noch nicht gesehen)Drehen Sie die For-Anweisung in der Liste der Filme
for item in set_new_movie:
# "Ähnlichkeit x Bewertungsergebnis"Wird als Empfehlungsstufe für alle Benutzer verwendet.
totals.setdefault(item,0)
totals[item] += dataset[other][item]*sim
#Speichern Sie auch den integrierten Wert der Benutzerähnlichkeit und teilen Sie die obige Punktzahl durch diese.
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