Self-RAG
På denne side
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