Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Self-RAG

16. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Önreflexió a RAG-ban
  2. Ténybeli alátámasztottság ellenőrzése
  3. Hasznosság ellenőrzése
  4. Az önkorrekciós ciklus
  5. A megbízhatóság ára
  6. Főbb megállapítások

Önreflexió a RAG-ban

A Corrective RAG szabályozza, mi kerül a promptba, de azt nem, ami onnan kijön. Még a tökéletes kontextus sem garantál jó választ: a modell hozzáadhat olyan részleteket, amelyek sehol sem szerepelnek a dokumentumokban, vagy olyan szöveget gyárthat, amely tényileg helyes, de kikerüli a tényleges kérdést. A Self-RAG (önreflexív RAG) ezt a rést két, generálás utáni ellenőrzéssel zárja be. Az első a ténybeli alátámasztottságot vizsgálja: a válasz valóban a megadott dokumentumokra épül? A második a hasznosságot: tényleg arra válaszol, amit kérdeztek? Ha bármelyik ellenőrzés sikertelen, a rendszer újrapróbálkozik, így ez nem egyszerű szűrő, hanem önkorrekciós mechanizmus.

A folyamat tehát kiterjeszti a Corrective RAG-ot. Megmarad a lekérdezés, majd a dokumentumok osztályozása, ezt követi a generálás. Ezután két új csomópont következik: a hallucináció-ellenőrzés, amely összehasonlítja a választ a dokumentumokkal, és a válasz-ellenőrzés, amely a kérdéshez viszonyítja. Ha valamelyik ellenőrzés megbukik, a rendszer vagy visszatér a generáláshoz, vagy friss anyagot fetchel a webből, attól függően, melyik verifikáció hibázott.

Ténybeli alátámasztottság ellenőrzése

Az első ellenőrző két bemenetet kap: az összefűzött dokumentumokat és a generált választ. Feladata nem annak megítélése, hogy a válasz abszolút értelemben igaz-e, hanem az, hogy teljes mértékben alátámasztott-e a rendelkezésre álló információkkal. Ez a különbségtétel fontos: egy pontos állítást, amely nincs benne a dokumentumokban, el kell utasítani, mert az a modell tanítási memóriájából származik, nem a te korpuszodból – és nincs garancia arra, hogy a következő állítás is pontos lesz. A kimeneti formátum megegyezik az osztályozóéval: bináris JSON objektum, nulla hőmérsékleten.

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"

Hasznosság ellenőrzése

A második ellenőrző sem a dokumentumokat, sem a lekérdezési eredményeket nem látja – csak a kérdést és a választ. Ez a szűk látómező szándékos, mert így izolálja azt a hibát, amit az első ellenőrzés átenged. Képzeld el, hogy valaki azt kérdezi, hány dimenziót állít elő egy beágyazási modell, a válasz pedig hosszan taglalja, mire használják a beágyazásokat, anélkül, hogy valaha is megadná a számot. Minden alátámasztott a dokumentumokban, így az első ellenőrző „igen“-t mond, a felhasználó pedig információ nélkül távozik. A második ellenőrző „nem“-et mond, és újabb próbálkozást indít.

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"

Az önkorrekciós ciklus

A SelfRAG osztály újrahasználja az ismerős lekérdezési és osztályozási lépéseket, majd egy max_retries által határolt újrapróbálkozási ciklusba csomagolja őket. A ciklus logikája finomabb, mint elsőre tűnik, mert a két hibatípus eltérő kezelést kap. Egy észlelt hallucináció egyszerűen újragenerálást vált ki ugyanazzal a kontextussal: a probléma a modellel van, amely túllépett a határain, és egy friss húzás gyakran elég. Egy haszontalannak ítélt válasz azonban további webes keresést indít az újrapróbálkozás előtt: itt a probléma a kontextussal van, amely túl vékony a teljes válaszhoz, és újragenerálás további adatok nélkül ugyanazt az eredményt hozná.

Figyeld meg a ciklus utáni tartalék kilépést. Amikor az összes próbálkozás kimerül, a rendszer nem dob kivételt: visszaadja az utolsó generálást a hozzá tartozó grounded és useful flagekkel együtt. Ez szándékos tervezési döntés – jobb visszaadni egy ilyen módon megjelölt, tökéletlen választ, amelyet a felületed jelezhet a felhasználónak, mint nyers hibát dobni.

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']}")

A megbízhatóság ára

Minden biztonsági korlát egy újabb LLM-hívást jelent, és az összeg gyorsan nő. Az alábbi függvény ezt teszi explicit módon, lebontva a hívásokat lépésenként: egy osztályozási hívás dokumentumonként, majd generálás, alátámasztottság-ellenőrzés és hasznosság-ellenőrzés, mindegyik megismételve minden újrapróbálkozáskor. Négy dokumentummal és egyetlen újrapróbálkozással elérjük a tíz hívást egyetlen kérdésnél – ahol az alap RAG-nak csak kettő kellett. Futtasd ezt a becslést a saját értékeiddel, mielőtt beállítanád a k és max_retries paramétereket: ez a számítás megmondja, hogy a költségkereted és a késleltetési követelményeid támogatják-e a Self-RAG alkalmazását az összes forgalomra, vagy csak a legérzékenyebb kérdésekre.

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

Főbb megállapítások

  • A Self-RAG két generálás utáni ellenőrzést ad hozzá: hallucináció és hasznosság
  • Ha a válasz nincs alátámasztva a dokumentumokban, a rendszer újragenerál
  • Ha a válasz nem hasznos, a rendszer webes keresést végez és újrapróbálkozik
  • Az újrapróbálkozások számát korlátozni kell a késleltetés kordában tartása érdekében
  • A Self-RAG drágább (több LLM-hívás), de megbízhatóbb