Steigern Sie die Präzision von Empfehlungssystemen mit LLMs unter Verwendung von Python

Steigern Sie die Präzision von Empfehlungssystemen mit LLMs unter Verwendung von Python

Traditionelle Empfehlungsmaschinen haben lange auf kollaborative Filterung, Matrixfaktorisierung und Deep-Learning-Architekturen gesetzt, um Benutzerpräferenzen vorherzusagen. Während diese Methoden hervorragend darin sind, große Verhaltensdatensätze auszuschöpfen, haben sie oft Schwierigkeiten mit Cold-Start-Elementen, spärlichen Interaktionshistorien und den semantischen Nuancen, die in unstrukturierten Metadaten wie Produktbeschreibungen, Rezensionen oder Inhaltszusammenfassungen verborgen sind. Große Sprachmodelle (LLMs) bieten eine überzeugende Ergänzung zu klassischen Pipelines. Durch die Kodierung von natürlichsprachlichem Verständnis, Zero-Shot-Reasoning und kontextueller Relevanzbewertung können LLMs die Lücke zwischen Rohtext und Benutzerabsicht schließen.

Die Konvergenz von generativer KI und Empfehlungsinfrastruktur ist ein wiederkehrendes Thema in führenden Branchenkanälen, darunter der [Google AI Blog](https://blog.google/technology/ai/), der [Microsoft AI Blog](https://www.microsoft.com/en-us/ai/blog/), [OpenAI News](https://openai.com/news/) und die [Towards Data Science](https://towardsdatascience.com/)-Community. Anstatt bewährte Retrieval-Ebenen zu ersetzen, setzen Praktiker zunehmend auf hybride Architekturen: Klassische Modelle generieren eine breite Menge an Kandidaten, und LLMs verfeinern, reranken oder erklären diese Kandidaten, um die Präzision zu steigern. Dieser Artikel bietet eine praktische Anleitung zum Aufbau solcher Hybrid-Workflows in Python, abgedeckt werden die Einrichtung der Umgebung, einbettungsbasierte Anreicherung und LLM-gesteuertes Reranking.

Anforderungen

Bevor Sie fortfahren, stellen Sie sicher, dass Ihre Arbeitsstation die folgenden Voraussetzungen erfüllt:

• **Python 3.9 oder neuer** ist installiert und in Ihrem Systempfad verfügbar.
• **pip**, der Python-Paketinstaller, ist auf eine aktuelle Version aktualisiert.
• **Virtual-Environment-Tooling** (`venv` ist ausreichend), um Projektabhängigkeiten zu isolieren.
• Ein **OpenAI-API-Schlüssel**, wenn Sie die GPT-basierten Reranking-Beispiele ausführen möchten. Sie können einen auf der OpenAI-Plattform erhalten.
• **Hardware**: Mindestens 4 GB RAM sind für kleine lokale Embedding-Modelle ausreichend. Wenn Sie planen, größere Open-Source-LLMs lokal zu testen, werden 16 GB RAM und eine moderne GPU empfohlen; die folgenden Beispiele verwenden jedoch API-basierte Modelle oder leichtgewichtige Sentence Transformer, um zugänglich zu bleiben.

Schritt-für-Schritt-Installation

Beginnen Sie damit, ein dediziertes Verzeichnis für Ihre Projektdateien und Code zu erstellen.

mkdir llm-recommender && cd llm-recommender

Erstellen Sie eine Python-Virtual-Environment namens `venv`, um Abhängigkeiten von Ihrer globalen Python-Installation isoliert zu halten.

python -m venv venv

Aktivieren Sie die Virtual Environment. Unter Linux oder macOS führen Sie den folgenden Befehl aus.

source venv/bin/activate

Unter Windows verwenden Sie das analoge Aktivierungsskript.

venv\Scripts\activate

Aktualisieren Sie `pip`, um Kompatibilitätsprobleme bei der Installation von Scientific-Computing-Wheels zu vermeiden.

pip install --upgrade pip

Installieren Sie die Kernbibliotheken, die für Datenmanipulation, traditionelle Ähnlichkeitsmetriken, lokale Embedding-Inferenz und OpenAI-API-Zugriff erforderlich sind.

pip install pandas numpy scikit-learn sentence-transformers openai python-dotenv

Erstellen Sie eine versteckte Umgebungsdatei namens `.env`, um Ihre API-Anmeldedaten sicher außerhalb der Versionskontrolle zu speichern.

touch .env

Öffnen Sie `.env` in Ihrem Texteditor und fügen Sie Ihren OpenAI-API-Schlüssel wie unten gezeigt hinzu. Ersetzen Sie den Platzhalter durch Ihren tatsächlichen Schlüssel.

OPENAI_API_KEY=sk-your-key-here

Ihre Umgebung ist nun bereit. Der installierte Stack ermöglicht es Ihnen, lokale Embedding-Modelle ohne GPU auszuführen, mit der OpenAI-API für rechenintensive generative Aufgaben zu interagieren und tabellarische Daten mit `pandas` zu verwalten.

Nutzungsbeispiele

Die folgenden Abschnitte demonstrieren drei unterschiedliche Möglichkeiten, LLM-Fähigkeiten in eine Empfehlungspipeline einzubinden. Jedes Beispiel ist in sich geschlossen und kann an Ihre eigenen Katalogdaten angepasst werden.

Beispiel 1: Semantische Item-Embeddings mit Sentence Transformers

Klassische kollaborative Filterung versagt, wenn neue Elemente in den Katalog aufgenommen werden, da es keine Benutzerinteraktionen zum Lernen gibt. Ein robuster erster Schritt ist die Kodierung von Item-Metadaten – wie Titel, Beschreibungen oder Tags – in dichte Vektoren unter Verwendung eines Transformer-Modells. Durch die Berechnung der Ähnlichkeit zwischen Benutzerprofilvektoren und Itemvektoren können Sie semantisch relevante Inhalte auch ohne historische Signale aufdecken.

Der folgende Code lädt ein leichtgewichtiges Modell, kodiert einen Beispielkatalog und ordnet Elemente anhand einer Benutzerinteressenzeichenkette.

import pandas as pd
import numpy as np
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity

# Lade ein kompaktes, hochwertiges Embedding-Modell, das für CPU-Inferenz geeignet ist.
model = SentenceTransformer('all-MiniLM-L6-v2')

# Erstelle einen Beispielkatalog, bei dem jedes Element unstrukturierten beschreibenden Text hat.
items = pd.DataFrame({
    'item_id': [1, 2, 3, 4],
    'description': [
        'Ein Cyberpunk-Thriller, der in einer dystopischen Tokioter Unterwelt spielt',
        'Ein praxisnaher Leitfaden zu Python-Maschinenlernen und pandas',
        'Eine romantische Komödie über zwei konkurrierende Konditoren in Paris',
        'Ein einführendes Lehrbuch über Deep Learning und neuronale Netze'
    ]
})

# Kodiere die Katalogbeschreibungen in 384-dimensionale dichte Vektoren.
item_embeddings = model.encode(
    items['description'].tolist(),
    convert_to_numpy=True,
    show_progress_bar=False
)

# Simuliere ein Benutzerprofil, ausgedrückt in natürlicher Sprache.
user_query = "Ich möchte etwas über künstliche Intelligenz und neuronale Netze lernen"

# Kodiere die Benutzeranfrage in denselben semantischen Raum.
user_embedding = model.encode([user_query], convert_to_numpy=True)

# Berechne die Kosinusähnlichkeit zwischen dem Benutzer und jedem Element.
similarity_scores = cosine_similarity(user_embedding, item_embeddings).flatten()

# Füge die Scores hinzu und sortiere, um das endgültige Ranking zu erzeugen.
items['similarity'] = similarity_scores
ranked_items = items.sort_values('similarity', ascending=False)

print(ranked_items[['item_id', 'description', 'similarity']])

In diesem Muster erfassen die LLM-abgeleiteten Embeddings semantische Beziehungen, die Item-IDs allein nicht können. Ein Matrixfaktorisierungsmodell könnte Element 2 und Element 4 nur dann assoziieren, wenn Benutzer sie gemeinsam angeklickt haben, während das Embedding-Modell ihre thematische Ähnlichkeit sofort erkennt. In der Produktion können Sie diese Vektoren in einem Vektor