Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Reranking: migliorare la pertinenza

Lezione 13 di 22 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Obiettivi
  2. Il problema del Bi-Encoder
  3. Reranking con Cohere
  4. Reranking con un LLM
  5. Integrazione nella pipeline RAG
  6. Impatto del Reranking
  7. Punti chiave

Obiettivi

  • Comprendere perché il reranking migliora i risultati
  • Implementare un reranker utilizzando un cross-encoder
  • Integrare il reranking in una pipeline RAG

Il problema del Bi-Encoder

Tutta la ricerca che hai costruito finora si basa su un bi-encoder: la query e i documenti vengono codificati separatamente, ognuno per conto proprio, e confrontati tramite prodotto scalare. È questo che rende la ricerca istantanea anche su un milione di chunk, poiché i vettori del corpus sono stati calcolati una volta per tutte. È anche ciò che la rende imprecisa, perché il modello non vede mai insieme query e documento: deve riassumere ogni testo in un vettore senza sapere cosa gli verrà chiesto in seguito.

Un cross-encoder, chiamato anche reranker, prende in input la coppia (query, documento) e produce un punteggio di pertinenza molto più fine, poiché legge entrambi i testi congiuntamente e può rilevare che un documento tratta l’argomento ma in senso opposto. Questo guadagno ha un costo: il modello deve elaborare ogni documento individualmente, il che ne proibisce l’uso sull’intero corpus. La soluzione è impiegarlo dove è conveniente, su un piccolo insieme di candidati già preselezionati.

Da qui la pipeline a due stadi, dove ogni modello fa ciò che sa fare meglio: quello veloce restringe il campo, quello preciso effettua la selezione finale.

Query → Bi-encoder → Top 50 Candidati → Cross-encoder → Top 5 Risultati

Reranking con Cohere

Cohere espone tramite API un reranker ad alte prestazioni, evitando così di dover ospitare un modello. La funzione seguente concatena i due passaggi: recupera prima venti candidati tramite similarità vettoriale, poi chiede a rerank-v3.5 di mantenerne solo cinque. Nota il campo index_original preservato nel risultato: il reranker restituisce posizioni relative alla lista dei candidati e ne avrai bisogno per mappare nuovamente al documento effettivo nel tuo corpus.

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]:
    """Ricerca semantica + reranking."""
    # Passo 1: Recupero veloce (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]

    # Passo 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 con un LLM

Se preferisci non aggiungere un altro provider alla tua architettura—per motivi contrattuali, localizzazione dei dati o semplicemente fatturazione—un LLM che chiami già può ricoprire questo ruolo. Invii la domanda e un documento, chiedi un punteggio da 0 a 10 e ordini. Impostando la temperatura a zero e max_tokens ridotto a cinque, ottieni un output deterministico ed economico; il blocco try/except gestisce i casi in cui il modello risponde con qualcosa di diverso da un numero.

from openai import OpenAI

client = OpenAI()

def llm_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[dict]:
    """Utilizza un LLM per valutare la pertinenza."""
    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]

Questa versione costa una chiamata per candidato, ovvero venti chiamate e altrettanta latenza cumulativa per una singola domanda dell’utente. In pratica, questo è proibitivo in un’interfaccia interattiva. Invece, chiediamo al modello di classificare tutti i documenti in una volta sola, presentando ogni candidato troncato a 200 caratteri e numerato, aspettandoci in ritorno solo una lista di indici.

def llm_batch_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[int]:
    """Reranking in una singola chiamata 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]

Integrazione nella pipeline RAG

In una pipeline completa, il reranking si inserisce tra il recupero e la generazione senza cambiare nient’altro. Il punto chiave nella classe sottostante è la soglia di 0.3 su relevance_score: permette di restituire meno di cinque contesti quando nessun candidato è veramente pertinente, invece di alimentare il generatore con rumore. Spesso questo filtro, più del reranking stesso, elimina le risposte allucinate.

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

    def respond(self, question: str, chunks, embeddings_corpus):
        # 1. Recupero ampio
        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. Selezione dei migliori
        contexts = [
            chunks[candidates[r.index]]
            for r in reranked.results
            if r.relevance_score > 0.3  # Soglia di pertinenza
        ]

        # 4. Generazione della risposta
        return self.generate(question, contexts)

Impatto del Reranking

MetricaSenza RerankingCon RerankingGuadagno
Recall@50.720.72=
Precision@50.580.78+34%
MRR0.650.82+26%

Questi numeri dicono esattamente cosa fa un reranker. La recall non si muove, ed è logico: i candidati sono gli stessi e il cross-encoder non può salvare un documento che il bi-encoder non ha fatto emergere. Tuttavia, precisione e MRR migliorano significativamente, perché il documento giusto passa dal sesto posto al primo. Corollario pratico: se la tua recall è scarsa, il reranking non ti salverà; devi prima ampliare il recupero o rivedere il chunking.

Punti chiave

  • Il reranking riordina i candidati con un modello più preciso
  • Pipeline tipica: bi-encoder (top 20–50) → cross-encoder (top 5)
  • Cohere rerank-v3.5 è una soluzione chiavi in mano
  • Un LLM può fungere da reranker se preferisci evitare una dipendenza
  • Il guadagno in precisione è significativo (tipicamente 20–35%)