Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Valutare una pipeline RAG

Lezione 15 di 22 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Obiettivi
  2. I due assi della valutazione
  3. Metriche di generazione
  4. Framework di valutazione completo
  5. Dashboard delle metriche
  6. Punti chiave

Obiettivi

  • Valutare separatamente il recupero e la generazione
  • Implementare metriche automatizzate per la qualità RAG
  • Costruire un framework di valutazione completo

I due assi della valutazione

Una pipeline RAG può fallire in due modi molto diversi e confonderli ti costerà settimane. O lo step di recupero non ha trovato i documenti giusti — in tal caso la risposta è errata per motivi estranei al modello di generazione e le metriche della Lezione 10 lo diagnosticheranno — oppure i documenti corretti erano presenti, ma lo step di generazione è andato fuori strada: il modello ha inventato un dettaglio o ha risposto a una domanda diversa da quella posta.

Quando un utente segnala «la risposta è sbagliata», non ti dirà quale delle due cause sia in gioco. Da qui la regola: misura entrambi i componenti in modo indipendente con metriche distinte e modifica uno solo dopo aver identificato quale dei due sta sottoperformando.

Metriche di generazione

La fedeltà (faithfulness) risponde alla domanda più importante in produzione: la risposta è interamente supportata dai documenti forniti o il modello ha aggiunto del suo? Invece di chiedere un punteggio globale — che i giudici tendono a assegnare con troppa generosità — chiedi al giudice di scomporre la risposta affermazione per affermazione e di classificare ciascuna come supportata, non supportata o contraddetta. Quest’ultima categoria è la più preziosa: un’affermazione che contraddice la fonte segnala un errore ben più grave di una semplice omissione.

from openai import OpenAI

client = OpenAI()

def evaluate_faithfulness(
    question: str,
    answer: str,
    contexts: list[str]
) -> dict:
    """Valuta se la risposta è fedele ai contesti."""
    full_context = "\n\n---\n\n".join(contexts)

    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"Evaluate the faithfulness of this answer relative to the "
                f"source documents.\n\n"
                f"Source documents:\n{full_context}\n\n"
                f"Question: {question}\n\n"
                f"Answer: {answer}\n\n"
                f"For each claim in the answer, indicate:\n"
                f"- SUPPORTED: if confirmed by the documents\n"
                f"- UNSUPPORTED: if it does not appear in the documents\n"
                f"- CONTRADICTED: if it contradicts the documents\n\n"
                f"End with a global score from 0 to 1."
            )
        }],
        temperature=0
    )
    return {"evaluation": response.choices[0].message.content}

Una risposta può essere perfettamente fedele ma inutile: potrebbe copiare fedelmente un passaggio che tratta tutt’altro. È ciò che misura la rilevanza della risposta, confrontando questa volta la risposta solo con la domanda, senza i documenti. Il prompt definisce una scala esplicita — 1,0 per una risposta completa, 0,7 per una risposta parziale ma utile, 0,3 per tangenziale, 0,0 per fuori tema — perché un giudice a cui si chiede semplicemente di «valutare da 0 a 1» produce punteggi instabili da un’esecuzione all’altra.

def evaluate_relevance(question: str, answer: str) -> float:
    """Punteggio di rilevanza della risposta rispetto alla domanda."""
    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"On a scale of 0 to 1, how well does this answer "
                f"address the question asked?\n\n"
                f"Question: {question}\n"
                f"Answer: {answer}\n\n"
                f"Criteria:\n"
                f"- 1.0: complete and precise answer\n"
                f"- 0.7: partial but useful answer\n"
                f"- 0.3: tangentially related\n"
                f"- 0.0: off-topic\n\n"
                f"Return only the numeric score."
            )
        }],
        temperature=0,
        max_tokens=10
    )
    try:
        return float(response.choices[0].message.content.strip())
    except ValueError:
        return 0.0

C’è poi la precisione del contesto, che fa da ponte tra i due assi: tra i cinque documenti che hai iniettato nel prompt, quanti sono stati effettivamente utilizzati? Se la risposta a una domanda sulle politiche di congedo ha attinto a uno solo dei cinque chunk, gli altri quattro hanno consumato budget di contesto e aggiunto rumore. Chiedi quindi al giudice di valutare ogni contesto in isolamento, con un semplice sì o no, e calcoli la proporzione di quelli utili.

