Self-RAG
F'din il-paġna
Awtoriflessjoni fir-RAG
Ir-RAG Korrettiv (Corrective RAG) jikkontrolla x’jidħol fil-prompt, iżda mhux x’joħroġ minnu. Anke kuntest perfett ma jiggarantix tweġiba tajba: il-mudell jista’ jżid dettalji li ma jinsabu mkien fid-dokumenti, jew jipproduċi test preċiż iżda li jevita l-mistoqsija attwali. Is-Self-RAG (RAG Awtoriflessiv) jagħlaq din il-lakuna billi jżid żewġ verifiki wara l-ġenerazzjoni. L-ewwel wieħed jeżamina l-bażi fattwali—it-tweġiba tiddependi verament fuq id-dokumenti pprovduti? It-tieni jeżamina l-utilità—tindirizza verament dak li ntalab? Jekk waħda minn dawn il-verifiki tfalli, is-sistema tirrepeti (loop) u tipprova mill-ġdid, u b’hekk issir mekkaniżmu ta’ awtokorrezjoni minflok filtru sempliċi.
Il-fluss għalhekk jestendi r-RAG Korrettiv. Għadek għandek l-irkupru segwit mill-valutazzjoni tad-dokumenti, imbagħad il-ġenerazzjoni. Jiġu żewġ nodi ġodda wara: iċ-check tal-alluċinazzjoni, li jqabbel it-tweġiba mad-dokumenti, u ċ-check tat-tweġiba, li jqabbelha mal-mistoqsija. Jekk verifika tfalli, is-sistema terġa’ lura għall-ġenerazzjoni jew tiġbor materjal ġdid mill-web, skont liema verifika falliet.
Verifika tal-Bażi Fattwali
L-ewwel checker jirċievi żewġ inputs: id-dokumenti magħqudin u t-tweġiba ġġenerata. Il-kompitu tiegħu mhuwiex li jiddetermina jekk it-tweġiba hijiex vera f’termini assoluti, iżda jekk hijiex kompletament ibbażata fuq dak li ngħata. Din id-distinzjoni hija importanti: dikjarazzjoni preċiża li ma tidhirx fid-dokumenti trid tiġi miċħuda għax tiġi mill-memorja tat-taħriġ tal-mudell, mhux mill-korpus tiegħek—u m’hemm l-ebda garanzija li d-dikjarazzjoni li jmiss se tkun preċiża. Il-format tal-output jaqbel ma’ dak tal-grader: oġġett JSON binarju f’temperatura żero.
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"
Verifika tal-Utilità
It-tieni checker ma jarax la d-dokumenti u lanqas ir-riżultati tal-irkupru—biss il-mistoqsija u t-tweġiba. Dan il-kamp ta’ viżjoni ristrett huwa deliberat għax j iżola difett li l-ewwel check iħalli jgħaddi. Immaġina li xi ħadd jistaqsi kemm-il dimensjoni jipproduċi mudell ta’ embeddings, u t-tweġiba tiddeskrivi fit-tul għal xiex jintużaw l-embeddings mingħajr qatt ma tagħti n-numru. Kollox huwa bbażat fuq id-dokumenti, allura l-ewwel checker jgħid “iva”, u l-utent jitlaq mingħajr l-informazzjoni tiegħu. It-tieni checker jgħid “le” u jattenta tentattiv ieħor.
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"
Iċ-Ċiklu ta’ Awtokorrezjoni
Il-klassi SelfRAG terġa’ tuża l-passi familjari ta’ rkupru u grading, imbagħad tgħaddihom minn ċiklu ta’ retry limitat minn max_retries. Il-loġika taċ-ċiklu hija aktar sottili milli tidher għax iż-żewġ tipi ta’ falliment jirċievu trattament differenti. Alluċinazzjoni skoperta sempliċiment terġa’ tiġġenera bl-istess kuntest: il-problema tinsab fil-mudell, li mar ‘il bogħod wisq, u tentattiv ġdid spiss ikun biżżejjed. Tweġiba ġudikata bħala inutili, madankollu, ttriggera tfittxija addizzjonali fuq il-web qabel ma terġa’ tipprova: hawnhekk il-problema tinsab fil-kuntest, li huwa rqiq wisq biex jappoġġja tweġiba sħiħa, u l-ġenerazzjoni mill-ġdid mingħajr ma żżid xejn tagħti l-istess riżultat.
Innota l-ħruġ ta’ fallback wara ċ-ċiklu. Meta jintużaw it-tentattivi kollha, is-sistema ma tressqx eċċezzjoni: tirritorna l-aħħar ġenerazzjoni flimkien mal-flaggs grounded u useful tagħha. Din hija għażla tad-disinn deliberata—aħjar tirritorna tweġiba mhux perfetta mmarkata bħala tali, li l-interfaċċa tiegħek tista’ tissinjalizza lill-utent, milli tarmi żball mhux ipproċessat.
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']}")
Il-Prezz tal-Affidabbiltà
Kull guardrail iż sejħa oħra tal-LLM, u t-total jiżdied malajr. Il-funzjoni hawn taħt tagħmel dan espliċitu billi taqsam is-sejħat għal kull pass: sejħa waħda ta’ grading għal kull dokument, imbagħad il-ġenerazzjoni, iċ-check tal-bażi fattwali, u ċ-check tal-utilità, kull wieħed ripetut f’kull retry. B’erba’ dokumenti u retry wieħed, tilħaq għaxar sejħat għal mistoqsija waħda—fejn ir-RAG bażiku kien jeħtieġ tnejn. Iddi din l-istima bil-valuri tiegħek stess qabel ma tissettja k u max_retries: din il-kalkolazzjoni tgħidlek jekk il-baġit u r-rekwiżiti tal-latency tiegħek jappoġġjawx is-Self-RAG fuq it-traffiku kollu, jew biss għall-mistoqsijiet l-aktar sensittivi.
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
Punti Ewlenin
- Is-Self-RAG iżid żewġ verifiki wara l-ġenerazzjoni: alluċinazzjonijiet u utilità
- Jekk it-tweġiba mhix ibbażata fuq id-dokumenti, is-sistema terġa’ tiġġenera
- Jekk it-tweġiba mhix utli, is-sistema twettaq tfittxija fuq il-web u terġa’ tipprova
- In-numru ta’ retries irid ikun limitat biex tikkontrolla l-latency
- Is-Self-RAG huwa aktar għali (aktar sejħat tal-LLM) iżda aktar affidabbli