Self-RAG
In questa pagina
Auto-riflessione nel RAG
Il Corrective RAG controlla ciò che entra nel prompt, ma non ciò che ne esce. Anche un contesto perfetto non garantisce una buona risposta: il modello potrebbe aggiungere dettagli assenti dai documenti o produrre un testo accurato che però elude la domanda reale. Il Self-RAG (Self-Reflective RAG) colma questa lacuna aggiungendo due verifiche dopo la generazione. La prima esamina la fondatezza fattuale: la risposta si basa effettivamente sui documenti forniti? La seconda esamina l’utilità: risponde davvero a ciò che è stato chiesto? Se una delle due verifiche fallisce, il sistema ripete il ciclo e riprova, trasformandosi in un meccanismo di autocorrezione piuttosto che in un semplice filtro.
Il flusso estende quindi il Corrective RAG. Hai sempre il recupero seguito dalla valutazione dei documenti, poi la generazione. Seguono due nuovi nodi: il controllo delle allucinazioni, che confronta la risposta con i documenti, e il controllo della risposta, che la confronta con la domanda. Se una verifica fallisce, il sistema torna alla generazione o recupera nuovo materiale dal web, a seconda di quale verifica è fallita.
Verifica della fondatezza fattuale
Il primo controllore riceve due input: i documenti concatenati e la risposta generata. Il suo compito non è giudicare se la risposta è vera in termini assoluti, ma se è interamente fondata su ciò che le è stato fornito. Questa distinzione è cruciale: un’affermazione accurata ma assente dai documenti deve essere rifiutata perché proviene dalla memoria di addestramento del modello, non dal tuo corpus, e non c’è garanzia che l’affermazione successiva sia accurata. Il formato di output corrisponde a quello del valutatore: un oggetto JSON binario a temperatura zero.
import json
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def check_hallucination(documents, generation):
"""Check whether the generation is grounded in the documents."""
docs_text = "\n\n".join([d["text"] for d in documents])
prompt = f"""You are a factual grounding evaluator. Given a set of
documents and a generated answer, determine whether the answer is entirely
grounded in the information contained in the documents.
Respond ONLY with a JSON object: {{"grounded": "yes"}} or {{"grounded": "no"}}
Documents:
{docs_text}
Generated answer:
{generation}
JSON evaluation:"""
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0,
response_format={"type": "json_object"},
)
result = json.loads(response.choices[0].message.content)
return result.get("grounded", "no") == "yes"
Verifica dell’utilità
Il secondo controllore non vede né i documenti né i risultati del recupero, ma solo la domanda e la risposta. Questo campo visivo ristretto è deliberato, poiché isola un difetto che la prima verifica lascia passare. Immagina che qualcuno chieda quante dimensioni produce un modello di embedding e la risposta descriva a lungo a cosa servono gli embedding senza mai fornire il numero. Tutto è fondato sui documenti, quindi il primo controllore dice “sì”, e l’utente se ne va senza le sue informazioni. Il secondo controllore dice “no” e innesca un altro tentativo.
def check_answer_usefulness(question, generation):
"""Check whether the answer actually addresses the question."""
prompt = f"""You are an answer quality evaluator. Given a question
and an answer, determine whether the answer usefully and completely addresses the question.
Respond ONLY with a JSON object: {{"useful": "yes"}} or {{"useful": "no"}}
Question: {question}
Answer: {generation}
JSON evaluation:"""
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0,
response_format={"type": "json_object"},
)
result = json.loads(response.choices[0].message.content)
return result.get("useful", "no") == "yes"
Il ciclo di autocorrezione
La classe SelfRAG riutilizza i familiari passaggi di recupero e valutazione, avvolgendoli poi in un ciclo di ripetizione limitato da max_retries. La logica del ciclo è più sottile di quanto sembri, poiché i due tipi di fallimento ricevono trattamenti diversi. Un’allucinazione rilevata genera semplicemente una nuova risposta con lo stesso contesto: il problema risiede nel modello, che ha esagerato, e un nuovo tentativo spesso basta. Una risposta giudicata inutile, invece, innesca una ricerca web aggiuntiva prima di riprovare: qui il problema risiede nel contesto, troppo sottile per supportare una risposta completa, e rigenerare senza aggiungere nulla produrrebbe lo stesso risultato.
Nota l’uscita di fallback dopo il ciclo. Quando tutti i tentativi sono esauriti, il sistema non solleva un’eccezione: restituisce l’ultima generazione insieme ai suoi flag grounded e useful. Questa è una scelta progettuale deliberata: è meglio restituire una risposta imperfetta etichettata come tale, che la tua interfaccia può segnalare all’utente, piuttosto che lanciare un errore grezzo.
import numpy as np
class SelfRAG:
"""Self-RAG pipeline with self-correction."""
def __init__(self, chunks, embeddings, index, max_retries=2):
self.chunks = chunks
self.embeddings = embeddings
self.index = index
self.max_retries = max_retries
def retrieve(self, question, k=4):
"""Standard retrieval."""
response = client.embeddings.create(
model="mistral-embed", inputs=[question]
)
query_vec = np.array([response.data[0].embedding], dtype=np.float32)
distances, indices = self.index.search(query_vec, k)
return [
{"text": self.chunks[idx]["text"], "source": self.chunks[idx].get("source", "")}
for dist, idx in zip(distances[0], indices[0]) if idx >= 0
]
def grade_documents(self, question, documents):
"""Evaluate document relevance."""
relevant = []
for doc in documents:
if grade_document(question, doc["text"]):
relevant.append(doc)
return relevant, len(relevant) < len(documents)
def generate(self, question, documents):
"""Generate an answer."""
context = "\n\n---\n\n".join([d["text"] for d in documents])
prompt = f"Context:\n{context}\n\nQuestion: {question}"
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.2,
)
return response.choices[0].message.content
def ask(self, question, k=4):
"""Complete Self-RAG pipeline with self-correction."""
print(f"\n=== Self-RAG: {question[:60]}... ===")
# 1. Retrieval
print("1. Retrieval...")
docs = self.retrieve(question, k=k)
# 2. Grading
print("2. Grading documents...")
relevant_docs, need_web = self.grade_documents(question, docs)
if need_web:
print(" -> Fallback web search")
web_docs = web_search_fallback(question)
relevant_docs.extend(web_docs)
# 3. Generation loop with self-correction
for attempt in range(self.max_retries + 1):
print(f"3. Generation (attempt {attempt + 1})...")
generation = self.generate(question, relevant_docs)
# 4. Hallucination check
print("4. Checking hallucinations...")
is_grounded = check_hallucination(relevant_docs, generation)
if not is_grounded:
print(" -> HALLUCINATION detected, retrying...")
continue
# 5. Usefulness check
print("5. Checking usefulness...")
is_useful = check_answer_usefulness(question, generation)
if not is_useful:
print(" -> Answer NOT USEFUL, fallback web search...")
web_docs = web_search_fallback(question)
relevant_docs.extend(web_docs)
continue
# Success
print(" -> Answer validated!")
return {
"answer": generation,
"attempts": attempt + 1,
"grounded": True,
"useful": True,
}
# If all attempts fail
print(" -> Maximum attempts reached")
return {
"answer": generation,
"attempts": self.max_retries + 1,
"grounded": is_grounded,
"useful": is_useful,
}
# Usage
self_rag = SelfRAG(chunks, embeddings, index, max_retries=2)
result = self_rag.ask("What are the advantages of RAG over fine-tuning?")
print(f"\nAnswer: {result['answer']}")
print(f"Attempts: {result['attempts']}")
print(f"Grounded: {result['grounded']}, Useful: {result['useful']}")
Il costo dell’affidabilità
Ogni guardrail aggiunge un’altra chiamata LLM e il totale aumenta rapidamente. La funzione seguente lo rende esplicito scomponendo le chiamate per passaggio: una chiamata di valutazione per documento, poi generazione, controllo di fondatezza e controllo di utilità, ciascuno ripetuto ad ogni retry. Con quattro documenti e un singolo retry, arrivi a dieci chiamate per una singola domanda, mentre il RAG base ne richiedeva due. Esegui questa stima con i tuoi valori prima di impostare k e max_retries: questo calcolo ti dice se il tuo budget e i requisiti di latenza supportano il Self-RAG per tutto il traffico o solo per le domande più sensibili.
def estimate_self_rag_cost(n_docs=4, n_retries=1):
"""Estimate the number of LLM calls for a Self-RAG question."""
calls = {
"grading": n_docs, # 1 call per document
"generation": 1 + n_retries, # 1 initial + retries
"hallucination_check": 1 + n_retries,
"answer_check": 1 + n_retries,
}
total = sum(calls.values())
print(f"Estimated LLM calls: {total}")
for step, count in calls.items():
print(f" {step}: {count}")
return total
estimate_self_rag_cost(n_docs=4, n_retries=1)
# Estimated LLM calls: 10
Punti chiave
- Il Self-RAG aggiunge due verifiche post-generazione: allucinazioni e utilità
- Se la risposta non è fondata sui documenti, il sistema rigenera
- Se la risposta non è utile, il sistema esegue una ricerca web e riprova
- Il numero di retry deve essere limitato per controllare la latenza
- Il Self-RAG è più costoso (più chiamate LLM) ma più affidabile