Cross-Encoder-Re-Ranking für höhere RAG-Genauigkeit

Warum Cross-Encoder ?

Die Bi-Encoder (standard embeddings) encodieren die Anfrage und das Dokument getrennt. Die Cross-Encoder verarbeiten sie zusammen - deutlich präziser, aber langsamer.

Bi-Encoder : sim(encode(query), encode(doc)) Cross-Encoder : score(query + doc ensemble)

Implementierung

DEVELOPERpython
from sentence_transformers import CrossEncoder

model = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')

def rerank(query, documents, top_k=5):
    # Erstelle Anfrage-Dokument-Paare
    pairs = [[query, doc] for doc in documents]

    # Bewerte alle Paare
    scores = model.predict(pairs)

    # Nach Score sortieren
    ranked = sorted(zip(documents, scores), key=lambda x: x[1], reverse=True)

    return [doc for doc, score in ranked[:top_k]]

# Utilisation
initial_results = vector_search(query, k=100)
final_results = rerank(query, initial_results, top_k=10)

Beste Modelle (November 2025)

1. ms-marco-MiniLM-L-12-v2

• Schnell, präzise
• Am besten für allgemeine Nutzung

2. bge-reranker-v2-m3

• Mehrsprachig
• Präzision auf dem Stand der Technik

3. jina-reranker-v2-base-multilingual

• 89 Sprachen
• Produktionsbereit

Zweistufiges Retrieval

DEVELOPERpython
def two_stage_rag(query, vector_db):
    # Schritt 1: Schnelles Retrieval mit Bi-Encoder (100 Kandidaten)
    candidates = vector_db.search(
        query_embedding=embed(query),
        k=100
    )

    # Schritt 2: Langsames, aber präzises reranking mit cross-encoder
    cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-12-v2')
    pairs = [[query, doc['content']] for doc in candidates]
    scores = cross_encoder.predict(pairs)

    # Gib die Top 10 zurück
    ranked = sorted(zip(candidates, scores), key=lambda x: x[1], reverse=True)
    return [doc for doc, _ in ranked[:10]]

Leistungsoptimierung

Die Cross-Encoder sind langsam - optimieren:

DEVELOPERpython
# Traitement par batch
def batch_rerank(query, documents, batch_size=32):
    pairs = [[query, doc] for doc in documents]
    all_scores = []

    for i in range(0, len(pairs), batch_size):
        batch = pairs[i:i+batch_size]
        scores = model.predict(batch)
        all_scores.extend(scores)

    return sorted(zip(documents, all_scores), key=lambda x: x[1], reverse=True)

Wann reranking durchführen

Immer reranking durchführen, wenn :

• Wenn Genauigkeit kritisch ist
• Die Kosten für falsche Positive hoch sind
• Sie ein Budget für Rechenleistung haben

Reranking ignorieren, wenn :

• Latenz < 100ms erforderlich
• Hohe QPS (> 1000/sec)
• Begrenztes Budget