Pārkārtotā rangā: atbilstības uzlabošana
Šajā lapā
Mērķi
- Saprast, kāpēc pārkārtotā ranga (reranking) uzlabo rezultātus
- Ieviest pārkārtotāju, izmantojot krustenisko kodētāju (cross-encoder)
- Integrēt pārkārtoto rangu RAG cauruļvadā
Divkāršā kodētāja problēma
Visa līdz šim izveidotā meklēšana balstās uz divkāršo kodētāju (bi-encoder): vaicājums un dokumenti tiek kodēti atsevišķi, neatkarīgi viens no otra, un salīdzināti, izmantojot skalāro reizinājumu. Tieši tas padara meklēšanu acumirklīgu pat miljona fragmentu apjomā, jo korpusa vektori ir aprēķināti vienreiz un uz visiem laikiem. Tas arī ir iemesls, kāpēc tā ir neprecīza: modelis nekad neredz vaicājumu un dokumentu kopā; tam ir jāapkopo katrs teksts vektorā, nezinot, kas tam vēlāk tiks prasīts.
Krusteniskais kodētājs (cross-encoder), ko dēvē arī par pārkārtotāju, kā ievadi saņem pāri (vaicājums, dokuments) un ģenerē daudz precīzāku atbilstības vērtējumu, jo tas nolasa abus tekstus kopīgi un spēj noteikt, ka dokuments apspriež tēmu, bet pretējā nozīmē. Šis ieguvums ir saistīts ar izmaksām: modelim katrs dokuments jāapstrādā individuāli, kas aizliedz to izmantot visam korpusam. Risinājums ir izmantot to tur, kur tas ir izdevīgi, – nelielam jau atlasītu kandidātu kopumam.
Tādējādi veidojas divu posmu cauruļvads, kur katrs modelis dara to, ko prot vislabāk: ātrais sašaurina lauku, bet precīzais veic galīgo atlasi.
Query → Bi-encoder → Top 50 Candidates → Cross-encoder → Top 5 Results
Pārkārtotā ranga veikšana ar Cohere
Cohere piedāvā augstas veiktspējas pārkārtotāju, izmantojot API, kas ļauj izvairīties no modeļa mitināšanas pašam. Tālāk redzamā funkcija savieno abus soļus: tā vispirms iegūst divdesmit kandidātus, izmantojot vektoru līdzību, un pēcāk pieprasa rerank-v3.5 atstāt tikai piecus. Ņem vērā lauku index_original, kas tiek saglabāts rezultātā: pārkārtotājs atgriež pozīcijas attiecībā pret kandidātu sarakstu, un tas tev būs nepieciešams, lai atgrieztos pie faktiskā dokumenta savā 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ā meklēšana + pārkārtotais rangs."""
# 1. solis: Ātra iegūšana (divkāršais kodētājs)
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. solis: Pārkārtotais rangs (krusteniskais kodētājs)
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
]
Pārkārtotā ranga veikšana ar LLM
Ja nevēlies savai arhitektūrai pievienot vēl vienu nodrošinātāju – līgumisku iemeslu, datu lokalizācijas vai vienkārši rēķinu dēļ –, šo lomu var uzņemties LLM, ko jau izmanto. Tu iesniedz jautājumu un dokumentu, pieprasi vērtējumu no 0 līdz 10 un sakārto tos. Temperatūras iestatīšana uz nulli un max_tokens samazināšana līdz pieciem nodrošina deterministisku un lētu izvadi; bloks try/except apstrādā gadījumus, kad modelis atbild ar kaut ko citu, nevis skaitli.
from openai import OpenAI
client = OpenAI()
def llm_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[dict]:
"""Izmanto LLM, lai vērtētu atbilstību."""
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]
Šī versija izmaksā vienu izsaukumu uz katru kandidātu, kas nozīmē divdesmit izsaukumus un tikpat lielu kopējo latentumu vienam lietotāja jautājumam. Praksē tas interaktīvā saskarnē ir nepieņemami. Tā vietā mēs lūdzam modeli sakārtot visus dokumentus vienlaikus, parādot katru kandidātu, saīsinātu līdz 200 rakstzīmēm un numurētu, sagaidot atbildē tikai indeksu sarakstu.
def llm_batch_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[int]:
"""Pārkārtotais rangs vienā LLM izsaukumā."""
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]
Integrācija RAG cauruļvadā
Pilnīgā cauruļvadā pārkārtotais rangs iekļaujas starp iegūšanu un ģenerēšanu, nemainot neko citu. Galvenais moments tālāk redzamajā klasē ir slieksnis 0,3 attiecībā uz relevance_score: tas ļauj atgriezt mazāk nekā piecus kontekstus, ja neviens kandidāts nav patiesi atbilstošs, tā vietā, lai ģeneratoram padotu trokšņus. Bieži vien šis filtrs, vairāk nekā pats pārkārtotais rangs, novērš halucinētas atbildes.
class RAGPipelineWithReranking:
def __init__(self):
self.client = OpenAI()
self.co = cohere.Client()
def respond(self, question: str, chunks, embeddings_corpus):
# 1. Plaša iegūšana
candidates = self.search(question, embeddings_corpus, k=20)
# 2. Pārkārtotais rangs
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. Labāko atlase
contexts = [
chunks[candidates[r.index]]
for r in reranked.results
if r.relevance_score > 0.3 # Atbilstības slieksnis
]
# 4. Atbildes ģenerēšana
return self.generate(question, contexts)
Pārkārtotā ranga ietekme
| Metrika | Bez pārkārtotā ranga | Ar pārkārtoto rangu | Pieaugums |
|---|---|---|---|
| Recall@5 | 0.72 | 0.72 | = |
| Precision@5 | 0.58 | 0.78 | +34% |
| MRR | 0.65 | 0.82 | +26% |
Šie skaitļi precīzi parāda, ko dara pārkārtotājs. Atmiņa (Recall) nemainās, un tas ir loģiski: kandidāti ir tie paši, un krusteniskais kodētājs nevar glābt dokumentu, ko divkāršais kodētājs nav izvirzījis priekšplānā. Tomēr precizitāte un MRR ievērojami uzlabojas, jo pareizais dokuments pārvietojas no sestās vietas uz pirmo. Praktiskas sekas: ja tava atmiņa ir vāja, pārkārtotais rangs tevi neglābs; vispirms ir jāpaplašina iegūšana vai jāpārskata fragmentēšana.
Galvenās atziņas
- Pārkārtotais rangs pārkārto kandidātus, izmantojot precīzāku modeli
- Tipisks cauruļvads: divkāršais kodētājs (top 20–50) → krusteniskais kodētājs (top 5)
- Cohere rerank-v3.5 ir gatavs risinājums
- LLM var kalpot kā pārkārtotājs, ja vēlies izvairīties no atkarībām
- Precizitātes pieaugums ir ievērojams (parasti 20–35%)