Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Reranking: Forbedring af relevans

Lektion 13 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Mål
  2. Problemet med bi-encodere
  3. Reranking med Cohere
  4. Reranking med en LLM
  5. Integration i RAG-pipelinen
  6. Virkningen af reranking
  7. Vigtige pointer

Mål

  • Forstå hvorfor reranking forbedrer resultaterne
  • Implementere en reranker ved hjælp af en cross-encoder
  • Integrere reranking i en RAG-pipeline

Problemet med bi-encodere

Al den søgning, du har bygget hidtil, er baseret på en bi-encoder: forespørgslen og dokumenterne kodernes separat, hver for sig, og sammenlignes via et prikprodukt. Det er dette, der gør søgning øjeblikkelig på tværs af en million chunks, da korpus-vektorerne blev beregnet én gang for alle. Det er også det, der gør den upræcis, fordi modellen aldrig ser forespørgslen og dokumentet sammen: den skal opsummere hver tekst til en vektor uden at vide, hvad der senere vil blive spurgt om.

En cross-encoder, også kaldet en reranker, tager parret (forespørgsel, dokument) som input og producerer en langt finere relevansscore, fordi den læser begge tekster sammen og kan opdage, at et dokument diskuterer emnet, men i en modsat betydning. Denne gevinst har en pris: modellen skal behandle hvert dokument individuelt, hvilket forbyder brug af den på hele korpusset. Løsningen er at anvende den, hvor det kan betale sig, på et lille sæt kandidater, der allerede er shortlistet.

Derfor eksisterer to-trins pipelinen, hvor hver model gør det, den er bedst til: den hurtige indsnævrer feltet, den præcise foretager det endelige udvalg.

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

Reranking med Cohere

Cohere stiller en højtydende reranker til rådighed via API, hvilket undgår behovet for at hoste en model selv. Følgende funktion kæder de to trin sammen: den henter først tyve kandidater via vektorlighed, og beder derefter rerank-v3.5 om kun at beholde fem. Bemærk feltet index_original, der bevares i resultatet: rerankeren returnerer positioner i forhold til kandidatlisten, og du får brug for dette til at mappe tilbage til det faktiske dokument i dit korpus.

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]:
    """Semantisk søgning + reranking."""
    # Trin 1: Hurtig hentning (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]

    # Trin 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 med en LLM

Hvis du foretrækker ikke at tilføje en anden udbyder til din arkitektur – af kontraktmæssige årsager, datalokalisering eller simpelthen fakturering – kan en LLM, du allerede kalder, udfylde rollen. Du indsender spørgsmålet og et dokument, beder om en score fra 0 til 10 og sorterer. Temperatur sat til nul og max_tokens reduceret til fem sikrer deterministisk, billig output; try/except håndterer tilfælde, hvor modellen svarer med noget andet end et tal.

from openai import OpenAI

client = OpenAI()

def llm_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[dict]:
    """Bruger en LLM til at score relevans."""
    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]

Denne version koster ét opkald pr. kandidat, hvilket betyder tyve opkald og lige så meget samlet ventetid for et enkelt brugerspørgsmål. I praksis er dette uoverkommeligt i en interaktiv grænseflade. I stedet beder vi modellen om at rangere alle dokumenter på én gang, hvor vi præsenterer hver kandidat trunkeret til 200 tegn og nummereret, og forventer kun en liste over indeks som svar.

def llm_batch_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[int]:
    """Reranking i et enkelt LLM-opkald."""
    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]

Integration i RAG-pipelinen

I en komplet pipeline passer reranking mellem hentning og generering uden at ændre noget andet. Nøglepunktet i klassen nedenfor er tærsklen på 0,3 for relevance_score: den tillader returnering af færre end fem kontekster, når ingen kandidat er virkelig relevant, i stedet for at fodre generatoren med støj. Ofte er det denne filtrering, mere end selve rerankingen, der eliminerer hallucinerede svar.

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

    def respond(self, question: str, chunks, embeddings_corpus):
        # 1. Bred hentning
        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ælg de bedste
        contexts = [
            chunks[candidates[r.index]]
            for r in reranked.results
            if r.relevance_score > 0.3  # Relevanstærskel
        ]

        # 4. Generer svaret
        return self.generate(question, contexts)

Virkningen af reranking

MetrikUden rerankingMed rerankingGevinst
Recall@50,720,72=
Precision@50,580,78+34 %
MRR0,650,82+26 %

Disse tal fortæller præcist, hvad en reranker gør. Recall flytter sig ikke, og det er logisk: kandidaterne er de samme, og cross-encoderen kan ikke redde et dokument, som bi-encoderen ikke fik frem. Derimod forbedres precision og MRR markant, fordi det rigtige dokument rykker fra sjettepladsen til førstepladsen. Praktisk konsekvens: hvis din recall er dårlig, vil reranking ikke redde dig; du skal først udvide hentningen eller genoverveje chunking.

Vigtige pointer

  • Reranking omrangere kandidater med en mere præcis model
  • Typisk pipeline: bi-encoder (top 20–50) → cross-encoder (top 5)
  • Cohere rerank-v3.5 er en plug-and-play-løsning
  • En LLM kan fungere som reranker, hvis du foretrækker at undgå en afhængighed
  • Gevinsten i precision er betydelig (typisk 20–35 %)