Ancorarea răspunsurilor în surse și reducerea halucinațiilor
Pe această pagină
Problema halucinațiilor în producție
O halucinație este un răspuns factual incorect, livrat cu încrederea unui răspuns corect. Exact această încredere o face periculoasă. Un chatbot de suport care inventează o procedură trimite utilizatorii într-un fund de sac; un asistent juridic care citează o lege inexistentă vă expune clientul la riscuri; un instrument medical care recomandă o doză greșită provoacă daune reale. În toate cele trei cazuri, nimic din formatul răspunsului nu semnalează problema.
Ancorarea (Grounding) abordează acest risc constrângând modelul să își bazeze răspunsurile exclusiv pe surse verificate. Combinată cu sistemul de citații abordat în lecțiile anterioare, aceasta creează o plasă de siguranță pe mai multe niveluri: promptul definește comportamentul așteptat, analizarea citațiilor permite verificarea, iar pipeline-ul decide cum să gestioneze răspunsurile care nu trec de acest control.
Promptul de sistem: prima linie de apărare
Un prompt vag produce o ancorare vagă. Trebuie să enunțați regulile ca pe o specificație: definiți domeniul surselor, furnizați fraza exactă de utilizat atunci când informațiile lipsesc, interziceți completarea golurilor cu cunoștințe generale, cereți citații pentru fiecare afirmație și specificați modul de gestionare a contradicțiilor dintre surse.
system_prompt = """
You are a specialized documentation assistant.
ABSOLUTE RULES:
1. Answer ONLY using the sources provided via references.
2. If the information is not in the sources, respond:
"This information is not available in the provided sources."
3. NEVER supplement with your general knowledge.
4. Cite every claim with the corresponding reference.
5. If two sources contradict each other, mention both versions.
"""
Acest prompt nu garantează zero halucinații, iar dumneavoastră trebuie să fiți clar în această privință cu părțile interesate: acesta reduce semnificativ frecvența lor. Modelele Mistral, antrenate pentru ancorare, urmează aceste instrucțiuni cu un grad ridicat de conformitate. Totuși, un grad ridicat nu înseamnă 100%, motiv pentru care pașii următori sunt necesari.
Verificarea ancorării după generare
Funcția validate_grounding transformă o intuiție — „pare acest răspuns bazat pe surse?“ — într-o metrică. Aceasta parcurge fragmentele răspunsului, însumând lungimea textului pe o parte și numărând citațiile și sursele distincte pe cealaltă. Apoi, derivează o densitate exprimată în citații la o mie de caractere. Un răspuns de 2.000 de caractere cu o singură referință devine imediat suspect, în timp ce un recenzor uman ar fi putut să nu observe acest lucru.
from mistralai.client.models import TextChunk, ReferenceChunk
def validate_grounding(response, min_citations=1):
"""Verifies that the response is grounded in sources."""
content = response.choices[0].message.content
text_length = 0
citation_count = 0
cited_refs = set()
for chunk in content:
if isinstance(chunk, TextChunk):
text_length += len(chunk.text)
elif isinstance(chunk, ReferenceChunk):
citation_count += 1
cited_refs.update(chunk.reference_ids)
# Checks
checks = {
"has_citations": citation_count >= min_citations,
"citation_count": citation_count,
"unique_sources": len(cited_refs),
"text_length": text_length,
"citations_per_1000_chars": round(
citation_count / max(text_length / 1000, 1), 1
)
}
checks["is_grounded"] = checks["has_citations"]
return checks
result = validate_grounding(final_response, min_citations=2)
if not result["is_grounded"]:
print("ALERT: Response potentially ungrounded!")
print(f" Citations found: {result['citation_count']}")
Identificarea afirmațiilor din afara domeniului de aplicare
Numărarea citațiilor nu vă spune dacă textul dintre acestea rămâne fidel surselor. Funcția detect_ungrounded_claims abordează acest punct orb printr-o euristică lexicală simplă: împarte răspunsul în propoziții, compară cuvintele cu mai mult de cinci caractere din fiecare propoziție cu fragmentele concatenate și marchează orice propoziție în care mai puțin de 30% din cuvintele-cheie apar în surse. Pentru un asistent de documentație, propozițiile care ajung în vârful listei de suspiciuni sunt de obicei conținutul de tip „cunoștințe generale“ adăugat de model.
def detect_ungrounded_claims(response_text, source_snippets):
"""Detects sentences that do not match any snippet."""
import re
# Split response into sentences
sentences = re.split(r'[.!?]+', response_text)
sentences = [s.strip() for s in sentences if len(s.strip()) > 20]
# Concatenate all snippets into a single text
all_sources = " ".join(source_snippets).lower()
suspicious = []
for sentence in sentences:
# Extract significant keywords (> 5 chars)
keywords = [
w.lower() for w in sentence.split()
if len(w) > 5
]
# Check coverage
matches = sum(1 for kw in keywords if kw in all_sources)
coverage = matches / max(len(keywords), 1)
if coverage < 0.3: # Less than 30% of keywords found
suspicious.append({
"sentence": sentence,
"coverage": round(coverage, 2)
})
return suspicious
Asamblarea unui pipeline de încredere
În producție, aceste verificări nu sunt doar scripturi de analiză: ele devin o poartă prin care răspunsul trebuie să treacă înainte de a ajunge la utilizator. Clasa GroundedRAG implementează această poartă. Aceasta generează răspunsul citat, îl validează și, în modul strict, respinge categoric răspunsurile cu o ancorare insuficientă, returnând o stare explicită în loc de un text îndoielnic. Scorul de încredere agregă trei semnale — prezența citațiilor, diversitatea surselor și densitatea — astfel încât interfața dumneavoastră să poată afișa un nivel de fiabilitate sau să direcționeze cazurile cu încredere scăzută pentru revizuire umană.
class GroundedRAG:
"""RAG pipeline with grounding and validation."""
def __init__(self, client, model="mistral-large-latest"):
self.client = client
self.model = model
def query(self, question, references, strict=True):
"""Executes a RAG query with grounding validation."""
# 1. Generate response with citations
response = self._generate_with_citations(
question, references
)
# 2. Validate grounding
grounding = validate_grounding(response, min_citations=1)
# 3. In strict mode, reject ungrounded responses
if strict and not grounding["is_grounded"]:
return {
"status": "rejected",
"reason": "Response insufficiently grounded in sources",
"grounding_score": grounding
}
# 4. Return validated response
return {
"status": "ok",
"response": response,
"grounding_score": grounding,
"confidence": self._compute_confidence(grounding)
}
def _compute_confidence(self, grounding):
"""Calculates a confidence score based on grounding."""
score = 0.0
if grounding["has_citations"]:
score += 0.4
if grounding["unique_sources"] >= 2:
score += 0.3
if grounding["citations_per_1000_chars"] >= 1.0:
score += 0.3
return round(score, 2)
Monitorizarea ancorării în timp
Un pipeline ancorat în prima zi de producție se poate degrada în timp, deoarece baza de documentație îmbătrânește, deoarece un prompt a fost modificat sau deoarece traficul se deplasează către subiecte slab acoperite. Cele cinci metrici de mai jos se calculează direct din ieșirile funcției validate_grounding și merită un tablou de bord permanent: derivă lor, mai mult decât valoarea lor absolută, este cea care vă alertează.
| Metrică | Ce măsoară |
|---|---|
| Rata de citații | Procentul de răspunsuri care conțin cel puțin o citație |
| Densitatea citațiilor | Numărul mediu de citații la 1.000 de caractere |
| Diversitatea surselor | Numărul mediu de surse distincte per răspuns |
| Rata de respingere | Procentul de răspunsuri respinse din cauza unei ancorări insuficiente |
| Scorul mediu de încredere | Evoluția scorului de încredere în timp |
Puncte cheie
- Ancorarea constrânge modelul să răspundă doar pe baza surselor verificate
- Un prompt de sistem strict este prima linie de apărare împotriva halucinațiilor
- Validarea post-generare verifică programatic ancorarea fiecărui răspuns
- Combinați aceste strategii într-un pipeline de încredere pe mai multe niveluri
- Monitorizați continuu metricile de ancorare pentru a detecta degradarea