🚀 Testen Sie Zilliz Cloud, die vollständig verwaltete Milvus, kostenlos – erleben Sie 10x schnellere Leistung! Jetzt testen>>

milvus-logo
LFAI
  • Home
  • Blog
  • Beschleunigte Kandidatengenerierung in Empfehlungssystemen mit Milvus in Verbindung mit PaddlePaddle

Beschleunigte Kandidatengenerierung in Empfehlungssystemen mit Milvus in Verbindung mit PaddlePaddle

  • Scenarios
November 26, 2021
Yunmei

Wenn Sie Erfahrung mit der Entwicklung eines Empfehlungssystems haben, sind Sie wahrscheinlich schon mindestens einem der folgenden Probleme zum Opfer gefallen:

  • Das System ist extrem langsam bei der Rückgabe von Ergebnissen aufgrund der enormen Menge an Datensätzen.
  • Neu eingegebene Daten können nicht in Echtzeit für die Suche oder Abfrage verarbeitet werden.
  • Der Einsatz des Empfehlungssystems ist entmutigend.

Dieser Artikel zielt darauf ab, die oben genannten Probleme anzugehen und Ihnen einige Einblicke zu geben, indem er ein Projekt für ein Produktempfehlungssystem vorstellt, das Milvus, eine Open-Source-Vektordatenbank, zusammen mit PaddlePaddle, einer Deep-Learning-Plattform, verwendet.

In diesem Artikel wird zunächst der minimale Arbeitsablauf eines Empfehlungssystems kurz beschrieben. Anschließend werden die Hauptkomponenten und die Implementierungsdetails dieses Projekts vorgestellt.

Der grundlegende Arbeitsablauf eines Empfehlungssystems

Bevor wir uns mit dem Projekt selbst befassen, werfen wir zunächst einen Blick auf den grundlegenden Arbeitsablauf eines Empfehlungssystems. Ein Empfehlungssystem kann personalisierte Ergebnisse entsprechend den individuellen Interessen und Bedürfnissen des Benutzers liefern. Um solche personalisierten Empfehlungen auszusprechen, durchläuft das System zwei Phasen: die Generierung von Kandidaten und das Ranking.

2.png 2.png

In der ersten Phase, der Kandidatengenerierung, werden die relevantesten oder ähnlichsten Daten ermittelt, wie z. B. ein Produkt oder ein Video, das dem Benutzerprofil entspricht. Während der Kandidatengenerierung vergleicht das System die Benutzereigenschaft mit den in seiner Datenbank gespeicherten Daten und ruft die ähnlichen Daten ab. Beim Ranking bewertet das System die abgerufenen Daten und ordnet sie neu an. Schließlich werden die Ergebnisse, die ganz oben auf der Liste stehen, den Benutzern angezeigt.

In unserem Fall eines Produktempfehlungssystems vergleicht es zunächst das Benutzerprofil mit den Merkmalen der Produkte im Bestand, um eine Liste von Produkten herauszufiltern, die den Bedürfnissen des Benutzers entsprechen. Dann bewertet das System die Produkte auf der Grundlage ihrer Ähnlichkeit mit dem Benutzerprofil, erstellt eine Rangliste und gibt dem Benutzer schließlich die 10 besten Produkte zurück.

3.png 3.png

Aufbau des Systems

Das Produktempfehlungssystem in diesem Projekt verwendet drei Komponenten: MIND, PaddleRec und Milvus.

MIND

MIND, kurz für "Multi-Interest Network with Dynamic Routing for Recommendation at Tmall", ist ein von der Alibaba Group entwickelter Algorithmus. Bevor MIND vorgeschlagen wurde, verwendeten die meisten der gängigen KI-Modelle für Empfehlungen einen einzigen Vektor, um die verschiedenen Interessen eines Nutzers darzustellen. Ein einzelner Vektor reicht jedoch bei weitem nicht aus, um die genauen Interessen eines Nutzers darzustellen. Daher wurde der MIND-Algorithmus vorgeschlagen, um die vielfältigen Interessen eines Nutzers in mehrere Vektoren umzuwandeln.

