Einführung in die implizite Matrixfaktorisierung: Klassische ALS mit Sketchfab-Modellen

Im letzten Beitrag habe ich beschrieben, wie ich implizite Suggestions-Daten von der Web site gesammelt habe Skizzenfab. Ich habe dann behauptet, ich würde darüber schreiben, wie man mit diesen Daten tatsächlich ein Empfehlungssystem aufbaut. Nun, hier sind wir! Lasst uns bauen.

Ich denke, der beste Ausgangspunkt bei der Untersuchung impliziter Suggestions-Empfehlungen ist das Modell, das in dem klassischen Artikel „Kollaboratives Filtern für implizite Suggestions-Datensätze„“ von Koren et.al. (Warnung: PDF-Hyperlink). Ich habe in der Literatur und in Bibliotheken für maschinelles Lernen viele Namen für dieses Modell gesehen. Ich werde es Weighted Regularized Matrix Factorization (WRMF) nennen, ein Title, der ziemlich oft verwendet wird. WRMF ist wie der Klassiker der impliziten Matrixfaktorisierung. Es ist vielleicht nicht das angesagteste, aber es wird nie aus der Mode kommen. Und jedes Mal, wenn ich es verwende, weiß ich, dass mir das Ergebnis garantiert gefallen wird. Insbesondere ist dieses Modell intuitiv einigermaßen sinnvoll, es ist skalierbar und, was am wichtigsten ist, ich fand es leicht anzupassen. Es gibt viel weniger Hyperparameter als beispielsweise bei stochastischen Gradientenabstiegsmodellen.

Wenn Sie sich an meinen Beitrag erinnern, Explizite Suggestions-Matrix-Faktorisierunghatten wir eine Verlustfunktion (ohne Verzerrungen), die wie folgt aussah:

$$L_{exp} = sumlimits_{u,i in S}(r_{ui} – textbf{x}_{u}^{intercal} cdot{} textbf{y}_{i})^{2} + lambda_{x} sumlimits_{u} leftVert textbf{x}_{u} rightVert^{2} + lambda_{y} sumlimits_{u} leftVert textbf{y}_{i} rightVert^{2}$$

wobei $r_{ui}$ ein Component der Matrix der Benutzerelemente ist Bewertungen$textbf{x}_{u}$ ($textbf{y}_{i}$) sind die latenten Faktoren von Benutzer $u$ (Component $i$) und $S$ warfare die Menge aller Benutzer-Component-Bewertungen. WRMF ist einfach eine Modifikation dieser Verlustfunktion:

$$L_{WRMF} = sumlimits_{u,i}c_{ui} huge( p_{ui} – textbf{x}_{u}^{intercal} cdot{} textbf{y}_{i} huge) ^{2} + lambda_{x} sumlimits_{u} leftVert textbf{x}_{u} rightVert^{2} + lambda_{y} sumlimits_{u} leftVert textbf{y}_{i} rightVert^{2}$$

Hier summieren wir nicht über Elemente von $S$, sondern über unsere gesamte Matrix. Denken Sie daran, dass wir bei implizitem Suggestions keine Bewertungen mehr haben, sondern die Präferenzen der Benutzer für Elemente. In der WRMF-Verlustfunktion wurde die Bewertungsmatrix $r_{ui}$ durch eine Präferenzmatrix $p_{ui}$ ersetzt. Wir gehen davon aus, dass $p_{ui} = 1$ ist, wenn ein Benutzer überhaupt mit einem Component interagiert hat. Andernfalls ist $p_{ui} = 0$.

Der andere neue Time period in der Verlustfunktion ist $c_{ui}$. Wir nennen dies die Konfidenzmatrix und sie beschreibt grob, wie sicher wir sind, dass Benutzer $u$ tatsächlich die Präferenz $p_{ui}$ für Component $i$ hat. In dem Artikel ist eine der Konfidenzformeln, die die Autoren betrachten, linear in der Anzahl der Interaktionen. Wenn wir $d_{ui}$ als die Anzahl der Klicks eines Benutzers auf ein Component auf einer Web site annehmen, dann

