LLM幻觉完全指南【2026】- 理解、检测与消除AI胡说八道

user_query = "爱因斯坦是哪一年获得诺贝尔物理学奖的？"

hallucinated_response = "爱因斯坦于1905年因相对论获得诺贝尔物理学奖。"

correct_response = "爱因斯坦于1921年获得诺贝尔物理学奖，获奖原因是光电效应理论，而非相对论。"

def simplified_llm_generation(prompt, temperature=1.0):
    """
    简化的LLM生成过程演示
    temperature越高，随机性越大，幻觉风险越高
    """
    probabilities = model.predict_next_token(prompt)
    
    if temperature > 0:
        probabilities = apply_temperature(probabilities, temperature)
    
    next_token = sample_from_distribution(probabilities)
    
    return next_token

from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain_openai import ChatOpenAI

def rag_with_hallucination_reduction(query, knowledge_base):
    """
    使用RAG减少幻觉的示例
    """
    embeddings = OpenAIEmbeddings()
    vectorstore = Chroma.from_documents(knowledge_base, embeddings)
    
    relevant_docs = vectorstore.similarity_search(query, k=5)
    context = "\n".join([doc.page_content for doc in relevant_docs])
    
    prompt = f"""基于以下参考资料回答问题。
    
规则：
1. 只使用参考资料中的信息
2. 如果资料中没有相关信息，明确说明"根据现有资料无法回答"
3. 不要编造任何信息

参考资料：
{context}

问题：{query}

回答："""
    
    llm = ChatOpenAI(model="gpt-4-turbo", temperature=0)
    response = llm.invoke(prompt)
    
    return response.content

anti_hallucination_prompt = """
你是一个严谨的AI助手。在回答问题时，请遵循以下原则：

## 核心原则
1. **诚实性**：如果不确定，请明确说明
2. **可验证性**：尽可能提供可验证的信息来源
3. **保守性**：宁可少说，不要编造

## 回答格式
- 确定的信息：直接陈述
- 不确定的信息：使用"据我所知"、"可能"等限定词
- 无法回答：明确说明"我没有足够的信息来回答这个问题"

## 禁止行为
- 不要编造引用、统计数据或专家言论
- 不要虚构不存在的事件或人物
- 不要对超出知识范围的问题给出确定性答案

用户问题：{question}
"""

def adjust_temperature_for_task(task_type):
    """
    根据任务类型调整温度参数
    """
    temperature_map = {
        "factual_qa": 0.0,
        "summarization": 0.3,
        "translation": 0.3,
        "creative_writing": 0.7,
        "brainstorming": 1.0
    }
    return temperature_map.get(task_type, 0.5)

def multi_model_verification(query, models):
    """
    多模型交叉验证减少幻觉
    """
    responses = []
    for model in models:
        response = model.generate(query)
        responses.append(response)
    
    consensus = find_consensus(responses)
    
    confidence = calculate_agreement_score(responses)
    
    return {
        "answer": consensus,
        "confidence": confidence,
        "requires_verification": confidence < 0.8
    }

import re
from typing import List, Dict, Any
from dataclasses import dataclass
from langchain_openai import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma

@dataclass
class FactCheckResult:
    claim: str
    verdict: str
    confidence: float
    evidence: List[str]
    explanation: str

