Self-RAG
Šiame puslapyje
Savirefleksija RAG sistemoje
„Corrective RAG“ kontroliuoja, kas patenka į užklausą, bet ne tai, kas iš jos išeina. Net ir tobulas kontekstas negarantuoja gero atsakymo: modelis gali pridėti detalių, kurių nėra jokiuose dokumentuose, arba sugeneruoti tekstą, kuris yra faktiškai teisingas, tačiau vengia tiesioginio atsakymo į klausimą. Self-RAG (savarankiškai reflektuojantis RAG) užpildo šią spragą pridėdamas du patikrinimus po generavimo. Pirmasis vertina faktinį pagrindimą – ar atsakymas iš tikrųjų remiasi pateiktais dokumentais? Antrasis vertina naudingumą – ar jis tikrai atsako į tai, ko buvo klausiama? Jei kuris nors patikrinimas nepavyksta, sistema kartojasi ir bando iš naujo, todėl tai yra savitaisos mechanizmas, o ne paprastas filtras.
Todėl ši eiga plečia „Corrective RAG“ principus. Jūs vis dar turite paiešką, po kurios seka dokumentų vertinimas ir generavimas. Toliau atsiranda du nauji mazgai: haliucinacijų patikra, lyginanti atsakymą su dokumentais, ir atsakymo patikra, lyginanti jį su klausimu. Jei patikra nepavyksta, sistema arba grįžta prie generavimo, arba iš interneto atsisiunčia naujos medžiagos, priklausomai nuo to, kuris patikrinimas nepavyko.
Faktinio pagrindimo tikrinimas
Pirmasis tikrintojas gauna du įvesties duomenis: sujungtus dokumentus ir sugeneruotą atsakymą. Jo užduotis – ne spręsti, ar atsakymas yra absoliučiai teisingas, o ar jis visiškai pagrįstas tuo, kas jam buvo pateikta. Šis skirtumas yra svarbus: teisingas teiginys, kurio nėra dokumentuose, turi būti atmestas, nes jis kyla iš modelio mokymosi atminties, o ne iš jūsų korpuso – ir nėra garantijos, kad kitas teiginys bus tikslus. Išvesties formatas atitinka vertintoją: dvejetainis JSON objektas, naudojant temperatūrą 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"
Naudingumo tikrinimas
Antrasis tikrintojas nemato nei dokumentų, nei paieškos rezultatų – tik klausimą ir atsakymą. Šis siauras matymo laukas yra tyčinis, nes jis išskiria trūkumą, kurį praleido pirmasis patikrinimas. Įsivaizduokite, kad kas nors paklausia, kiek matmenų sukuria įterpimų (embeddings) modelis, o atsakymas ilgai aiškina, kam naudojami įterpimai, taip ir nepateikdamas skaičiaus. Viskas yra pagrįsta dokumentais, todėl pirmasis tikrintojas sako „taip“, o vartotojas lieka be reikiamos informacijos. Antrasis tikrintojas sako „ne“ ir inicijuoja naują bandymą.
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"
Savitaisos ciklas
SelfRAG klasė iš naujo naudoja pažįstamus paieškos ir vertinimo žingsnius, tada apgaubia juos kartojimų ciklu, kurį riboja max_retries. Ciklo logika yra subtilesnė, nei atrodo iš pirmo žvilgsnio, nes dviejų tipų nesėkmės yra traktuojamos skirtingai. Aptikus haliucinaciją, tiesiog generuojama iš naujo su tuo pačiu kontekstu: problema slypi modelyje, kuris per daug nutolo, ir dažnai pakanka naujo bandymo. Tačiau jei atsakymas įvertintas kaip nenaudingas, prieš kartojant atliekama papildoma paieška internete: čia problema kyla iš konteksto, kuris yra per silpnas, kad palaikytų pilną atsakymą, ir generavimas iš naujo nieko nepridėjus duotų tą patį rezultatą.
Atkreipkite dėmesį į atsarginį išėjimą po ciklo. Kai visi bandymai išnaudojami, sistema neišmeta klaidos: ji grąžina paskutinį sugeneruotą atsakymą kartu su jo grounded (pagrįstumo) ir useful (naudingumo) žymėmis. Tai sąmoningas dizaino sprendimas – geriau grąžinti netobulą, bet taip pažymėtą atsakymą, kurį jūsų sąsaja gali parodyti vartotojui, nei išmesti „pliką“ klaidą.
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']}")
Patikimumo kaina
Kiekviena apsaugos priemonė priduria dar vieną LLM užklausą, ir bendra suma greitai auga. Toliau pateikta funkcija tai aiškiai parodo, suskirstydama užklausas pagal žingsnius: viena vertinimo užklausa kiekvienam dokumentui, tada generavimas, pagrindimo patikra ir naudingumo patikra, kartojami kiekvieno bandymo metu. Turint keturis dokumentus ir vieną kartojimą, vienam klausimui tenka dešimt užklausų – tuo tarpu paprastam RAG jų reikėjo tik dviejų. Prieš nustatydami k ir max_retries, atlikite šį įvertinimą su savo vertėmis: šis skaičiavimas parodys, ar jūsų biudžetas ir delsos reikalavimai leidžia naudoti Self-RAG visam srautui, ar tik patiems jautriausiems klausimams.
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
Svarbiausi punktai
- Self-RAG prideda du patikrinimus po generavimo: haliucinacijų ir naudingumo
- Jei atsakymas nėra pagrįstas dokumentais, sistema jį generuoja iš naujo
- Jei atsakymas nėra naudingas, sistema atlieka paiešką internete ir bando iš naujo
- Kartojimų skaičius turi būti ribojamas, norint kontroliuoti delsą
- Self-RAG yra brangesnis (daugiau LLM užklausų), bet patikimesnis