Ponovno razvrščanje: izboljšanje ustreznosti
Na tej strani
Cilji
- Razumeš, zakaj ponovno razvrščanje izboljša rezultate
- Implementiraš ponovno razvrščanje z uporabo navzkrižnega kodirnika (cross-encoder)
- Integriraš ponovno razvrščanje v cevovod RAG
Težava z dvojnimi kodirniki (Bi-Encoder)
Vso dosedanje iskanje, ki si ga zgradil, temelji na dvojnem kodirniku (bi-encoder): poizvedba in dokumenti so kodirani ločeno, vsak zase, in primerjani prek skalarnega produkta. To omogoča trenutno iskanje med milijonom kosov besedila, saj so vektorji korpusa izračunani enkrat za vselej. Prav to pa tudi povzroča netočnost, ker model nikoli ne vidi poizvedbe in dokumenta hkrati: vsako besedilo mora strniti v vektor, ne da bi vedel, kaj ga bo kasneje vprašal.
Navzkrižni kodirnik (cross-encoder), imenovan tudi ponovni razvrščevalnik (reranker), kot vhod sprejme par (poizvedba, dokument) in ustvari veliko natančnejšo oceno ustreznosti, ker prebere oba teksta skupaj in lahko zazna, da dokument obravnava temo, vendar v nasprotnem smislu. Ta dobiček ima svojo ceno: model mora obdelati vsak dokument posebej, kar onemogoča njegovo uporabo na celotnem korpusu. Rešitev je uporaba tam, kjer je stroškovno učinkovit, in sicer na majhnem naboru kandidatov, ki so bili že predhodno izbrani.
Zato obstaja dvostopenjski cevovod, kjer vsak model opravi tisto, kar zna najbolje: hitri model zoži izbor, natančni pa naredi končni izbor.
Query → Bi-encoder → Top 50 Candidates → Cross-encoder → Top 5 Results
Ponovno razvrščanje s Cohere
Cohere ponuja zmogljiv ponovni razvrščevalnik prek API-ja, kar odpravi potrebo po gostovanju modela. Naslednja funkcija združuje oba koraka: najprej pridobi dvajset kandidatov prek vektorske podobnosti, nato pa zahteva od rerank-v3.5, da obdrži le pet. Upoštevaj polje index_original, ki je ohranjeno v rezultatu: ponovni razvrščevalnik vrne položaje glede na seznam kandidatov, kar boš potreboval za preslikavo nazaj na dejanski dokument v svojem korpusu.
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]:
"""Semantično iskanje + ponovno razvrščanje."""
# 1. korak: Hitro pridobivanje (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. korak: Ponovno razvrščanje (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
]
Ponovno razvrščanje z LLM
Če zaradi pogodbenih razlogov, lokalizacije podatkov ali preprosto zaradi zaračunavanja ne želiš dodati drugega ponudnika v svojo arhitekturo, lahko to vlogo opravi LLM, ki ga že kličeš. Pošlješ vprašanje in dokument, zahtevaš oceno od 0 do 10 in razvrstiš. Temperatura, nastavljena na nič, in max_tokens, zmanjšani na pet, zagotavljata determinističen in poceni izhod; blok try/except pa obravnava primere, ko model odgovori z nečim drugim kot s številko.
from openai import OpenAI
client = OpenAI()
def llm_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[dict]:
"""Uporaba LLM za ocenjevanje ustreznosti."""
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 različica stane en klic na kandidata, kar pomeni dvajset klicev in enako kumulativno zakasnitev za eno uporabnikovo vprašanje. V praksi je to v interaktivnem vmesniku nesprejemljivo. Namesto tega model prosimo, naj razvrsti vse dokumente hkrati, pri čemer vsakega kandidata prikaže okrajšanega na 200 znakov in oštevilčenega, ter pričakujemo le seznam indeksov kot odgovor.
def llm_batch_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[int]:
"""Ponovno razvrščanje v enem samem klicu 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]
Integracija v cevovod RAG
V popolnem cevovodu se ponovno razvrščanje umesti med pridobivanje in generiranje, ne da bi karkoli drugega spremenilo. Ključna točka v spodnjem razredu je prag 0,3 pri relevance_score: ta omogoča vrnitev manj kot petih kontekstov, ko noben kandidat ni resnično ustrezen, namesto da bi generatorju podali šum. Pogosto ta filter, bolj kot samo ponovno razvrščanje, odpravi halucinirane odgovore.
class RAGPipelineWithReranking:
def __init__(self):
self.client = OpenAI()
self.co = cohere.Client()
def respond(self, question: str, chunks, embeddings_corpus):
# 1. Široko pridobivanje
candidates = self.search(question, embeddings_corpus, k=20)
# 2. Ponovno razvrščanje
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. Izbor najboljših
contexts = [
chunks[candidates[r.index]]
for r in reranked.results
if r.relevance_score > 0.3 # Prag ustreznosti
]
# 4. Generiranje odgovora
return self.generate(question, contexts)
Vpliv ponovnega razvrščanja
| Metrika | Brez ponovnega razvrščanja | S ponovnim razvrščanjem | Dobiček |
|---|---|---|---|
| Recall@5 | 0,72 | 0,72 | = |
| Precision@5 | 0,58 | 0,78 | +34 % |
| MRR | 0,65 | 0,82 | +26 % |
Te številke natančno povedo, kaj ponovni razvrščevalnik počne. Recall se ne spremeni, kar je logično: kandidati so isti in navzkrižni kodirnik ne more rešiti dokumenta, ki ga dvojni kodirnik ni našel. Vendar se precision in MRR znatno izboljšata, ker se pravi dokument premakne s šestega na prvo mesto. Praktična posledica: če je tvoj recall slab, te ponovno razvrščanje ne bo rešilo; najprej moraš razširiti pridobivanje ali ponovno pregledati razdeljevanje na kose.
Ključne ugotovitve
- Ponovno razvrščanje znova razvrsti kandidate z natančnejšim modelom
- Tipičen cevovod: dvojni kodirnik (najboljših 20–50) → navzkrižni kodirnik (najboljših 5)
- Cohere rerank-v3.5 je rešitev, pripravljena za uporabo
- LLM lahko služi kot ponovni razvrščevalnik, če se želiš izogniti odvisnosti od drugega ponudnika
- Dobiček v natančnosti je znaten (običajno 20–35 %)