Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Reranking: Zlepšenie relevantnosti

Lekcia 13 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Ciele
  2. Problém bi-encoderu
  3. Reranking s Cohere
  4. Reranking pomocou LLM
  5. Integrácia do RAG pipeline
  6. Vplyv rerankingu
  7. Kľúčové poznatky

Ciele

  • Pochopiť, prečo reranking zlepšuje výsledky
  • Implementovať reranker pomocou cross-encoderu
  • Integrovať reranking do RAG pipeline

Problém bi-encoderu

Všetky doteraz vytvorené vyhľadávania spoliehajú na bi-encoder: dopyt aj dokumenty sa kódujú oddelene, samostatne, a porovnávajú sa pomocou skalárneho súčinu. To umožňuje okamžité vyhľadávanie v milióne chunkov, keďže vektory korpusu boli vypočítané raz a navždy. Zároveň je to však príčinou nepresnosti, pretože model nikdy nevidí dopyt a dokument spoločne: musí každý text zhrnúť do vektora bez toho, aby vedel, čo sa od neho neskôr bude žiadať.

Cross-encoder, nazývaný aj reranker, prijíma ako vstup pár (dopyt, dokument) a produkuje oveľa presnejšie skóre relevantnosti, pretože číta oba texty spoločne a dokáže rozpoznať, že dokument síce diskutuje o téme, ale v opačnom zmysle. Tento zisk má svoju cenu: model musí spracovať každý dokument individuálne, čo znemožňuje jeho použitie na celý korpus. Riešením je nasadiť ho tam, kde je to nákladovo efektívne – na malú množinu kandidátov, ktorí už boli predbežne vybratí.

Preto existuje dvojfázová pipeline, kde každý model robí to, v čom je najlepší: rýchly model zúži pole a presný model urobí finálny výber.

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

Reranking s Cohere

Cohere poskytuje vysoko výkonný reranker prostredníctvom API, čo eliminuje potrebu hostovať vlastný model. Nasledujúca funkcia spája oba kroky: najprv získa dvadsať kandidátov pomocou vektorovej podobnosti a potom požiada rerank-v3.5, aby zachoval iba päť z nich. Všimni si pole index_original, ktoré sa vo výsledku zachováva: reranker vracia pozície relatívne k zoznamu kandidátov a ty budeš potrebovať tieto údaje na spätné mapovanie na skutočný dokument v tvojom 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]:
    """Sémantické vyhľadávanie + reranking."""
    # Krok 1: Rýchle získanie (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]

    # Krok 2: Reranking (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
    ]

Reranking pomocou LLM

Ak nechceš do svojej architektúry pridávať ďalšieho poskytovateľa – či už z dôvodu zmluvných podmienok, lokalizácie dát alebo jednoducho fakturácie – túto úlohu môže prevziať LLM, ktoré už aj tak používaš. Odošleš otázku a dokument, požiadaš o skóre od 0 do 10 a výsledky zoradíš. Nastavenie teploty na nulu a obmedzenie max_tokens na päť zabezpečí deterministický a lacný výstup; blok try/except ošetruje prípady, keď model odpovie niečím iným než číslom.

from openai import OpenAI

client = OpenAI()

def llm_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[dict]:
    """Používa LLM na hodnotenie relevantnosti."""
    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]

Táto verzia stojí jedno volanie na každého kandidáta, čo znamená dvadsať volaní a rovnakú kumulatívnu latenciu pre jednu používateľskú otázku. V praxi je to v interaktívnom rozhraní neúnosné. Namiesto toho požiadaš model, aby zoradil všetky dokumenty naraz, pričom každého kandidáta skrátíš na 200 znakov a očíslovať, pričom očakávaš späť iba zoznam indexov.

def llm_batch_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[int]:
    """Reranking v jednom volaní LLM."""
    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ácia do RAG pipeline

V kompletnej pipeline zapadá reranking medzi fázu získavania a generovania bez toho, aby menil čokoľvek iné. Kľúčovým bodom v nižšie uvedenej triede je prahová hodnota 0,3 pre relevance_score: umožňuje vrátiť menej ako päť kontextov, keď žiadny kandidát nie je skutočne relevantný, namiesto toho, aby sa generátoru predával šum. Práve tento filter, často viac než samotný reranking, eliminuje halucinované odpovede.

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

    def respond(self, question: str, chunks, embeddings_corpus):
        # 1. Široké získavanie
        candidates = self.search(question, embeddings_corpus, k=20)

        # 2. Reranking
        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. Výber najlepších
        contexts = [
            chunks[candidates[r.index]]
            for r in reranked.results
            if r.relevance_score > 0.3  # Prah relevantnosti
        ]

        # 4. Generovanie odpovede
        return self.generate(question, contexts)

Vplyv rerankingu

MetrikaBez rerankinguS rerankingomZisk
Recall@50.720.72=
Precision@50.580.78+34%
MRR0.650.82+26%

Tieto čísla presne hovoria o tom, čo reranker robí. Recall sa nemení, čo je logické: kandidáti sú tí istí a cross-encoder nemôže zachrániť dokument, ktorý bi-encoder nevytiahlo na povrch. Avšak presnosť a MRR sa výrazne zlepšujú, pretože správny dokument sa posunie zo šiesteho miesta na prvé. Praktický dôsledok: ak máš slabý recall, reranking ťa nezachráni; musíš najprv rozšíriť získavanie alebo prehodnotiť chunking.

Kľúčové poznatky

  • Reranking znovu zoradí kandidátov pomocou presnejšieho modelu
  • Typická pipeline: bi-encoder (top 20–50) → cross-encoder (top 5)
  • Cohere rerank-v3.5 je hotové riešenie
  • LLM môže slúžiť ako reranker, ak chceš predísť ďalšej závislosti
  • Zisk na presnosti je významný (zvyčajne 20–35 %)