Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Self-RAG

Lektion 16 af 18 Opdateret 2. november 2026 Udvikler
På denne side
  1. Selvrefleksion i RAG
  2. Kontrol af faktuel forankring
  3. Kontrol af nytteværdi
  4. Selv-korrektions-løkken
  5. Prisen på pålidelighed
  6. Vigtige pointer

Selvrefleksion i RAG

Corrective RAG styrer, hvad der kommer ind i prompten, men ikke hvad der kommer ud. Selv perfekt kontekst garanterer ikke et godt svar: modellen kan tilføje detaljer, der slet ikke findes i dokumenterne, eller producere tekst, der er faktuel korrekt, men undgår det egentlige spørgsmål. Self-RAG (Self-Reflective RAG) lukker dette gab ved at tilføje to kontroltrin efter genereringen. Det første undersøger den faktuelle forankring – hviler svaret faktisk på de medfølgende dokumenter? Det andet undersøger nytteværdien – besvarer det virkelig det, der blev spurgt om? Hvis et af tjekkene fejler, løkker systemet og prøver igen, hvilket gør det til en selv-korrigerende mekanisme frem for et simpelt filter.

Flowet udvider derfor Corrective RAG. Du har stadig hentning efterfulgt af dokumentvurdering og derefter generering. To nye noder kommer herefter: hallucinations-tjekket, som sammenligner svaret med dokumenterne, og svar-tjekket, som sammenligner det med spørgsmålet. Hvis et tjek fejler, vender systemet enten tilbage til generering eller henter nyt materiale fra webbet, afhængigt af hvilken verifikation der fejlede.

Kontrol af faktuel forankring

Det første kontrolmodul modtager to input: de sammenkædede dokumenter og det genererede svar. Dets opgave er ikke at bedømme, om svaret er sandt i absolut forstand, men om det er fuldstændigt forankret i det, det har fået udleveret. Denne skelnen er vigtig: En nøjagtig udtalelse, der mangler i dokumenterne, skal afvises, fordi den stammer fra modellens træningshukommelse, ikke dit korpus – og der er ingen garanti for, at den næste udtalelse vil være nøjagtig. Output-formatet matcher gradersystemet: et binært JSON-objekt ved temperatur nul.

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"

Kontrol af nytteværdi

Det andet kontrolmodul ser hverken dokumenterne eller hentningsresultaterne – kun spørgsmålet og svaret. Dette snævre synsfelt er bevidst, fordi det isolerer en fejl, som det første tjek lader slippe igennem. Forestil dig, at nogen spørger, hvor mange dimensioner en embeddings-model producerer, og svaret beskriver udførligt, hvad embeddings bruges til, uden nogensinde at nævne tallet. Alt er forankret i dokumenterne, så det første tjek siger „ja”, og brugeren går videre uden at få sin information. Det andet tjek siger „nej” og udløser et nyt forsøg.

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"

Selv-korrektions-løkken

Klassen SelfRAG genbruger de velkendte trin for hentning og vurdering og pakker dem derefter ind i en gentagelsesløkke begrænset af max_retries. Løkkens logik er mere subtil, end den ser ud, fordi de to fejltyper behandles forskelligt. En opdaget hallucination udløser blot en ny generering med samme kontekst: problemet ligger hos modellen, som overtrådte grænserne, og et nyt træk er ofte nok. Et svar, der vurderes som ubrugeligt, udløser derimod en ekstra websøgning før genforsøget: her ligger problemet i konteksten, som er for tynd til at understøtte et komplet svar, og en ny generering uden at tilføje noget ville give samme resultat.

Bemærk fallback-udgangen efter løkken. Når alle forsøg er udtømte, kaster systemet ikke en undtagelse: det returnerer den sidste generering sammen med dens grounded- og useful-flag. Dette er et bevidst designvalg – det er bedre at returnere et uperfekt svar mærket som sådan, hvilket din grænseflade kan flagge over for brugeren, end at kaste en rå fejl.

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']}")

Prisen på pålidelighed

Hver sikkerhedsforanstaltning tilføjer endnu et LLM-kald, og totalen løber hurtigt op. Funktionen nedenfor gør dette eksplicit ved at opdele kald pr. trin: ét vurderingskald pr. dokument, derefter generering, forankringstjek og nytteværditjek, hver gentaget ved hvert genforsøg. Med fire dokumenter og ét genforsøg når du op på ti kald for et enkelt spørgsmål – hvor basal RAG krævede to. Kør dette estimat med dine egne værdier, før du sætter k og max_retries: denne beregning fortæller dig, om dit budget og dine latenskrav understøtter Self-RAG på al trafik, eller kun på de mest følsomme spørgsmål.

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

Vigtige pointer

  • Self-RAG tilføjer to kontroltrin efter generering: hallucinationer og nytteværdi
  • Hvis svaret ikke er forankret i dokumenterne, genererer systemet det igen
  • Hvis svaret ikke er nyttigt, udfører systemet en websøgning og prøver igen
  • Antallet af genforsøg skal begrænses for at kontrollere latensen
  • Self-RAG er dyrere (flere LLM-kald), men mere pålidelig