Reranking mit Embedding-Modellen

Python-Code für das Reranking von RAG

Inhaltsverzeichnis

Reranking ist ein zweiter Schritt in Retrieval-Augmented-Generation-Systemen (RAG) Systeme, genau zwischen dem Abrufen (Retrieval) und der Generierung.

Elektrische Würfel im digitalen Raum

So stellt Flux-1 dev den Begriff Elektrische Würfel im digitalen Raum dar.

Für eine vollständige Anleitung zum Aufbau von RAG-Systemen sehen Sie den RAG-Tutorial: Architektur, Implementierung und Leitfaden für den Produktiveinsatz.

Dieser Artikel behandelt das Reranking mit Embedding-Modellen. Für alternative Ansätze können Sie auch einen Blick auf Reranking von Texten mit Ollama und Qwen3 Embedding-LLM - in Go und Reranking von Dokumenten mit Ollama und Qwen3 Reranker-Modell - in Go werfen.

Abruf mit Reranking

Wenn wir die Dokumente von Anfang an in Form von Embeddings in der Vektordatenbank speichern, liefert uns der Abruf sofort die Liste der ähnlichen Dokumente.

Eigenständiges Reranking

Wenn wir jedoch die Dokumente zunächst aus dem Internet herunterladen, kann die Antwort des Suchsystems durch die Präferenzen/Algorithmen des Suchanbieters, bezahlte Inhalte, SEO-Optimierung usw. beeinflusst werden. Daher benötigen wir ein Reranking nach der Suche (Post-Search-Reranking).

Meine Vorgehensweise war folgende:

  • Erstellen von Embeddings für die Suchanfrage
  • Erstellen von Embeddings für jedes Dokument. Das Dokument sollte ohnehin nicht mehr als 8k Tokens umfassen.
  • Berechnung der Ähnlichkeit zwischen der Anfrage und den Embeddings jedes Dokuments
  • Sortierung der Dokumente nach dieser Ähnlichkeit.

Hier ist keine Vektordatenbank im Spiel, los geht’s.

Beispielcode

Verwendung von Langchain zur Verbindung mit Ollama und der Funktion cosine_similarity von Langchain. Sie können nach Ähnlichkeitsmaß filtern, aber bedenken Sie, dass die Schwelle für verschiedene Domänen und Embedding-LLMs unterschiedlich sein wird.

Ich freue mich, wenn dieser Codeausschnitt Ihnen auf irgendeine Weise nützlich ist. Copy/Paste/UseAnyWayYouWant-Lizenz. Auf Ihr Wohl.

from langchain_core.documents import Document
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.utils.math import cosine_similarity
import numpy as np


def cosine_distance(a: np.ndarray, b: np.ndarray) -> np.ndarray:
    return 1.0 - cosine_similarity(a, b)

def compute_score(vectors: np.ndarray) -> float:
    score = cosine_distance(vectors[0].reshape(1, -1), vectors[1].reshape(1, -1)).item()
    return score

def list_to_array(lst):
    return np.array(lst, dtype=float)   

def compute_scorel(lists) -> float:
    v1 = list_to_array(lists[0])
    v2 = list_to_array(lists[1])
    return compute_score([v1, v2])

def filter_docs(emb_model_name, docs, query, num_docs):
    content_arr = [doc.page_content for doc in docs]

    ollama_emb = OllamaEmbeddings(
        model=emb_model_name
    )

    docs_embs = ollama_emb.embed_documents(content_arr)
    query_embs = ollama_emb.embed_query(query)
    sims = []
    for i, emb in enumerate(docs_embs):
        idx = docs[i].id
        s = compute_scorel([query_embs, docs_embs[i]])
        simstr = str(round(s, 4))
        docs[i].metadata["sim"] = simstr
        sim = {
            "idx": idx,
            "i": i,
            "sim": s,
        }
        sims.append(sim)

    sims.sort(key=sortFn)

    sorted_docs = [docs[x["i"]] for x in sims]
    filtered_docs = sorted_docs[:num_docs]
    return filtered_docs

Beste Embedding-Modelle

Für meine Aufgaben ist das derzeit beste Embedding-Modell bge-large:335m-en-v1.5-fp16.

Den zweiten Platz belegten nomic-embed-text:137m-v1.5-fp16 und jina/jina-embeddings-v2-base-en:latest.

Führen Sie jedoch Ihre eigenen Tests für Ihre eigene Domäne und Ihre eigenen Abfragen durch.