$$c_{ui} = 1 + alpha d_{ui}$$

wobei $alpha$ ein durch Kreuzvalidierung ermittelter Hyperparameter ist. Im Fall der Sketchfab-Daten haben wir nur binäre „Likes“, additionally $d_{ui} in {0, 1}$

Um einen Schritt zurückzugehen: WRMF geht nicht davon aus, dass ein Benutzer, der nicht mit einem Artikel interagiert hat, nicht wie der Artikel. tut Nehmen wir an, dass der Benutzer eine destructive Präferenz gegenüber diesem Artikel hat, aber wir können über den Hyperparameter „Vertrauen“ wählen, wie sicher wir uns dieser Annahme sind.

Ich könnte jetzt die ganze Herleitung in blutigem Latex durchgehen, wie man diesen Algorithmus optimiert, wie in meinem vorherigen expliziten MF-Beitrag, aber andere Leute haben das schon viele Male getan. Hier ist ein großartiger StackOverflow Antwortoder, wenn Sie Ihre Ableitungen in Dirac-Notation mögen, dann schauen Sie sich Sudeep Das‘ Publish.

WRMF-Bibliotheken

Es gibt eine Reihe von Orten, an denen man Open-Supply-Code findet, der WRMF implementiert. Die beliebteste Methode zur Optimierung der Verlustfunktion ist die Methode der alternierenden kleinsten Quadrate. Diese Methode ist tendenziell weniger schwierig zu optimieren als der stochastische Gradientenabstieg, und das Modell ist peinlich parallel.

Der erste Code, den ich für diesen Algorithmus sah, stammte von Chris Johnsons repo. Dieser Code ist in Python, nutzt intestine dünn besetzte Matrizen und erledigt im Allgemeinen die Aufgabe. Thierry Bertin-Mahieux nahm dann diesen Code und parallelisiert es unter Verwendung der Python-Multiprocessing-Bibliothek. Dies sorgt für eine ordentliche Beschleunigung ohne Genauigkeitsverlust.

Die Leute bei Quora haben eine Bibliothek namens qmf das parallelisiert und in C++ geschrieben ist. Ich habe es nicht verwendet, aber es ist vermutlich schneller als die Multiprocessing-Python-Model. Schließlich schrieb Ben Frederickson parallelisierten Code in reinem Cython Hier. Dies übertrifft die anderen Python-Versionen in puncto Leistung um Längen und ist irgendwie Schneller als qmf (was seltsam erscheint).

Wie dem auch sei, ich habe für diesen Beitrag letztendlich Bens Bibliothek verwendet, weil (1) ich bei Python bleiben konnte und (2) es superschnell ist. Ich habe die Bibliothek geforkt und eine kleine Klasse geschrieben, um den Algorithmus zu umschließen, damit es einfach ist, Rastersuchen auszuführen und Lernkurven zu berechnen. Sie können sich gerne meinen Fork ansehen. Hierallerdings habe ich keine Assessments geschrieben, additionally verwenden Sie sie auf eigene Gefahr 🙂

Die Daten bearbeiten

Nachdem das nun erledigt ist, trainieren wir ein WRMF-Modell, damit wir endlich einige Sketchfab-Modelle empfehlen können!

Der erste Schritt besteht darin, die Daten zu laden und sie in eine Interaktionsmatrix der Größe „Anzahl der Benutzer“ mal „Anzahl der Elemente“ umzuwandeln. Die Daten werden derzeit als CSV-Datei gespeichert, wobei jede Zeile ein Modell bezeichnet, das einem Benutzer auf der Sketchfab-Web site „gefällt“. Die erste Spalte ist der Title des Modells, die zweite Spalte ist die eindeutige Modell-ID (mid) und die dritte Spalte ist die anonymisierte Benutzer-ID (uid).

