Reranking: Poprawa trafności wyników
Na tej stronie
Cele
- Zrozumienie, dlaczego reranking poprawia wyniki wyszukiwania
- Implementacja rerankera przy użyciu modelu cross-encoder
- Integracja rerankingu z potokiem RAG
Problem bi-encodera
Wszystkie mechanizmy wyszukiwania, które dotychczas zbudowałeś, opierają się na bi-encoderze: zapytanie i dokumenty są kodowane osobno, niezależnie od siebie, a następnie porównywane za pomocą iloczynu skalarnego. To właśnie pozwala na natychmiastowe przeszukiwanie milionów fragmentów tekstu, ponieważ wektory całego korpusu zostały obliczone raz na zawsze. Jest to jednak również przyczyną niedokładności, ponieważ model nigdy nie widzi zapytania i dokumentu razem: musi streścić każdy tekst do postaci wektora, nie wiedząc, o co zostanie później zapytany.
Cross-encoder, zwany również rerankerem, przyjmuje parę (zapytanie, dokument) jako dane wejściowe i generuje znacznie dokładniejszy wynik trafności, ponieważ analizuje oba teksty łącznie. Dzięki temu potrafi wykryć, że dokument porusza dany temat, ale w sensie przeciwnym do oczekiwanego. Ta poprawa jakości ma swoją cenę: model musi przetwarzać każdy dokument indywidualnie, co uniemożliwia jego zastosowanie na całym korpusie. Rozwiązaniem jest użycie go tam, gdzie jest to opłacalne – na niewielkim zestawie kandydatów już wstępnie wyselekcjonowanych.
Stąd wynika architektura dwuetapowa, w której każdy model robi to, co potrafi najlepiej: szybki zawęża pole wyszukiania, a precyzyjny dokonuje ostatecznej selekcji.
Query → Bi-encoder → Top 50 Candidates → Cross-encoder → Top 5 Results
Reranking z Cohere
Cohere udostępnia wydajny reranker poprzez API, co eliminuje konieczność hostowania własnego modelu. Poniższa funkcja łączy dwa kroki: najpierw pobiera dwudziestu kandydatów poprzez podobieństwo wektorowe, a następnie prosi model rerank-v3.5 o wybranie tylko pięciu najlepszych. Zwróć uwagę na pole index_original zachowane w wyniku: reranker zwraca pozycje względem listy kandydatów, więc będziesz potrzebować tej informacji, aby odwzorować je na właściwy dokument w swoim korpusie.
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 z użyciem LLM
Jeśli wolisz nie dodawać kolejnego dostawcy do swojej architektury – ze względów kontraktowych, lokalizacji danych lub po prostu kosztów – LLM, którego już używasz, może przejąć tę rolę. Przesyłasz pytanie i dokument, prosząc o ocenę w skali od 0 do 10, a następnie sortujesz wyniki. Ustawienie parametru temperature na zero i ograniczenie max_tokens do pięciu zapewnia deterministyczne i tanie wyjście; blok try/except obsługuje przypadki, w których model odpowiada czymś innym niż liczba.
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]
Ta wersja kosztuje jedno wywołanie API na każdego kandydata, co oznacza dwadzieścia wywołań i odpowiednio dużą łączną latencję dla jednego pytania użytkownika. W praktyce jest to nieakceptowalne w interfejsie interaktywnym. Zamiast tego prosimy model o uszeregowanie wszystkich dokumentów naraz, prezentując każdego kandydata skróconego do 200 znaków i ponumerowanego, oczekując w zamian tylko listy indeksów.
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]
Integracja z potokiem RAG
W kompletnym potoku reranking wpisuje się między etap pobierania danych a generowanie odpowiedzi, nie zmieniając niczego innego. Kluczowym elementem w poniższej klasie jest próg 0,3 dla relevance_score: pozwala on zwrócić mniej niż pięć kontekstów, gdy żaden kandydat nie jest naprawdę istotny, zamiast karmić generator szumem. Często to właśnie ten filtr, bardziej niż sam reranking, eliminuje halucynacje w odpowiedziach.
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)
Wpływ rerankingu
| Metryka | Bez rerankingu | Z rerankingiem | Zysk |
|---|---|---|---|
| Recall@5 | 0.72 | 0.72 | = |
| Precision@5 | 0.58 | 0.78 | +34% |
| MRR | 0.65 | 0.82 | +26% |
Liczby te precyzyjnie opisują działanie rerankera. Recall (pełność) się nie zmienia i jest to logiczne: kandydaci są ci sami, a cross-encoder nie uratuje dokumentu, którego bi-encoder nie wydobył. Jednak precyzja i MRR (Mean Reciprocal Rank) poprawiają się znacząco, ponieważ właściwy dokument przesuwa się z szóstego miejsca na pierwsze. Praktyczny wniosek: jeśli twój recall jest niski, reranking ci nie pomoże; musisz najpierw poszerzyć zakres pobierania danych lub przejrzeć sposób dzielenia tekstu na fragmenty (chunking).
Kluczowe wnioski
- Reranking ponownie ocenia kandydatów przy użyciu bardziej precyzyjnego modelu
- Typowy potok: bi-encoder (top 20–50) → cross-encoder (top 5)
- Cohere rerank-v3.5 to gotowe rozwiązanie typu „pod klucz“
- LLM może pełnić funkcję rerankera, jeśli chcesz uniknąć dodatkowych zależności
- Zysk na precyzji jest znaczący (zazwyczaj 20–35%)