Reranking: Îmbunătățirea Relevanței
Pe această pagină
Obiective
- Înțelegeți de ce reranking-ul îmbunătățește rezultatele
- Implementați un reranker folosind un cross-encoder
- Integrați reranking-ul într-un pipeline RAG
Problema Bi-Encoder-ului
Toată căutarea pe care ați construit-o până acum se bazează pe un bi-encoder: interogarea și documentele sunt codificate separat, independent, și comparate prin produs scalar. Acest lucru face cautarea instantanee chiar și pe un milion de fragmente, deoarece vectorii corpusului au fost calculați o singură dată. Totuși, acesta este și motivul impreciziei, deoarece modelul nu vede niciodată interogarea și documentul împreună: trebuie să rezume fiecare text într-un vector fără a ști ce i se va cere mai târziu.
Un cross-encoder, numit și reranker, primește perechea (interogare, document) ca intrare și produce un scor de relevanță mult mai fin, deoarece citește ambele texte simultan și poate detecta dacă un document discută subiectul, dar într-un sens opus. Acest câștig are un cost: modelul trebuie să proceseze fiecare document individual, ceea ce interzice utilizarea sa pe întregul corpus. Soluția este să îl employați acolo unde este eficient din punct de vedere al costurilor, pe un set mic de candidați deja preselectați.
De aici rezultă pipeline-ul în două etape, în care fiecare model face ceea ce știe mai bine: cel rapid restrânge câmpul de căutare, iar cel precis face selecția finală.
Query → Bi-encoder → Top 50 Candidates → Cross-encoder → Top 5 Results
Reranking cu Cohere
Cohere expune un reranker de înaltă performanță prin API, ceea ce evită necesitatea găzduirii unui model. Funcția următoare înlănțuie cei doi pași: mai întâi recuperează douăzeci de candidați prin similaritate vectorială, apoi cere lui rerank-v3.5 să păstreze doar cinci. Observați câmpul index_original păstrat în rezultat: reranker-ul returnează poziții relative la lista de candidați, iar dumneavoastră veți avea nevoie de aceasta pentru a mapa înapoi la documentul real din corpusul dumneavoastră.
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]:
"""Semantic search + reranking."""
# Step 1: Fast retrieval (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]
# Step 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 cu un LLM
Dacă preferați să nu adăugați un alt provider arhitecturii dumneavoastră—din motive contractuale, localizare a datelor sau simplu motiv de facturare—un LLM pe care îl apelați deja poate îndeplini acest rol. Trimiteți întrebarea și un document, cereți un scor de la 0 la 10 și sortați. Temperatura setată la zero și max_tokens redus la cinci asigură un output determinist și ieftin; blocul try/except gestionează cazurile în care modelul răspunde cu altceva decât un număr.
from openai import OpenAI
client = OpenAI()
def llm_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[dict]:
"""Uses an LLM to score relevance."""
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]
Această versiune costă o apelare per candidat, adică douăzeci de apeluri și o latență cumulativă pe măsură pentru o singură întrebare a utilizatorului. În practică, acest lucru este prohibitiv într-o interfață interactivă. În schimb, cerem modelului să clasifice toate documentele deodată, prezentând fiecare candidat trunchiat la 200 de caractere și numerotat, așteptând doar o listă de indici ca răspuns.
def llm_batch_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[int]:
"""Reranking in a single LLM call."""
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]
Integrarea în Pipeline-ul RAG
Într-un pipeline complet, reranking-ul se plasează între recuperare și generare fără a schimba nimic altceva. Punctul cheie în clasa de mai jos este pragul de 0.3 pe relevance_score: acesta permite returnarea a mai puțin de cinci contexte atunci când niciun candidat nu este cu adevărat relevant, în loc să hrănească generatorul cu zgomot. Adesea, acest filtru, mai mult decât reranking-ul în sine, elimină răspunsurile halucinate.
class RAGPipelineWithReranking:
def __init__(self):
self.client = OpenAI()
self.co = cohere.Client()
def respond(self, question: str, chunks, embeddings_corpus):
# 1. Broad retrieval
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. Select the best
contexts = [
chunks[candidates[r.index]]
for r in reranked.results
if r.relevance_score > 0.3 # Relevance threshold
]
# 4. Generate the answer
return self.generate(question, contexts)
Impactul Reranking-ului
| Metrică | Fără Reranking | Cu Reranking | Câștig |
|---|---|---|---|
| Recall@5 | 0.72 | 0.72 | = |
| Precision@5 | 0.58 | 0.78 | +34% |
| MRR | 0.65 | 0.82 | +26% |
Aceste cifre spun exact ce face un reranker. Recall-ul nu se mișcă, și acest lucru este logic: candidații sunt aceiași, iar cross-encoder-ul nu poate salva un document pe care bi-encoder-ul nu l-a adus la suprafață. Totuși, precizia și MRR se îmbunătățesc semnificativ, deoarece documentul corect trece de pe locul șase pe primul loc. Corolar practic: dacă recall-ul dumneavoastră este slab, reranking-ul nu vă va salva; trebuie mai întâi să lărgiți recuperarea sau să revizuiți fragmentarea (chunking).
Puncte cheie
- Reranking-ul reclasează candidații cu un model mai precis
- Pipeline tipic: bi-encoder (top 20–50) → cross-encoder (top 5)
- Cohere rerank-v3.5 este o soluție la cheie
- Un LLM poate servi ca reranker dacă preferați să evitați o dependență externă
- Câștigul de precizie este semnificativ (de obicei 20–35%)