Abgerufene Chunks neu bewerten
Re-Ranking mit Cross-Encodern
Abgerufene Chunks neu bewerten ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Prompt Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.
Warum überhaupt Re-Ranking?
Das Retrieval der ersten Stufe (Dense oder Sparse) optimiert bei großem Maßstab den Recall: Der Gold-Chunk soll irgendwo in den Top 50 enthalten sein. Es ist schnell, aber grob. Ein Re-Ranker der zweiten Stufe ordnet diese Shortlist anschließend für eine höhere Precision neu und bringt die tatsächlich relevanten Chunks nach oben.
Dieses Muster – breit abrufen und anschließend präzise re-ranken – bildet das Rückgrat fortgeschrittener RAG-Systeme.
def two_stage(query, k_retrieve=50, k_final=5):
candidates = first_stage_retrieve(query, k_retrieve) # high recall
reranked = rerank(query, candidates) # high precision
return reranked[:k_final]Bi-Encoder vs. Cross-Encoder
Ein Bi-Encoder kodiert Query und Dokument getrennt in Vektoren und vergleicht sie anhand der Kosinusähnlichkeit. Das ist schnell und indexierbar, verliert jedoch die Interaktion zwischen Query und Dokument. Ein Cross-Encoder führt Query und Kandidat gemeinsam durch das Modell und gibt einen Relevanzwert aus, der die feingranulare Interaktion erfasst.
Cross-Encoder sind deutlich genauer, können aber nicht vorab berechnet werden und laufen daher nur auf der Shortlist.
# Bi-encoder: score = cos(enc(q), enc(d)) -> precomputable
# Cross-encoder: score = model(q, d) -> 0..1 -> per-pair, no index
def cross_encode(query, doc):
return cross_encoder.predict([(query, doc)])[0] # joint attentionEin Cross-Encoder-Re-Ranking-Durchlauf
Der Re-Ranker bewertet jeden Kandidaten im Verhältnis zur Query und sortiert anschließend absteigend. Da der Cross-Encoder Query und Dokument gemeinsam verarbeitet, erkennt er subtile Relevanzunterschiede, die der Bi-Encoder verfehlt: Negationen, Anforderungen an exakte Treffer und den Unterschied zwischen Antwort und Thema.
Diese Stufe steigert die Antwortgenauigkeit typischerweise stärker als jede andere einzelne Verbesserung an einem RAG-System.
def rerank(query, candidates):
pairs = [(query, c.text) for c in candidates]
scores = cross_encoder.predict(pairs) # batched
for c, s in zip(candidates, scores):
c.rerank_score = s
return sorted(candidates, key=lambda c: c.rerank_score, reverse=True)LLM als Re-Ranker
Wenn kein trainierter Cross-Encoder zu Ihrer Domäne passt, kann ein LLM das Re-Ranking übernehmen. Listwise-Prompting fordert das Modell auf, eine Liste von Passagen in einem einzigen Aufruf nach Relevanz zu ordnen; Pointwise bewertet jede Passage unabhängig.
Listwise erfasst relative Vergleiche und ist tokeneffizient, aber achten Sie auf Positionsbias und stellen Sie sicher, dass das Parsen der Ausgabe robust gegenüber dem Weglassen oder Duplizieren von IDs ist.
def llm_listwise(query, candidates):
passages = '\n'.join(
'[' + str(i) + '] ' + c.text for i, c in enumerate(candidates)
)
prompt = (
'Rank the passages by relevance to the query. '
'Return only IDs, most relevant first.\nQuery: ' + query +
'\n' + passages
)
order = parse_ids(llm(prompt, temperature=0))
return [candidates[i] for i in order]Latenz und Shortlist-Größe
Die Kosten des Re-Rankings skalieren mit der Shortlist-Größe. Ein Cross-Encoder für 50 Kandidaten ist deutlich günstiger als für 500. Wählen Sie das k der ersten Stufe groß genug, um den Gold-Chunk zu erfassen (validieren Sie den Recall@k), aber klein genug, um das Re-Ranking innerhalb Ihres Latenzbudgets durchzuführen.
Bündeln Sie die Paarbewertungen und führen Sie sie auf beschleunigter Hardware aus; Cross-Encoder lassen sich über die Paare hinweg gut parallelisieren.
def tune_shortlist(eval_set, ks=(20, 50, 100, 200)):
# find smallest k where recall@k saturates -> rerank fewer pairs
return {k: (recall_at_k(eval_set, k), rerank_latency(k)) for k in ks}Hybride erste Stufe plus Re-Ranking
Die höchste Recall-Leistung erzielen Sie mit einer hybriden ersten Stufe (Dense Retrieval + BM25 zusammengeführt), die eine einzige deduplizierte Shortlist an den Re-Ranker übergibt. Dense Retrieval findet Paraphrasen; Sparse Retrieval findet exakte Bezeichner; der Cross-Encoder sortiert die Vereinigung anschließend nach tatsächlicher Relevanz.
Diese Kombination ist bei verschiedenen Query-Typen robust – von Fragen in natürlicher Sprache bis zu exakten Nachschlageabfragen.
def hybrid_then_rerank(query, k_final=6):
dense = dense_retrieve(query, 50)
sparse = bm25_retrieve(query, 50)
fused = dedup(rrf(dense, sparse)) # reciprocal rank fusion
return rerank(query, fused)[:k_final]Score-Schwellenwerte und Grenzwerte
Re-Ranker-Scores lassen sich kalibrieren. Statt immer die Top-n zu übernehmen, wenden Sie einen Relevanzschwellenwert an: Behalten Sie Chunks oberhalb eines bestimmten Scores, und geben Sie, wenn keiner die Schwelle erreicht, ehrlich zurück, dass keine Antwort vorliegt. So verhindern Sie, dass der Prompt mit schwach relevanten Füllinhalten überladen wird.
Stimmen Sie den Schwellenwert anhand eines Validierungsdatensatzes ab, um die Abdeckung beantwortbarer Fragen und die Aufnahme von Ablenkungen auszubalancieren.
def threshold_select(reranked, tau=0.3, max_n=8):
kept = [c for c in reranked if c.rerank_score >= tau][:max_n]
if not kept:
return None # signal: no sufficiently relevant context
return keptVielfalt nach dem Re-Ranking
Eine reine Sortierung nach Relevanz kann mehrere nahezu identische Chunks aus demselben Dokument zurückgeben und dadurch das Kontextbudget verschwenden. Wenden Sie nach dem Re-Ranking MMR oder Obergrenzen pro Dokument an, damit die endgültige Auswahl unterschiedliche Aspekte und Quellen abdeckt.
Das ist bei Multi-Hop-Fragen wichtig, deren Antwort sich über mehrere Dokumente erstreckt.
def diversify(reranked, max_per_doc=2, k=6):
out, per_doc = [], {}
for c in reranked:
d = c.meta['doc_id']
if per_doc.get(d, 0) < max_per_doc:
out.append(c)
per_doc[d] = per_doc.get(d, 0) + 1
if len(out) == k:
break
return outReihenfolge für den Generator
Nachdem Sie die besten Chunks ausgewählt haben, platzieren Sie sie so, dass Sie die Aufmerksamkeit optimal nutzen. Angesichts des Lost-in-the-Middle-Effekts sollten Sie den Chunk mit dem höchsten Score an den Anfang oder das Ende des Kontexts setzen, statt ihn zwischen anderen Chunks zu vergraben.
Einige Pipelines ordnen Chunks nach aufsteigender Relevanz, sodass der beste am nächsten an der Frage steht – analog zur Recency-Strategie bei Few-Shot-Beispielen.
def order_for_llm(chunks):
chunks = sorted(chunks, key=lambda c: c.rerank_score) # ascending
return chunks # most relevant chunk ends up last,
# nearest the trailing questionDen Re-Ranker bewerten
Messen Sie den Re-Ranker anhand von Ranking-Metriken, insbesondere NDCG und MRR, auf Basis annotierter Relevanz von Query-Chunk-Paaren und anschließend anhand der nachgelagerten Antwortgenauigkeit. Ein Re-Ranker, der NDCG verbessert, aber nicht die Antworten, ordnet möglicherweise nur Chunks neu, mit denen der Generator bereits zurechtkam.
Bewerten Sie immer die Qualität der eigentlichen Aufgabe und nicht nur Ranking-Metriken.
import math
def ndcg_at_k(relevances, k):
dcg = sum(r / math.log2(i + 2) for i, r in enumerate(relevances[:k]))
ideal = sorted(relevances, reverse=True)
idcg = sum(r / math.log2(i + 2) for i, r in enumerate(ideal[:k]))
return dcg / idcg if idcg else 0.0Eine Re-Ranking-Pipeline für den Produktionseinsatz
Ende zu Ende: Rufen Sie per Hybrid-Retrieval eine Shortlist mit 50 Kandidaten ab, deduplizieren Sie sie, wenden Sie Cross-Encoder-Re-Ranking und einen Score-Schwellenwert an, sorgen Sie für Diversität nach Dokument, ordnen Sie die Chunks aufmerksamkeitsgerecht an und generieren Sie Antworten mit Zitaten. Verwenden Sie den Schwellenwert als Gate, um ehrlich anzuzeigen, wenn keine Antwort vorliegt.
Wenn sich Queries wiederholen, können Sie Embeddings und Re-Ranker-Scores pro (Query, Chunk) zwischenspeichern, um Kosten zu senken.
def pipeline(query):
shortlist = hybrid_then_rerank(query, k_final=20)
kept = threshold_select(shortlist, tau=0.3, max_n=8)
if kept is None:
return 'No relevant information found.'
ctx = order_for_llm(diversify(kept))
return generate_with_citations(query, ctx)Schnelltest
Wählen Sie die richtige Re-Ranking-Architektur.
Zusammenfassung
Wichtigste Erkenntnisse:
- Rufen Sie zunächst breit ab, um den Recall zu maximieren, und führen Sie anschließend ein Re-Ranking der Shortlist für mehr Präzision durch.
- Cross-Encoder bewerten Query-Dokument-Paare gemeinsam (präzise, aber nicht indexierbar); Bi-Encoder sind schnell, aber grob.
- LLM-basiertes Listwise-/Pointwise-Re-Ranking ist eine Ausweichlösung; behalten Sie Positionsverzerrung und Parsing im Blick.
- Stimmen Sie die Größe der Shortlist so ab, dass der Recall innerhalb des Latenzbudgets gesättigt wird, und kombinieren Sie sie mit hybridem Retrieval in der ersten Stufe.
- Wenden Sie Score-Schwellenwerte an, sorgen Sie für Diversität nach Dokument, ordnen Sie Chunks aufmerksamkeitsgerecht an und bewerten Sie mit NDCG sowie nachgelagerter Antwortgenauigkeit.
Häufig gestellte Fragen
Ist die Lektion „Abgerufene Chunks neu bewerten“ kostenlos?
Ja — der vollständige Text von „Abgerufene Chunks neu bewerten“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Prompt Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Abgerufene Chunks neu bewerten“?
Re-Ranking mit Cross-Encodern Du übst AI Prompt Engineering mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Prompt Engineering zu starten?
Keine Vorkenntnisse erforderlich. AI Prompt Engineering auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Abgerufene Chunks neu bewerten“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Prompt Engineering-Lektion Code schreiben und ausführen?
Ja. Jede AI Prompt Engineering-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Über naives RAG hinaus
- Abgerufene Chunks neu bewerten
- Kontextkomprimierung
- Query-Rewriting und HyDE