Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Self-RAG

Õppetund 16 / 18 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Enesepeegeldus RAG-s
  2. Faktilise põhjendatuse kontrollimine
  3. Kasulikkuse kontrollimine
  4. Enesekorrigeerimise tsükkel
  5. Usaldusväärsuse hind
  6. Peamised punktid

Enesepeegeldus RAG-s

Corrective RAG kontrollib, mis siseneb vihjesse, kuid mitte seda, mis sealt väljub. Isegi täiuslik kontekst ei garanteeri head vastust: mudel võib lisada detaile, mida dokumentides pole, või toota teksti, mis on küll täpne, kuid mööda hiilib tegelikust küsimusest. Self-RAG (enesereflektiivne RAG) sulgeb selle lõhe, lisades pärast genereerimist kaks kontrolli. Esimene uurib faktilist põhjendatust – kas vastus tugineb tegelikult esitatud dokumentidele? Teine uurib kasulikkust – kas see vastab tõesti sellele, mida küsiti? Kui kumbki kontroll ebaõnnestub, teeb süsteem tsükli ja proovib uuesti, muutes selle enesekorrigeerimise mehhanismiks, mitte lihtsaks filtriks.

Voog laiendab seega Corrective RAG-i. Sul on endiselt otsing, millele järgneb dokumentide hindamine ja seejärel genereerimine. Järgnevad kaks uut sõlme: hallutsinatsioonide kontroll, mis võrdleb vastust dokumentidega, ja vastuse kontroll, mis võrdleb seda küsimusega. Kui kontroll ebaõnnestub, naaseb süsteem kas genereerimise juurde või toob veebist värsket materjali, olenevalt sellest, milline verifikatsioon nurjus.

Faktilise põhjendatuse kontrollimine

Esimene kontrollija saab kaks sisendit: liidetud dokumendid ja genereeritud vastuse. Selle ülesanne ei ole hinnata, kas vastus on absoluutses mõttes tõene, vaid kas see on täielikult põhjendatud sellega, mis talle anti. See eristus on oluline: täpne väide, mida dokumentides pole, tuleb tagasi lükata, sest see pärineb mudeli treeningmälust, mitte sinu korpusest – ja pole garantiid, et järgmine väide on täpne. Väljundvorming vastab hindajale: binaarne JSON-objekt temperatuuril null.

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"

Kasulikkuse kontrollimine

Teine kontrollija ei näe ei dokumente ega otsingutulemusi – ainult küsimust ja vastust. See kitsas vaateväli on tahtlik, sest see isoleerib vea, mille esimene kontroll läbi laseb. Kujuta ette, et keegi küsib, mitu dimensiooni embeddings-mudel toodab, ja vastus kirjeldab pikalt, milleks embeddinguid kasutatakse, andmata kunagi numbrit. Kõik on dokumentides põhjendatud, nii et esimene kontrollija ütleb „jah“, ja kasutaja lahkub ilma oma infota. Teine kontrollija ütleb „ei“ ja käivitab uue katse.

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"

Enesekorrigeerimise tsükkel

Klass SelfRAG kasutab uuesti tuttavaid otsingu ja hindamise samme, seejärel pakib need kordustsüklisse, mida piirab max_retries. Tsükli loogika on peenem, kui esmapilgul tundub, sest kahte tüüpi tõrkeid koheldakse erinevalt. Tuvastatud hallutsinatsioon lihtsalt genereerib uuesti sama kontekstiga: probleem seisneb mudelis, mis läks liiale, ja värske tõmme sageli aitab. Kasutuks hinnatud vastus käivitab aga enne uuesti proovimist täiendava veebiotsingu: siin seisneb probleem kontekstis, mis on liiga õhuke täieliku vastuse toetamiseks, ja uuesti genereerimine ilma midagi lisamata annaks sama tulemuse.

Pane tähele varuväljundit pärast tsüklit. Kui kõik katsed on ammendatud, süsteem ei tekita erindit: see tagastab viimase genereeringu koos selle grounded ja useful lippudega. See on tahtlik disainivalik – parem on tagastada ebatäiuslik vastus, mis on sellisena märgistatud ja mida sinu liides saab kasutajale näidata, kui visata toores viga.

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

Usaldusväärsuse hind

Iga turvameede lisab veel ühe LLM-i väljakutse ja kogusumma kasvab kiiresti. Allpool olev funktsioon teeb selle selgeks, jaotades väljakutsed sammude kaupa: üks hindamisväljakutse dokumendi kohta, seejärel genereerimine, põhjendatuse kontroll ja kasulikkuse kontroll, kusjuures igaüks kordub igal katsel. Nelja dokumendi ja ühe kordusega jõuad ühe küsimuse puhul kümne väljakutseni – seal, kus baas-RAG vajas kahte. Käivita see hinnang oma väärtustega enne k ja max_retries määramist: see arvutus ütleb sulle, kas sinu eelarve ja latentsusnõuded toetavad Self-RAG-i kogu liikluse lõikes või ainult kõige tundlikumate küsimuste puhul.

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

Peamised punktid

  • Self-RAG lisab kaks pärast genereerimist tehtavat kontrolli: hallutsinatsioonid ja kasulikkus
  • Kui vastus ei ole dokumentides põhjendatud, genereerib süsteem uuesti
  • Kui vastus ei ole kasulik, teeb süsteem veebiotsingu ja proovib uuesti
  • Korduste arv peab olema piiratud, et kontrollida latentsust
  • Self-RAG on kallim (rohkem LLM-i väljakutseid), kuid usaldusväärsem