Újrarendezés: A relevancia javítása
Ezen az oldalon
Célok
- Megérteni, miért javítja az újrarendezés az eredményeket
- Újrarendező (reranker) implementálása kereszt-kódoló (cross-encoder) segítségével
- Az újrarendezés integrálása egy RAG folyamatba
A kétirányú kódoló (Bi-Encoder) problémája
Az eddig felépített keresés mind egy kétirányú kódolón (bi-encoder) alapul: a lekérdezést és a dokumentumokat külön-külön kódolja, majd pontszorzattal hasonlítja össze. Ez teszi lehetővé, hogy a keresés azonnali legyen milliónyi szövegrészlet esetén is, mivel a korpusz vektorait egyszer és mindenkorra kiszámoltuk. Ugyanakkor ez okozza a pontatlanságot is, mert a modell sosem látja együtt a lekérdezést és a dokumentumot: minden szöveget vektorként kell összefoglalnia anélkül, hogy tudná, mit fognak később kérdezni tőle.
Ezzel szemben a kereszt-kódoló (cross-encoder), más néven újrarendező, a (lekérdezés, dokumentum) párost veszi bemenetként, és sokkal finomabb relevancia-pontszámot állít elő, mivel mindkét szöveget együtt olvassa, és képes felismerni, ha egy dokumentum ugyan tárgyalja a témát, de ellentétes értelemben. Ennek a nyereségnek ára van: a modellnek minden dokumentumot egyedileg kell feldolgoznia, ami lehetetlenné teszi a teljes korpuszon való alkalmazást. A megoldás az, hogy ott vetjük be, ahol költséghatékony: egy már előszűrt, kis méretű jelölthalmazon.
Így születik meg a kétlépcsős folyamat, ahol mindkét modell azt csinálja, amiben a legjobb: a gyors leszűkíti a kört, a pontos pedig meghozza a végső döntést.
Lekérdezés → Kétirányú kódoló → Top 50 jelölt → Kereszt-kódoló → Top 5 találat
Újrarendezés Cohere-rel
A Cohere nagy teljesítményű újrarendezőt tesz elérhetővé API-n keresztül, így elkerülhető egy saját modell üzemeltetése. Az alábbi függvény láncolja össze a két lépést: először húsz jelöltet hív le vektorhasonlóság alapján, majd a rerank-v3.5 modellt kérdezi meg, hogy ezek közül csak ötöt tartson meg. Figyeld meg a válaszban megőrzött index_original mezőt: az újrarendező a jelöltlistához viszonyított pozíciókat adja vissza, és erre szükséged lesz, hogy visszavezesd az eredményt a korpuszodban lévő tényleges dokumentumhoz.
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]:
"""Szemantikai keresés + újrarendezés."""
# 1. lépés: Gyors lekérés (kétirányú kódoló)
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. lépés: Újrarendezés (kereszt-kódoló)
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
]
Újrarendezés LLM-mel
Ha nem szeretnél új szolgáltatót bevonnani az architektúrádba – szerződéses okok, adatlocalizáció vagy egyszerűen a számlázás miatt –, akkor egy már használt LLM is betöltheti ezt a szerepet. Beküldöd a kérdést és egy dokumentumot, kérsz egy 0 és 10 közötti pontszámot, majd rendezel. A nullára állított hőmérséklet (temperature) és az öt tokenre korlátozott max_tokens biztosítja a determinisztikus és olcsó választ; a try/except blokk pedig kezeli azokat az eseteket, amikor a modell nem számot válaszol.
from openai import OpenAI
client = OpenAI()
def llm_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[dict]:
"""LLM használata a relevancia pontozására."""
scores = []
for i, doc in enumerate(candidates):
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"0 és 10 közötti skálán mennyire releváns ez a dokumentum "
f"a kérdés megválaszolásához?\n\n"
f"Kérdés: {question}\n\n"
f"Dokumentum: {doc}\n\n"
f"Csak egy 0 és 10 közötti számot válaszolj."
)
}],
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]
Ennek a verziónak az ára hívásonként egy lekérdezés, ami húsz hívást és ugyanennyi halmozott késleltetést jelent egyetlen felhasználói kérdés esetén. Gyakorlatilag ez interaktív felületeken kivitelezhetetlen. Ehelyett arra kérjük a modellt, hogy egyszerre rangsorolja az összes dokumentumot: minden jelöltet 200 karakterre rövidítve és sorszámozva prezentálunk, és cserébe csak az indexek listáját várjuk vissza.
def llm_batch_reranker(
question: str,
candidates: list[str],
k: int = 5
) -> list[int]:
"""Újrarendezés egyetlen LLM hívással."""
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"Rangsorold ezeket a dokumentumokat a kérdéshez való relevanciájuk alapján. "
f"Add vissza a {k} legrelevánsabb dokumentum indexeit, "
f"vesszővel elválasztva, a legrelevánsabbtól a legkevésbé relevánsig.\n\n"
f"Kérdés: {question}\n\n"
f"Dokumentumok:\n{formatted_docs}\n\n"
f"Indexek (pl. 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áció a RAG folyamatba
Egy teljes folyamatban az újrarendezés a lekérés és a generálás közé illeszkedik, anélkül, hogy bármi mást megváltoztatna. Az alábbi osztály kulcspontja a relevance_score 0,3-as küszöbértéke: ez lehetővé teszi, hogy kevesebb mint öt kontextust adjon vissza, ha egyetlen jelölt sem igazán releváns, ahelyett, hogy zajt etetnénk a generátorral. Gyakran ez a szűrő – inkább mint maga az újrarendezés – szünteti meg a hallucinált válaszokat.
class RAGPipelineWithReranking:
def __init__(self):
self.client = OpenAI()
self.co = cohere.Client()
def respond(self, question: str, chunks, embeddings_corpus):
# 1. Széles körű lekérés
candidates = self.search(question, embeddings_corpus, k=20)
# 2. Újrarendezés
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. A legjobbak kiválasztása
contexts = [
chunks[candidates[r.index]]
for r in reranked.results
if r.relevance_score > 0.3 # Relevancia küszöb
]
# 4. A válasz generálása
return self.generate(question, contexts)
Az újrarendezés hatása
| Metrika | Újrarendezés nélkül | Újrarendezéssel | Nyereség |
|---|---|---|---|
| Recall@5 | 0.72 | 0.72 | = |
| Precision@5 | 0.58 | 0.78 | +34% |
| MRR | 0.65 | 0.82 | +26% |
Ezek a számok pontosan megmutatják, mit csinál egy újrarendező. A visszahívási arány (Recall) nem változik, és ez logikus: a jelöltek ugyanazok, és a kereszt-kódoló nem tudja megmenteni azt a dokumentumot, amit a kétirányú kódoló fel sem hozott. Ezzel szemben a pontosság (Precision) és az MRR jelentősen javul, mert a megfelelő dokumentum a hatodik helyről az elsőre kerül. Gyakorlati következmény: ha a visszahívási arányod gyenge, az újrarendezés nem fog megmenteni; először szélesítened kell a lekérést vagy felül kell vizsgálnod a szövegdarabolást (chunking).
Főbb megállapítások
- Az újrarendezés egy pontosabb modellel sorolja újra a jelölteket
- Tipikus folyamat: kétirányú kódoló (top 20–50) → kereszt-kódoló (top 5)
- A Cohere rerank-v3.5 egy kész megoldás
- Egy LLM is szolgálhat újrarendezőként, ha elkerülnéd a további függőségeket
- A pontosság nyeresége jelentős (jellemzően 20–35%)