Reranking: Förbättra relevansen
På denna sida
Mål
- Förstå varför reranking förbättrar resultaten
- Implementera en reranker med hjälp av en cross-encoder
- Integrera reranking i en RAG-pipeline
Problemet med bi-encodrar
All sökning du har byggt hittills förlitar sig på en bi-encoder: frågan och dokumenten kodas separat, var för sig, och jämförs via en skalärprodukt (dot product). Det är detta som gör sökningen ögonblicklig över en miljon chunkar, eftersom korpusvektorerna beräknades en gång för alla. Det är också det som gör den imprecis, eftersom modellen aldrig ser frågan och dokumentet tillsammans: den måste sammanfatta varje text till en vektor utan att veta vad som kommer att frågas om den senare.
En cross-encoder, även kallad en reranker, tar paret (fråga, dokument) som indata och producerar ett mycket finare relevansbetyg, eftersom den läser båda texterna gemensamt och kan upptäcka att ett dokument diskuterar ämnet men i en motsatt betydelse. Denna vinst har ett pris: modellen måste bearbeta varje dokument individuellt, vilket förbjuder användning på hela korpusen. Lösningen är att använda den där det är kostnadseffektivt, på en liten uppsättning kandidater som redan har shortlistats.
Därav tvåstegspipelinen, där varje modell gör det den är bäst på: den snabba smalnar av fältet, den precisa gör det slutgiltiga urvalet.
Query → Bi-encoder → Top 50 Candidates → Cross-encoder → Top 5 Results
Reranking med Cohere
Cohere tillhandahåller en högpresterande reranker via API, vilket undviker behovet av att hosta en modell själv. Följande funktion kedjar ihop de två stegen: den hämtar först tjugo kandidater via vektorlikhet, och ber sedan rerank-v3.5 att bara behålla fem. Observera fältet index_original som bevaras i resultatet: rerankern returnerar positioner relativt kandidatlistan, och du behöver detta för att mappa tillbaka till det faktiska dokumentet i din korpus.
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]:
"""Semantisk sökning + reranking."""
# Steg 1: Snabb hämtning (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]
# Steg 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 med en LLM
Om du föredrar att inte lägga till en annan leverantör i din arkitektur – på grund av avtalsmässiga skäl, datalokalisering eller helt enkelt fakturering – kan en LLM du redan anropar fylla rollen. Du skickar in frågan och ett dokument, ber om ett betyg från 0 till 10 och sorterar. Temperatur inställd på noll och max_tokens reducerat till fem säkerställer deterministisk och billig utdata; try/except hanterar fall där modellen svarar med något annat än ett tal.
from openai import OpenAI
client = OpenAI()
def llm_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[dict]:
"""Använder en LLM för att poängsätta relevans."""
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]
Denna version kostar ett anrop per kandidat, vilket innebär tjugo anrop och lika mycket kumulativ latens för en enda användarfråga. I praktiken är detta förbjudande i ett interaktivt gränssnitt. Istället ber vi modellen att rangordna alla dokument på en gång, presenterar varje kandidat trunkerad till 200 tecken och numrerad, och förväntar oss bara en lista med index tillbaka.
def llm_batch_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[int]:
"""Reranking i ett enda LLM-anrop."""
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]
Integration i RAG-pipelinen
I en komplett pipeline passar reranking in mellan hämtning och generering utan att ändra något annat. Nyckelpunkten i klassen nedan är tröskeln på 0,3 för relevance_score: den tillåter returnering av färre än fem kontexter när ingen kandidat är verkligen relevant, snarare än att mata generatorn med brus. Ofta eliminerar detta filter, mer än själva rerankingen, hallucinerade svar.
class RAGPipelineWithReranking:
def __init__(self):
self.client = OpenAI()
self.co = cohere.Client()
def respond(self, question: str, chunks, embeddings_corpus):
# 1. Bred hämtning
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älj de bästa
contexts = [
chunks[candidates[r.index]]
for r in reranked.results
if r.relevance_score > 0.3 # Relevanströskel
]
# 4. Generera svaret
return self.generate(question, contexts)
Effekten av reranking
| Metrik | Utan reranking | Med reranking | Vinst |
|---|---|---|---|
| Recall@5 | 0.72 | 0.72 | = |
| Precision@5 | 0.58 | 0.78 | +34% |
| MRR | 0.65 | 0.82 | +26% |
Dessa siffror berättar exakt vad en reranker gör. Recall rör sig inte, och det är logiskt: kandidaterna är desamma, och cross-encodern kan inte rädda ett dokument som bi-encodern inte fick fram. Däremot förbättras precision och MRR avsevärt, eftersom rätt dokument flyttas från sjätte plats till första. Praktisk följd: om din recall är dålig kommer reranking inte att rädda dig; du måste först bredda hämtningen eller se över chunkingen.
Viktiga punkter
- Reranking sorterar om kandidater med en mer precis modell
- Typisk pipeline: bi-encoder (topp 20–50) → cross-encoder (topp 5)
- Cohere rerank-v3.5 är en färdig lösning
- En LLM kan fungera som reranker om du föredrar att undvika ett beroende
- Vinsten i precision är betydande (vanligtvis 20–35%)