MIND verwendet ein Multi-Interest-Netzwerk mit dynamischem Routing, um die verschiedenen Interessen eines Nutzers in der Phase der Kandidatengenerierung zu verarbeiten. Das Multi-Interest-Netzwerk ist eine Schicht des Multi-Interest-Extraktors, die auf einem Kapsel-Routing-Mechanismus basiert. Es kann dazu verwendet werden, das frühere Verhalten eines Benutzers mit seinen verschiedenen Interessen zu kombinieren, um ein genaues Benutzerprofil zu erstellen.

Das folgende Diagramm veranschaulicht die Netzwerkstruktur von MIND.

4.png 4.png

Um die Eigenschaften von Nutzern darzustellen, nimmt MIND das Nutzerverhalten und die Nutzerinteressen als Eingaben und speist sie dann in die Einbettungsschicht ein, um Nutzervektoren zu erzeugen, einschließlich Vektoren der Nutzerinteressen und des Nutzerverhaltens. Anschließend werden die Vektoren des Nutzerverhaltens in die Multi-Interest-Extraktionsschicht eingespeist, um Nutzerinteressen-Kapseln zu erzeugen. Nach der Verkettung der Nutzerinteressen-Kapseln mit den Einbettungen des Nutzerverhaltens und der Verwendung mehrerer ReLU-Schichten zu deren Transformation gibt MIND mehrere Vektoren zur Nutzerrepräsentation aus. In diesem Projekt wurde festgelegt, dass MIND letztendlich vier Vektoren zur Nutzerrepräsentation ausgeben wird.

Auf der anderen Seite durchlaufen die Produkteigenschaften die Einbettungsschicht und werden in spärliche Item-Vektoren umgewandelt. Dann durchläuft jeder Item-Vektor eine Pooling-Schicht, um zu einem dichten Vektor zu werden.

Wenn alle Daten in Vektoren umgewandelt sind, wird eine zusätzliche markierungsbewusste Aufmerksamkeitsschicht eingeführt, um den Trainingsprozess zu steuern.

PaddleRec

PaddleRec ist eine groß angelegte Suchmodellbibliothek für Empfehlungen. Sie ist Teil des Baidu PaddlePaddle-Ökosystems. PaddleRec zielt darauf ab, Entwicklern eine integrierte Lösung zur Verfügung zu stellen, um ein Empfehlungssystem auf einfache und schnelle Weise zu erstellen.

5.png 5.png

Wie im ersten Absatz erwähnt, sehen sich Ingenieure, die Empfehlungssysteme entwickeln, oft mit den Herausforderungen einer schlechten Benutzerfreundlichkeit und einer komplizierten Bereitstellung des Systems konfrontiert. PaddleRec kann den Entwicklern jedoch in den folgenden Punkten helfen:

  • Benutzerfreundlichkeit: PaddleRec ist eine Open-Source-Bibliothek, die verschiedene in der Branche gängige Modelle kapselt, darunter Modelle für Kandidatengenerierung, Ranking, Reranking, Multitasking und mehr. Mit PaddleRec können Sie die Wirksamkeit des Modells sofort testen und seine Effizienz durch Iteration verbessern. PaddleRec bietet Ihnen eine einfache Möglichkeit, Modelle für verteilte Systeme mit hervorragender Leistung zu trainieren. Es ist für die Verarbeitung großer Datenmengen mit spärlichen Vektoren optimiert. Sie können PaddleRec problemlos horizontal skalieren und seine Rechengeschwindigkeit beschleunigen. Daher können Sie mit PaddleRec schnell Trainingsumgebungen auf Kubernetes aufbauen.

  • Unterstützung für die Bereitstellung: PaddleRec bietet Online-Bereitstellungslösungen für seine Modelle. Die Modelle sind nach dem Training sofort einsatzbereit und zeichnen sich durch Flexibilität und hohe Verfügbarkeit aus.

Milvus

