Self-RAG
Šajā lapā
L’auto-réflexion dans le RAG
Le RAG correctif contrôle ce qui entre dans le prompt, mais pas ce qui en sort. Même un contexte parfait ne garantit pas une bonne réponse : le modèle peut ajouter des détails absents des documents ou produire un texte exact qui élude la question réelle. Self-RAG (RAG auto-réflexif) comble cette lacune en ajoutant deux vérifications après la génération. La première examine l’ancrage factuel : la réponse s’appuie-t-elle réellement sur les documents fournis ? La seconde examine l’utilité : répond-elle vraiment à la question posée ? Si l’une des deux vérifications échoue, le système boucle et réessaie, faisant de ce mécanisme une auto-correction plutôt qu’un simple filtre.
Le flux étend donc le RAG correctif. Tu conserves la récupération suivie de l’évaluation des documents, puis la génération. Deux nouveaux nœuds s’ajoutent ensuite : la vérification d’hallucination, qui compare la réponse aux documents, et la vérification de la réponse, qui la compare à la question. Si une vérification échoue, le système retourne soit à la génération, soit va chercher de nouveaux contenus sur le web, selon le type d’échec.
Vérifier l’ancrage factuel
Le premier vérificateur reçoit deux entrées : les documents concaténés et la réponse générée. Son rôle n’est pas de juger si la réponse est vraie dans l’absolu, mais si elle est entièrement ancrée dans ce qui lui a été fourni. Cette distinction compte : une affirmation exacte absente des documents doit être rejetée car elle provient de la mémoire d’entraînement du modèle, pas de ton corpus, et rien ne garantit que la phrase suivante le sera aussi. Le format de sortie correspond à celui de l’évaluateur : un objet JSON binaire à température zéro.
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"
Vérifier l’utilité
Le second vérificateur ne voit ni les documents ni les résultats de la récupération, seulement la question et la réponse. Ce champ de vision restreint est délibéré car il isole un défaut que le premier contrôle laisse passer. Imagine que quelqu’un demande combien de dimensions produit un modèle d’embeddings, et que la réponse décrit longuement l’usage des embeddings sans jamais donner le nombre. Tout est ancré dans les documents, donc le premier vérificateur dit « oui », et l’utilisateur repart sans son information. Le second vérificateur dit « non » et déclenche une nouvelle tentative.
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"
La boucle d’auto-correction
La classe SelfRAG réutilise les étapes familières de récupération et d’évaluation, puis les enveloppe dans une boucle de retry limitée par max_retries. La logique de la boucle est plus subtile qu’il n’y paraît car les deux types d’échec reçoivent un traitement différent. Une hallucination détectée entraîne simplement une régénération avec le même contexte : le problème vient du modèle, qui a dépassé les bornes, et un nouveau tirage suffit souvent. Une réponse jugée inutile déclenche en revanche une recherche web supplémentaire avant de réessayer : ici, le problème vient du contexte, trop mince pour supporter une réponse complète, et régénérer sans rien ajouter donnerait le même résultat.
Note la sortie de secours après la boucle. Quand toutes les tentatives sont épuisées, le système ne lève pas d’exception : il renvoie la dernière génération accompagnée de ses drapeaux grounded et useful. C’est un choix de conception délibéré : mieux vaut renvoyer une réponse imparfaite étiquetée comme telle, que ton interface peut signaler à l’utilisateur, que de lancer une erreur brute.
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']}")
Le coût de la fiabilité
Chaque garde-fou ajoute un appel LLM supplémentaire, et le total grimpe vite. La fonction ci-dessous le rend explicite en détaillant les appels par étape : un appel d’évaluation par document, puis la génération, la vérification d’ancrage et la vérification d’utilité, chacun répété à chaque retry. Avec quatre documents et un seul retry, tu atteins dix appels pour une seule question, là où un RAG de base en requérait deux. Exécute cette estimation avec tes propres valeurs avant de fixer k et max_retries : ce calcul t’indique si ton budget et tes exigences de latence supportent Self-RAG sur tout le trafic, ou seulement pour les questions les plus sensibles.
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
Galvenās atziņas
- Self-RAG ajoute deux vérifications post-génération : hallucinations et utilité
- Si la réponse n’est pas ancrée dans les documents, le système régénère
- Si la réponse n’est pas utile, le système effectue une recherche web et réessaie
- Le nombre de retries doit être limité pour maîtriser la latence
- Self-RAG est plus coûteux (plus d’appels LLM) mais plus fiable