Self-RAG
Tällä sivulla
Itsearviointi RAG:ssa
Corrective RAG hallitsee kehotteeseen syötettävän sisällön, mutta ei sitä, mitä sieltä tulee ulos. Edes täydellinen konteksti ei takaa hyvää vastausta: malli voi lisätä yksityiskohtia, joita ei ole missään dokumenteissa, tai tuottaa tekstiä, joka on faktuaalisesti oikein mutta väistää varsinaisen kysymyksen. Self-RAG (itseheijastava RAG) kuromaa tämän kuilun lisäämällä kaksi tarkistusta generoinnin jälkeen. Ensimmäinen tutkii faktapohjaa: perustuuko vastaus todella annettuihin dokumentteihin? Toinen tutkii hyödyllisyyttä: vastaako se todella siihen, mitä kysyttiin? Jos jompikumpi tarkistus epäonnistuu, järjestelmä toistaa prosessin, jolloin kyseessä on itsekorjaava mekanismi eikä pelkkä suodatin.
Virta laajentaa siis Corrective RAG -mallia. Sinulla on edelleen haku, jota seuraa dokumenttien arviointi ja sitten generointi. Tämän jälkeen tulevat kaksi uutta solmua: hallusinaatiotarkistus, joka vertaa vastausta dokumentteihin, ja vastauksen tarkistus, joka vertaa sitä kysymykseen. Jos tarkistus epäonnistuu, järjestelmä joko palaa generointiin tai hakee uutta materiaalia verkosta sen mukaan, kumpi varmennus epäonnistui.
Faktapohjan tarkistus
Ensimmäinen tarkistin saa kaksi syötettä: yhdistetyt dokumentit ja generoidun vastauksen. Sen tehtävä ei ole arvioida, onko vastaus absoluuttisesti totta, vaan onko se täysin perusteltu sille annetulla tiedolla. Tämä ero on tärkeä: tarkka väittämä, jota ei ole dokumenteissa, on hylättävä, koska se tulee mallin oppimismuistista, ei sinun korpuksestasi – eikä ole takeita siitä, että seuraava väittämä olisi tarkka. Tulosteen muotoilu vastaa arvioijaa: binäärinen JSON-objekti lämpötilassa nolla.
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"
Hyödyllisyyden tarkistus
Toinen tarkistin ei näe dokumentteja eikä hakutuloksia – vain kysymyksen ja vastauksen. Tämä kapea näkökulma on tarkoituksellinen, koska se eristää vian, jonka ensimmäinen tarkistus päästää läpi. Kuvittele, että joku kysyy, montako ulottuvuutta upotusmalli tuottaa, ja vastaus kuvailee pitkällisesti, mihin upotuksia käytetään, antamatta koskaan lukua. Kaikki perustuu dokumentteihin, joten ensimmäinen tarkistin sanoo “kyllä”, ja käyttäjä jää ilman kaipaamaansa tietoa. Toinen tarkistin sanoo “ei” ja käynnistää uuden yrityksen.
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"
Itsekorjaussilmukka
SelfRAG-luokka käyttää uudelleen tuttuja haku- ja arviointivaiheita ja kietoo ne max_retries-rajoitetun toistosilmukan sisään. Silmukan logiikka on hienovaraisempi kuin miltä näyttää, koska kahdenlaiset epäonnistumiset saavat erilaisen kohtelun. Havaittu hallusinaatio johtaa yksinkertaisesti uudelleengenerointiin samalla kontekstilla: ongelma on mallissa, joka liioitteli, ja uusi yritys usein riittää. Hyödyttömäksi arvioitu vastaus sen sijaan käynnistää lisähaun verkosta ennen uudelleenyritystä: tässä ongelma on kontekstissa, joka on liian ohut tukemaan täydellistä vastausta, ja uudelleengenerointi ilman lisäyksiä tuottaisi saman tuloksen.
Huomaa silmukan jälkeinen varauloskäynti. Kun kaikki yritykset on käytetty, järjestelmä ei heitä poikkeusta: se palauttaa viimeisen generoinnin yhdessä sen grounded- ja useful-lippujen kanssa. Tämä on tarkoituksellinen suunnitteluratkaisu – on parempi palautaa epätäydellinen vastaus sellaisenaan merkittynä, jotta käyttöliittymäsi voi varoittaa käyttäjää, kuin heittää raaka virhe.
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']}")
Luotettavuuden hinta
Jokainen turvamekanismi lisää yhden LLM-kutsun, ja kokonaismäärä kasvaa nopeasti. Alla oleva funktio tekee tämän ilmeiseksi purkamalla kutsut vaiheittain: yksi arviointikutsu dokumenttia kohden, sitten generointi, faktapohjan tarkistus ja hyödyllisyyden tarkistus, joista jokainen toistuu jokaisella uudelleenyrityksellä. Neljällä dokumentilla ja yhdellä uudelleenyrityksellä päädytään kymmeneen kutsuun yhtä kysymystä kohden – kun perus-RAG vaati kaksi. Suorita tämä arvio omilla arvoillasi ennen kuin asetat k:n ja max_retries:n arvot: tämä laskelma kertoo, tukevatko budjettisi ja viivevaatimuksesi Self-RAG:a koko liikenteelle vai vain herkimmille kysymyksille.
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
Keskeiset asiat
- Self-RAG lisää kaksi generoinnin jälkeistä tarkistusta: hallusinaatiot ja hyödyllisyyden
- Jos vastaus ei perustu dokumentteihin, järjestelmä generoi uudelleen
- Jos vastaus ei ole hyödyllinen, järjestelmä suorittaa verkkohaun ja yrittää uudelleen
- Uudelleenyritysten määrä on rajoitettava viiveen hallitsemiseksi
- Self-RAG on kalliimpi (enemmän LLM-kutsuja) mutta luotettavampi