Milvus ist eine Vektordatenbank mit einer Cloud-nativen Architektur. Sie steht auf GitHub als Open Source zur Verfügung und kann zum Speichern, Indizieren und Verwalten umfangreicher Einbettungsvektoren verwendet werden, die von tiefen neuronalen Netzen und anderen Modellen des maschinellen Lernens (ML) erzeugt werden. Milvus kapselt mehrere erstklassige ANN-Suchbibliotheken (Approximate Nearest Neighbour), darunter Faiss, NMSLIB und Annoy. Sie können Milvus auch je nach Bedarf skalieren. Der Milvus-Dienst ist hochverfügbar und unterstützt eine einheitliche Batch- und Stream-Verarbeitung. Milvus hat sich zum Ziel gesetzt, den Prozess der Verwaltung unstrukturierter Daten zu vereinfachen und eine konsistente Benutzererfahrung in verschiedenen Einsatzumgebungen zu bieten. Milvus verfügt über die folgenden Merkmale:

  • Hohe Leistung bei der Durchführung von Vektorsuchen in großen Datensätzen.

  • Eine auf Entwickler ausgerichtete Community, die mehrsprachige Unterstützung und Toolchain bietet.

  • Skalierbarkeit in der Cloud und hohe Zuverlässigkeit auch im Falle einer Störung.

  • Hybride Suche durch Kombination von skalarer Filterung und vektorieller Ähnlichkeitssuche.

Milvus wird in diesem Projekt für die Vektorähnlichkeitssuche und das Vektormanagement verwendet, da es das Problem der häufigen Datenaktualisierungen lösen kann und gleichzeitig die Systemstabilität aufrechterhält.

Implementierung des Systems

Um das Produktempfehlungssystem in diesem Projekt aufzubauen, müssen Sie die folgenden Schritte durchlaufen:

  1. Datenverarbeitung
  2. Modell-Training
  3. Testen des Modells
  4. Generierung von Produktkandidaten
    1. Datenspeicherung: Artikelvektoren werden durch das trainierte Modell gewonnen und in Milvus gespeichert.
    2. Datensuche: Vier von MIND generierte Nutzervektoren werden in Milvus für die Vektorähnlichkeitssuche eingegeben.
    3. Daten-Ranking: Jeder der vier Vektoren hat seine eigenen top_k ähnlichen Elementvektoren, und vier Sätze von top_k Vektoren werden in eine Rangfolge gebracht, um eine endgültige Liste der top_k ähnlichsten Vektoren zu erhalten.

Der Quellcode dieses Projekts wird auf der Baidu AI Studio Plattform gehostet. Im folgenden Abschnitt wird der Quellcode für dieses Projekt ausführlich erläutert.

Schritt 1. Verarbeitung der Daten

Der Originaldatensatz stammt aus dem Amazon-Buchdatensatz, der von ComiRec zur Verfügung gestellt wurde. Dieses Projekt verwendet jedoch die Daten, die von PaddleRec heruntergeladen und verarbeitet wurden. Weitere Informationen finden Sie unter dem AmazonBook-Datensatz im PaddleRec-Projekt.

Es wird erwartet, dass der Datensatz für das Training das folgende Format hat, wobei jede Spalte Folgendes darstellt:

  • Uid: Benutzer-ID.
  • item_id: ID des Produktartikels, auf den der Benutzer geklickt hat.
  • Time: Der Zeitstempel oder die Reihenfolge des Klicks.

Der Datensatz für die Tests sollte das folgende Format haben, wobei jede Spalte Folgendes darstellt:

  • Uid: Benutzer-ID.

  • hist_item: ID des Produktartikels im historischen Klickverhalten des Benutzers. Wenn es mehrere hist_item gibt, werden sie nach dem Zeitstempel sortiert.

  • eval_item: Die tatsächliche Reihenfolge, in der der Benutzer die Produkte anklickt.

Schritt 2. Modell-Training

Für das Modelltraining werden die im vorherigen Schritt verarbeiteten Daten verwendet und das auf PaddleRec aufbauende Kandidatengenerierungsmodell MIND eingesetzt.

1. Modell-Eingabe

