Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Self-RAG

Ceacht 16 as 18 Nuashonraithe 2 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Féinmheastóireacht i RAG
  2. Bunús Fíorasach a Sheiceáil
  3. Úsáideacht a Sheiceáil
  4. An Lúb Féincheartaithe
  5. Costas na hIontaofachta
  6. Príomhphointí

Féinmheastóireacht i RAG

Rialaíonn RAG Ceartaitheach an méid a théann isteach sa leid, ach ní rialaíonn sé an méid a thagann amach. Ní ráthaíonn comhthéacs foirfe freagra maith: d’fhéadfadh an tsamhail mionsonraí a chur leis nach bhfuil le fáil in aon áit sna doiciméid, nó téacs a tháirgeadh atá cruinn ach a sheachnaíonn an cheist iarbhír. Dúnann Self-RAG (RAG Féinmheastóireachta) an bhearna seo trí dhá sheiceáil a chur leis tar éis na giniúna. Déanann an chéad cheann scrúdú ar bhunús fíorasach—an bhfuil an freagra bunaithe go hiomlán ar na doiciméid a soláthraíodh? Déanann an dara ceann scrúdú ar úsáideacht—an bhfuil sé ag freagairt go díreach don a iarradh? Má theipeann ar cheachtar seiceáil, déanann an córas lúb agus triail arís, rud a fhágann gur meicníocht féincheartaithe é seachas scagaire simplí.

Leathnaíonn an sreabhsa RAG Ceartaitheach, mar sin. Tá aisghabháil agat fós, arna leanúint ag grádú doiciméad, agus ansin giniúint. Tagann dhá nód nua ina ndiaidh: an seiceáil hallaisinéise, a dhéanann comparáid idir an freagra agus na doiciméid, agus an seiceáil freagra, a dhéanann comparáid idir é agus an cheist. Má theipeann ar sheiceáil, filleann an córas ar an nginiúint nó faigheann sé ábhar úr ón ngréasán, ag brath ar cé acu fíorú a theip.

Bunús Fíorasach a Sheiceáil

Faigheann an chéad seiceálaí dhá ionchur: na doiciméid chumaiscthe agus an freagra ginte. Ní hé a chúram a bhreithniú an bhfuil an freagra fíor i dtéarmaí absalóideacha, ach an bhfuil sé bunaithe go hiomlán ar an méid a tugadh dó. Tá tábhacht leis an idirdhealú seo: caithfear ráiteas cruinn nach bhfuil sna doiciméid a dhiúltú toisc go dtagann sé ó chuimhne oiliúna na samhla, ní ó do chorpas féin—agus níl aon ráthaíocht go mbeidh an ráiteas seo a leanas cruinn. Meaitseálann an formáid aschuir an grádóir: oibiacht JSON dhénártha ag teocht nialasach.

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"

Úsáideacht a Sheiceáil

Ní fheiceann an dara seiceálaí na doiciméid ná torthaí an aisghabhála—ní fheiceann sé ach an cheist agus an freagra. Tá an réimse radhairc cúng seo d’aon ghnó toisc go n-aonraíonn sé locht a ligeann an chéad seiceáil tríd. Samhlaigh go bhfuil duine ag fiafraí cé mhéad toise a tháirgeann samhail leabaithe, agus go ndéanann an freagra cur síos fada ar cad a úsáidtear leabaithe dóibh gan an uimhir a thabhairt riamh. Tá gach rud bunaithe sna doiciméid, mar sin deir an chéad seiceálaí “tá”, agus imíonn an t-úsáideoir gan a chuid eolais. Deir an dara seiceálaí “níl” agus spreagann sé iarracht eile.

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"

An Lúb Féincheartaithe

Athúsáideann an rang SelfRAG na céimeanna eolacha aisghabhála agus grádaithe, ansin cuimsíonn sé iad i lúb athiarrtha atá teoranta ag max_retries. Tá loighic na lúibe níos subtle ná mar a dealraíonn sé toisc go bhfaigheann an dá chineál teip cóireáil difriúil. Déanann hallaisinéis a bhrath athghiniúint leis an gcomhthéacs céanna: baineann an fhadhb leis an tsamhail, a rinne ró-ghníomhú, agus is minic a leor tarraingt úr. Spreagann freagra a mheastar a bheith gan úsáid, áfach, cuardach gréasáin breise sula ndéantar iarracht arís: anseo baineann an fhadhb leis an gcomhthéacs, atá ró-thanaí chun freagra iomlán a thacú, agus thabharfadh athghiniúint gan aon rud a chur leis an toradh céanna.

Tabhair faoi deara an tslí éalaithe tar éis na lúibe. Nuair a ídítear gach iarracht, ní chuireann an córas eisceacht ar ard: filleann sé an ghiniúint dheireanach mar aon lena bratacha grounded agus useful. Is rogha dearaidh d’aon ghnó é seo—is fearr freagra neamhfhoirfe a thabhairt ar ais atá lipéadaithe mar sin, ar féidir le do chomhéadan bratach a chur air don úsáideoir, ná earráid amh a chaitheamh.

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

Costas na hIontaofachta

Cuireann gach garda-réile glao LLM eile leis, agus méadaíonn an t-iomlán go tapa. Déanann an fheidhm thíos é seo a dhéanamh soiléir trí ghlaonna a bhriseadh síos in aghaidh na céime: glao grádaithe amháin in aghaidh an doiciméid, ansin giniúint, seiceáil bunaithe, agus seiceáil úsáideachta, gach ceann arna athdhéanamh ar gach athiarracht. Le ceithre doiciméad agus athiarracht amháin, sroicheann tú deich nglaonna d’aon cheist amháin—áit a raibh dhá ghla ag teastáil ó RAG bunúsach. Rith an meastachán seo le do luachanna féin sula socraíonn tú k agus max_retries: insíonn an ríomh seo duit an dtacaíonn do bhuiséad agus do riachtanais moille le Self-RAG ar fud na tráchta go léir, nó do na ceisteanna is íogaire amháin.

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

Príomhphointí

  • Cuireann Self-RAG dhá sheiceáil iarchineálacha leis: hallaisinéisí agus úsáideacht
  • Mura bhfuil an freagra bunaithe sna doiciméid, déanann an córas athghiniúint
  • Mura bhfuil an freagra úsáideach, déanann an córas cuardach gréasáin agus déanann sé iarracht arís
  • Caithfear líon na n-athiarrachtaí a theorannú chun moill a rialú
  • Tá Self-RAG níos costasaí (níos mó glaonna LLM) ach níos iontaofa