――Dies ist ein einführender Artikel, in dem Sie mithilfe einer Bibliothek schnell den Algorithmus für Faktorisierungsmaschinen ausprobieren können, der in den letzten Jahren in der Empfehlungstechnologie Aufmerksamkeit erregt hat. ――Es ist keine theoretische Erklärung, sondern ein Artikel zum Bewegen. ―― Befolgen Sie grundsätzlich das Tutorial + Ergänzung.

Verschiedene Referenzmaterialien

Diesmal habe ich eine Bibliothek namens fastFM verwendet. Darüber hinaus werden die Erläuterungen und die Leistung dieser Bibliothek auf arXiv veröffentlicht.

Für diejenigen, die die Umrisse und Trends von Faktorisierungsmaschinen kennenlernen möchten, gibt es Referenzartikel innerhalb und außerhalb von Qiita, daher werde ich einige davon veröffentlichen. Die folgenden Bücher sind auch für fastFM verfügbar. Grob gesagt handelt es sich um einen Algorithmus, der "die Matrixzerlegung verwendet, um eine Regression, Klassifizierung und Rangfolge durchzuführen, die gegenüber spärlichen Daten stark ist".

Referenzinformationen --Qiita: Ich habe nach Faktorisierungsmaschinen gesucht
Neueste Trends bei Deep Factorization Machines (2018)
Bücher: Maschinelles Lernen ab der Arbeit

Hauptgeschichte

Einführung

Es gibt Notizen. In meiner eigenen Umgebung war es wie folgt.

Für Python 3.6.10.

Kann mit pip install fastFM installiert werden

Für Python 3.7.6

Bei der Installation von pip ist ein Fehler aufgetreten. -Kann mit Von der in GitHub beschriebenen Quelle installieren betrieben werden.

Installieren Sie für neue Umgebungen von der Quelle aus, erstellen Sie eine Umgebung, in der mehrere Pythons wie pyenv ausgeführt und 3.6-Serien eingeführt werden können, oder erstellen Sie eine 3.6-Umgebung mit Docker usw. Ich denke, es wird.

Beispieldaten

Wenn es um FM-Stichproben (Factorization Machines) geht, werden meiner Meinung nach häufig Stichproben vom Typ Wörterbuch für Beispieldaten verwendet.

[
{user:A, item:X, ...},
{user:B, item:Y, ...}, ...
]

Mögen. Es scheint, dass solche Daten oft für spärliche Daten eingegeben werden, aber dieses Mal möchte ich sie unter der Annahme einer einfachen CSV behandeln.

`Beispiel-Dummy-Daten`


Kategorie,rating,is_A,is_B,is_C,is_X,is_Y,is_Z
A,5,0,0,1,0,1,0
A,1,1,0,0,0,0,1
B,2,0,1,0,0,0,0
B,5,0,0,0,0,1,0
C,1,1,0,0,0,0,1
C,4,0,0,0,0,1,0
...

Ich werde alle Versionen unten setzen. Der Wert ist ein Dummy, der entsprechend erstellt wurde.

Spalte "Kategorie" mit Informationen zur Kategorie
"Bewertungs" -Säule mit 5 Noten von 1 bis 5 --is_? Spalte mit Flag-Informationen Stellen Sie sich eine Flagge vor, die ein Produkt gekauft hat, oder eine Flagge, die Benutzerattribute angibt.

Wird angenommen.

Verarbeitungsflussbestätigung mit Regressionsanalyse

Die Nutzung der Bibliothek selbst ist einfach und denjenigen bekannt, die Scicit-Learn usw. verwendet haben. Lassen Sie uns zunächst einen Verarbeitungsablauf mit einer einfachen Regressionsanalyselogik erstellen. Die Details sind fehlerhaft, aber die allgemeine Modellerstellung scheint wie folgt zu sein.

Daten lesen
Vorverarbeitung (Daten in ein Format konvertieren, das zum Modell passt)
Unterteilt in "Trainingsdaten" (, "Validierungsdaten") und "Testdaten"
Erstellen Sie ein Modell mit Trainingsdaten
Modell auf Testdaten anwenden
Definieren und bewerten Sie Leistungsbewertungsindikatoren

Dieses Mal werde ich ein Regressionsmodell mit dem Thema ** Bewertung ** erstellen. (Aus Gründen der Übersichtlichkeit importiere ich jedes Mal, aber Sie können alles oben importieren.)

Daten gelesen

import numpy as np
import pandas as pd

#CSV-Daten lesen
raw = pd.read_csv('fm_sample.csv')

