Self-RAG
На тази страница
Саморефлексия в RAG
Corrective RAG контролира какво влиза в промпта, но не и какво излиза от него. Дори перфектният контекст не гарантира добър отговор: моделът може да добави детайли, които липсват в документите, или да генерира текст, който е точен, но заобикаля същината на въпроса. Self-RAG (Self-Reflective RAG) запълва тази празнота, като добавя две проверки след генерирането. Първата анализира фактическата обосновка – дали отговорът наистина се базира на предоставените документи? Втората оценява полезността – дали той действително адресира зададеното? Ако някоя от проверките се провали, системата повтаря цикъла, превръщайки се в механизъм за самокорекция, а не просто във филтър.
Потокът следователно разширява Corrective RAG. Вие все още разполагате с извличане, последвано от оценяване на документите и след това генериране. Следват два нови възела: проверка за халюцинации, която сравнява отговора с документите, и проверка на отговора, която го сравнява с въпроса. Ако проверка се провали, системата или се връща към генерирането, или извлича нови материали от уеб, в зависимост от това коя верификация е неуспешна.
Проверка на фактическата обосновка
Първата проверка получава два входа: конкатенираните документи и генерирания отговор. Нейната задача не е да прецени дали отговорът е истински в абсолютен смисъл, а дали е изцяло обоснован в предоставената информация. Това разграничение е важно: точно твърдение, което липсва в документите, трябва да бъде отхвърлено, защото произлиза от обучителната памет на модела, а не от вашия корпус – и няма гаранция, че следващото твърдение ще бъде точно. Изходният формат съвпада с този на оценителя: двоичен JSON обект при температура нула.
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"
Проверка на полезността
Втората проверка не вижда нито документите, нито резултатите от извличането – само въпроса и отговора. Това тясно поле на зрение е умишлено, защото изолира дефект, който първата проверка пропуска. Представете си, че някой пита колко измерения произвежда един модел за вграждания (embeddings), а отговорът описва подробно за какво се използват вгражданията, без никога да даде числото. Всичко е обосновано в документите, така че първата проверка казва „да“, и потребителят си тръгва без търсената информация. Втората проверка казва „не“ и задейства нов опит.
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"
Цикълът за самокорекция
Класът SelfRAG използва познатите стъпки за извличане и оценяване, след което ги обгръща в цикъл за повторни опити, ограничен от max_retries. Логиката на цикъла е по-финa, отколкото изглежда, защото двата типа неуспехи получават различно третиране. Открита халюцинация просто предизвиква повторно генериране със същия контекст: проблемът е в модела, който е превишил правомощията си, и един нов опит често е достатъчен. Отговор, оценен като безполезен, обаче задейства допълнително търсене в уеб преди повторния опит: тук проблемът е в контекста, който е твърде оскъден, за да поддържа пълен отговор, и повторното генериране без добавяне на нещо ново би довело до същия резултат.
Обърнете внимание на резервния изход след цикъла. Когато всички опити са изчерпани, системата не хвърля изключение: тя връща последното генериране заедно с неговите флагове grounded и useful. Това е умишлен дизайнерски избор – по-добре е да върнете несъвършен отговор, маркиран като такъв, който вашият интерфейс може да сигнализира на потребителя, отколкото да хвърлите сурова грешка.
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']}")
Цената на надеждността
Всяка предпазна мярка добавя още едно LLM обаждане и общият брой нараства бързо. Функцията по-долу прави това явно, като разбива обажданията за всяка стъпка: едно обаждане за оценяване на документ, след това генериране, проверка за обосновка и проверка за полезност, като всяко се повтаря при всеки опит. С четири документа и един повторен опит достигате десет обаждания за един въпрос – докато основният RAG изискваше две. Изпълнете тази оценка със собствените си стойности, преди да зададете k и max_retries: това изчисление Ви показва дали Вашият бюджет и изискванията за латентност поддържат Self-RAG за целия трафик, или само за най-чувствителните въпроси.
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
Ключови изводи
- Self-RAG добавя две проверки след генерирането: за халюцинации и за полезност
- Ако отговорът не е обоснован в документите, системата го генерира отново
- Ако отговорът не е полезен, системата извършва уеб търсене и прави нов опит
- Броят на повторните опити трябва да бъде ограничен, за да се контролира латентността
- Self-RAG е по-скъп (повече LLM обаждания), но по-надежден