Self-RAG
Na tej strani
Samorefleksija v RAG
Corrective RAG nadzira, kaj gre v poziv, ne pa tudi, kaj pride ven. Tudi popoln kontekst ne zagotavlja dobrega odgovora: model lahko doda podrobnosti, ki jih v dokumentih ni, ali pa ustvari besedilo, ki je sicer točno, a se izogne bistvu vprašanja. Self-RAG (samorefleksivni RAG) to vrzel zapre z dodajanjem dveh preverjanj po generiranju. Prvo preveri dejansko utemeljenost – ali odgovor res temelji na priloženih dokumentih? Drugo preveri uporabnost – ali res naslavlja zastavljeno vprašanje? Če katero koli preverjanje odpove, sistem ponovi postopek, kar ga spremeni v mehanizem za samopopravljanje namesto v preprost filter.
Tok se torej razširi iz Corrective RAG. Še vedno imaš pridobivanje, ki mu sledi ocenjevanje dokumentov, nato pa generiranje. Sledita dva nova vozlišča: preverjanje halucinacij, ki primerja odgovor z dokumenti, in preverjanje odgovora, ki ga primerja z vprašanjem. Če preverjanje odpove, se sistem vrne bodisi k generiranju bodisi pridobi sveže gradivo s spleta, odvisno od tega, katero preverjanje je odpovedalo.
Preverjanje dejanske utemeljenosti
Prvi preverjevalec prejme dva vhoda: združene dokumente in generirani odgovor. Njegova naloga ni presojati, ali je odgovor absolutno resničen, temveč ali je v celoti utemeljen v tem, kar je dobil. Ta razlika je ključna: točna izjava, ki je ni v dokumentih, mora biti zavrnjena, ker izvira iz učnega spomina modela, ne iz tvojega korpusa – in ni nobenega zagotovila, da bo naslednja izjava enako točna. Izhodni format ustreza ocenjevalcu: binarni objekt JSON pri temperaturi nič.
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"
Preverjanje uporabnosti
Drugi preverjevalec ne vidi niti dokumentov niti rezultatov pridobivanja – vidi le vprašanje in odgovor. Ta ozek vidik je nameren, saj izolira napako, ki jo prvi preverjevalec spregleda. Predstavljaj si, da nekdo vpraša, koliko dimenzij proizvaja model za vgradnje (embeddings), odgovor pa dolgo opisuje, čemu so vgradnje namenjene, ne da bi kdaj navedel število. Vse je utemeljeno v dokumentih, zato prvi preverjevalec reče „da”, uporabnik pa odide brez iskanih informacij. Drugi preverjevalec reče „ne” in sproži nov poskus.
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"
Zanka za samopopravljanje
Razred SelfRAG ponovno uporabi znane korake pridobivanja in ocenjevanja, nato pa jih ovije v zanko za ponovne poskuse, omejeno z max_retries. Logika zanke je bolj subtilna, kot se zdi, saj sta dve vrsti napak obravnavani različno. Zaznana halucinacija preprosto sproži ponovno generiranje z istim kontekstom: težava je v modelu, ki je pretiraval, in svež poskus pogosto zadošča. Odgovor, ki je ocenjen kot neuporaben, pa sproži dodatno iskanje po spletu pred ponovnim poskusom: tu je težava v kontekstu, ki je preveč tanek, da bi podprl popoln odgovor, in ponovno generiranje brez dodajanja česar koli bi dalo enak rezultat.
Opazi izhod v sili po zanki. Ko so vsi poskusi izčrpani, sistem ne vrže izjeme: vrne zadnje generiranje skupaj z njegovima zastavicama grounded in useful. To je namerna načrtovalska odločitev – bolje je vrniti nepopoln odgovor, ki je kot tak označen in ga lahko tvoj vmesnik označi za uporabnika, kot pa vreči surovo napako.
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']}")
Cena zanesljivosti
Vsak varnostni mehanizem doda še en klic LLM, skupno število pa hitro naraste. Spodnja funkcija to jasno prikaže z razčlenitvijo klicev na korak: en klic za ocenjevanje na dokument, nato generiranje, preverjanje utemeljenosti in preverjanje uporabnosti, pri čemer se vsako ponovi ob vsakem ponovnem poskusu. S štirimi dokumenti in enim ponovnim poskusom dosežeš deset klicev za eno samo vprašanje – tam, ko je osnovni RAG zahteval dva. Pred nastavitvijo k in max_retries zaženi to oceno s svojimi vrednostmi: ta izračun ti pove, ali tvoj proračun in zahteve glede zakasnitve podpirajo Self-RAG za ves promet ali le za najbolj občutljiva vprašanja.
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
Ključne ugotovitve
- Self-RAG doda dve preverjanji po generiranju: halucinacije in uporabnost
- Če odgovor ni utemeljen v dokumentih, sistem ponovno generira
- Če odgovor ni uporaben, sistem izvede iskanje po spletu in ponovi poskus
- Število ponovnih poskusov mora biti omejeno za nadzor zakasnitve
- Self-RAG je dražji (več klicev LLM), a bolj zanesljiv