Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Újrarendezés: A relevancia javítása

13. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Célok
  2. A kétirányú kódoló (Bi-Encoder) problémája
  3. Újrarendezés Cohere-rel
  4. Újrarendezés LLM-mel
  5. Integráció a RAG folyamatba
  6. Az újrarendezés hatása
  7. Főbb megállapítások

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ésselNyereség
Recall@50.720.72=
Precision@50.580.78+34%
MRR0.650.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%)