Self-RAG
Σε αυτήν τη σελίδα
Αυτο-αναστοχασμός στο RAG
Το Corrective RAG ελέγχει τι εισέρχεται στο prompt, αλλά όχι τι εξέρχεται. Ακόμη και ένα ιδανικό πλαίσιο δεν εγγυάται μια καλή απάντηση: το μοντέλο μπορεί να προσθέσει λεπτομέρειες που δεν υπάρχουν πουθενά στα έγγραφα ή να παράγει κείμενο που είναι ακριβές αλλά αποφεύγει την πραγματική ερώτηση. Το Self-RAG (Self-Reflective RAG) καλύπτει αυτό το κενό προσθέτοντας δύο ελέγχους μετά τη δημιουργία. Ο πρώτος εξετάζει την πραγματική θεμελίωση—βασίζεται η απάντηση πραγματικά στα παρεχόμενα έγγραφα; Ο δεύτερος εξετάζει τη χρησιμότητα—πραγματικά απαντά σε αυτό που ζητήθηκε; Εάν αποτύχει ένας από τους δύο ελέγχους, το σύστημα κάνει επανάληψη (loop), καθιστώντας το έναν μηχανισμό αυτο-διόρθωσης και όχι ένα απλό φίλτρο.
Η ροή επεκτείνει επομένως το Corrective RAG. Διαθέτετε ακόμα την ανάκτηση ακολουθούμενη από τη βαθμολόγηση των εγγράφων και στη συνέχεια τη δημιουργία. Ακολουθούν δύο νέοι κόμβοι: ο έλεγχος παραισθήσεων (hallucination check), ο οποίος συγκρίνει την απάντηση με τα έγγραφα, και ο έλεγχος απάντησης, ο οποίος τη συγκρίνει με την ερώτηση. Εάν αποτύχει ένας έλεγχος, το σύστημα είτε επιστρέφει στη δημιουργία είτε ανακτά νέο υλικό από τον ιστό, ανάλογα με το ποιος έλεγχος απέτυχε.
Έλεγχος Πραγματικής Θεμελίωσης
Ο πρώτος ελεγκτής λαμβάνει δύο εισόδους: τα συγχωνευμένα έγγραφα και τη δημιουργηθείσα απάντηση. Ο ρόλος του δεν είναι να κρίνει αν η απάντηση είναι αληθινή απόλυτα, αλλά αν είναι πλήρως θεμελιωμένη σε αυτά που της δόθηκαν. Αυτή η διάκριση έχει σημασία: μια ακριβής δήλωση που απουσιάζει από τα έγγραφα πρέπει να απορριφθεί επειδή προέρχεται από τη μνήμη εκπαίδευσης του μοντέλου και όχι από το δικό σας σώμα κειμένων—και δεν υπάρχει εγγύηση ότι η επόμενη δήλωση θα είναι ακριβής. Η μορφή εξόδου ταιριάζει με αυτήν του βαθμολογητή: ένα δυαδικό αντικείμενο 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 και η απάντηση περιγράφει εκτενώς πού χρησιμοποιούνται τα 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. Η λογική του βρόχου είναι πιο λεπτή από ό,τι φαίνεται, καθώς οι δύο τύποι αποτυχίας λαμβάνουν διαφορετική μεταχείριση. Μια ανιχνευμένη παραίσθηση απλώς αναδημιουργείται με το ίδιο πλαίσιο: το πρόβλημα βρίσκεται στο μοντέλο, το οποίο υπερβάλλει, και μια νέα κλήση συχνά αρκεί. Μια απάντηση που κρίνεται άχρηστη, ωστόσο, ενεργοποιεί μια επιπλέον αναζήτηση στον ιστό πριν από την επανάληψη: εδώ το πρόβλημα βρίσκεται στο πλαίσιο, το οποίο είναι πολύ λεπτό για να υποστηρίξει μια πλήρη απάντηση, και η αναδημιουργία χωρίς προσθήκη οτιδήποτε θα απέδιδε το ίδιο αποτέλεσμα.
Σημειώστε την εναλλακτική έξοδο μετά τον βρόχο. Όταν εξαντληθούν όλες οι προσπάθειες, το σύστημα δεν εγείρει εξαίρεση: επιστρέφει την τελευταία δημιουργία μαζί με τις σημαίες 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) αλλά πιο αξιόπιστο