Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Ümberjärjestamine: asjakohasuse parandamine

Õppetund 13 / 22 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Eesmärgid
  2. Kahekodeerija (Bi-encoder) probleem
  3. Ümberjärjestamine Cohere’iga
  4. Ümberjärjestamine LLM-iga
  5. Integreerimine RAG-töövoogu
  6. Ümberjärjestamise mõju
  7. Peamised punktid

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äitajaIlma ümberjärjestamisetaÜmberjärjestamisegaKasv
Recall@50.720.72=
Precision@50.580.78+34%
MRR0.650.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%)