[PYTHON]

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.

Originale Daten

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.

Erstellung von Originaldaten

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}}

Datenverarbeitung

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}

Implementierung der Co-Filterung

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

Berechnen Sie die Ähnlichkeit

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')]

Suchen Sie ein empfohlenes Menü

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']

schließlich

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