Obwohl implizite Empfehlungen bei spärlichen Daten intestine funktionieren, kann es oft hilfreich sein, die Interaktionsmatrix etwas dichter zu gestalten. Wir haben unsere Datensammlung auf Modelle beschränkt, die mindestens 5 Likes hatten. Es ist jedoch nicht unbedingt der Fall, dass jeder Benutzer mindestens 5 Modelle geliked hat. Lassen Sie uns nun Benutzer ausschließen, denen weniger als 5 Modelle gefallen haben. Dies könnte möglicherweise bedeuten, dass einige Modelle weniger als 5 Likes haben, nachdem diese Benutzer ausgeschlossen wurden. Wir müssen additionally abwechselnd Benutzer und Modelle ausschließen, bis sich die Lage stabilisiert hat.

Intestine, wir sind über 0,1%, was für anständige Empfehlungen ausreichen sollte. Wir müssen jetzt jeden uid Und mid in eine Zeile bzw. Spalte für unsere Interaktionen oder „Likes“-Matrix. Dies kann einfach mit Python-Wörterbüchern erfolgen

Der letzte Schritt besteht darin, die Matrix tatsächlich zu erstellen. Wir werden dünn besetzte Matrizen verwenden, um nicht zu viel Speicher zu beanspruchen. Dünne Matrizen sind schwierig, da sie in vielen Formen vorkommen und zwischen ihnen große Leistungseinbußen bestehen. Unten finden Sie eine sehr langsame Möglichkeit, eine Likes-Matrix zu erstellen. Ich habe versucht, Folgendes auszuführen: %%timeit aber es hat mir langweilig gemacht, als ich darauf gewartet habe, dass es zu Ende geht.

Alternativ ist das Folgende verdammt schnell, wenn man bedenkt, dass wir eine Matrix mit einer halben Million Likes erstellen.

Kreuzvalidierung: Splitsville

Okay, wir haben eine Likes-Matrix und müssen sie in Trainings- und Testmatrizen aufteilen. Ich mache das ein bisschen trickreich (was ist vielleicht ein Wort?). Ich möchte später precision@okay als meine Optimierungsmetrik verfolgen. Ein okay von 5 wäre schön. Wenn ich jedoch für einige der Benutzer 5 Elemente vom Coaching zum Check verschiebe, haben sie möglicherweise keine Daten mehr im Trainingssatz (denken Sie daran, dass sie mindestens 5 Likes hatten). Daher sucht train_test_split nur nach Personen, die mindestens 2*okay (in diesem Fall 10) Likes haben, bevor einige ihrer Daten in den Testsatz verschoben werden. Dies verzerrt unsere Kreuzvalidierung offensichtlich in Richtung Benutzer mit mehr Likes. So geht das.

Kreuzvalidierung: Rastersuche

Nachdem die Daten nun in Trainings- und Testmatrizen aufgeteilt sind, führen wir eine riesige Rastersuche durch, um unsere Hyperparameter zu optimieren. Wir haben vier Parameter, die wir optimieren möchten:

1. num_factors: Die Anzahl der latenten Faktoren oder der Grad der Dimensionalität in unserem Modell.
2. regularization: Maßstab der Regularisierung für Benutzer- und Artikelfaktoren.
3. alpha: Unser Begriff zur Skalierung des Vertrauens.
4. iterations: Anzahl der Iterationen zum Ausführen der Alternating Least Squares-Optimierung.

Ich werde den mittleren quadratischen Fehler (MSE) und die Präzision bei okay (p@okay) verfolgen, aber mir geht es hauptsächlich um Letzteres. Ich habe unten einige Funktionen geschrieben, die bei der Berechnung der Metriken helfen und dafür sorgen, dass der Ausdruck des Trainingsprotokolls intestine aussieht. Ich werde eine Reihe von Lernkurven berechnen (d. h. Leistungsmetriken in verschiedenen Phasen des Trainingsprozesses auswerten) für eine Reihe verschiedener Hyperparameterkombinationen. Ein Lob an scikit-learn dafür, dass es Open Supply ist und ich im Grunde ihren GridSearchCV-Code abschreiben durfte.

