Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Self-RAG

Paskaita 16 iš 18 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Savirefleksija RAG sistemoje
  2. Faktinio pagrindimo tikrinimas
  3. Naudingumo tikrinimas
  4. Savitaisos ciklas
  5. Patikimumo kaina
  6. Svarbiausi punktai

Savirefleksija RAG sistemoje

„Corrective RAG“ kontroliuoja, kas patenka į užklausą, bet ne tai, kas iš jos išeina. Net ir tobulas kontekstas negarantuoja gero atsakymo: modelis gali pridėti detalių, kurių nėra jokiuose dokumentuose, arba sugeneruoti tekstą, kuris yra faktiškai teisingas, tačiau vengia tiesioginio atsakymo į klausimą. Self-RAG (savarankiškai reflektuojantis RAG) užpildo šią spragą pridėdamas du patikrinimus po generavimo. Pirmasis vertina faktinį pagrindimą – ar atsakymas iš tikrųjų remiasi pateiktais dokumentais? Antrasis vertina naudingumą – ar jis tikrai atsako į tai, ko buvo klausiama? Jei kuris nors patikrinimas nepavyksta, sistema kartojasi ir bando iš naujo, todėl tai yra savitaisos mechanizmas, o ne paprastas filtras.

Todėl ši eiga plečia „Corrective RAG“ principus. Jūs vis dar turite paiešką, po kurios seka dokumentų vertinimas ir generavimas. Toliau atsiranda du nauji mazgai: haliucinacijų patikra, lyginanti atsakymą su dokumentais, ir atsakymo patikra, lyginanti jį su klausimu. Jei patikra nepavyksta, sistema arba grįžta prie generavimo, arba iš interneto atsisiunčia naujos medžiagos, priklausomai nuo to, kuris patikrinimas nepavyko.

Faktinio pagrindimo tikrinimas

Pirmasis tikrintojas gauna du įvesties duomenis: sujungtus dokumentus ir sugeneruotą atsakymą. Jo užduotis – ne spręsti, ar atsakymas yra absoliučiai teisingas, o ar jis visiškai pagrįstas tuo, kas jam buvo pateikta. Šis skirtumas yra svarbus: teisingas teiginys, kurio nėra dokumentuose, turi būti atmestas, nes jis kyla iš modelio mokymosi atminties, o ne iš jūsų korpuso – ir nėra garantijos, kad kitas teiginys bus tikslus. Išvesties formatas atitinka vertintoją: dvejetainis JSON objektas, naudojant temperatūrą nulį.

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"

Naudingumo tikrinimas

Antrasis tikrintojas nemato nei dokumentų, nei paieškos rezultatų – tik klausimą ir atsakymą. Šis siauras matymo laukas yra tyčinis, nes jis išskiria trūkumą, kurį praleido pirmasis patikrinimas. Įsivaizduokite, kad kas nors paklausia, kiek matmenų sukuria įterpimų (embeddings) modelis, o atsakymas ilgai aiškina, kam naudojami įterpimai, taip ir nepateikdamas skaičiaus. Viskas yra pagrįsta dokumentais, todėl pirmasis tikrintojas sako „taip“, o vartotojas lieka be reikiamos informacijos. Antrasis tikrintojas sako „ne“ ir inicijuoja naują bandymą.

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"

Savitaisos ciklas

SelfRAG klasė iš naujo naudoja pažįstamus paieškos ir vertinimo žingsnius, tada apgaubia juos kartojimų ciklu, kurį riboja max_retries. Ciklo logika yra subtilesnė, nei atrodo iš pirmo žvilgsnio, nes dviejų tipų nesėkmės yra traktuojamos skirtingai. Aptikus haliucinaciją, tiesiog generuojama iš naujo su tuo pačiu kontekstu: problema slypi modelyje, kuris per daug nutolo, ir dažnai pakanka naujo bandymo. Tačiau jei atsakymas įvertintas kaip nenaudingas, prieš kartojant atliekama papildoma paieška internete: čia problema kyla iš konteksto, kuris yra per silpnas, kad palaikytų pilną atsakymą, ir generavimas iš naujo nieko nepridėjus duotų tą patį rezultatą.

Atkreipkite dėmesį į atsarginį išėjimą po ciklo. Kai visi bandymai išnaudojami, sistema neišmeta klaidos: ji grąžina paskutinį sugeneruotą atsakymą kartu su jo grounded (pagrįstumo) ir useful (naudingumo) žymėmis. Tai sąmoningas dizaino sprendimas – geriau grąžinti netobulą, bet taip pažymėtą atsakymą, kurį jūsų sąsaja gali parodyti vartotojui, nei išmesti „pliką“ klaidą.

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

Patikimumo kaina

Kiekviena apsaugos priemonė priduria dar vieną LLM užklausą, ir bendra suma greitai auga. Toliau pateikta funkcija tai aiškiai parodo, suskirstydama užklausas pagal žingsnius: viena vertinimo užklausa kiekvienam dokumentui, tada generavimas, pagrindimo patikra ir naudingumo patikra, kartojami kiekvieno bandymo metu. Turint keturis dokumentus ir vieną kartojimą, vienam klausimui tenka dešimt užklausų – tuo tarpu paprastam RAG jų reikėjo tik dviejų. Prieš nustatydami k ir max_retries, atlikite šį įvertinimą su savo vertėmis: šis skaičiavimas parodys, ar jūsų biudžetas ir delsos reikalavimai leidžia naudoti Self-RAG visam srautui, ar tik patiems jautriausiems klausimams.

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

Svarbiausi punktai

  • Self-RAG prideda du patikrinimus po generavimo: haliucinacijų ir naudingumo
  • Jei atsakymas nėra pagrįstas dokumentais, sistema jį generuoja iš naujo
  • Jei atsakymas nėra naudingas, sistema atlieka paiešką internete ir bando iš naujo
  • Kartojimų skaičius turi būti ribojamas, norint kontroliuoti delsą
  • Self-RAG yra brangesnis (daugiau LLM užklausų), bet patikimesnis