Python-Basisüberprüfungsliste Dies ist die einzige Grundüberprüfung von Python ~ 1 ~ Python, Grundlagen, Überprüfung, Grammatik, lassen Sie Python die langweiligen Dinge tun Empfehlung mit Python Seit der zweiten Hälfte dieses Jahres, als das Fundament implementiert wurde, hat die Häufigkeit von Plattierungsaktualisierungen abgenommen, aber dies ist das erste Update seit langer Zeit. Der Artikel in Letztes Mal ist älter als 3 Monate und der Artikel mit viel Lagerbestand wird als vor mehr als einem Jahr angezeigt, Qiitas Notation ( Ich vergesse (≒ Markdown), es ist miserabel ...
Dieses Mal werde ich Co-Filtering (Empfehlung) in Python schreiben.
Allerdings gibt es im Januar dieses Jahres einen Artikel in Ruby. Bitte beziehen Sie sich auch darauf.
Verwendet dieselben Daten wie im vorherigen Artikel (http://qiita.com/ynakayama/items/ceb3f6408231ea3d230c).
Wir haben eine Person, die in der Firmencafeteria einer Firma A zu Mittag gegessen hat, gebeten, für die Eindrücke der letzten 10 Tage eine perfekte Punktzahl von 5,0 zu vergeben.
Die Bewertungen für jedes Menü waren wie folgt. Das Menü, das ich noch nie gegessen habe, ist-.
| Name | Curry | Ramen | Gebratener Reis | Sushi | Rindfleischschale | Udon |
|---|---|---|---|---|---|---|
| Herr Yamada | 2.5 | 3.5 | 3.0 | 3.5 | 2.5 | 3.0 |
| Tanaka-san | 3.0 | 3.5 | 1.5 | 5.0 | 3.0 | 3.5 |
| Herr Sato | 2.5 | 3.0 | -- | 3.5 | -- | 4.0 |
| Herr Nakamura | -- | 3.5 | 3.0 | 4.0 | 2.5 | 4.5 |
| Herr Kawamura | 3.0 | 4.0 | 2.0 | 3.0 | 2.0 | 3.0 |
| Suzuki | 3.0 | 4.0 | -- | 5.0 | 3.5 | 3.0 |
| Herr Shimobayashi | -- | 4.5 | -- | 4.0 | 1.0 | -- |
Jeder hat unterschiedliche Geschmackspräferenzen und es scheint, dass dasselbe Menü je nach Person höhere oder niedrigere Werte aufweist.
Bereiten Sie zunächst die Daten in einer Form vor, die von Python verarbeitet werden kann, und nennen Sie sie empfehle_data.py.
dataset = {
'Yamada': {'Curry': 2.5,
'Ramen': 3.5,
'Gebratener Reis': 3.0,
'Sushi': 3.5,
'Rindfleischschale': 2.5,
'Udon': 3.0},
'Tanaka': {'Curry': 3.0,
'Ramen': 3.5,
'Gebratener Reis': 1.5,
'Sushi': 5.0,
'Udon': 3.0,
'Rindfleischschale': 3.5},
'Sato': {'Curry': 2.5,
'Ramen': 3.0,
'Sushi': 3.5,
'Udon': 4.0},
'Nakamura': {'Ramen': 3.5,
'Gebratener Reis': 3.0,
'Udon': 4.5,
'Sushi': 4.0,
'Rindfleischschale': 2.5},
'Kawamura': {'Curry': 3.0,
'Ramen': 4.0,
'Gebratener Reis': 2.0,
'Sushi': 3.0,
'Udon': 3.0,
'Rindfleischschale': 2.0},
'Suzuki': {'Curry': 3.0,
'Ramen': 4.0,
'Udon': 3.0,
'Sushi': 5.0,
'Rindfleischschale': 3.5},
'Shimobayashi': {'Ramen': 4.5,
'Rindfleischschale': 1.0,
'Sushi': 4.0}}
Lesen wir die Daten aus Empfehlung_data.py oben und zeigen sie in Python an.
from recommendation_data import dataset
from math import sqrt
print(("Bewertung von Mr. Yamadas Curry: {}".format(
dataset['Yamada']['Curry'])))
print(("Bewertung von Herrn Yamadas Udon: {}\n".format(
dataset['Yamada']['Udon'])))
print(("Bewertung von Mr. Satos Curry: {}".format(
dataset['Sato']['Curry'])))
print(("Bewertung von Herrn Satos Udon: {}\n".format(
dataset['Sato']['Udon'])))
print("Suzukis Bewertung: {}\n".format((dataset['Suzuki'])))
#=>Bewertung von Mr. Yamadas Curry: 2.5
#=>Bewertung von Herrn Yamadas Udon: 3.0
#=>Bewertung von Mr. Satos Curry: 2.5
#=>Bewertung von Herrn Satos Udon: 4.0
#=>Suzukis Bewertung: {'Sushi': 5.0, 'Udon': 3.0, 'Curry': 3.0, 'Rindfleischschale': 3.5, 'Ramen': 4.0}
Es gibt verschiedene Ähnlichkeitsmaße. Unten finden Sie den Code zum Ermitteln der euklidischen Entfernung.
def similarity_score(person1, person2):
#Der Rückgabewert ist der euklidische Abstand zwischen Person1 und Person2
both_viewed = {} #Holen Sie sich Elemente, die beiden gemeinsam sind
for item in dataset[person1]:
if item in dataset[person2]:
both_viewed[item] = 1
#Gibt 0 zurück, wenn Sie kein gemeinsames Element haben
if len(both_viewed) == 0:
return 0
#Euklidische Entfernungsberechnung
sum_of_eclidean_distance = []
for item in dataset[person1]:
if item in dataset[person2]:
sum_of_eclidean_distance.append(
pow(dataset[person1][item] - dataset[person2][item], 2))
total_of_eclidean_distance = sum(sum_of_eclidean_distance)
return 1 / (1 + sqrt(total_of_eclidean_distance))
print("Ähnlichkeit zwischen Herrn Yamada und Herrn Suzuki(Euklidische Entfernung)",
similarity_score('Yamada', 'Suzuki'))
#=>Ähnlichkeit zwischen Herrn Yamada und Herrn Suzuki(Euklidische Entfernung) 0.3405424265831667
Unten finden Sie den Code zum Ermitteln des Pearson-Korrelationskoeffizienten. Es wird oft gesagt, dass in Situationen, in denen die Daten nicht normalisiert sind, bessere Ergebnisse als euklidische Abstände erzielt werden.
def pearson_correlation(person1, person2):
#Holen Sie sich beide Artikel
both_rated = {}
for item in dataset[person1]:
if item in dataset[person2]:
both_rated[item] = 1
number_of_ratings = len(both_rated)
#Sucht nach allgemeinen Elementen und gibt 0 zurück, wenn nicht
if number_of_ratings == 0:
return 0
#Fügen Sie alle Einstellungen für jeden Benutzer hinzu
person1_preferences_sum = sum(
[dataset[person1][item] for item in both_rated])
person2_preferences_sum = sum(
[dataset[person2][item] for item in both_rated])
#Berechnen Sie das Quadrat des bevorzugten Werts jedes Benutzers
person1_square_preferences_sum = sum(
[pow(dataset[person1][item], 2) for item in both_rated])
person2_square_preferences_sum = sum(
[pow(dataset[person2][item], 2) for item in both_rated])
#Berechnen und summieren Sie die Bewertungen zwischen Benutzern für jeden Artikel
product_sum_of_both_users = sum(
[dataset[person1][item] * dataset[person2][item] for item in both_rated])
#Pearson Score Berechnung
numerator_value = product_sum_of_both_users - \
(person1_preferences_sum * person2_preferences_sum / number_of_ratings)
denominator_value = sqrt((person1_square_preferences_sum - pow(person1_preferences_sum, 2) / number_of_ratings) * (
person2_square_preferences_sum - pow(person2_preferences_sum, 2) / number_of_ratings))
if denominator_value == 0:
return 0
else:
r = numerator_value / denominator_value
return r
print("Ähnlichkeit zwischen Herrn Yamada und Herrn Tanaka(Pearson-Korrelationskoeffizient)",
(pearson_correlation('Yamada', 'Tanaka')))
#=>Ähnlichkeit zwischen Herrn Yamada und Herrn Tanaka(Pearson-Korrelationskoeffizient) 0.39605901719066977
Wir suchen die Top 3 Leute, die ähnliche Essenspräferenzen wie Herr Yamada haben.
def most_similar_users(person, number_of_users):
#Gibt ähnliche Benutzer und deren Ähnlichkeit zurück
scores = [(pearson_correlation(person, other_person), other_person)
for other_person in dataset if other_person != person]
#Sortieren Sie so, dass die Person mit der höchsten Ähnlichkeit an erster Stelle steht
scores.sort()
scores.reverse()
return scores[0:number_of_users]
print("Die besten 3 Leute wie Mr. Yamada",
most_similar_users('Yamada', 3))
#=>Die besten 3 Leute wie Mr. Yamada[(0.9912407071619299, 'Shimobayashi'), (0.7470178808339965, 'Suzuki'), (0.5940885257860044, 'Kawamura')]
Abschließend möchte ich Herrn Shimobayashi ein empfohlenes Menü empfehlen.
def user_reommendations(person):
#Suchen Sie nach Empfehlungen aus Rankings nach gewichteten Durchschnittswerten anderer Benutzer
totals = {}
simSums = {}
for other in dataset:
#Vergleiche mich nicht
if other == person:
continue
sim = pearson_correlation(person, other)
#Werte unter Null ignorieren
if sim <= 0:
continue
for item in dataset[other]:
#Anzahl der Artikel, die Sie noch nicht haben
if item not in dataset[person] or dataset[person][item] == 0:
# Similrity *Ergebnis
totals.setdefault(item, 0)
totals[item] += dataset[other][item] * sim
#Summe der Ähnlichkeit
simSums.setdefault(item, 0)
simSums[item] += sim
#Erstellen Sie eine normalisierte Liste
rankings = [(total / simSums[item], item)
for item, total in list(totals.items())]
rankings.sort()
rankings.reverse()
#Empfohlene Artikel zurückgeben
recommendataions_list = [
recommend_item for score, recommend_item in rankings]
return recommendataions_list
print("Empfohlenes Menü für Herrn Shimobayashi",
user_reommendations('Shimobayashi'))
#=>Empfohlenes Menü für Herrn Shimobayashi['Udon', 'Curry', 'Gebratener Reis']
Der Quellcode für diesen Artikel lautet hier.
Die kooperative Filterung kann grob in objektbasierte und benutzerbasierte Methoden unterteilt werden. Einen Kommentar mit spezifischem Code finden Sie in Kapitel 2 von "Aggregate Knowledge Programming". Dieser Artikel folgt diesem.
Wenn Sie systematisch über den Algorithmus des Empfehlungssystems Bescheid wissen möchten, ist der folgende Artikel in Journal der Gesellschaft für künstliche Intelligenz von Toshihiro Kamishima persönlich. Es ist leicht zu verstehen und zu empfehlen.
Toshihiro Kamishima:Empfehlungssystem Algorithmus(1),Zeitschrift der Gesellschaft für Künstliche Intelligenz, vol.22, no.6, pp.826-837, 2007.
Toshihiro Kamishima:Empfehlungssystem Algorithmus(2),Zeitschrift der Gesellschaft für Künstliche Intelligenz, vol.23, no.1, pp.89-103, 2008.
Toshihiro Kamishima:Empfehlungssystem Algorithmus(3),Zeitschrift der Gesellschaft für Künstliche Intelligenz, vol.23, no.2, pp.248-263, 2008.
Wenn Sie keine Umgebung zum Lesen von Artikeln haben, lesen Sie den Kommentar zum Empfehlungssystem auf der Website des Autors, da er fast den gleichen Inhalt hat. ..
Beim Schreiben dieses Artikels verweise ich auf das obige Dokument Group Knowledge Programming und die folgenden Artikel. collaborative filtering recommendation engine implementation in python http://dataaspirant.com/2015/05/25/collaborative-filtering-recommendation-engine-implementation-in-python/
Recommended Posts