Führen Sie in dygraph_model.py den folgenden Code aus, um die Daten zu verarbeiten und sie in Modelleingaben umzuwandeln. Dieser Prozess sortiert die Elemente, die von demselben Benutzer in den Originaldaten angeklickt wurden, nach dem Zeitstempel und kombiniert sie zu einer Sequenz. Dann wird zufällig ein item``_``id aus der Sequenz als target_item ausgewählt, und die 10 Elemente vor target_item werden als hist_item für die Modelleingabe extrahiert. Wenn die Sequenz nicht lang genug ist, kann sie auf 0 gesetzt werden. seq_len sollte die tatsächliche Länge der Sequenz hist_item sein.

def create_feeds_train(self, batch_data):
    hist_item = paddle.to_tensor(batch_data[0], dtype="int64")
    target_item = paddle.to_tensor(batch_data[1], dtype="int64")
    seq_len = paddle.to_tensor(batch_data[2], dtype="int64")
    return [hist_item, target_item, seq_len]

Den Code zum Lesen des Originaldatensatzes finden Sie im Skript /home/aistudio/recommend/model/mind/mind_reader.py.

2. Modellvernetzung

Der folgende Code ist ein Auszug aus net.py. class Mind_Capsual_Layer definiert die Multi-Interest-Extraktionsschicht, die auf dem Zinskapsel-Routing-Mechanismus aufbaut. Die Funktion label_aware_attention() implementiert die label-aware attention-Technik im MIND-Algorithmus. Die Funktion forward() in class MindLayer modelliert die Benutzereigenschaften und erzeugt entsprechende Gewichtsvektoren.

class Mind_Capsual_Layer(nn.Layer):
    def __init__(self):
        super(Mind_Capsual_Layer, self).__init__()
        self.iters = iters
        self.input_units = input_units
        self.output_units = output_units
        self.maxlen = maxlen
        self.init_std = init_std
        self.k_max = k_max
        self.batch_size = batch_size
        # B2I routing
        self.routing_logits = self.create_parameter(
            shape=[1, self.k_max, self.maxlen],
            attr=paddle.ParamAttr(
                name="routing_logits", trainable=False),
            default_initializer=nn.initializer.Normal(
                mean=0.0, std=self.init_std))
        # bilinear mapping
        self.bilinear_mapping_matrix = self.create_parameter(
            shape=[self.input_units, self.output_units],
            attr=paddle.ParamAttr(
                name="bilinear_mapping_matrix", trainable=True),
            default_initializer=nn.initializer.Normal(
                mean=0.0, std=self.init_std))
                
class MindLayer(nn.Layer):

    def label_aware_attention(self, keys, query):
        weight = paddle.sum(keys * query, axis=-1, keepdim=True)
        weight = paddle.pow(weight, self.pow_p)  # [x,k_max,1]
        weight = F.softmax(weight, axis=1)
        output = paddle.sum(keys * weight, axis=1)
        return output, weight

    def forward(self, hist_item, seqlen, labels=None):
        hit_item_emb = self.item_emb(hist_item)  # [B, seqlen, embed_dim]
        user_cap, cap_weights, cap_mask = self.capsual_layer(hit_item_emb, seqlen)
        if not self.training:
            return user_cap, cap_weights
        target_emb = self.item_emb(labels)
        user_emb, W = self.label_aware_attention(user_cap, target_emb)

        return self.sampled_softmax(
            user_emb, labels, self.item_emb.weight,
            self.embedding_bias), W, user_cap, cap_weights, cap_mask

Die spezifische Netzwerkstruktur von MIND finden Sie im Skript /home/aistudio/recommend/model/mind/net.py.

3. Optimierung des Modells

Dieses Projekt verwendet den Adam-Algorithmus als Modelloptimierer.

def create_optimizer(self, dy_model, config):
    lr = config.get("hyper_parameters.optimizer.learning_rate", 0.001)
    optimizer = paddle.optimizer.Adam(
        learning_rate=lr, parameters=dy_model.parameters())
    return optimizer

Darüber hinaus schreibt PaddleRec Hyperparameter in config.yaml, so dass Sie nur diese Datei ändern müssen, um einen klaren Vergleich zwischen der Effektivität der beiden Modelle zu sehen und die Modelleffizienz zu verbessern. Beim Training des Modells kann die schlechte Modellwirkung auf eine Unter- oder Überanpassung des Modells zurückzuführen sein. Sie können dies daher verbessern, indem Sie die Anzahl der Trainingsrunden ändern. In diesem Projekt müssen Sie nur den Parameter Epochen in config.yaml ändern, um die perfekte Anzahl von Trainingsrunden zu finden. Darüber hinaus können Sie auch den Modell-Optimierer, optimizer.class, oder learning_rate zur Fehlersuche ändern. Im Folgenden wird ein Teil der Parameter in config.yaml gezeigt.