#Separate Zielspalten und andere Informationen
target_label = "rating"

data_y = raw[target_label]
data_X = raw.drop(target_label, axis=1)

Datenaufteilung vor der Verarbeitung

#Vorverarbeitung
##Praktische Datenverarbeitungsbibliothek für Kategorien, Scikit-Nutzen Sie die praktischen Funktionen des Lernens
import category_encoders as ce

##Eine für die angegebene Spalte-Hot-Codierung
enc = ce.OneHotEncoder(cols=['Kategorie'])

X = enc.fit_transform(data_X)
y = data_y

#Datenaufteilung
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=810)

Modellierungsbewertung

Die Bewertung ist MAE (durchschnittlicher absoluter Fehler), aber MSE usw. können schnell berechnet werden.

from sklearn import linear_model
from sklearn.metrics import mean_squared_error, mean_absolute_error

#Modellieren
reg = linear_model.LinearRegression()
reg.fit(X_train, y_train)

#Auswertung
##Anwendbarkeit auf Trainingsdaten
mean_absolute_error(y_train, reg.predict(X_train))
##Testdatenfehler
mean_absolute_error(y_test, reg.predict(X_test))

Ich denke es wird so sein. Natürlich würde ich im Bewertungsteil mehr tun, z. B. die berechnete Regressionslinie zeichnen und sehen, wie der Fehler abweicht, aber diesmal, bis ich ihn verschiebe.

Rückgabe per FM

Wenn der obige Ablauf ausgeführt werden kann, ist der Rest abgeschlossen, wenn der Berechnungsteil in die diesmal zu verwendende fastFM-Spezifikation aufgenommen wird. Ein zu beachtender Punkt ist, dass ** DataFrame nicht so behandelt werden kann, wie es ist, daher wird csr_matrix verwendet **.

Modellierungsbewertung

from fastFM import als
from scipy.sparse import csr_matrix

#Modellieren
fm = als.FMRegression(n_iter=1000, init_stdev=0.1, rank=8, l2_reg_w=0.5, l2_reg_V=0.5, random_state=810)
fm.fit(csr_matrix(X_train), y_train)

#Auswertung
##Anwendbarkeit auf Trainingsdaten
mean_absolute_error(y_train, fm.predict(csr_matrix(X_train)))
##Testdatenfehler
mean_absolute_error(y_test, fm.predict(csr_matrix(X_test)))

Sparse Matrix, csr_matrix

Hier kommt die csr_matrix. Es handelt sich um spärliche Daten. Das Bild ist einfach und wenn DataFrame oder eine normale Matrix zweidimensionale Daten wie folgt verarbeitet:

`matrix`


array([
  [0, 0, 1],
  [0, 0, 0],
  [0, 3, 0]
])

Es wird nur der Teil behandelt, der die Daten enthält

`Umgang mit spärlichen Daten`


Größe: 3 x 3
Wo es Daten gibt:
([0,2]1 am Punkt)
([2,1]3 am Punkt)

Es ist ein Bild wie. Es gibt verschiedene Arten der Handhabung, wie z. B. csr_matrix, coo_matrix, csc_matrix, lil_matrix, und es scheint, dass die Handhabungs- und Verarbeitungsgeschwindigkeit unterschiedlich sind. Wenn Sie also interessiert sind, suchen Sie bitte mit "scipy sparse matrix" usw. note.nkmk.me und so weiter.

Woran man sich diesmal erinnern sollte

Beispiel für die Konvertierung von DataFrame: csr_matrix (df) --konvertieren von csr_matrix in eine Matrix Todense Beispiel: csr_matrix (X_train) .todense ()

Ich frage mich, ob.

Klassifizierung nach FM

Eine binäre Klassifizierung ist ebenfalls möglich, daher werde ich es versuchen. Dieses Mal werde ich die Aufgabe übernehmen, 2 Klassen mit einer Bewertung von 4 oder mehr oder weniger zu erraten. Nach dem Teil der Datenverarbeitung vor der Verarbeitung wird das Modell erstellt und ausgewertet, nachdem die Antwortdaten erstellt wurden, um festzustellen, ob die Bewertung 4 oder höher ist. Beachten Sie auch, dass die fastFM-Klassifizierung "-1 oder 1" anstelle von "0 oder 1" verwendet.

from fastFM import sgd
from sklearn.metrics import roc_auc_score

#Die Vorverarbeitung wurde fortgesetzt
##1 wenn 4 oder mehr sonst-Auf 1 setzen
y_ = np.array([1 if r > 3 else -1 for r in y])

##Erstellung von Trainingsdaten / Testdaten
X_train, X_test, y_train, y_test = train_test_split(X, y_, random_state=810)

#Modellieren
fm = sgd.FMClassification(n_iter=5000, init_stdev=0.1, l2_reg_w=0,
                          l2_reg_V=0, rank=2, step_size=0.1)
fm.fit(csr_matrix(X_train), y_train)

##Es scheint, dass Sie zwei Arten von vorhergesagten Werten erhalten können.
y_pred = fm.predict(csr_matrix(X_test))
y_pred_proba = fm.predict_proba(csr_matrix(X_test))

#Auswertung
##Beispiel für die Bewertung des AUC-Werts
roc_auc_score(y_test, y_pred_proba)

Zeichnen Sie die ROC-Kurve

Ich werde die ROC-Kurve unter Bezugnahme auf die Seite von note.nkmk.me schreiben. ..

fpr, tpr, thresholds = metrics.roc_curve(y_test, y_pred_proba, drop_intermediate=False)

auc = metrics.auc(fpr, tpr)

#Zeichnen Sie die ROC-Kurve
plt.plot(fpr, tpr, label='ROC curve (area = %.2f)'%auc)
plt.legend()
plt.title('ROC curve')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.grid(True)
plt.show()

Ich konnte es schaffen.

andere

Fügen Sie unten die Beispieldaten ein. Es ist richtig gemacht, also sind es keine interessanten Daten. Bitte überprüfen Sie den Betrieb.

`fm_sample.csv`


Kategorie,rating,is_A,is_B,is_C,is_X,is_Y,is_Z
A,5,0,0,1,0,1,0
A,1,1,0,0,0,0,1
A,3,0,0,1,0,1,0
A,2,1,0,0,0,0,1
A,4,0,0,0,0,0,1
A,5,1,0,0,1,1,0
A,1,0,1,0,0,0,1
A,2,0,0,0,0,0,1
B,2,0,1,0,0,0,0
B,5,0,0,0,0,1,0
B,3,1,1,0,0,1,0
B,2,0,0,1,0,0,0
B,1,0,0,0,0,0,1
B,3,0,0,1,0,0,1
B,4,0,1,0,0,0,0
B,1,0,0,0,0,0,1
B,2,0,1,0,0,0,1
C,1,1,0,0,0,0,1
C,4,0,0,0,0,1,0
C,2,1,0,1,0,1,0
C,4,0,0,0,0,0,0
C,5,0,0,1,1,1,0
C,2,0,1,0,0,0,1
C,5,1,0,0,0,1,0
C,3,0,0,1,1,1,0
C,2,0,0,0,0,0,1
C,3,0,0,0,0,1,0
A,2,0,0,0,0,0,1
A,4,1,0,0,0,1,0
A,3,0,0,0,0,0,0
A,1,0,0,0,0,0,1
A,3,1,0,0,0,0,0
A,4,0,0,1,0,1,0
A,5,1,1,0,0,1,0
A,3,1,0,0,1,0,0
B,4,0,0,0,0,1,0
B,1,0,0,0,0,0,1
B,5,0,0,0,0,1,0
B,3,0,0,0,0,0,0
B,1,0,0,0,1,0,1
B,3,0,0,1,0,0,0
B,2,0,1,0,0,0,1
B,5,1,0,0,0,1,0
B,4,0,0,0,1,1,1
C,1,0,0,0,0,0,0
C,2,0,0,0,0,0,1
C,3,0,0,1,0,0,0
C,4,0,1,0,0,1,0
C,1,0,0,1,0,0,1
C,1,0,0,0,0,0,0
C,3,0,0,1,0,0,0
C,3,0,0,1,0,1,0
C,5,0,0,0,1,1,0
C,3,0,0,1,0,1,0

[PYTHON] Ein Beispiel, um Faktorisierungsmaschinen schnell mit fastFM auszuprobieren

Verschiedene Referenzmaterialien

Hauptgeschichte

Einführung

Für Python 3.6.10.

Für Python 3.7.6

Beispieldaten

Beispiel-Dummy-Daten

Verarbeitungsflussbestätigung mit Regressionsanalyse

Daten gelesen

Datenaufteilung vor der Verarbeitung

Modellierungsbewertung

Rückgabe per FM

Modellierungsbewertung

Sparse Matrix, csr_matrix

matrix

Umgang mit spärlichen Daten

Klassifizierung nach FM

Zeichnen Sie die ROC-Kurve

andere

fm_sample.csv

`Beispiel-Dummy-Daten`

`matrix`

`Umgang mit spärlichen Daten`

`fm_sample.csv`