Ümberjärjestamine: asjakohasuse parandamine
Sellel lehel
Eesmärgid
- Mõista, miks ümberjärjestamine tulemusi parandab
- Rakendada ümberjärjestaja kasutades ristkodeerijat (cross-encoder)
- Integreerida ümberjärjestamine RAG-töövoogu
Kahekodeerija (Bi-encoder) probleem
Kogu senine otsing, mille oled üles ehitanud, tugineb kahekodeerijale: päring ja dokumendid kodeeritakse eraldi, iseseisvalt, ja võrreldakse skalaarkorrutise abil. See võimaldab otsingul olla välkkiire isegi miljoni plokiga, kuna korpuse vektorid on arvutatud üks kord ja igaveseks. Samas teeb see otsingu ebatäpseks, sest mudel ei näe kunagi päringut ja dokumenti koos: ta peab iga teksti vektoriks kokku võtma, teadmata, mida temalt hiljem küsitakse.
Ristkodeerija ehk ümberjärjestaja võtab sisendiks paari (päring, dokument) ja toodab palju täpsema asjakohasuse hinnangu, sest ta loeb mõlemat teksti koos ja suudab tuvastada, et dokument käsitleb teemat, kuid vastupidises tähenduses. See täpsus maksab: mudel peab töötlema iga dokumenti eraldi, mis välistab selle kasutamise kogu korpuse ulatuses. Lahendus on kasutada seda seal, kus see on kuluefektiivne – juba eelvalitud väikese kandidaatide hulga peal.
Seega kaheastmeline töövoog, kus iga mudel teeb seda, mida ta oskab kõige paremini: kiire mudel kitsendab valikut, täpne teeb lõpliku valiku.
Query → Bi-encoder → Top 50 Candidates → Cross-encoder → Top 5 Results
Ümberjärjestamine Cohere’iga
Cohere pakub API kaudu suure jõudlusega ümberjärjestajat, mis välistab mudeli enda majutamise vajaduse. Järgnev funktsioon aheldab kaks sammu: esmalt hangitakse vektorsarnasuse abil kakskümmend kandidaati, seejärel palutakse rerank-v3.5-l jätta alles vaid viis. Pane tähele välja index_original, mis tulemuses säilitatakse: ümberjärjestaja tagastab positsioonid suhtes kandidaatide loendiga ja sul on seda vaja, et mapida tulemus tagasi tegelikule dokumendile sinu korpuses.
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]:
"""Semantiline otsing + ümberjärjestamine."""
# 1. samm: Kiire leidmine (kahekodeerija)
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. samm: Ümberjärjestamine (ristkodeerija)
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
]
Ümberjärjestamine LLM-iga
Kui eelistad oma arhitektuuri mitte lisada uut teenusepakkujat – lepinguliste põhjuste, andmete lokaliseerimise või lihtsalt arvelduse tõttu – saab seda rolli täita juba kasutatav suur keelemudel (LLM). Saadad küsimuse ja dokumendi, küsid hinnangut skaalal 0–10 ja sorteerid. Temperatuuri seadmine nulli ja max_tokens vähendamine viieni tagavad deterministliku ja odava väljundi; try/except käsitleb juhtumeid, kus mudel vastab millegi muuga kui numbriga.
from openai import OpenAI
client = OpenAI()
def llm_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[dict]:
"""Kasutab LLM-i asjakohasuse hindamiseks."""
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]
See versioon maksab ühe väljakutse kandidaadi kohta, mis tähendab kakskümmend väljakutset ja sama palju kumulatiivset latentsust ühe kasutaja küsimuse jaoks. Praktikas on see interaktiivses liideses lubamatu. Selle asemel palume mudelil järjestada kõik dokumendid korraga, esitades iga kandidaadi lühendatuna 200 märgini ja nummerdatuna, oodates vastuseks vaid indeksite loendit.
def llm_batch_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[int]:
"""Ümberjärjestamine ühe LLM-i väljakutsega."""
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]
Integreerimine RAG-töövoogu
Terviklikus töövoos sobitub ümberjärjestamine leidmise ja genereerimise vahele, muutmata midagi muud. Allpool olevas klassis on võtmepunktiks lävi 0,3 väljal relevance_score: see võimaldab tagastada vähem kui viit konteksti, kui ükski kandidaat pole tõeliselt asjakohane, selle asemel et toita generaatorit müraga. Sageli kõrvaldab just see filter, rohkem kui ümberjärjestamine ise, hallutsineeritud vastused.
class RAGPipelineWithReranking:
def __init__(self):
self.client = OpenAI()
self.co = cohere.Client()
def respond(self, question: str, chunks, embeddings_corpus):
# 1. Lai leidmine
candidates = self.search(question, embeddings_corpus, k=20)
# 2. Ümberjärjestamine
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. Parimate valimine
contexts = [
chunks[candidates[r.index]]
for r in reranked.results
if r.relevance_score > 0.3 # Asjakohasuse lävi
]
# 4. Vastuse genereerimine
return self.generate(question, contexts)
Ümberjärjestamise mõju
| Näitaja | Ilma ümberjärjestamiseta | Ümberjärjestamisega | Kasv |
|---|---|---|---|
| Recall@5 | 0.72 | 0.72 | = |
| Precision@5 | 0.58 | 0.78 | +34% |
| MRR | 0.65 | 0.82 | +26% |
Need arvud kirjeldavad täpselt, mida ümberjärjestaja teeb. Recall ei muutu ja see on loogiline: kandidaadid on samad ning ristkodeerija ei suuda päästa dokumenti, mida kahekodeerija esile ei toonud. Küll aga paranevad oluliselt täpsus (precision) ja MRR, sest õige dokument liigub kuuendalt kohalt esimeseks. Praktiline järeldus: kui sinu recall on kehv, ei päästa sind ümberjärjestamine; sa pead esmalt laiendama leidmist või vaatama üle plokistamise.
Peamised punktid
- Ümberjärjestamine järjestab kandidaadid ümber täpsema mudeliga
- Tüüpiline töövoog: kahekodeerija (top 20–50) → ristkodeerija (top 5)
- Cohere rerank-v3.5 on valmislahendus
- LLM võib toimida ümberjärjestajana, kui soovid vältida sõltuvust
- Täpsuse kasv on märkimisväärne (tavaliselt 20–35%)