Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Self-RAG

Lektion 16 av 18 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Autoréflexion dans le RAG
  2. Vérification de l’ancrage factuel
  3. Vérification de l’utilité
  4. La boucle d’autocorrection
  5. Le coût de la fiabilité
  6. Viktiga punkter

Autoré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 posée. Self-RAG (RAG autoré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 ? Si l’une des deux échoue, le système boucle et réessaie, faisant de ce mécanisme une autocorrection 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 cherche de nouveaux éléments sur le web, selon le type d’échec.

Vérification de 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érification de 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 volontaire car il isole un défaut que le premier contrôle laisse passer. Imagine qu’on 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’autocorrection

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 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 régénère simplement 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 génération, vérification d’ancrage et 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. Lance 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

Viktiga punkter

  • 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