[PYTHON] [Empfehlung] Zusammenfassung der Vor- und Nachteile der inhaltsbasierten und kooperativen Filter- / Implementierungsmethode

Dies ist ein Lernprotokoll, in dem die Stärken, Schwächen und Implementierungsmethoden der kooperativen Filterung und inhaltsbasierten (inhaltsbasierten) Filterung des empfohlenen Algorithmus zusammengefasst werden. Ich habe zuvor die Cooperative Filtering Recommendation Engine entwickelt, daher möchte ich eine inhaltsbasierte Empfehlungs-Engine entwickeln. (･ ㅂ ･) و

Vor- und Nachteile von inhaltsbasiertem und Co-Filtern

■ Liste der Stärken und Schwächen

• Diese Tabelle stammt aus Kommentarartikel "Algorithmus des Empfehlungssystems", der von Professor Toshihiro Kamishima im Journal der Gesellschaft für künstliche Intelligenz serialisiert wurde.

Beschreibung des Algorithmus

■ Was ist kooperative Filterung? Es ist eine Methode, die basierend auf dem Aktionsverlauf des Elementbenutzers empfohlen wird. Die Funktion "Leute, die dieses Produkt gekauft haben, haben auch dieses Produkt" von Amazon ist berühmt. Empfehlung durch Co-Filterung ist eine Methode, um Empfehlungen basierend auf dem Benutzerverhalten abzugeben.

■ Was ist inhaltsbasierte (inhaltsbasierte) Filterung? Es ist eine Methode, um die Ähnlichkeit nach dem Merkmalsvektor des Elements zu sortieren und zu empfehlen. Dies gilt, wenn die Geschäfte angezeigt werden, die mit dem vom Benutzer auf der Gourmet-Website eingegebenen Schlüsselwort "Shinjuku / Ethnic Cuisine" verknüpft sind. Inhaltsbasierte Empfehlungen sind eine Methode, um Empfehlungen basierend auf den Merkmalen des Elements abzugeben.

Über die Details der Eigenschaften

■ Vielfalt Zusammenarbeit: o Inhaltsbasiert: x Informationen, die nicht im Produktinhalt beschrieben sind, werden nicht auf Inhaltsbasis empfohlen. Bei der Co-Filterung werden jedoch Informationen durch andere Benutzer empfohlen, sodass Sie Informationen empfehlen können, die Sie nicht kennen.

■ Domänenwissen Zusammenarbeit: o Inhaltsbasiert: x Durch kooperatives Filtern können Sie Empfehlungen über den Verhaltensverlauf anderer Benutzer abgeben, ohne Informationen oder Kenntnisse über das Zielelement zu haben. Andererseits ist es in der Inhaltsbasis wichtig, die Merkmale des Elements in den Merkmalsvektor umzuwandeln.

■ Startproblem Kooperation: x Inhaltsbasis: △ Die kooperative Filterung kann nicht in Situationen verwendet werden, in denen sich keine anderen Benutzer im neuen System befinden oder in denen es schwierig ist, ein Benutzerprofil zu erhalten. Inhaltlich ist es möglich, Empfehlungen abzugeben, selbst in Situationen, in denen es nicht möglich ist, ein Benutzerprofil zu erhalten, solange die Eigenschaften des Artikels erhalten werden können.

■ Anzahl der Benutzer Kooperation: x Inhaltsbasis: o Durch die Co-Filterung können Sie keine Elemente bewerten, die noch niemand bewertet hat. Auf der anderen Seite ist es inhaltlich möglich, Empfehlungen basierend auf den Merkmalen abzugeben, auch wenn keine Benutzer vorhanden sind.

■ Abdeckung Kooperation: x Inhaltsbasis: o Wie bei der Anzahl der Benutzer kann die Co-Filterung keine Elemente bewerten, die noch niemand bewertet hat. Daher ist es nicht möglich, Empfehlungen für alle Produkte abzugeben.

■ Ähnliche Artikel Kooperation: x Inhaltsbasis: o Eine kooperative Filterung, bei der die Eigenschaften von Gegenständen überhaupt nicht berücksichtigt werden, kann beispielsweise verschiedene Farben von Bechern nicht unterscheiden. Sie können das Problem unterschiedlicher Farben vermeiden, indem Sie Elemente abschneiden, die inhaltlich zu ähnlich sind.

■ Minderheitsbenutzer Kooperation: x Inhaltsbasis: o Auf kollaborativer Basis können ähnliche Elemente nicht vorhergesagt und nicht empfohlen werden, wenn die Anzahl der Benutzer eines bestimmten Elements extrem gering ist. Inhaltlich können Sie Empfehlungen entsprechend den Eigenschaften des Artikels abgeben.

Berechnungsmethode für die inhaltsbasierte Filterähnlichkeit

Sobald die Elementmerkmale extrahiert und vektorisiert sind, kann die Ähnlichkeit durch Kosinusähnlichkeit berechnet werden. Wenn Sie die Ähnlichkeit zwischen den Produkten X und den Produkten A-F berechnen und sortieren, können Sie Empfehlungen durch inhaltsbasierte Filterung abgeben.

Nachgedruckt: Fünf beliebtesten Implementierungen von Ähnlichkeitsmaßnahmen in Python

CosineSimilarity

# -*- coding: utf-8 -*-
from math import sqrt


def similarity(tfidf1, tfidf2):
    """
    Get Cosine Similarity
    cosθ =A / B./|A||B|
    :param tfidf1: list[list[str, float]]
    :param tfidf2: list[list[str, float]]
    :rtype : float
    """
    tfidf2_dict = {key: value for key, value in tfidf2}

    ab = 0  #A / B.
    for key, value in tfidf1:
        value2 = tfidf2_dict.get(key)
        if value2:
            ab += float(value * value2)

    # |A| and |B|
    a = sqrt(sum([v ** 2 for k, v in tfidf1]))
    b = sqrt(sum([v ** 2 for k, v in tfidf2]))

    return float(ab / (a * b))

So implementieren Sie inhaltsbasierte Filterung

[Ich gehe jetzt](https://ja.wikipedia.org/wiki/%E4%BB%8A%E3%81%84%E3%81%8F%E3%82%88%E3%83%BB % E3% 81% 8F% E3% 82% 8B% E3% 82% 88) Meister und [Korokoro Chiki Chiki Peppers](https://ja.wikipedia.org/wiki/%E3%82%B3%E3%83% AD% E3% 82% B3% E3% 83% AD% E3% 83% 81% E3% 82% AD% E3% 83% 81% E3% 82% AD% E3% 83% 9A% E3% 83% 83% E3% 83% 91% E3% 83% BC% E3% 82% BA) Eine morphologische Analyse wurde durchgeführt, um Nomen zu extrahieren, und die Anzahl der häufigen Nomenklaturen / die Gesamtzahl der Nomenklaturen wurde als Merkmalsvektor verwendet. Diese Methode heißt TF-IDF.

# -*- coding: utf-8 -*-
from math import sqrt


def similarity(tfidf1, tfidf2):
    """
    Get Cosine Similarity
    cosθ =A / B./|A||B|
    :param tfidf1: list[list[str, float]]
    :param tfidf2: list[list[str, float]]
    :rtype : float
    """
    tfidf2_dict = {key: value for key, value in tfidf2}

    ab = 0  #A / B.
    for key, value in tfidf1:
        value2 = tfidf2_dict.get(key)
        if value2:
            ab += float(value * value2)

    # |A| and |B|
    a = sqrt(sum([v ** 2 for k, v in tfidf1]))
    b = sqrt(sum([v ** 2 for k, v in tfidf2]))

    return float(ab / (a * b))

#Ich gehe jetzt, Kuruyo-Meister
ikuyo_kuruyo = [
    ['Kyoto', 0.131578947369],
    ['Mansai', 0.122807017544],
    ['Komödie', 0.122807017544],
    ['Radio', 0.105263157894],
    ['Yoshimoto Kogyo', 0.09649122807],
    ['Entertainer', 0.09649122807],
    ['ich werde gehen', 0.0701754385966],
    ['Kombination', 0.0701754385966],
    ['Osaka', 0.0526315789474],
    ['Meister', 0.0438596491229],
    ['Nach oben', 0.0438596491229],
    ['Kao', 0.0438596491229],
]


#Korochiki
chikichiki = [
    ['Komödie', 0.169014084507],
    ['Nishino', 0.12676056338],
    ['Osaka', 0.112676056338],
    ['Nadal', 0.0845070422536],
    ['Kombination', 0.0845070422536],
    ['Gewinner', 0.0704225352114],
    ['Korokoro Chiki Chiki Paprika', 0.0704225352114],
    ['Neta', 0.0704225352114],
    ['Entertainer', 0.056338028169],
    ['Yoshimoto Kogyo', 0.056338028169],
    ['Mansai', 0.056338028169],
    ['König von Conte', 0.0422535211267],
]

#Berechnung der Ähnlichkeit
print similarity(ikuyo_kuruyo, chikichiki)

"""
>>>Ausführungsergebnis
0.521405857242
"""

Vorteile der Implementierung einer inhaltsbasierten Filterung mit Cosinus-Ähnlichkeit

Wenn Sie eine inhaltsbasierte Filterung mit Feature-Vektoren implementieren, können Sie diese leicht widerspiegeln, indem Sie einen Vektor hinzufügen, wenn Sie die Gewichtung ändern möchten, was einen flexiblen Betrieb ermöglicht. Fügen wir beispielsweise 20% der Funktion "DVD" hinzu, um die Ähnlichkeit zu erhöhen.

#Ich gehe jetzt, Kuruyo-Meister
ikuyo_kuruyo = [
    ['DVD', 0.2],
    ['Kyoto', 0.131578947369],
    ['Mansai', 0.122807017544],
...
]


#Korochiki
chikichiki = [
    ['DVD', 0.2],
    ['Komödie', 0.169014084507],
    ['Nishino', 0.12676056338],
...
]

#Berechnung der Ähnlichkeit
print similarity(ikuyo_kuruyo, chikichiki)

"""
>>>Ausführungsergebnis
0.661462974013
"""

Es gibt eine Bibliothek

PyPi hat eine Bibliothek simple_tfidf_japanese veröffentlicht, die die Anzahl der Nomen mit der TF-IDF-Funktion berechnet, die Sätze im Web morphologisch analysiert und die Cosinus-Ähnlichkeit berechnet. .. Da die Implementierung 142 Zeilen umfasst, können Sie Quellcode in kurzer Zeit lesen.

simple_tfidf_Implementiert mit Japanisch

# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
from simple_tfidf_japanese.tfidf import TFIDF

ikuyo_wikipedia_url = 'https://ja.wikipedia.org/wiki/%E4%BB%8A%E3%81%84%E3%81%8F%E3%82%88%E3%83%BB%E3%81%8F%E3%82%8B%E3%82%88'
korochiki_wikipedia_url = 'https://ja.wikipedia.org/wiki/%E3%82%B3%E3%83%AD%E3%82%B3%E3%83%AD%E3%83%81%E3%82%AD%E3%83%81%E3%82%AD%E3%83%9A%E3%83%83%E3%83%91%E3%83%BC%E3%82%BA'
ikuyo_tfidf = TFIDF.gen_web(ikuyo_wikipedia_url)
chiki_tfidf = TFIDF.gen_web(korochiki_wikipedia_url)

#Ähnlichkeitsberechnung
print TFIDF.similarity(ikuyo_tfidf, chiki_tfidf)

Ähnlichkeitsberechnungsmethode und Implementierungsmethode der Co-Filterung

Es gibt mehrere Möglichkeiten, die Ähnlichkeit der Co-Filterung zu berechnen. Dieses Mal werde ich ein Beispiel für die Verwendung des gemeinsamen Auftretens und des Jackard-Index vorstellen.

■ Beispieldaten

■ Koop Berechnet basierend auf der Anzahl der anderen Produkte, die der Kunde, der Produkt X gekauft hat, gekauft hat. Es ist weniger genau als der Jackard-Index, aber leicht zu berechnen. Wenn Sie beispielsweise den Wert für das gleichzeitige Auftreten von Produkt X und Produkt A berechnen, beträgt der Wert für das gleichzeitige Auftreten "1", da nur Kunde E beide Produkte gekauft hat. Das Merkmal ist, dass die Berechnungszeit etwas kurz ist.

■ So berechnen Sie den Jackard-Index

Berechnen Sie die Anzahl durch gleichzeitiges Auftreten und Aufbocken

# -*- coding: utf-8 -*-
from __future__ import absolute_import
from __future__ import unicode_literals
from collections import defaultdict


def jaccard(e1, e2):
    """
Berechnen Sie den Jackard-Index
    :param e1: list of int
    :param e2: list of int
    :rtype: float
    """
    set_e1 = set(e1)
    set_e2 = set(e2)
    return float(len(set_e1 & set_e2)) / float(len(set_e1 | set_e2))

#Die Kunden-ID des gekauften Produkts X lautet 1,3,5
product_x = [1, 3, 5]
product_a = [2, 4, 5]
product_b = [1, 2, 3]
product_c = [2, 3, 4, 7]
product_d = [3]
product_e = [4, 6, 7]

#Produktdaten
products = {
    'A': product_a,
    'B': product_b,
    'C': product_c,
    'D': product_d,
    'E': product_e,
}

#Berechnen Sie den Wert für das gleichzeitige Auftreten mit X.
print "Koop"
r = defaultdict(int)

for key in products:
    overlap = list(set(product_x) & set(products[key]))
    r[key] = len(overlap)
print r

#Berechnen Sie den Jackard-Index mit X.
print "Jackard Index"
r2 = defaultdict(float)
for key in products:
    r2[key] = jaccard(product_x, products[key])
print r2

Ausführungsergebnis

"""
>>> python cf.py
Koop
defaultdict(<type 'int'>, {u'A': 1, u'C': 1, u'B': 2, u'E': 0, u'D': 1})
Jackard Index
defaultdict(<type 'float'>, {u'A': 0.2, u'C': 0.16666666666666666, u'B': 0.5, u'E': 0.0, u'D': 0.3333333333333333})
"""

■ Zusammenfassung der Ergebnisse Im Vergleich zum gleichzeitigen Auftreten kann der Jackard-Index die Ähnlichkeit zwischen Produkt X und den Produkten A, C, D detaillierter berechnen. Die Berechnungskosten sind entsprechend hoch.

Referenz

Algorithmus des Empfehlungssystems Ich habe eine kooperative Filterung (Empfehlung) mit Redis und Python implementiert