Self-RAG
Sellel lehel
Enesepeegeldus RAG-s
Corrective RAG kontrollib, mis siseneb vihjesse, kuid mitte seda, mis sealt väljub. Isegi täiuslik kontekst ei garanteeri head vastust: mudel võib lisada detaile, mida dokumentides pole, või toota teksti, mis on küll täpne, kuid mööda hiilib tegelikust küsimusest. Self-RAG (enesereflektiivne RAG) sulgeb selle lõhe, lisades pärast genereerimist kaks kontrolli. Esimene uurib faktilist põhjendatust – kas vastus tugineb tegelikult esitatud dokumentidele? Teine uurib kasulikkust – kas see vastab tõesti sellele, mida küsiti? Kui kumbki kontroll ebaõnnestub, teeb süsteem tsükli ja proovib uuesti, muutes selle enesekorrigeerimise mehhanismiks, mitte lihtsaks filtriks.
Voog laiendab seega Corrective RAG-i. Sul on endiselt otsing, millele järgneb dokumentide hindamine ja seejärel genereerimine. Järgnevad kaks uut sõlme: hallutsinatsioonide kontroll, mis võrdleb vastust dokumentidega, ja vastuse kontroll, mis võrdleb seda küsimusega. Kui kontroll ebaõnnestub, naaseb süsteem kas genereerimise juurde või toob veebist värsket materjali, olenevalt sellest, milline verifikatsioon nurjus.
Faktilise põhjendatuse kontrollimine
Esimene kontrollija saab kaks sisendit: liidetud dokumendid ja genereeritud vastuse. Selle ülesanne ei ole hinnata, kas vastus on absoluutses mõttes tõene, vaid kas see on täielikult põhjendatud sellega, mis talle anti. See eristus on oluline: täpne väide, mida dokumentides pole, tuleb tagasi lükata, sest see pärineb mudeli treeningmälust, mitte sinu korpusest – ja pole garantiid, et järgmine väide on täpne. Väljundvorming vastab hindajale: binaarne JSON-objekt temperatuuril null.
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"
Kasulikkuse kontrollimine
Teine kontrollija ei näe ei dokumente ega otsingutulemusi – ainult küsimust ja vastust. See kitsas vaateväli on tahtlik, sest see isoleerib vea, mille esimene kontroll läbi laseb. Kujuta ette, et keegi küsib, mitu dimensiooni embeddings-mudel toodab, ja vastus kirjeldab pikalt, milleks embeddinguid kasutatakse, andmata kunagi numbrit. Kõik on dokumentides põhjendatud, nii et esimene kontrollija ütleb „jah“, ja kasutaja lahkub ilma oma infota. Teine kontrollija ütleb „ei“ ja käivitab uue katse.
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"
Enesekorrigeerimise tsükkel
Klass SelfRAG kasutab uuesti tuttavaid otsingu ja hindamise samme, seejärel pakib need kordustsüklisse, mida piirab max_retries. Tsükli loogika on peenem, kui esmapilgul tundub, sest kahte tüüpi tõrkeid koheldakse erinevalt. Tuvastatud hallutsinatsioon lihtsalt genereerib uuesti sama kontekstiga: probleem seisneb mudelis, mis läks liiale, ja värske tõmme sageli aitab. Kasutuks hinnatud vastus käivitab aga enne uuesti proovimist täiendava veebiotsingu: siin seisneb probleem kontekstis, mis on liiga õhuke täieliku vastuse toetamiseks, ja uuesti genereerimine ilma midagi lisamata annaks sama tulemuse.
Pane tähele varuväljundit pärast tsüklit. Kui kõik katsed on ammendatud, süsteem ei tekita erindit: see tagastab viimase genereeringu koos selle grounded ja useful lippudega. See on tahtlik disainivalik – parem on tagastada ebatäiuslik vastus, mis on sellisena märgistatud ja mida sinu liides saab kasutajale näidata, kui visata toores viga.
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']}")
Usaldusväärsuse hind
Iga turvameede lisab veel ühe LLM-i väljakutse ja kogusumma kasvab kiiresti. Allpool olev funktsioon teeb selle selgeks, jaotades väljakutsed sammude kaupa: üks hindamisväljakutse dokumendi kohta, seejärel genereerimine, põhjendatuse kontroll ja kasulikkuse kontroll, kusjuures igaüks kordub igal katsel. Nelja dokumendi ja ühe kordusega jõuad ühe küsimuse puhul kümne väljakutseni – seal, kus baas-RAG vajas kahte. Käivita see hinnang oma väärtustega enne k ja max_retries määramist: see arvutus ütleb sulle, kas sinu eelarve ja latentsusnõuded toetavad Self-RAG-i kogu liikluse lõikes või ainult kõige tundlikumate küsimuste puhul.
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
Peamised punktid
- Self-RAG lisab kaks pärast genereerimist tehtavat kontrolli: hallutsinatsioonid ja kasulikkus
- Kui vastus ei ole dokumentides põhjendatud, genereerib süsteem uuesti
- Kui vastus ei ole kasulik, teeb süsteem veebiotsingu ja proovib uuesti
- Korduste arv peab olema piiratud, et kontrollida latentsust
- Self-RAG on kallim (rohkem LLM-i väljakutseid), kuid usaldusväärsem