AI幻觉问题深度解析：成因、缓解与检测技术

HALLUCINATION_TYPES = {
    "事实性幻觉": {
        "description": "生成与客观事实不符的内容",
        "subtypes": {
            "实体幻觉": "编造不存在的人名、地名、机构",
            "关系幻觉": "错误描述实体间的关系",
            "数字幻觉": "编造不准确的统计数据",
            "时间幻觉": "错误的时间线",
            "来源幻觉": "编造不存在的引用来源"
        },
        "example": "爱因斯坦于1923年获得诺贝尔物理学奖"  # 实际是1921年
    },
    "忠实性幻觉": {
        "description": "生成与输入/上下文矛盾的内容",
        "subtypes": {
            "指令违背": "没有遵循用户指令",
            "上下文矛盾": "与给定上下文矛盾",
            "逻辑矛盾": "自身前后矛盾",
            "计算错误": "推理过程中计算错误"
        },
        "example": "用户说'不要用Python'，模型回复用Python实现"
    }
}

class DataInducedHallucination:
    def __init__(self):
        self.causes = {
            "数据噪声": {
                "description": "训练数据本身包含错误信息",
                "example": "维基百科中的错误事实被学习",
                "mitigation": "数据清洗和事实核查"
            },
            "知识冲突": {
                "description": "不同数据源对同一事实有不同表述",
                "example": "不同网站给出不同的历史日期",
                "mitigation": "可信度排序和数据源标注"
            },
            "长尾知识不足": {
                "description": "小众领域数据不足，模型靠猜",
                "example": "冷门历史事件的细节",
                "mitigation": "RAG增强"
            },
            "知识过时": {
                "description": "训练数据有时效性",
                "example": "模型不知道最新的公司财务数据",
                "mitigation": "实时检索"
            }
        }

class DecodingInducedHallucination:
    def analyze(self, model, prompt, strategies):
        """分析不同解码策略的幻觉率"""
        results = {}
        for strategy_name, params in strategies.items():
            hallucination_count = 0
            for _ in range(100):  # 100次采样
                response = model.generate(prompt, **params)
                if self._is_hallucination(response, prompt):
                    hallucination_count += 1
            
            results[strategy_name] = {
                "hallucination_rate": hallucination_count / 100,
                "params": params
            }
        
        return results

# 典型结果：
# greedy (temperature=0):     15% 幻觉率
# temperature=0.3:            18% 幻觉率
# temperature=0.7:            25% 幻觉率
# temperature=1.0:            35% 幻觉率
# top_p=0.9:                  22% 幻觉率
# top_k=50:                   28% 幻觉率

class KnowledgeRepresentationIssue:
    """
    模型的知识存储在参数中，不是数据库查询。
    这意味着：
    1. 知识边界模糊（不知道自己不知道什么）
    2. 知识提取不可靠（同样的知识不同问法结果不同）
    3. 知识干扰（相关知识互相干扰）
    """
    
    def measure_knowledge_boundary(self, model, questions):
        """测量模型的知识边界感知"""
        results = []
        for q in questions:
            # 让模型评估自己的确定性
            response = model.generate(f"{q}\n\n你对答案的确定程度？（1-10）")
            
            # 验证答案正确性
            is_correct = verify_answer(q, response)
            confidence = extract_confidence(response)
            
            results.append({
                "question": q,
                "correct": is_correct,
                "confidence": confidence,
                "calibrated": (is_correct and confidence > 7) or 
                              (not is_correct and confidence < 4)
            })
        
        calibration_rate = sum(r["calibrated"] for r in results) / len(results)
        return {
            "calibration_rate": calibration_rate,
            "over_confident": sum(1 for r in results if not r["correct"] and r["confidence"] > 7),
            "under_confident": sum(1 for r in results if r["correct"] and r["confidence"] < 4)
        }

class TruthfulnessReward:
    def compute_reward(self, response, reference_facts):
        """在RLHF中加入真实性奖励"""
        # 基础奖励（有用性、无害性）
        base_reward = self.base_reward_model(response)
        
        # 真实性奖励
        facts_in_response = extract_facts(response)
        truth_score = 0
        for fact in facts_in_response:
            if self._verify_fact(fact, reference_facts):
                truth_score += 1
            else:
                truth_score -= 2  # 幻觉惩罚
        
        # 拒绝回答也是正确的
        if "我不知道" in response or "我不确定" in response:
            truth_score += 0.5  # 鼓励承认不知道
        
        return base_reward + 0.3 * truth_score

def factuality_finetuning(model, factuality_data):
    """使用事实性数据微调"""
    # 数据格式：(问题, 正确答案, 易混淆的错误答案)
    for question, correct, misleading in factuality_data:
        # 对比学习：正确答案 vs 错误答案
        loss = contrastive_loss(
            model, question, correct, misleading
        )
        loss.backward()

