Self-RAG
Ezen az oldalon
Önreflexió a RAG-ban
A Corrective RAG szabályozza, mi kerül a promptba, de azt nem, ami onnan kijön. Még a tökéletes kontextus sem garantál jó választ: a modell hozzáadhat olyan részleteket, amelyek sehol sem szerepelnek a dokumentumokban, vagy olyan szöveget gyárthat, amely tényileg helyes, de kikerüli a tényleges kérdést. A Self-RAG (önreflexív RAG) ezt a rést két, generálás utáni ellenőrzéssel zárja be. Az első a ténybeli alátámasztottságot vizsgálja: a válasz valóban a megadott dokumentumokra épül? A második a hasznosságot: tényleg arra válaszol, amit kérdeztek? Ha bármelyik ellenőrzés sikertelen, a rendszer újrapróbálkozik, így ez nem egyszerű szűrő, hanem önkorrekciós mechanizmus.
A folyamat tehát kiterjeszti a Corrective RAG-ot. Megmarad a lekérdezés, majd a dokumentumok osztályozása, ezt követi a generálás. Ezután két új csomópont következik: a hallucináció-ellenőrzés, amely összehasonlítja a választ a dokumentumokkal, és a válasz-ellenőrzés, amely a kérdéshez viszonyítja. Ha valamelyik ellenőrzés megbukik, a rendszer vagy visszatér a generáláshoz, vagy friss anyagot fetchel a webből, attól függően, melyik verifikáció hibázott.
Ténybeli alátámasztottság ellenőrzése
Az első ellenőrző két bemenetet kap: az összefűzött dokumentumokat és a generált választ. Feladata nem annak megítélése, hogy a válasz abszolút értelemben igaz-e, hanem az, hogy teljes mértékben alátámasztott-e a rendelkezésre álló információkkal. Ez a különbségtétel fontos: egy pontos állítást, amely nincs benne a dokumentumokban, el kell utasítani, mert az a modell tanítási memóriájából származik, nem a te korpuszodból – és nincs garancia arra, hogy a következő állítás is pontos lesz. A kimeneti formátum megegyezik az osztályozóéval: bináris JSON objektum, nulla hőmérsékleten.
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"
Hasznosság ellenőrzése
A második ellenőrző sem a dokumentumokat, sem a lekérdezési eredményeket nem látja – csak a kérdést és a választ. Ez a szűk látómező szándékos, mert így izolálja azt a hibát, amit az első ellenőrzés átenged. Képzeld el, hogy valaki azt kérdezi, hány dimenziót állít elő egy beágyazási modell, a válasz pedig hosszan taglalja, mire használják a beágyazásokat, anélkül, hogy valaha is megadná a számot. Minden alátámasztott a dokumentumokban, így az első ellenőrző „igen“-t mond, a felhasználó pedig információ nélkül távozik. A második ellenőrző „nem“-et mond, és újabb próbálkozást indít.
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"
Az önkorrekciós ciklus
A SelfRAG osztály újrahasználja az ismerős lekérdezési és osztályozási lépéseket, majd egy max_retries által határolt újrapróbálkozási ciklusba csomagolja őket. A ciklus logikája finomabb, mint elsőre tűnik, mert a két hibatípus eltérő kezelést kap. Egy észlelt hallucináció egyszerűen újragenerálást vált ki ugyanazzal a kontextussal: a probléma a modellel van, amely túllépett a határain, és egy friss húzás gyakran elég. Egy haszontalannak ítélt válasz azonban további webes keresést indít az újrapróbálkozás előtt: itt a probléma a kontextussal van, amely túl vékony a teljes válaszhoz, és újragenerálás további adatok nélkül ugyanazt az eredményt hozná.
Figyeld meg a ciklus utáni tartalék kilépést. Amikor az összes próbálkozás kimerül, a rendszer nem dob kivételt: visszaadja az utolsó generálást a hozzá tartozó grounded és useful flagekkel együtt. Ez szándékos tervezési döntés – jobb visszaadni egy ilyen módon megjelölt, tökéletlen választ, amelyet a felületed jelezhet a felhasználónak, mint nyers hibát dobni.
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']}")
A megbízhatóság ára
Minden biztonsági korlát egy újabb LLM-hívást jelent, és az összeg gyorsan nő. Az alábbi függvény ezt teszi explicit módon, lebontva a hívásokat lépésenként: egy osztályozási hívás dokumentumonként, majd generálás, alátámasztottság-ellenőrzés és hasznosság-ellenőrzés, mindegyik megismételve minden újrapróbálkozáskor. Négy dokumentummal és egyetlen újrapróbálkozással elérjük a tíz hívást egyetlen kérdésnél – ahol az alap RAG-nak csak kettő kellett. Futtasd ezt a becslést a saját értékeiddel, mielőtt beállítanád a k és max_retries paramétereket: ez a számítás megmondja, hogy a költségkereted és a késleltetési követelményeid támogatják-e a Self-RAG alkalmazását az összes forgalomra, vagy csak a legérzékenyebb kérdésekre.
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
Főbb megállapítások
- A Self-RAG két generálás utáni ellenőrzést ad hozzá: hallucináció és hasznosság
- Ha a válasz nincs alátámasztva a dokumentumokban, a rendszer újragenerál
- Ha a válasz nem hasznos, a rendszer webes keresést végez és újrapróbálkozik
- Az újrapróbálkozások számát korlátozni kell a késleltetés kordában tartása érdekében
- A Self-RAG drágább (több LLM-hívás), de megbízhatóbb