def evaluate_context_precision(
    question: str,
    contexts: list[str],
    answer: str
) -> dict:
    """Valuta quali contesti sono stati utili per la risposta."""
    results = []

    for i, ctx in enumerate(contexts):
        response = client.chat.completions.create(
            model="gpt-5.6-terra",
            messages=[{
                "role": "user",
                "content": (
                    f"Was this document useful for answering "
                    f"the question?\n\n"
                    f"Question: {question}\n"
                    f"Document: {ctx[:500]}\n"
                    f"Generated answer: {answer}\n\n"
                    f"Answer YES or NO."
                )
            }],
            temperature=0,
            max_tokens=5
        )
        useful = "yes" in response.choices[0].message.content.lower()
        results.append({"index": i, "useful": useful})

    num_useful = sum(1 for r in results if r["useful"])
    return {
        "details": results,
        "precision": num_useful / len(contexts) if contexts else 0
    }

Framework di valutazione completo

Queste tre funzioni sono inutili finché restano manuali. Lo step decisivo è eseguirle su un set fisso di domande ogni volta che modifichi la pipeline: è questo che trasforma una sensazione istintiva — «penso che sia migliorato da quando ho cambiato il chunking» — in un numero confrontabile. La classe seguente esegue la pipeline su ogni elemento del dataset, raccoglie i punteggi e restituisce le loro medie.

Osserva il dataset di esempio: due domande HR, ciascuna con una risposta attesa e l’identificatore dei documenti che dovrebbero essere recuperati. Venti-cinquanta voci di questo tipo, scritte una volta per tutte a partire da domande reali degli utenti, bastano a rilevare regressioni.

class RAGEvaluator:
    def __init__(self, rag_pipeline):
        self.pipeline = rag_pipeline
        self.client = OpenAI()

    def evaluate_dataset(self, dataset: list[dict]) -> dict:
        """Valuta la pipeline su un dataset di domande e risposte.

        Ogni elemento: {question, expected_answer, relevant_docs}
        """
        results = {
            "faithfulness": [],
            "relevance": [],
            "context_precision": [],
        }

        for item in dataset:
            # Esegui la pipeline
            output = self.pipeline.respond(item["question"])
            answer = output["answer"]
            contexts = [s["excerpt"] for s in output["sources"]]

            # Valuta
            relevance = evaluate_relevance(item["question"], answer)
            results["relevance"].append(relevance)

            ctx_eval = evaluate_context_precision(
                item["question"], contexts, answer
            )
            results["context_precision"].append(ctx_eval["precision"])

        # Medie
        import numpy as np
        return {
            metric: round(float(np.mean(scores)), 4)
            for metric, scores in results.items()
        }

# Utilizzo
dataset = [
    {
        "question": "How many leave days do I have?",
        "expected_answer": "25 days of paid leave per year",
        "relevant_docs": ["leave-policy"]
    },
    {
        "question": "Can I work remotely on Mondays?",
        "expected_answer": "Yes, remote work is allowed except on Tuesdays and Thursdays",
        "relevant_docs": ["remote-work-policy"]
    },
]

evaluator = RAGEvaluator(rag_pipeline)
metrics = evaluator.evaluate_dataset(dataset)
print("Results:")
for k, v in metrics.items():
    print(f"  {k}: {v}")

Dashboard delle metriche

Ecco i target da raggiungere in un sistema di produzione, insieme al significato concreto di ciascun numero.

MetricaTargetCosa misura
Recall@5> 0,90I documenti giusti sono nei primi 5?
Precision@5> 0,70I documenti restituiti sono rilevanti?
Faithfulness> 0,85La risposta è fedele alle fonti?
Answer Relevance> 0,80La risposta affronta la domanda?
Context Precision> 0,60I contesti forniti sono utili?

Leggi questa tabella dall’alto verso il basso come un albero diagnostico. Un recall inferiore a 0,90 rende inutile qualsiasi analisi delle righe successive: sistema prima il chunking o l’indice. Al contrario, un recall eccellente abbinato a una fedeltà scarsa indica un problema nel prompt di generazione, non nella ricerca.

Punti chiave

  • Valuta separatamente il recupero (recall, precisione) e la generazione (fedeltà, rilevanza)
  • La fedeltà rileva le allucinazioni dell’LLM
  • La rilevanza verifica che la risposta sia utile
  • Costruisci un dataset di test e misura prima di ogni modifica