class RAGHallucinationMitigation:
    def generate(self, question):
        # 1. 检索相关事实
        facts = self.retriever.search(question, top_k=5)
        
        if not facts or facts[0].score < 0.3:
            # 没有可靠来源 → 鼓励拒绝回答
            return "我没有找到可靠的信息来回答这个问题。"
        
        # 2. 带引用的生成
        prompt = f"""
        基于以下来源信息回答问题。
        
        来源：
        {[f"[{i+1}] {f.content}" for i, f in enumerate(facts)]}
        
        问题：{question}
        
        要求：
        1. 只基于来源信息回答
        2. 每个事实标注来源编号
        3. 来源中没有的信息要明确说明
        4. 如果来源信息矛盾，说明分歧
        """
        
        return self.llm.generate(prompt)

class SelfConsistencyCheck:
    def check(self, question, model, n_samples=5):
        """多次采样检查一致性"""
        responses = [
            model.generate(question, temperature=0.7)
            for _ in range(n_samples)
        ]
        
        # 提取每个回答中的事实声明
        all_claims = [extract_claims(r) for r in responses]
        
        # 检查一致性
        consistent_claims = []
        for claim in all_claims[0]:
            appears_in = sum(1 for claims in all_claims if claim in claims)
            if appears_in >= n_samples * 0.6:  # 60%以上一致
                consistent_claims.append(claim)
        
        # 只保留一致的声明
        verified_response = self._reconstruct(consistent_claims)
        return verified_response

class FactVerification:
    def verify_and_correct(self, response, knowledge_base):
        """对生成内容进行事后事实核查"""
        # 1. 提取事实声明
        claims = self._extract_claims(response)
        
        # 2. 逐一验证
        corrections = []
        for claim in claims:
            verification = self._verify(claim, knowledge_base)
            
            if not verification["supported"]:
                corrections.append({
                    "original": claim,
                    "correction": verification.get("correct_info"),
                    "confidence": verification["confidence"]
                })
        
        # 3. 应用修正
        corrected = response
        for corr in corrections:
            if corr["correction"]:
                corrected = corrected.replace(
                    corr["original"],
                    corr["correction"]
                )
            else:
                # 无法修正的标记
                corrected = corrected.replace(
                    corr["original"],
                    f"[未验证: {corr['original']}]"
                )
        
        return corrected

class InconsistencyDetector:
    def detect(self, response):
        """检测回答内部的一致性"""
        # 1. 分解为声明
        claims = self._extract_claims(response)
        
        # 2. 检查声明间的矛盾
        contradictions = []
        for i, c1 in enumerate(claims):
            for c2 in claims[i+1:]:
                if self._are_contradictory(c1, c2):
                    contradictions.append((c1, c2))
        
        # 3. 检查逻辑一致性
        logical_flow = self._check_logical_flow(response)
        
        return {
            "claims_count": len(claims),
            "contradictions": contradictions,
            "logical_issues": logical_flow,
            "hallucination_risk": len(contradictions) / max(len(claims), 1)
        }

class ExternalVerification:
    def __init__(self, search_engine, knowledge_graph):
        self.search = search_engine
        self.kg = knowledge_graph
    
    def verify(self, response):
        """用外部知识验证回答"""
        claims = self._extract_claims(response)
        results = []
        
        for claim in claims:
            # 搜索验证
            search_results = self.search.query(claim["text"])
            support_score = self._compute_support(claim, search_results)
            
            # 知识图谱验证
            kg_result = self.kg.query(claim["entities"])
            
            results.append({
                "claim": claim,
                "search_support": support_score,
                "kg_support": kg_result,
                "verified": support_score > 0.5 or kg_result["found"]
            })
        
        return {
            "total_claims": len(claims),
            "verified_claims": sum(1 for r in results if r["verified"]),
            "unverified": [r for r in results if not r["verified"]],
            "overall_confidence": sum(r["verified"] for r in results) / max(len(results), 1)
        }

HALLUCINATION_BENCHMARKS = {
    "TruthfulQA": {
        "description": "测试模型是否模仿人类谬误",
        "metric": "真实性百分比",
        "best_models": "GPT-4o: 75%, Claude-4: 78%"
    },
    "HaluEval": {
        "description": "幻觉评估基准",
        "metric": "非幻觉率",
        "best_models": "GPT-4o: 88%"
    },
    "FactScore": {
        "description": "原子事实精确度",
        "metric": "事实得分",
        "best_models": "GPT-4o: 0.74"
    },
    "TrueQA": {
        "description": "复杂事实问答",
        "metric": "准确率",
        "best_models": "GPT-4o: 65%"
    }
}