runner:
  use_gpu: True
  use_auc: False
  train_batch_size: 128
  epochs: 20
  print_interval: 10
  model_save_path: "output_model_mind"

# hyper parameters of user-defined network
hyper_parameters:
  # optimizer config
  optimizer:
    class: Adam
    learning_rate: 0.005

Die detaillierte Implementierung finden Sie in dem Skript /home/aistudio/recommend/model/mind/dygraph_model.py.

4. Modell-Training

Führen Sie den folgenden Befehl aus, um das Modelltraining zu starten.

python -u trainer.py -m mind/config.yaml

Siehe /home/aistudio/recommend/model/trainer.py für das Modelltrainingsprojekt.

Schritt 3. Testen des Modells

In diesem Schritt wird ein Testdatensatz verwendet, um die Leistung, z. B. die Wiedererkennungsrate des trainierten Modells, zu überprüfen.

Während des Modelltests werden alle Elementvektoren aus dem Modell geladen und dann in Milvus, die Open-Source-Vektordatenbank, importiert. Lesen Sie den Testdatensatz über das Skript /home/aistudio/recommend/model/mind/mind_infer_reader.py. Laden Sie das Modell im vorherigen Schritt und füttern Sie den Testdatensatz in das Modell, um vier Interessenvektoren des Nutzers zu erhalten. Suchen Sie in Milvus nach den 50 Item-Vektoren, die den vier Interessenvektoren am ähnlichsten sind. Sie können die zurückgegebenen Ergebnisse den Benutzern empfehlen.

Führen Sie den folgenden Befehl aus, um das Modell zu testen.

python -u infer.py -m mind/config.yaml -top_n 50

Während des Modelltests stellt das System mehrere Indikatoren zur Bewertung der Modelleffektivität bereit, z. B. Recall@50, NDCG@50 und HitRate@50. In diesem Artikel wird nur das Ändern eines Parameters vorgestellt. In Ihrem eigenen Anwendungsszenario müssen Sie jedoch mehr Epochen trainieren, um eine bessere Modellwirkung zu erzielen. Sie können die Modelleffektivität auch verbessern, indem Sie verschiedene Optimierer verwenden, unterschiedliche Lernraten einstellen und die Anzahl der Testrunden erhöhen. Es wird empfohlen, mehrere Modelle mit unterschiedlichen Effekten zu speichern und dann dasjenige mit der besten Leistung auszuwählen, das am besten zu Ihrer Anwendung passt.

Schritt 4. Generierung von Kandidaten für Produktartikel

Um den Dienst zur Generierung von Produktkandidaten zu erstellen, verwendet dieses Projekt das in den vorherigen Schritten trainierte Modell, gepaart mit Milvus. Während der Kandidatengenerierung wird FASTAPI als Schnittstelle verwendet. Wenn der Dienst startet, können Sie über curl direkt Befehle im Terminal ausführen.

Führen Sie den folgenden Befehl aus, um vorläufige Kandidaten zu generieren.

uvicorn main:app

Der Dienst bietet vier Arten von Schnittstellen:

  • Einfügen: Führen Sie den folgenden Befehl aus, um die Elementvektoren aus Ihrem Modell zu lesen und sie in eine Sammlung in Milvus einzufügen.
curl -X 'POST' \
  'http://127.0.0.1:8000/rec/insert_data' \
  -H 'accept: application/json' \
  -d ''
  • Vorläufige Kandidaten generieren: Geben Sie die Reihenfolge ein, in der Produkte vom Benutzer angeklickt werden, und ermitteln Sie das nächste Produkt, das der Benutzer anklicken könnte. Sie können auch Produktkandidaten in Stapeln für mehrere Benutzer auf einmal generieren. hist_item im folgenden Befehl ist ein zweidimensionaler Vektor, und jede Zeile stellt eine Sequenz von Produkten dar, die der Benutzer in der Vergangenheit angeklickt hat. Sie können die Länge der Sequenz festlegen. Die zurückgegebenen Ergebnisse sind ebenfalls Sätze von zweidimensionalen Vektoren, wobei jede Zeile die zurückgegebenen item ids für Benutzer darstellt.
