Reranking: gerinamas aktualumas
Šiame puslapyje
Tikslai
- Suprasti, kodėl rerankingas gerina rezultatus
- Įgyvendinti rerankerį naudojant kryžminį koduotuvą (cross-encoder)
- Integruoti rerankingą į RAG sistemą
Dvikrypčio koduotuvo (Bi-Encoder) problema
Visa iki šiol sukurta paieška remiasi dvikrypčiu koduotuvu (bi-encoder): užklausa ir dokumentai koduojami atskirai, savarankiškai, o palyginimas atliekamas naudojant skaliarinę sandaugą. Būtent tai leidžia paieškai būti akimirksnine net ir tarp milijono fragmentų, nes korpuso vektoriai apskaičiuojami vieną kartą ir visiems laikams. Tačiau būtent tai daro paiešką netikslią, nes modelis niekada nemato užklausos ir dokumento kartu: jis turi apibendrinti kiekvieną tekstą į vektorių nežinodamas, ko vėliau bus klausiama.
Kryžminis koduotuvas (cross-encoder), dar vadinamas rerankeriu, kaip įvestį gauna porą (užklausa, dokumentas) ir sugeneruoja daug tikslesnį aktualumo įvertinimą, nes skaito abu tekstus kartu ir gali aptikti, kad dokumentas nagrinėja temą, tačiau priešinga prasme. Šis pagerėjimas turi savo kainą: modelis turi apdoroti kiekvieną dokumentą individualiai, todėl jo neįmanoma taikyti visam korpusui. Sprendimas – naudoti jį ten, kur tai ekonomiškai efektyvu, t. y. nedideliam jau atrinktų kandidatų rinkiniui.
Taigi gauname dviejų etapų sistemą, kurioje kiekvienas modelis atlieka tai, ką moka geriausiai: greitas modelis susiaurina paieškos lauką, o tikslus atlieka galutinę atranką.
Query → Bi-encoder → Top 50 Candidates → Cross-encoder → Top 5 Results
Rerankingas naudojant „Cohere“
„Cohere“ per API suteikia našų rerankerį, todėl nereikia pačiam talpinti modelio. Toliau pateikta funkcija sujungia du žingsnius: pirmiausia pagal vektorių panašumą gaunami dvidešimt kandidatų, o tada rerank-v3.5 palieka tik penkis. Atkreipk dėmesį į laukelį index_original, kuris išsaugomas rezultate: rerankeris grąžina pozicijas kandidatų sąrašo atžvilgiu, ir tau jų prireiks norint susieti rezultatus su tikraisiais dokumentais tavo 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]:
"""Semantinė paieška + rerankingas."""
# 1 žingsnis: Greitas gavimas (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]
# 2 žingsnis: Rerankingas (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
]
Rerankingas naudojant didįjį kalbos modelį (LLM)
Jei nenori į savo architektūrą įtraukti papildomo tiekėjo – dėl sutartinių priežasčių, duomenų lokalizacijos ar tiesiog kainodaros – tą patį vaidmenį gali atlikti jau naudojamas didysis kalbos modelis (LLM). Pateiki klausimą ir dokumentą, prašai įvertinimo nuo 0 iki 10 ir rūšiuoji rezultatus. Nustatytas nulinis temperature ir sumažintas max_tokens iki penkių užtikrina deterministinę ir pigią išvestį; blokas try/except apdoroja atvejus, kai modelis atsako ne skaičiumi.
from openai import OpenAI
client = OpenAI()
def llm_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[dict]:
"""Naudoja LLM aktualumui įvertinti."""
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]
Ši versija kainuoja vieną užklausą vienam kandidatui, vadinasi, vienam naudotojo klausimui tenka dvidešimt užklausų ir tiek pat sukauptos delsos. Praktiškai tai interaktyvioje sąsajoje yra nepriimtina. Vietoj to prašome modelio vienu metu įvertinti visus dokumentus: pateikiame kiekvieną kandidatą, sutrumpintą iki 200 simbolių ir sunumeruotą, tikėdamiesi gauti tik indeksų sąrašą.
def llm_batch_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[int]:
"""Rerankingas vienu LLM iškvietimu."""
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]
Integracija į RAG sistemą
Pilnoje sistemoje rerankingas įsiterpia tarp gavimo (retrieval) ir generavimo fazės nieko kito nekeisdamas. Svarbiausias momentas žemiau pateiktoje klasėje yra 0,3 slenkstis laukeliui relevance_score: jis leidžia grąžinti mažiau nei penkis kontekstus, jei nė vienas kandidatas nėra tikrai aktualus, užuot maitinus generatorių triukšmu. Dažnai būtent šis filtras, labiau nei pats rerankingas, pašalina haliucinuotus atsakymus.
class RAGPipelineWithReranking:
def __init__(self):
self.client = OpenAI()
self.co = cohere.Client()
def respond(self, question: str, chunks, embeddings_corpus):
# 1. Plati gavimo fazė
candidates = self.search(question, embeddings_corpus, k=20)
# 2. Rerankingas
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. Geriausių pasirinkimas
contexts = [
chunks[candidates[r.index]]
for r in reranked.results
if r.relevance_score > 0.3 # Aktualumo slenkstis
]
# 4. Atsakymo generavimas
return self.generate(question, contexts)
Rerankingo poveikis
| Metrika | Be rerankingo | Su rerankingu | Prieaugis |
|---|---|---|---|
| Recall@5 | 0.72 | 0.72 | = |
| Precision@5 | 0.58 | 0.78 | +34% |
| MRR | 0.65 | 0.82 | +26% |
Šie skaičiai tiksliai nusako, ką daro rerankeris. „Recall“ (pilnumas) nesikeičia, ir tai logiška: kandidatai tie patys, o kryžminis koduotuvas negali išgelbėti dokumento, kurio dvikryptis koduotuvas neiškelė. Tačiau „Precision“ (tikslumas) ir MRR žymiai pagerėja, nes tinkamas dokumentas iš šeštos vietos pakyla į pirmąją. Praktinė išvada: jei tavo „recall“ rodiklis prastas, rerankingas tavęs neišgelbės; pirmiausia turi išplėsti gavimo fazę arba peržiūrėti fragmentavimą.
Svarbiausi punktai
- Rerankingas perrikiuoja kandidatus naudodamas tikslesnį modelį
- Tipinė sistema: dvikryptis koduotuvas (top 20–50) → kryžminis koduotuvas (top 5)
- „Cohere rerank-v3.5“ yra paruoštas naudoti sprendimas
- LLM gali veikti kaip rerankeris, jei nori išvengti papildomų priklausomybių
- Tikslumo prieaugis yra reikšmingas (paprastai 20–35 %)