Reranking: Zlepšenie relevantnosti
Na tejto strane
Ciele
- Pochopiť, prečo reranking zlepšuje výsledky
- Implementovať reranker pomocou cross-encoderu
- Integrovať reranking do RAG pipeline
Problém bi-encoderu
Všetky doteraz vytvorené vyhľadávania spoliehajú na bi-encoder: dopyt aj dokumenty sa kódujú oddelene, samostatne, a porovnávajú sa pomocou skalárneho súčinu. To umožňuje okamžité vyhľadávanie v milióne chunkov, keďže vektory korpusu boli vypočítané raz a navždy. Zároveň je to však príčinou nepresnosti, pretože model nikdy nevidí dopyt a dokument spoločne: musí každý text zhrnúť do vektora bez toho, aby vedel, čo sa od neho neskôr bude žiadať.
Cross-encoder, nazývaný aj reranker, prijíma ako vstup pár (dopyt, dokument) a produkuje oveľa presnejšie skóre relevantnosti, pretože číta oba texty spoločne a dokáže rozpoznať, že dokument síce diskutuje o téme, ale v opačnom zmysle. Tento zisk má svoju cenu: model musí spracovať každý dokument individuálne, čo znemožňuje jeho použitie na celý korpus. Riešením je nasadiť ho tam, kde je to nákladovo efektívne – na malú množinu kandidátov, ktorí už boli predbežne vybratí.
Preto existuje dvojfázová pipeline, kde každý model robí to, v čom je najlepší: rýchly model zúži pole a presný model urobí finálny výber.
Query → Bi-encoder → Top 50 Candidates → Cross-encoder → Top 5 Results
Reranking s Cohere
Cohere poskytuje vysoko výkonný reranker prostredníctvom API, čo eliminuje potrebu hostovať vlastný model. Nasledujúca funkcia spája oba kroky: najprv získa dvadsať kandidátov pomocou vektorovej podobnosti a potom požiada rerank-v3.5, aby zachoval iba päť z nich. Všimni si pole index_original, ktoré sa vo výsledku zachováva: reranker vracia pozície relatívne k zoznamu kandidátov a ty budeš potrebovať tieto údaje na spätné mapovanie na skutočný dokument v tvojom korpuse.
import cohere
from openai import OpenAI
co = cohere.Client(api_key="your-cohere-key")
openai_client = OpenAI()
def search_and_rerank(
question: str,
documents: list[str],
embeddings_corpus,
k_retrieval: int = 20,
k_final: int = 5
) -> list[dict]:
"""Sémantické vyhľadávanie + reranking."""
# Krok 1: Rýchle získanie (bi-encoder)
query_emb = openai_client.embeddings.create(
input=question,
model="text-embedding-3-large"
).data[0].embedding
import numpy as np
scores = embeddings_corpus @ np.array(query_emb)
top_indices = np.argsort(scores)[-k_retrieval:][::-1]
candidates = [documents[i] for i in top_indices]
# Krok 2: Reranking (cross-encoder)
rerank_response = co.rerank(
query=question,
documents=candidates,
top_n=k_final,
model="rerank-v3.5"
)
return [
{
"text": candidates[r.index],
"rerank_score": r.relevance_score,
"original_index": int(top_indices[r.index])
}
for r in rerank_response.results
]
Reranking pomocou LLM
Ak nechceš do svojej architektúry pridávať ďalšieho poskytovateľa – či už z dôvodu zmluvných podmienok, lokalizácie dát alebo jednoducho fakturácie – túto úlohu môže prevziať LLM, ktoré už aj tak používaš. Odošleš otázku a dokument, požiadaš o skóre od 0 do 10 a výsledky zoradíš. Nastavenie teploty na nulu a obmedzenie max_tokens na päť zabezpečí deterministický a lacný výstup; blok try/except ošetruje prípady, keď model odpovie niečím iným než číslom.
from openai import OpenAI
client = OpenAI()
def llm_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[dict]:
"""Používa LLM na hodnotenie relevantnosti."""
scores = []
for i, doc in enumerate(candidates):
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"On a scale of 0 to 10, how relevant is this document "
f"for answering the question?\n\n"
f"Question: {question}\n\n"
f"Document: {doc}\n\n"
f"Respond only with a number between 0 and 10."
)
}],
temperature=0,
max_tokens=5
)
try:
score = float(response.choices[0].message.content.strip())
except ValueError:
score = 0.0
scores.append({"index": i, "text": doc, "score": score})
scores.sort(key=lambda x: x["score"], reverse=True)
return scores[:k]
Táto verzia stojí jedno volanie na každého kandidáta, čo znamená dvadsať volaní a rovnakú kumulatívnu latenciu pre jednu používateľskú otázku. V praxi je to v interaktívnom rozhraní neúnosné. Namiesto toho požiadaš model, aby zoradil všetky dokumenty naraz, pričom každého kandidáta skrátíš na 200 znakov a očíslovať, pričom očakávaš späť iba zoznam indexov.
def llm_batch_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[int]:
"""Reranking v jednom volaní LLM."""
formatted_docs = "\n".join(
f"[{i}] {doc[:200]}" for i, doc in enumerate(candidates)
)
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"Rank these documents by relevance to the question. "
f"Return the indices of the {k} most relevant "
f"documents, separated by commas, from most to "
f"least relevant.\n\n"
f"Question: {question}\n\n"
f"Documents:\n{formatted_docs}\n\n"
f"Indices (e.g., 3,1,7,0,5):"
)
}],
temperature=0,
max_tokens=50
)
indices_str = response.choices[0].message.content.strip()
return [int(i.strip()) for i in indices_str.split(",")][:k]
Integrácia do RAG pipeline
V kompletnej pipeline zapadá reranking medzi fázu získavania a generovania bez toho, aby menil čokoľvek iné. Kľúčovým bodom v nižšie uvedenej triede je prahová hodnota 0,3 pre relevance_score: umožňuje vrátiť menej ako päť kontextov, keď žiadny kandidát nie je skutočne relevantný, namiesto toho, aby sa generátoru predával šum. Práve tento filter, často viac než samotný reranking, eliminuje halucinované odpovede.
class RAGPipelineWithReranking:
def __init__(self):
self.client = OpenAI()
self.co = cohere.Client()
def respond(self, question: str, chunks, embeddings_corpus):
# 1. Široké získavanie
candidates = self.search(question, embeddings_corpus, k=20)
# 2. Reranking
candidate_docs = [chunks[i]["text"] for i in candidates]
reranked = self.co.rerank(
query=question,
documents=candidate_docs,
top_n=5,
model="rerank-v3.5"
)
# 3. Výber najlepších
contexts = [
chunks[candidates[r.index]]
for r in reranked.results
if r.relevance_score > 0.3 # Prah relevantnosti
]
# 4. Generovanie odpovede
return self.generate(question, contexts)
Vplyv rerankingu
| Metrika | Bez rerankingu | S rerankingom | Zisk |
|---|---|---|---|
| Recall@5 | 0.72 | 0.72 | = |
| Precision@5 | 0.58 | 0.78 | +34% |
| MRR | 0.65 | 0.82 | +26% |
Tieto čísla presne hovoria o tom, čo reranker robí. Recall sa nemení, čo je logické: kandidáti sú tí istí a cross-encoder nemôže zachrániť dokument, ktorý bi-encoder nevytiahlo na povrch. Avšak presnosť a MRR sa výrazne zlepšujú, pretože správny dokument sa posunie zo šiesteho miesta na prvé. Praktický dôsledok: ak máš slabý recall, reranking ťa nezachráni; musíš najprv rozšíriť získavanie alebo prehodnotiť chunking.
Kľúčové poznatky
- Reranking znovu zoradí kandidátov pomocou presnejšieho modelu
- Typická pipeline: bi-encoder (top 20–50) → cross-encoder (top 5)
- Cohere rerank-v3.5 je hotové riešenie
- LLM môže slúžiť ako reranker, ak chceš predísť ďalšej závislosti
- Zisk na presnosti je významný (zvyčajne 20–35 %)