Bitte beachten Sie, dass das folgende Parameterraster verdammt groß ist und auf meinem 6 Jahre alten 4-Core i5 etwa 2 Tage zum Ausführen benötigte. Es stellte sich heraus, dass die Funktionen für die Leistungsmetriken tatsächlich ein gutes Stück langsamer sind als der Trainingsprozess. Diese Funktionen könnten einfach parallelisiert werden – etwas, das ich zu einem späteren Zeitpunkt tun werde.

Das Trainingsprotokoll ist unglaublich lang, aber klicken Sie einfach Hier und probier es aus. Ansonsten hier der Ausdruck des besten Laufs:

alpha: 50 | num_factors: 40 | regularization: 0.1
+------------+------------+------------+------------+------------+
|   epochs   | p@okay practice  |  p@okay take a look at  | mse practice  |  mse take a look at  |
+============+============+============+============+============+
|     2      |  0.33988   |  0.02541   |  0.01333   |  0.01403   |
+------------+------------+------------+------------+------------+
|     4      |  0.31395   |  0.03916   |  0.01296   |  0.01377   |
+------------+------------+------------+------------+------------+
|     6      |  0.30085   |  0.04231   |  0.01288   |  0.01372   |
+------------+------------+------------+------------+------------+
|     8      |  0.29175   |  0.04231   |  0.01285   |  0.01370   |
+------------+------------+------------+------------+------------+
|     10     |  0.28638   |  0.04407   |  0.01284   |  0.01370   |
+------------+------------+------------+------------+------------+
|     12     |  0.28684   |  0.04492   |  0.01284   |  0.01371   |
+------------+------------+------------+------------+------------+
|     14     |  0.28533   |  0.04571   |  0.01285   |  0.01371   |
+------------+------------+------------+------------+------------+
|     16     |  0.28389   |  0.04689   |  0.01285   |  0.01372   |
+------------+------------+------------+------------+------------+
|     18     |  0.28454   |  0.04695   |  0.01286   |  0.01373   |
+------------+------------+------------+------------+------------+
|     20     |  0.28454   |  0.04728   |  0.01287   |  0.01374   |
+------------+------------+------------+------------+------------+
|     22     |  0.28409   |  0.04761   |  0.01288   |  0.01376   |
+------------+------------+------------+------------+------------+
|     24     |  0.28251   |  0.04689   |  0.01289   |  0.01377   |
+------------+------------+------------+------------+------------+
|     26     |  0.28186   |  0.04656   |  0.01290   |  0.01378   |
+------------+------------+------------+------------+------------+
|     28     |  0.28199   |  0.04676   |  0.01291   |  0.01379   |
+------------+------------+------------+------------+------------+
|     30     |  0.28127   |  0.04669   |  0.01292   |  0.01380   |
+------------+------------+------------+------------+------------+
|     32     |  0.28173   |  0.04650   |  0.01292   |  0.01381   |
+------------+------------+------------+------------+------------+
|     34     |  0.28153   |  0.04650   |  0.01293   |  0.01382   |
+------------+------------+------------+------------+------------+
|     36     |  0.28166   |  0.04604   |  0.01294   |  0.01382   |
+------------+------------+------------+------------+------------+
|     38     |  0.28153   |  0.04637   |  0.01295   |  0.01383   |
+------------+------------+------------+------------+------------+

Mal sehen, wie die Lernkurve für unseren besten Lauf aussieht.

Obwohl die Kurve ein wenig gezackt ist, nimmt sie nicht zu stark ab, wenn wir unsere beste Epoche von 22 hinter uns lassen. Das bedeutet, dass wir bei der Implementierung eines frühzeitigen Stopps nicht übermäßig vorsichtig sein müssen (wenn wir p@okay als die einzige für uns relevante Kennzahl betrachten).

