Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Přehodnocení pořadí: Zlepšení relevance

Lekce 13 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Problém bi-encoderu
  3. Přehodnocení pořadí s Cohere
  4. Přehodnocení pořadí pomocí LLM
  5. Integrace do RAG pipeline
  6. Dopad přehodnocení pořadí
  7. Klíčové poznatky

Cíle

  • Pochopit, proč přehodnocení pořadí (reranking) zlepšuje výsledky
  • Implementovat přehodnocovač pomocí cross-encoderu
  • Integrovat přehodnocení do RAG pipeline

Problém bi-encoderu

Veškeré vyhledávání, které jsi doposud vybudoval, spoléhá na bi-encoder: dotaz a dokumenty jsou kódovány odděleně, samostatně, a porovnávány prostřednictvím skalárního součinu. To je to, co činí vyhledávání okamžitým i přes milion chunků, protože vektory korpusu byly vypočítány jednou provždy. Zároveň je to však příčina nepřesnosti, protože model nikdy nevidí dotaz a dokument společně: musí každý text shrnout do vektoru, aniž by věděl, co bude později požadováno.

Cross-encoder, nazývaný také přehodnocovač (reranker), bere jako vstup pár (dotaz, dokument) a produkuje mnohem jemnější skóre relevance, protože čte oba texty společně a dokáže rozpoznat, že se dokument sice týká daného tématu, ale v opačném smyslu. Tento zisk má svou cenu: model musí zpracovat každý dokument jednotlivě, což znemožňuje jeho použití na celý korpus. Řešením je nasadit jej tam, kde je to nákladově efektivní – na malou sadu kandidátů, kteří již byli předvybráni.

Odtud plyne dvoufázová pipeline, kde každý model dělá to, v čem je nejlepší: ten rychlý zúží pole výběru a ten přesný provede finální výběr.

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

Přehodnocení pořadí s Cohere

Cohere zpřístupňuje vysoce výkonný přehodnocovač přes API, čímž se vyhneš nutnosti hostovat vlastní model. Následující funkce řetězí oba kroky: nejprve získá dvacet kandidátů pomocí vektorové podobnosti a poté požádá rerank-v3.5, aby vybral pouze pět. Všimni si pole index_original, které je ve výsledku zachováno: přehodnocovač vrací pozice relativně k seznamu kandidátů a ty budeš potřebovat toto mapování zpět na skutečný dokument ve svém korpusu.

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é vyhledávání + přehodnocení pořadí."""
    # Krok 1: Rychlé získání (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: Přehodnocení pořadí (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
    ]

Přehodnocení pořadí pomocí LLM

Pokud nechceš do své architektury přidávat dalšího poskytovatele – ať už kvůli smluvním podmínkám, lokalizaci dat, nebo jednoduše fakturaci – může tuto roli zastoupit LLM, který již používáš. Odešleš otázku a dokument, požádáš o skóre od 0 do 10 a seřadíš je. Nastavení teploty na nulu a snížení max_tokens na pět zajistí deterministický a levný výstup; blok try/except ošetří případy, kdy model odpoví něčím jiným než číslem.

from openai import OpenAI

client = OpenAI()

def llm_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[dict]:
    """Používá LLM k ohodnocení relevance."""
    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]

Tato verze stojí jedno volání na každého kandidáta, což znamená dvacet volání a odpovídající kumulativní latenci pro jediný uživatelský dotaz. V praxi je to v interaktivním rozhraní nepřípustné. Místo toho požádáme model, aby seřadil všechny dokumenty najednou, přičemž každého kandidáta zkrátíme na 200 znaků a očíslováme, a očekáváme pouze seznam indexů jako odpověď.

def llm_batch_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[int]:
    """Přehodnocení pořadí v jediném volání 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]

Integrace do RAG pipeline

V kompletní pipeline zapadá přehodnocení pořadí mezi fázi získávání (retrieval) a generování, aniž by měnilo cokoli jiného. Klíčovým bodem v níže uvedené třídě je práh 0,3 pro relevance_score: umožňuje vrátit méně než pět kontextů, pokud žádný kandidát není skutečně relevantní, místo abychom generátoru předali šum. Často právě tento filtr, více než samotné přehodnocení, eliminuje halucinované odpovědi.

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

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

        # 2. Přehodnocení pořadí
        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ýběr těch nejlepších
        contexts = [
            chunks[candidates[r.index]]
            for r in reranked.results
            if r.relevance_score > 0.3  # Prahová hodnota relevance
        ]

        # 4. Generování odpovědi
        return self.generate(question, contexts)

Dopad přehodnocení pořadí

MetrikaBez přehodnoceníS přehodnocenímZisk
Recall@50.720.72=
Precision@50.580.78+34 %
MRR0.650.82+26 %

Tato čísla přesně vypovídají o tom, co přehodnocovač dělá. Recall se nemění, což je logické: kandidáti jsou stejní a cross-encoder nemůže zachránit dokument, který bi-encoder neodhalil. Precision a MRR se však výrazně zlepšují, protože správný dokument se posune ze šestého místa na první. Praktický důsledek: pokud máš špatný recall, přehodnocení ti nepomůže; musíš nejprve rozšířit získávání nebo zrevidovat chunkování.

Klíčové poznatky

  • Přehodnocení pořadí znovu seřadí kandidáty pomocí přesnějšího modelu
  • Typická pipeline: bi-encoder (top 20–50) → cross-encoder (top 5)
  • Cohere rerank-v3.5 je hotové řešení
  • LLM může sloužit jako přehodnocovač, pokud se chceš vyhnout další závislosti
  • Zisk v přesnosti je významný (obvykle 20–35 %)