class HallucinationDetector:
    """LLM幻觉检测与事实核查系统"""
    
    def __init__(self, knowledge_base_path: str = None):
        self.llm = ChatOpenAI(model="gpt-4-turbo", temperature=0)
        self.embeddings = OpenAIEmbeddings()
        self.knowledge_base = None
        
        if knowledge_base_path:
            self.load_knowledge_base(knowledge_base_path)
    
    def load_knowledge_base(self, path: str):
        """加载知识库用于事实核查"""
        from langchain.document_loaders import DirectoryLoader
        
        loader = DirectoryLoader(path, glob="**/*.txt")
        documents = loader.load()
        self.knowledge_base = Chroma.from_documents(
            documents, 
            self.embeddings
        )
    
    def extract_claims(self, text: str) -> List[str]:
        """从文本中提取事实性声明"""
        prompt = f"""从以下文本中提取所有事实性声明（可以被验证为真或假的陈述）。
        
每个声明单独一行，不要包含观点或主观判断。

文本：
{text}

事实性声明："""
        
        response = self.llm.invoke(prompt)
        claims = [c.strip() for c in response.content.split('\n') if c.strip()]
        return claims
    
    def verify_claim(self, claim: str) -> FactCheckResult:
        """验证单个声明"""
        evidence = []
        if self.knowledge_base:
            docs = self.knowledge_base.similarity_search(claim, k=3)
            evidence = [doc.page_content for doc in docs]
        
        evidence_text = "\n".join(evidence) if evidence else "无可用证据"
        
        prompt = f"""作为事实核查专家，请验证以下声明。

声明：{claim}

参考证据：
{evidence_text}

请分析并给出：
1. 判定结果（支持/反驳/无法验证）
2. 置信度（0-1之间的数值）
3. 详细解释

格式：
判定：[结果]
置信度：[数值]
解释：[详细说明]"""
        
        response = self.llm.invoke(prompt)
        result = self._parse_verification_result(response.content, claim, evidence)
        
        return result
    
    def _parse_verification_result(
        self, 
        response: str, 
        claim: str, 
        evidence: List[str]
    ) -> FactCheckResult:
        """解析验证结果"""
        verdict = "无法验证"
        confidence = 0.5
        explanation = response
        
        if "支持" in response:
            verdict = "支持"
        elif "反驳" in response:
            verdict = "反驳"
        
        confidence_match = re.search(r'置信度[：:]\s*([\d.]+)', response)
        if confidence_match:
            confidence = float(confidence_match.group(1))
        
        return FactCheckResult(
            claim=claim,
            verdict=verdict,
            confidence=confidence,
            evidence=evidence,
            explanation=explanation
        )
    
    def check_consistency(self, text: str) -> Dict[str, Any]:
        """检查文本内部一致性"""
        prompt = f"""分析以下文本是否存在内部矛盾或逻辑不一致。

文本：
{text}

请指出：
1. 是否存在矛盾（是/否）
2. 具体矛盾之处（如有）
3. 矛盾的严重程度（高/中/低）"""
        
        response = self.llm.invoke(prompt)
        
        has_contradiction = "是" in response.content and "存在矛盾" in response.content
        
        return {
            "has_contradiction": has_contradiction,
            "analysis": response.content
        }
    
    def full_check(self, text: str) -> Dict[str, Any]:
        """完整的幻觉检测流程"""
        claims = self.extract_claims(text)
        
        claim_results = []
        for claim in claims:
            result = self.verify_claim(claim)
            claim_results.append(result)
        
        consistency = self.check_consistency(text)
        
        hallucination_score = self._calculate_hallucination_score(
            claim_results, 
            consistency
        )
        
        return {
            "claims_checked": len(claims),
            "claim_results": claim_results,
            "consistency_check": consistency,
            "hallucination_score": hallucination_score,
            "recommendation": self._get_recommendation(hallucination_score)
        }
    
    def _calculate_hallucination_score(
        self, 
        claim_results: List[FactCheckResult],
        consistency: Dict
    ) -> float:
        """计算幻觉风险分数（0-1，越高风险越大）"""
        if not claim_results:
            return 0.5
        
        refuted_count = sum(1 for r in claim_results if r.verdict == "反驳")
        unverified_count = sum(1 for r in claim_results if r.verdict == "无法验证")
        total = len(claim_results)
        
        claim_score = (refuted_count * 1.0 + unverified_count * 0.5) / total
        
        consistency_score = 0.3 if consistency["has_contradiction"] else 0
        
        return min(1.0, claim_score * 0.7 + consistency_score)
    
    def _get_recommendation(self, score: float) -> str:
        """根据分数给出建议"""
        if score < 0.2:
            return "低风险：内容可信度较高"
        elif score < 0.5:
            return "中等风险：建议人工复核关键信息"
        else:
            return "高风险：强烈建议进行事实核查"


if __name__ == "__main__":
    detector = HallucinationDetector()
    
    test_text = """
    据研究表明，GPT-4于2022年发布，是OpenAI最强大的模型。
    该模型拥有1万亿参数，训练成本超过10亿美元。
    OpenAI CEO Sam Altman表示，GPT-5将在2024年底发布。
    """
    
    result = detector.full_check(test_text)
    
    print(f"检查声明数：{result['claims_checked']}")
    print(f"幻觉风险分数：{result['hallucination_score']:.2f}")
    print(f"建议：{result['recommendation']}")