Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Reranking: gerinamas aktualumas

Paskaita 13 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Tikslai
  2. Dvikrypčio koduotuvo (Bi-Encoder) problema
  3. Rerankingas naudojant „Cohere“
  4. Rerankingas naudojant didįjį kalbos modelį (LLM)
  5. Integracija į RAG sistemą
  6. Rerankingo poveikis
  7. Svarbiausi punktai

Tikslai

  • Suprasti, kodėl rerankingas gerina rezultatus
  • Įgyvendinti rerankerį naudojant kryžminį koduotuvą (cross-encoder)
  • Integruoti rerankingą į RAG sistemą

Dvikrypčio koduotuvo (Bi-Encoder) problema

Visa iki šiol sukurta paieška remiasi dvikrypčiu koduotuvu (bi-encoder): užklausa ir dokumentai koduojami atskirai, savarankiškai, o palyginimas atliekamas naudojant skaliarinę sandaugą. Būtent tai leidžia paieškai būti akimirksnine net ir tarp milijono fragmentų, nes korpuso vektoriai apskaičiuojami vieną kartą ir visiems laikams. Tačiau būtent tai daro paiešką netikslią, nes modelis niekada nemato užklausos ir dokumento kartu: jis turi apibendrinti kiekvieną tekstą į vektorių nežinodamas, ko vėliau bus klausiama.

Kryžminis koduotuvas (cross-encoder), dar vadinamas rerankeriu, kaip įvestį gauna porą (užklausa, dokumentas) ir sugeneruoja daug tikslesnį aktualumo įvertinimą, nes skaito abu tekstus kartu ir gali aptikti, kad dokumentas nagrinėja temą, tačiau priešinga prasme. Šis pagerėjimas turi savo kainą: modelis turi apdoroti kiekvieną dokumentą individualiai, todėl jo neįmanoma taikyti visam korpusui. Sprendimas – naudoti jį ten, kur tai ekonomiškai efektyvu, t. y. nedideliam jau atrinktų kandidatų rinkiniui.

Taigi gauname dviejų etapų sistemą, kurioje kiekvienas modelis atlieka tai, ką moka geriausiai: greitas modelis susiaurina paieškos lauką, o tikslus atlieka galutinę atranką.

Query → Bi-encoder → Top 50 Candidates → Cross-encoder → Top 5 Results

Rerankingas naudojant „Cohere“

„Cohere“ per API suteikia našų rerankerį, todėl nereikia pačiam talpinti modelio. Toliau pateikta funkcija sujungia du žingsnius: pirmiausia pagal vektorių panašumą gaunami dvidešimt kandidatų, o tada rerank-v3.5 palieka tik penkis. Atkreipk dėmesį į laukelį index_original, kuris išsaugomas rezultate: rerankeris grąžina pozicijas kandidatų sąrašo atžvilgiu, ir tau jų prireiks norint susieti rezultatus su tikraisiais dokumentais tavo korpuse.

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]:
    """Semantinė paieška + rerankingas."""
    # 1 žingsnis: Greitas gavimas (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 žingsnis: Rerankingas (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
    ]

Rerankingas naudojant didįjį kalbos modelį (LLM)

Jei nenori į savo architektūrą įtraukti papildomo tiekėjo – dėl sutartinių priežasčių, duomenų lokalizacijos ar tiesiog kainodaros – tą patį vaidmenį gali atlikti jau naudojamas didysis kalbos modelis (LLM). Pateiki klausimą ir dokumentą, prašai įvertinimo nuo 0 iki 10 ir rūšiuoji rezultatus. Nustatytas nulinis temperature ir sumažintas max_tokens iki penkių užtikrina deterministinę ir pigią išvestį; blokas try/except apdoroja atvejus, kai modelis atsako ne skaičiumi.

from openai import OpenAI

client = OpenAI()

def llm_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[dict]:
    """Naudoja LLM aktualumui įvertinti."""
    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]

Ši versija kainuoja vieną užklausą vienam kandidatui, vadinasi, vienam naudotojo klausimui tenka dvidešimt užklausų ir tiek pat sukauptos delsos. Praktiškai tai interaktyvioje sąsajoje yra nepriimtina. Vietoj to prašome modelio vienu metu įvertinti visus dokumentus: pateikiame kiekvieną kandidatą, sutrumpintą iki 200 simbolių ir sunumeruotą, tikėdamiesi gauti tik indeksų sąrašą.

def llm_batch_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[int]:
    """Rerankingas vienu LLM iškvietimu."""
    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 į RAG sistemą

Pilnoje sistemoje rerankingas įsiterpia tarp gavimo (retrieval) ir generavimo fazės nieko kito nekeisdamas. Svarbiausias momentas žemiau pateiktoje klasėje yra 0,3 slenkstis laukeliui relevance_score: jis leidžia grąžinti mažiau nei penkis kontekstus, jei nė vienas kandidatas nėra tikrai aktualus, užuot maitinus generatorių triukšmu. Dažnai būtent šis filtras, labiau nei pats rerankingas, pašalina haliucinuotus atsakymus.

class RAGPipelineWithReranking:
    def __init__(self):
        self.client = OpenAI()
        self.co = cohere.Client()

    def respond(self, question: str, chunks, embeddings_corpus):
        # 1. Plati gavimo fazė
        candidates = self.search(question, embeddings_corpus, k=20)

        # 2. Rerankingas
        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. Geriausių pasirinkimas
        contexts = [
            chunks[candidates[r.index]]
            for r in reranked.results
            if r.relevance_score > 0.3  # Aktualumo slenkstis
        ]

        # 4. Atsakymo generavimas
        return self.generate(question, contexts)

Rerankingo poveikis

MetrikaBe rerankingoSu rerankinguPrieaugis
Recall@50.720.72=
Precision@50.580.78+34%
MRR0.650.82+26%

Šie skaičiai tiksliai nusako, ką daro rerankeris. „Recall“ (pilnumas) nesikeičia, ir tai logiška: kandidatai tie patys, o kryžminis koduotuvas negali išgelbėti dokumento, kurio dvikryptis koduotuvas neiškelė. Tačiau „Precision“ (tikslumas) ir MRR žymiai pagerėja, nes tinkamas dokumentas iš šeštos vietos pakyla į pirmąją. Praktinė išvada: jei tavo „recall“ rodiklis prastas, rerankingas tavęs neišgelbės; pirmiausia turi išplėsti gavimo fazę arba peržiūrėti fragmentavimą.

Svarbiausi punktai

  • Rerankingas perrikiuoja kandidatus naudodamas tikslesnį modelį
  • Tipinė sistema: dvikryptis koduotuvas (top 20–50) → kryžminis koduotuvas (top 5)
  • „Cohere rerank-v3.5“ yra paruoštas naudoti sprendimas
  • LLM gali veikti kaip rerankeris, jei nori išvengti papildomų priklausomybių
  • Tikslumo prieaugis yra reikšmingas (paprastai 20–35 %)