Wir können alle unsere Lernkurven darstellen und sehen, dass Unterschiede in den Hyperparametern definitiv einen Unterschied in der Leistung bewirken.

Erstellen Sie eine Skizze

Nach all dem haben wir endlich einige optimale Hyperparameter. Wir könnten jetzt eine feinere Rastersuche durchführen oder uns ansehen, wie sich das Variieren des Verhältnisses zwischen Benutzer- und Elementregularisierungseffekten auswirkt, aber ich habe keine Lust, noch zwei Tage zu warten…

Wir trainieren nun ein WRMF-Modell auf alle unserer Daten mit den optimalen Hyperparametern und visualisieren einige Artikel-zu-Artikel-Empfehlungen. Benutzer-zu-Artikel-Empfehlungen sind etwas schwieriger zu visualisieren und ein Gefühl dafür zu bekommen, wie genau sie sein können.

Um Artikel-zu-Artikel-Empfehlungen zu erhalten, habe ich eine kleine Methode entwickelt predict_for_items im ALS Klasse. Dies ist im Wesentlichen nur ein Skalarprodukt zwischen allen Kombinationen von Elementvektoren. Wenn Sie norm=True (Normal), dann wird dieses Skalarprodukt durch die Norm jedes Elementvektors normalisiert, was zur Kosinusähnlichkeit führt. Dies sagt uns, wie ähnlich sich zwei Elemente im eingebetteten oder latenten Raum sind.

    def predict_for_items(self, norm=True):
        """Suggest merchandise for all merchandise"""
        pred = self.item_vectors.dot(self.item_vectors.T)
        if norm:
            norms = np.array((np.sqrt(np.diagonal(pred))))
            pred = pred / norms / norms.T
        return pred

Lassen Sie uns nun einige der Modelle und die zugehörigen Empfehlungen visualisieren, um ein Gefühl dafür zu bekommen, wie intestine unser Empfehlungssystem funktioniert. Wir können einfach die Sketchfab-API abfragen, um die Miniaturansichten der Modelle abzurufen. Unten finden Sie eine Hilfsfunktion, die die Elementähnlichkeiten, einen Index und den Index-zu- verwendet.mid Mapper, um eine Liste der Miniaturansicht-URLs der Empfehlungen zurückzugeben. Beachten Sie, dass die erste Empfehlung immer das Modell selbst ist, da es eine Kosinusähnlichkeit von 1 mit sich selbst aufweist.

Wir können die Bilder jetzt mit etwas HTML und Core anzeigen IPython Funktionen.

Auch wenn die Empfehlungen möglicherweise nicht perfekt sind (siehe Polizeiauto + grünes Monster oben), ist es offensichtlich, dass unser Empfehlungsmodell Ähnlichkeiten gelernt hat.

Machen Sie einen Schritt zurück und denken Sie einen Second darüber nach:

Unser Algorithmus weiß nichts darüber, wie diese Fashions aussehen, welche Tags sie möglicherweise haben oder irgendetwas über die Künstler. Der Algorithmus weiß lediglich, welche Benutzer welche Fashions geliked haben. Ziemlich gruselig, oder?

Was kommt als nächstes?

Heute haben wir die gewichtete, regulierte Matrixfaktorisierung gelernt, den Klassiker der impliziten MF. Das nächste Mal lernen wir eine andere Methode zur Optimierung impliziter Suggestions-Modelle kennen, die „Studying to Rank“ heißt. Mit „Studying to Rank“-Modellen können wir zusätzliche Informationen über die Modelle und Benutzer einbeziehen, z. B. die den Modellen zugewiesenen Kategorien und Tags. Danach werden wir sehen, wie sich eine unüberwachte Empfehlung mit Bildern und vorab trainierten neuronalen Netzwerken im Vergleich zu diesen Methoden schlägt, und schließlich werden wir eine Flask-App erstellen, um diese Empfehlungen einem Endbenutzer bereitzustellen.

Bleiben Sie dran!