Empfehlungssystem mit Matrixzerlegung [Unüberwachtes Lernen mit Python Kapitel 10]

Was ist in diesem Artikel zu tun?

** - Einführung eines Empfehlungssystems unter Verwendung von Filmdatensätzen

• Implementierung des Filmbewertungs-Vorhersagesystems unter Verwendung der Matrixzerlegung **

Einführung

Beim letzten Mal habe ich die Erkennung von Anomalien durch den Auto-Encoder mithilfe von unbeaufsichtigtem Lernen eingeführt. https://qiita.com/nakanakana12/items/f238b9760af2c62fa0e8

Diese Methoden identifizieren jedoch nur neue Daten und können diese nicht generieren. Als nächstes werde ich das Modell vorstellen, das Daten generiert.

Solche Modelle möchten möglicherweise die Wahrscheinlichkeitsverteilung des Datensatzes lernen und Rückschlüsse auf Daten ziehen, die sie noch nie gesehen haben.

Nachschlagewerk ["Lernen ohne Lehrer durch Python"](URL https://www.amazon.co.jp/Python%E3%81%A7%E3%81%AF%E3%81%98%E3%82 % 81% E3% 82% 8B% E6% 95% 99% E5% B8% AB% E3% 81% AA% E3% 81% 97% E5% AD% A6% E7% BF% 92-% E2% 80% 95% E6% A9% 9F% E6% A2% B0% E5% AD% A6% E7% BF% 92% E3% 81% AE% E5% 8F% AF% E8% 83% BD% E6% 80% A7% E3% 82% 92% E5% BA% 83% E3% 81% 92% E3% 82% 8B% E3% 83% A9% E3% 83% 99% E3% 83% AB% E3% 81% AA% E3% 81% 97% E3% 83% 87% E3% 83% BC% E3% 82% BF% E3% 81% AE% E5% 88% A9% E7% 94% A8-Ankur-Patel / dp / 4873119103 Das Empfehlungssystem von wurde als Beispiel angegeben. In diesem Artikel werde ich zunächst ** "Evaluierungsvorhersagesystem durch Matrixzerlegung" ** vorstellen, was eine weit verbreitete Methode zu sein scheint.

Zu behandelnde Daten

Die verarbeiteten Daten sind ein Filmauswertungsdatensatz. Es heißt MovieLens 20M und besteht aus etwa 20.000.000 Bewertungen. Da die Gesamtdaten bis zu 200 MB groß sind, werden ** 1000 hoch bewertete Filme und Daten nur für 1000 zufällig ausgewählte Benutzer ** verarbeitet. Zu diesem Zeitpunkt beträgt die Anzahl der Bewertungen 90.000.

Klicken Sie hier für die verarbeiteten Daten https://drive.google.com/file/d/1mXioVp1LiBQt1TJyE9IStCCpjijpb4SX/view?usp=sharing

Hier können Sie die Originaldaten herunterladen. https://grouplens.org/datasets/movielens/20m/

Was ist Matrixzerlegung?

Im Empfehlungssystem wird häufig eine Methode verwendet, die als kooperatives Filtersystem bezeichnet wird. Dies ist ein System, das Empfehlungen basierend auf einem ähnlichen Benutzerverhalten abgibt. Netflix ist berühmt.

Eine Methode namens ** Co-Filtersystem ** wird häufig verwendet. Dies ist ein System, das Empfehlungen basierend auf einem ähnlichen Benutzerverhalten abgibt. Netflix ist berühmt. Bei Verwendung eines Co-Filtersystems treten jedoch Probleme auf, z. B. die Notwendigkeit einer großen Datenmenge und die Unfähigkeit, Ähnlichkeiten zwischen ähnlichen Filmelementen zu erkennen.

Hier wird ** Dimensionsreduktion durch Matrixzerlegung ** verwendet.

Hier ist eine supereinfache Übersicht. Das detaillierte Prinzip entnehmen Sie bitte dem Referenzartikel. Referenzartikel: Matrixfaktorisierung, Empfehlungen und ich https://qiita.com/michi_wkwk/items/52660778ad6a900965ee

Die Matrixzerlegung extrahiert zuerst die latenten Faktoren jedes Benutzers und jedes Films. Dieser latente Faktor bedeutet, die Eigenschaften jedes Benutzers zu vektorisieren.

Wenn ein Benutzer beispielsweise 1000 Filme bewertet hat, wird dieser Benutzer durch eine 1000-Matrix dargestellt.

** Drücken Sie diese Matrix fest zusammen, um die Abmessungen zu verringern. In der Abbildung sieht es so aus. In der Abbildung wird es auf k Spalten komprimiert. ** ** **

Durch Vorhersagen der Bewertung jedes Benutzerelements aus diesen komprimierten Daten ist es möglich, Vorhersagen mit weniger Daten zu treffen.

Bibliothek importieren

Es ist immer noch ein Nachschlagewerk.

python

'''Main'''
import numpy as np
import pandas as pd
import os, time, re
import pickle, gzip, datetime
from datetime import datetime

'''Data Viz'''
import matplotlib.pyplot as plt
import seaborn as sns
color = sns.color_palette()
import matplotlib as mpl

%matplotlib inline

'''Data Prep and Model Evaluation'''
from sklearn import preprocessing as pp
from sklearn.model_selection import train_test_split 
from sklearn.model_selection import StratifiedKFold 
from sklearn.metrics import log_loss
from sklearn.metrics import precision_recall_curve, average_precision_score
from sklearn.metrics import roc_curve, auc, roc_auc_score, mean_squared_error

'''Algos'''
import lightgbm as lgb

'''TensorFlow and Keras'''
# import tensorflow as tf
# import tensorflow as tf
import keras
from keras import backend as K
from keras.models import Sequential, Model
from keras.layers import Activation, Dense, Dropout
from keras.layers import BatchNormalization, Input, Lambda
from keras.layers import Embedding, Flatten, dot
from keras import regularizers
from keras.losses import mse, binary_crossentropy

sns.set("talk")

Daten lesen und prüfen

python

ratingDFX3 = pd.read_pickle(DATA_DIR + "data/datasets/movielens_data/ratingReducedPickle.pkl")

#Überprüfen Sie den Inhalt
n_users = ratingDFX3.userId.unique().shape[0]
n_movies = ratingDFX3.movieId.unique().shape[0]
n_ratings = len(ratingDFX3)
avg_ratings_per_user = n_ratings/n_users

print('Number of unique users: ', n_users)
print('Number of unique movies: ', n_movies)
print('Number of total ratings: ', n_ratings)
print('Average number of ratings per user: ', avg_ratings_per_user)
"""
Number of unique users:  1000
Number of unique movies:  1000
Number of total ratings:  90213
Average number of ratings per user:  90.213
"""

ratingDFX3.head()

Wenn Sie den Inhalt überprüfen, wird er wie folgt angezeigt. Bewertung ist die Bewertung, und newMovieID und newUserID sind die IDs, die für die Bewertung verwendet werden.

python

#Trennung von Trainingsdaten und Trainingsdaten
X_train, X_test = train_test_split(ratingDFX3, test_size=0.10, \
                                   shuffle=True, random_state=2018)

X_validation, X_test = train_test_split(X_test, test_size=0.50, \
                                        shuffle=True, random_state=2018)

Erstellen einer Bewertungsmatrix

Erstellen Sie zunächst eine Matrix aus movieID * userID. Da jeder Benutzer nur eine kleine Anzahl von Filmen bewertet, sind die meisten von ihnen 0 Warteschlangen. Darüber hinaus werden die Verifizierungsdaten in einer Zeile abgeflacht. Wir werden dies als Matrix für die Bewertung verwenden.

python

#Erstellen Sie eine Bewertungsmatrix, meistens eine Null-Sparse-Matrix
ratings_train = np.zeros((n_users,n_movies))
for row in X_train.itertuples():
  ratings_train[row[6]-1,row[5]-1] = row[3]

ratings_train.shape
#(1000,1000)

#Bewertungsmatrix für Validierungsdaten
ratings_validation = np.zeros((n_users, n_movies))
for row in X_validation.itertuples():
    ratings_validation[row[6]-1, row[5]-1] = row[3]

#Validierungsdaten reduzieren
actual_validation = ratings_validation[ratings_validation.nonzero()].flatten()

Grundeinstellungen

Die Bewertung verwendet den quadratischen Fehler der vorhergesagten Bewertung und der tatsächlichen Bewertung. Als Grundlage für die Bewertung

** "Was ist der Fehler, wenn alles auf 3.5 vorhergesagt wird?" **

Ich denke, dass.

python

#Voraussichtlicher Wert 3.Quadratischer Fehler bei Einstellung auf 5(MSE)Berechnen Sie anhand des Validierungssatzes
#Verwenden Sie dies als Basis

pred_validation = np.zeros((len(X_validation),1))
pred_validation[pred_validation==0] = 3.5

print("3.5 MSE:",mean_squared_error(pred_validation,actual_validation))
#3.5 MSE: 1.055420084238528

** Es wurde 1.055. Dies ist die Grundlinie einmal. ** ** **

Kann das Empfehlungssystem durch Matrixzerlegung dies überschreiten?

Vorhersage durch Matrixzerlegung

python

#Matrixzerlegung
#Benutzer- und Artikelabmessungen reduzieren und komprimieren

n_latent_factors = 3 #Latenter Faktor, in welcher Dimension eingebettet werden soll

#Erstellen einer keras-komprimierten Benutzerspalte
user_input = Input(shape=[1], name="user")
user_embedding = Embedding(input_dim=n_users+1, output_dim=n_latent_factors,name="user_embedding")(user_input)
user_vec = Flatten(name="flatten_users")(user_embedding)

#Erstellen einer mit Keras komprimierten Filmsequenz
movie_input = Input(shape=[1], name='movie')
movie_embedding = Embedding(input_dim=n_movies + 1, \
                            output_dim=n_latent_factors,
                            name='movie_embedding')(movie_input)
movie_vec = Flatten(name='flatten_movies')(movie_embedding)


product = dot([movie_vec, user_vec], axes=1)
model = Model(inputs=[user_input, movie_input], outputs=product)
model.compile('adam', 'mean_squared_error')

history = model.fit(x=[X_train.newUserId, X_train.newMovieId], \
                    y=X_train.rating, epochs=30, \
                    validation_data=([X_validation.newUserId, \
                    X_validation.newMovieId], X_validation.rating), \
                    verbose=1)

Überprüfen Sie das berechnete Ergebnis.

python

pd.Series(history.history['val_loss'][10:]).plot(logy=False)
plt.xlabel("Epoch")
plt.ylabel("Validation Error")
print('Minimum MSE: ', min(history.history['val_loss']))
#Minimum MSE:  0.7946764826774597

** Bei Verwendung der Matrixzerlegung beträgt sie 0,794, was kleiner als die Grundlinie von 1,055 ist. ** ** ** Daraus ist ersichtlich, dass das Bewertungsvorhersagesystem durch Matrixzerlegung gut funktioniert.

Wenn Sie damit einen Film vorschlagen, den die Evaluierungsbenutzer noch nicht evaluiert haben, der jedoch hoch evaluiert zu sein scheint, kann ein Empfehlungssystem erstellt werden.

Am Ende

Dieses Mal habe ich ein Bewertungsvorhersagesystem durch Matrixzerlegung eingeführt, wenn das Thema ein Filmempfehlungssystem ist.

Aber die wahre Kraft des unbeaufsichtigten Lernens ist

** "Unüberwachtes Generationsmodell" **

Es ist in. Ich möchte weiter lernen und bis dahin zusammenkommen.

Referenzartikel

Matrixfaktorisierung, Empfehlungen und ich https://qiita.com/michi_wkwk/items/52660778ad6a900965ee