Wie hilft Matrix-Zerlegung, eine spärliche Nutzen-/Bewertungsmatrix für neue Benutzer auszufüllen?

Question

Dies ist mein erster Versuch, maschinell zu lernen. Ich schreibe eine sehr einfache Empfehlungs-Engine, die den Yelp-Datensatz verwendet. Es ist in Python geschrieben mit Pandas und numpy Bibliotheken für (Datenverarbeitung). Ich habe die Daten zuerst auf Restaurants (Millionen) reduziert, dann auf Restaurants in Vegas (Tausende), dann nur Restaurants mit 3,5 Sternen oder höher mit über 50 Bewertungen (Hunderte). Auch habe ich die Nutzer auf diejenigen beschränkt, die mindestens 20% der Restaurants überprüft haben. Endlich bin ich in einer Bewertungsmatrix angekommen, die 100 Benutzer bei 1800 Restaurants hat.

Allerdings finde ich es immer noch zu spärlich, (relativ) nützliche Empfehlungen zu geben. Das Ziel besteht darin, auf kollaborationsbasierter Filterung basierend auf dem Item-Item die Vektorentfernung unter Verwendung der Kosinusähnlichkeit zu verwenden.

Ich habe gelesen über den Umgang mit dünn besetzten Matrizen und der Konsens scheint zu Matrixfaktorisierung zu verwenden. Es scheint jedoch, dass die meisten dieser Lesungen aktuelle Benutzer betreffen und die Matrixfaktorisierung als den Algorithmus verwenden, der die Empfehlung für gegenwärtige Benutzer antreibt, während das Problem der Seltenheit als ein Nebenprodukt gelöst wird. Stimmt mein Verständnis hier? Nach was ich suche, ist eine Methode, die das sparsity Problem zuerst löst und dann Cosinus-Vektorabstände verwendet, um die Empfehlung zu führen.

Wenn Zersetzung ist in der Tat der Weg zu gehen: Was sklearn.decomposition Methode sollte ich verwenden, d. H. PCA, SVD, NMF?

[[ 3, 0, 0, ..., 0, 0, 0], 
[ 0, 0, 0, ..., 0, 0, 0], 
[ 0, 0, 0, ..., 0, 4, 3], 
... 
[ 1, 0, 0, ..., 0, 0, 0], 
[ 0, 0, 0, ..., 0, 0, 2], 
[ 0, 0, 5, ..., 0, 1, 3]] 

(100 Benutzer X 1800 Restaurants)

Answer 1

die Menge der Bewertungen zu reduzieren, ist keine gute Lösung, die Genauigkeit Ihrer Empfehlung (zumindest direkt) zu verbessern. Sagte, dass Sparsity kein "großes" Problem ist. In der Tat sind Faktorisierungsalgorithmen für die Empfehlung entworfen, um mit dieser Art von Sparsitäten umzugehen, die gehen zu: 99%, 98%, 95% Sparsity.

Gegenwärtig liefert Matrixfaktorisierung die besten Ergebnisse und das Konzept ist ziemlich einfach. Darüber hinaus sind speicherbasierte CF-Ansätze (wie itembasiert, benutzerbasiert, ...) ineffizienter, weniger flexibel und weisen schlechtere Ergebnisse auf als die modellbasierten.

Die beliebtesten Algorithmen sind auf SVD basiert:

• Funks SVD (aka SVD, wenn auch nicht der wirkliche SVD ist Es ist eine Annäherung..)
• BRISMF (Biased regularisierten Version des Funks)
• SVD ++: BRISMF plus implizite Feedback-Informationen.
• timesSVD: SVD ++, dass auch Modelle der Datumzeit
• trustSVD: SVD ++, die Vertrauensinformationen (wie Freunde)

Die Grundlagen dieser Algorithmen besteht in umfasst:

1. einige Low erstellen -rank Matrizen und initialisieren sie zufällig
2. Berechnen Sie für jede Bewertung im Datensatz den Fehler in Bezug auf Ihre Vorhersage.
3. Aktualisieren Sie die Low-Rang Matrizen, die die Gradienten der Funktion, die Sie optimieren
4. Repeat

Python Beispiel (BRISMF):

# Initialize low-rank matrices (K is the number of latent factors) 
P = np.random.rand(num_users, K) # User-feature matrix 
Q = np.random.rand(num_items, K) # Item-feature matrix 

# Factorize R matrix using SGD 
for step in range(steps): 

    # Compute predictions 
    for k in range(0, len(data)): 
     i = data.X[k, user_col] # Users 
     j = data.X[k, item_col] # Items 
     r_ij = data.Y[k] # rating(i, j) 

     # NOTE: For simplicity (here) I've considered the 
     # bias a standard deviation, but it should be 
     # learned for better accuracy. 
     bias = global_avg + std_user[i] + std_item[j] 

     # Make prediction and compute error 
     rij_pred = bias + np.dot(Q[j, :], P[i, :]) 
     eij = rij_pred - r_ij 

     # Update P and Q at the same time, they're dependents 
     tempP = alpha * 2 * (eij * Q[j, :] + beta * P[i, :]) 
     tempQ = alpha * 2 * (eij * P[i, :] + beta * Q[j, :]) 
     P[i] -= tempP 
     Q[j] -= tempQ 

Extra-:

• Für Geschwindigkeit Gründe (und Einfachheit des Codes), empfehle ich Ihnen, alles vektorisiert zu haben
• Versuchen Sie, Caches bei Bedarf zu erstellen. Der Zugriff in dünn besetzten Matrizen kann selbst bei korrekter Datenstruktur ziemlich langsam sein.
• Diese Algorithmen sind rechnerisch sehr teuer, so für einfache Versionen Sie 10s/iter in Datensätze von 1.000.000 Ratings nehmen erwarten
• Ich Orange3 Data Mining eine einfache Bibliothek für den Aufbau also, wenn Sie Sie können interessiert sind Schau mal: