Salt la conținutul principal
Română— Alege o limbă
Meniu

Reranking: Îmbunătățirea Relevanței

Lecția 13 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Obiective
  2. Problema Bi-Encoder-ului
  3. Reranking cu Cohere
  4. Reranking cu un LLM
  5. Integrarea în Pipeline-ul RAG
  6. Impactul Reranking-ului
  7. Puncte cheie

Obiective

  • Înțelegeți de ce reranking-ul îmbunătățește rezultatele
  • Implementați un reranker folosind un cross-encoder
  • Integrați reranking-ul într-un pipeline RAG

Problema Bi-Encoder-ului

Toată căutarea pe care ați construit-o până acum se bazează pe un bi-encoder: interogarea și documentele sunt codificate separat, independent, și comparate prin produs scalar. Acest lucru face cautarea instantanee chiar și pe un milion de fragmente, deoarece vectorii corpusului au fost calculați o singură dată. Totuși, acesta este și motivul impreciziei, deoarece modelul nu vede niciodată interogarea și documentul împreună: trebuie să rezume fiecare text într-un vector fără a ști ce i se va cere mai târziu.

Un cross-encoder, numit și reranker, primește perechea (interogare, document) ca intrare și produce un scor de relevanță mult mai fin, deoarece citește ambele texte simultan și poate detecta dacă un document discută subiectul, dar într-un sens opus. Acest câștig are un cost: modelul trebuie să proceseze fiecare document individual, ceea ce interzice utilizarea sa pe întregul corpus. Soluția este să îl employați acolo unde este eficient din punct de vedere al costurilor, pe un set mic de candidați deja preselectați.

De aici rezultă pipeline-ul în două etape, în care fiecare model face ceea ce știe mai bine: cel rapid restrânge câmpul de căutare, iar cel precis face selecția finală.

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

Reranking cu Cohere

Cohere expune un reranker de înaltă performanță prin API, ceea ce evită necesitatea găzduirii unui model. Funcția următoare înlănțuie cei doi pași: mai întâi recuperează douăzeci de candidați prin similaritate vectorială, apoi cere lui rerank-v3.5 să păstreze doar cinci. Observați câmpul index_original păstrat în rezultat: reranker-ul returnează poziții relative la lista de candidați, iar dumneavoastră veți avea nevoie de aceasta pentru a mapa înapoi la documentul real din corpusul dumneavoastră.

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]:
    """Semantic search + reranking."""
    # Step 1: Fast retrieval (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]

    # Step 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 cu un LLM

Dacă preferați să nu adăugați un alt provider arhitecturii dumneavoastră—din motive contractuale, localizare a datelor sau simplu motiv de facturare—un LLM pe care îl apelați deja poate îndeplini acest rol. Trimiteți întrebarea și un document, cereți un scor de la 0 la 10 și sortați. Temperatura setată la zero și max_tokens redus la cinci asigură un output determinist și ieftin; blocul try/except gestionează cazurile în care modelul răspunde cu altceva decât un număr.

from openai import OpenAI

client = OpenAI()

def llm_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[dict]:
    """Uses an LLM to score 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]

Această versiune costă o apelare per candidat, adică douăzeci de apeluri și o latență cumulativă pe măsură pentru o singură întrebare a utilizatorului. În practică, acest lucru este prohibitiv într-o interfață interactivă. În schimb, cerem modelului să clasifice toate documentele deodată, prezentând fiecare candidat trunchiat la 200 de caractere și numerotat, așteptând doar o listă de indici ca răspuns.

def llm_batch_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[int]:
    """Reranking in a single LLM call."""
    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]

Integrarea în Pipeline-ul RAG

Într-un pipeline complet, reranking-ul se plasează între recuperare și generare fără a schimba nimic altceva. Punctul cheie în clasa de mai jos este pragul de 0.3 pe relevance_score: acesta permite returnarea a mai puțin de cinci contexte atunci când niciun candidat nu este cu adevărat relevant, în loc să hrănească generatorul cu zgomot. Adesea, acest filtru, mai mult decât reranking-ul în sine, elimină răspunsurile halucinate.

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

    def respond(self, question: str, chunks, embeddings_corpus):
        # 1. Broad retrieval
        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. Select the best
        contexts = [
            chunks[candidates[r.index]]
            for r in reranked.results
            if r.relevance_score > 0.3  # Relevance threshold
        ]

        # 4. Generate the answer
        return self.generate(question, contexts)

Impactul Reranking-ului

MetricăFără RerankingCu RerankingCâștig
Recall@50.720.72=
Precision@50.580.78+34%
MRR0.650.82+26%

Aceste cifre spun exact ce face un reranker. Recall-ul nu se mișcă, și acest lucru este logic: candidații sunt aceiași, iar cross-encoder-ul nu poate salva un document pe care bi-encoder-ul nu l-a adus la suprafață. Totuși, precizia și MRR se îmbunătățesc semnificativ, deoarece documentul corect trece de pe locul șase pe primul loc. Corolar practic: dacă recall-ul dumneavoastră este slab, reranking-ul nu vă va salva; trebuie mai întâi să lărgiți recuperarea sau să revizuiți fragmentarea (chunking).

Puncte cheie

  • Reranking-ul reclasează candidații cu un model mai precis
  • Pipeline tipic: bi-encoder (top 20–50) → cross-encoder (top 5)
  • Cohere rerank-v3.5 este o soluție la cheie
  • Un LLM poate servi ca reranker dacă preferați să evitați o dependență externă
  • Câștigul de precizie este semnificativ (de obicei 20–35%)