curl -X 'POST' \
  'http://127.0.0.1:8000/rec/recall' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "top_k": 50,
  "hist_item": [[43,23,65,675,3456,8654,123454,54367,234561],[675,3456,8654,123454,76543,1234,9769,5670,65443,123098,34219,234098]]
}'
  • Abfrage der Gesamtzahl der Produktartikel: Führen Sie den folgenden Befehl aus, um die Gesamtzahl der in der Milvus-Datenbank gespeicherten Artikelvektoren zu ermitteln.
curl -X 'POST' \
  'http://127.0.0.1:8000/rec/count' \
  -H 'accept: application/json' \
  -d ''
  • Löschen: Führen Sie den folgenden Befehl aus, um alle in der Milvus-Datenbank gespeicherten Daten zu löschen.
curl -X 'POST' \
  'http://127.0.0.1:8000/qa/drop' \
  -H 'accept: application/json' \
  -d ''

Wenn Sie den Kandidatengenerierungsdienst auf Ihrem lokalen Server ausführen, können Sie die oben genannten Schnittstellen auch unter 127.0.0.1:8000/docs aufrufen. Klicken Sie auf die vier Schnittstellen und geben Sie die Werte für die Parameter ein, um sie auszuprobieren. Klicken Sie dann auf "Ausprobieren", um das Ergebnis der Empfehlung zu erhalten.

6.png 6.png

7.png 7.png

Rekapitulation

Dieser Artikel konzentriert sich hauptsächlich auf die erste Phase der Kandidatengenerierung beim Aufbau eines Empfehlungssystems. Er bietet auch eine Lösung zur Beschleunigung dieses Prozesses durch die Kombination von Milvus mit dem MIND-Algorithmus und PaddleRec und hat damit das im ersten Absatz angesprochene Problem gelöst.

Was ist, wenn das System aufgrund der enormen Menge an Datensätzen extrem langsam ist, wenn es Ergebnisse liefert? Milvus, die Open-Source-Vektordatenbank, ist für eine blitzschnelle Ähnlichkeitssuche in dichten Vektordatensätzen mit Millionen, Milliarden oder sogar Billionen von Vektoren konzipiert.

Was ist, wenn neu eingefügte Daten nicht in Echtzeit für die Suche oder Abfrage verarbeitet werden können? Sie können Milvus verwenden, da es eine einheitliche Batch- und Stream-Verarbeitung unterstützt und es Ihnen ermöglicht, neu eingefügte Daten in Echtzeit zu suchen und abzufragen. Außerdem ist das MIND-Modell in der Lage, neues Benutzerverhalten in Echtzeit zu konvertieren und die Benutzervektoren sofort in Milvus einzufügen.

Was tun, wenn die komplizierte Bereitstellung zu einschüchternd ist? PaddleRec, eine leistungsstarke Bibliothek, die zum PaddlePaddle-Ökosystem gehört, kann Ihnen eine integrierte Lösung bieten, mit der Sie Ihr Empfehlungssystem oder andere Anwendungen auf einfache und schnelle Weise einsetzen können.

Über den Autor

Yunmei Li, Zilliz Data Engineer, hat einen Abschluss in Informatik von der Huazhong University of Science and Technology. Seit sie zu Zilliz gekommen ist, arbeitet sie an der Erforschung von Lösungen für das Open-Source-Projekt Milvus und hilft Benutzern, Milvus in realen Szenarien anzuwenden. Ihr Hauptaugenmerk liegt auf NLP und Empfehlungssystemen, und sie möchte ihren Fokus auf diese beiden Bereiche weiter vertiefen. Sie verbringt gerne Zeit alleine und liest.

Suchen Sie nach weiteren Ressourcen?

Like the article? Spread the word

Weiterlesen