1. 项目缘起：当RAG遇上幻觉，我们到底在解决什么问题？

最近在折腾大模型应用落地的朋友，估计没少被“幻觉”问题折磨。你精心搭建了一个基于RAG（检索增强生成）的智能客服或者知识库问答系统，指望着它能精准地从企业文档里找到答案。结果呢？用户问“我们公司今年的年假政策是什么？”，它可能给你编一个“根据最新规定，每位员工享有20天带薪年假，并可叠加法定节假日”的完美答案，听起来头头是道，但实际情况可能是公司规定只有10天。这种一本正经地胡说八道，就是大模型最让人头疼的“幻觉”。

传统的RAG流程，简单说就是“检索-拼接-生成”。系统先从向量数据库里捞出几篇最相关的文档片段，把它们和用户问题一起塞给大语言模型，说：“喏，这是参考资料，请基于此回答。” 模型的任务是综合这些信息生成最终回复。这里的核心假设是：模型会“乖乖地”主要依据你提供的参考文本来回答。但现实很骨感，LLM（大语言模型）本质上是基于海量数据训练出的概率生成器，它有极强的语言建模和逻辑推理能力，但同时也保留了“自由发挥”的习性。当检索到的文档信息模糊、不全，或者模型自身的“知识”与文档冲突时，它就可能选择忽略或曲解你给的参考资料，转而依赖自己训练数据中的记忆来“编造”答案。

所以，RAGognizer这个项目的目标非常明确：它不是要取代RAG，而是要给RAG系统加上一个“质检员”。这个“质检员”的任务，就是在模型生成最终答案的同时，实时地、自动地判断答案中的每一部分信息，到底有多少是忠实于你提供的参考文档的，有多少是模型自己“加戏”产生的幻觉。更进一步，它不仅仅是一个事后的检测器，而是将这种“幻觉感知”能力，通过一个额外的“检测头”集成到模型微调过程中，让模型在训练时就学会“自我审查”，从而在根本上提升生成答案的可靠性和事实一致性。这相当于给模型装了一个“诚实度传感器”，让它生成答案时自己心里有数，知道哪句话是有据可查，哪句话是推测甚至虚构的。

2. 核心架构拆解：检测头如何实现“幻觉感知”？

RAGognizer的核心创新，在于它提出的“集成检测头”架构。要理解它，我们得先抛开复杂的数学公式，从功能模块的角度来看。

想象一下，一个标准的、用于RAG场景的微调后的大模型，可以看作一个黑箱：输入是问题（Query）和检索到的参考上下文（Context），输出是答案（Answer）。传统的微调目标，是让这个答案在流畅度、相关性和事实准确性上尽可能好。但“事实准确性”是一个事后评估指标，模型在生成时并没有一个内置的机制来量化自己对每个生成token的“信心来源”。

RAGognizer的做法是，在这个主模型（我们称之为“生成主干网络”）的旁边，并联一个轻量级的“检测头”网络。这个检测头通常只有几层全连接层或小型Transformer层，参数很少，计算开销低。它的输入，并不是原始的问题和上下文，而是生成主干网络在生成答案过程中的“内部状态”——具体来说，是每个解码步骤（即生成每个答案token时）对应的隐藏层表示（Hidden States）。

这个设计非常巧妙。因为模型的隐藏层表示，蕴含了模型在生成当前词时“思考”的全部信息，包括它对问题、上下文的理解，以及它即将生成的内容的倾向。检测头的任务，就是学习分析这些隐藏状态，并输出一个概率值：对于当前正在生成的这个词，它有多大可能是直接来源于参考上下文的（即“可归因于上下文”），又有多大可能是模型基于自身参数“凭空创造”的（即“幻觉”或“不可归因”）。

从技术实现上看，这个过程是并行的：

1. 生成流 ：主干网络接收 [Query, Context] ，开始自回归地生成答案Token序列 A1, A2, ..., An 。
2. 检测流 ：在生成每个答案Token Ai 时，主干网络会产生一个对应的隐藏状态向量 Hi 。这个 Hi 被实时地送入检测头。
3. 检测头计算 ：检测头对 Hi 进行计算，输出一个标量分数 si （例如，通过Sigmoid函数映射到0到1之间），这个分数就代表了Token Ai 来源于上下文的置信度。
4. 联合输出 ：最终，系统不仅输出答案文本 [A1, A2, ..., An] ，还同步输出一个对应的置信度序列 [s1, s2, ..., sn] 。你可以把它理解为答案的“可溯源分数”序列。

那么，这个检测头是如何学会区分“可归因”和“幻觉”的呢？关键在于微调阶段的数据和损失函数设计。我们需要构造专门的训练数据对 (Query, Context, Answer, Attribution Labels) 。这里的 Attribution Labels 是一个与答案Token一一对应的0/1标签序列，标注每个Token是否能在给定的Context中找到直接或强力的支持证据。构建这样的数据需要一定的人工或启发式规则（例如，使用文本匹配、命名实体识别工具进行对齐）。

在微调时，我们有两个损失函数在同时工作：

• 生成损失（L_gen） ：就是标准的语言模型损失，比如交叉熵损失，确保生成的答案 Answer 本身是流畅、相关的。
• 归因损失（L_attr） ：这是检测头的训练目标。通常使用二元交叉熵损失，让检测头输出的置信度序列 [si] 尽可能接近真实的归因标签序列 [li] 。

总的损失函数是两者的加权和： L_total = L_gen + λ * L_attr 。这里的 λ 是一个超参数，用于平衡生成质量和归因准确性。通过这种多任务学习的方式，主干网络在学习如何生成更好答案的同时，其内部表示也被“塑造”得更容易让检测头区分信息的来源。这就是“幻觉感知微调”的本质——让模型在训练中内化对自身输出可溯源性的判断能力。

3. 从零到一：基于LLaMA-Factory的RAGognizer实战微调

理论讲完了，我们来点硬的。如何亲手实现一个RAGognizer风格的模型？这里我们选择目前社区最活跃、对中文支持也较好的微调框架 LLaMA-Factory 作为实战平台，并以 Qwen1.5-7B-Chat 模型为基础，演示如何为其增加幻觉感知的检测头并进行微调。

3.1 环境准备与数据构造

首先，你需要一个能够运行LLaMA-Factory的环境。强烈建议使用Python 3.10及以上版本，并准备好足够的GPU资源（例如，单卡A100 40G对于7B模型的全参数微调是足够的，如果资源有限，可以使用QLoRA等高效微调方法）。

# 1. 克隆LLaMA-Factory仓库
git clone https://github.com/hiyouga/LLaMA-Factory.git
cd LLaMA-Factory

# 2. 安装依赖 (推荐使用conda创建虚拟环境)
conda create -n llama_factory python=3.10
conda activate llama_factory
pip install -r requirements.txt

# 3. 安装PyTorch (根据你的CUDA版本)
# 例如，对于CUDA 11.8
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

接下来是最关键也最耗时的一步： 构造训练数据 。RAGognizer需要四元组数据 (query, context, answer, attribution_labels) 。

假设我们有一个简单的JSONL格式数据集 train.jsonl ，每一行是一个样本：

{
  "query": "公司年假有多少天？",
  "context": "根据《员工手册》第三章第五条规定，正式员工入职满一年后，每年享有10天带薪年假。年假可分段休，但最小请假单位为0.5天。",
  "answer": "正式员工入职满一年后，每年有10天带薪年假。",
  "attribution_labels": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] // 对应answer每个token的标签
}

这里的难点在于 attribution_labels 的生成。一个实用的方法是：

1. 对 answer 进行分词（使用与模型相同的tokenizer）。
2. 对于 answer 中的每个token或token组，使用字符串匹配、编辑距离或更高级的NLI（自然语言推理）模型，判断其是否在 context 中出现或能被 context 所蕴含。
3. 将可以归因的token标记为1，否则标记为0。对于中文，可能需要以词或短句为单位进行判断，而不是单个字。

注意 ：数据质量直接决定检测头的性能。如果条件允许，最好能进行一定的人工校验和清洗。初期可以尝试用规则（如关键词匹配）生成粗糙标签，再用小批量人工标注的数据进行微调。

3.2 修改模型结构：添加检测头

LLaMA-Factory本身不直接支持这种“并联检测头”的架构，我们需要对模型代码进行一些修改。这里以Qwen1.5模型为例，展示核心的修改思路。

我们创建一个新的模型类 QwenWithAttnHead ，它继承自原始的 Qwen2ForCausalLM 。核心是重写 forward 方法，在生成过程中插入检测头的计算。

# 文件：modeling_qwen_with_head.py
import torch
import torch.nn as nn
from transformers import Qwen2ForCausalLM, Qwen2Config

class AttributionHead(nn.Module):
    """轻量级归因检测头"""
    def __init__(self, hidden_size):
        super().__init__()
        self.dense = nn.Linear(hidden_size, hidden_size)
        self.activation = nn.Tanh()
        self.classifier = nn.Linear(hidden_size, 1) # 输出单个分数

    def forward(self, hidden_states):
        # hidden_states: [batch_size, seq_len, hidden_size]
        pooled_output = hidden_states[:, -1, :] # 通常取最后一个token的隐藏状态，代表当前生成步的“思考”
        x = self.dense(pooled_output)
        x = self.activation(x)
        logits = self.classifier(x) # [batch_size, 1]
        return torch.sigmoid(logits).squeeze(-1) # 输出概率 [batch_size]

class QwenWithAttnHead(Qwen2ForCausalLM):
    def __init__(self, config):
        super().__init__(config)
        self.hidden_size = config.hidden_size
        self.attribution_head = AttributionHead(self.hidden_size)

    def forward(
        self,
        input_ids=None,
        attention_mask=None,
        position_ids=None,
        past_key_values=None,
        inputs_embeds=None,
        labels=None,
        attribution_labels=None, # 新增：归因标签
        use_cache=None,
        output_attentions=None,
        output_hidden_states=None, # 必须设置为True，我们需要隐藏状态
        return_dict=None,
    ):
        # 调用父类forward，获取输出
        outputs = super().forward(
            input_ids=input_ids,
            attention_mask=attention_mask,
            position_ids=position_ids,
            past_key_values=past_key_values,
            inputs_embeds=inputs_embeds,
            labels=labels,
            use_cache=use_cache,
            output_attentions=output_attentions,
            output_hidden_states=True, # 强制输出隐藏状态
            return_dict=return_dict,
        )

        # 获取最后一个隐藏层的状态 [batch_size, seq_len, hidden_size]
        last_hidden_states = outputs.hidden_states[-1]

        # 计算归因分数
        # 我们需要为每个生成的位置计算分数。这里简化处理，只计算labels不为-100的位置（即需要预测的token）
        if labels is not None:
            # 找到需要预测的token位置
            pred_positions = (labels != -100).nonzero(as_tuple=True)
            if pred_positions[0].numel() > 0:
                selected_hidden = last_hidden_states[pred_positions[0], pred_positions[1], :]
                attribution_logits = self.attribution_head(selected_hidden) # [num_pred_tokens]
                outputs.attribution_logits = attribution_logits
            else:
                outputs.attribution_logits = None
        else:
            # 推理时，可以为每个生成的token计算分数，需要更复杂的逻辑
            outputs.attribution_logits = None

        # 计算归因损失
        if attribution_labels is not None and outputs.attribution_logits is not None:
            # attribution_labels 形状应与 labels 中非-100的位置对应
            attr_labels_flat = attribution_labels[labels != -100].float()
            loss_fct = nn.BCELoss()
            attribution_loss = loss_fct(outputs.attribution_logits, attr_labels_flat)
            # 将归因损失加到总损失上
            if outputs.loss is not None:
                outputs.loss = outputs.loss + 0.5 * attribution_loss # lambda 设为 0.5
            else:
                outputs.loss = attribution_loss

        return outputs

然后，我们需要修改LLaMA-Factory的数据处理和训练循环，使其能加载我们自定义的模型，并正确处理 attribution_labels 这个新的字段。这涉及到修改 dataset.py 和 trainer.py 中的相关部分，将四元组数据加载进来，并在计算损失时传入 attribution_labels 。

3.3 配置与启动微调

在LLaMA-Factory中，我们通常使用一个配置文件来定义训练参数。我们需要创建一个新的配置文件 train_ragognizer.json ，并指定我们自定义的模型。

{
  "model_name_or_path": "/path/to/your/qwen1.5-7b-chat",
  "custom_model": "QwenWithAttnHead", // 告诉LLaMA-Factory使用我们的自定义类
  "data_path": "./data/train.jsonl",
  "template": "qwen",
  "finetuning_type": "full", // 全参数微调，也可用 "lora"
  "output_dir": "./output/ragognizer_qwen",
  "overwrite_output_dir": true,
  "per_device_train_batch_size": 4,
  "gradient_accumulation_steps": 8,
  "lr_scheduler_type": "cosine",
  "logging_steps": 10,
  "save_steps": 500,
  "learning_rate": 2e-5,
  "num_train_epochs": 3,
  "max_length": 1024,
  "fp16": true,
  "report_to": "none"
}

然后，使用LLaMA-Factory的脚本启动训练：

CUDA_VISIBLE_DEVICES=0 python src/train_bash.py \
  --stage sft \
  --do_train \
  --model_name_or_path /path/to/qwen1.5-7b-chat \
  --custom_model QwenWithAttnHead \
  --dataset train_data \
  --template qwen \
  --finetuning_type full \
  --output_dir ./output/ragognizer_qwen \
  --overwrite_cache \
  --per_device_train_batch_size 4 \
  --gradient_accumulation_steps 8 \
  --lr_scheduler_type cosine \
  --logging_steps 10 \
  --save_steps 500 \
  --learning_rate 2e-5 \
  --num_train_epochs 3 \
  --max_length 1024 \
  --fp16 \
  --plot_loss

这个过程会同时优化语言模型损失和归因损失。训练完成后，你就得到了一个具有“幻觉感知”能力的Qwen模型。

3.4 推理与结果解读

训练好的模型，在推理时会有两个输出：生成的答案文本和每个token的归因置信度。

from transformers import AutoTokenizer, pipeline
from modeling_qwen_with_head import QwenWithAttnHead

model = QwenWithAttnHead.from_pretrained("./output/ragognizer_qwen/checkpoint-final")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen1.5-7B-Chat")

pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, device=0)

query = "公司年假有多少天？"
context = "根据《员工手册》第三章第五条规定，正式员工入职满一年后，每年享有10天带薪年假。"
prompt = f"根据以下上下文回答问题：\n上下文：{context}\n问题：{query}\n答案："

# 注意：需要修改generate函数以获取隐藏状态和归因分数，这里仅为示意
output = pipe(prompt, max_new_tokens=50, return_dict_in_generate=True, output_hidden_states=True)
answer = output[0]['generated_text'][len(prompt):]

# 假设我们通过某种方式获取了每个token的归因分数 attribution_scores
# attribution_scores = [0.95, 0.98, 0.12, ...]
print(f"答案：{answer}")
print("归因置信度（逐词）：")
for token, score in zip(tokenizer.tokenize(answer), attribution_scores):
    print(f"  {token}: {score:.3f}")

输出可能类似于：

答案：正式员工入职满一年后，每年有10天带薪年假。
归因置信度（逐词）：
  正式: 0.992
  员工: 0.987
  入职: 0.978
  满: 0.965
  一年: 0.953
  后: 0.941
  ，: 0.120
  每年: 0.989
  有: 0.125
  10: 0.998
  天: 0.995
  带薪: 0.991
  年假: 0.993
  。: 0.110

你可以看到，像“正式”、“员工”、“10”、“天”、“带薪年假”这些直接从上下文中抽取或高度相关的词，置信度非常高（接近1）。而“，”、“有”、“。”这类功能性词语或连接词，置信度较低，因为它们并非来源于上下文的具体事实，而是模型语言习惯的一部分。如果模型在“10天”后面自己加了一句“并且可以折现”，那么“折现”这个词的置信度会非常低（例如0.05），这就被成功标记为潜在的幻觉。

4. 关键挑战与实战避坑指南

理想很丰满，但实现一个可用的RAGognizer系统，路上坑不少。结合我自己的实验经验，分享几个最关键的挑战和应对策略。

挑战一：高质量归因标签数据的匮乏与噪声 这是最大的瓶颈。自动生成的标签（如基于字符串匹配）噪声极大。例如，答案中的“可以”可能对应上下文里的“允许”，严格匹配会判为0，但语义上应判为1。反之，“公司”这个词可能在上下文高频出现，但答案中的“公司”指代可能不同，严格匹配会判为1，实则可能是幻觉。

应对策略 ：采用“分阶段训练”和“数据蒸馏”。

1. 阶段一（冷启动） ：使用规则（精确匹配、模糊匹配）或轻量级NLI模型（如DeBERTa）生成一批带有噪声的标签数据，先训练一个初版检测头。这个版本的精度可能只有60-70%，但足以作为一个起点。
2. 阶段二（数据蒸馏） ：用初版模型对大量未标注的 (query, context, answer) 三元组进行推理，得到模型预测的归因分数。设定一个高阈值（如>0.95）和低阈值（如<0.05），筛选出高置信度的正负样本，加入到训练集中。这相当于用模型自己的判断来清洗和扩充数据。
3. 阶段三（主动学习与人工校验） ：针对模型预测置信度在中间模糊区域（如0.3-0.7）的样本，进行小批量的人工标注。这批高质量数据对提升模型在困难案例上的判别能力至关重要。

挑战二：检测头与生成主干的耦合与干扰 检测头是附加组件，如果设计不当或训练不充分，可能会“带偏”主干网络的生成能力。例如，模型可能为了获得高的归因分数，倾向于生成一些非常保守、完全照抄上下文的、不流畅的答案。

应对策略 ：精细调整损失权重 λ 和训练策略。

• 动态权重 ：在训练初期，可以设置较小的 λ （如0.1），让模型先专注于学习生成任务。随着训练进行，逐步增大 λ （如到0.5或1.0），加强归因任务的训练。
• 课程学习 ：先使用简单的、归因清晰的样本进行训练，再逐步引入模糊、困难的样本。
• 共享层冻结 ：可以考虑只微调主干网络的最后几层，而让前面的层保持冻结，减少检测头对底层语言理解能力的干扰。

挑战三：推理阶段的性能与延迟 在推理时，每生成一个token都需要调用一次检测头来计算归因分数，这会增加额外的计算开销。对于延迟敏感的应用，这可能成为瓶颈。

应对策略 ：工程优化与近似计算。

• 检测头轻量化 ：确保检测头结构足够简单（如2层MLP）。
• 缓存与并行 ：利用Transformer的KV缓存机制，检测头的输入（隐藏状态）计算可以和下一token的生成计算部分重叠。
• 稀疏计算 ：不必对每个token都计算归因分数。可以每隔2-3个token计算一次，或者只在生成名词、实体、数字等关键信息点时计算。
• 后处理模式 ：对于某些不要求实时归因的应用，可以先让模型快速生成完整答案，然后再用检测头对整个答案序列进行一次性的归因分析。但这失去了在生成过程中进行引导的可能性。

挑战四：归因粒度的选择 是以词（token）为粒度，还是以短语（phrase）或句子（sentence）为粒度？词级粒度最精细，但标签最难标注，且输出对用户不友好（一串数字）。句子级粒度更易理解，但可能掩盖句子内部的幻觉。

应对策略 ：根据应用场景折中。对于高可靠性要求的领域（如医疗、法律），建议采用词级或子词级粒度，并在前端对低置信度部分进行高亮预警。对于普通问答，可以采用“句子+关键实体”的混合粒度，即输出整个句子的置信度，并对句中识别出的关键实体（如日期、金额、人名）单独给出置信度。

5. 效果评估与未来展望：不止于检测

训练完成后，如何评估RAGognizer的效果？不能只看生成答案的BLEU或ROUGE分数，更需要一套针对“幻觉感知”能力的评估体系。

1. 归因分类准确率 ：这是最直接的指标。构建一个测试集，其中每个答案token都有真实的人工归因标签。计算检测头预测的置信度（二值化后）与真实标签的准确率、精确率、召回率和F1分数。
2. 幻觉检测的F1分数 ：将“幻觉token”（标签为0）视为正例，计算模型检测幻觉的能力。
3. 生成质量保持度 ：在引入归因任务后，需要评估模型原本的生成能力（流畅性、相关性、事实准确性）是否下降。可以使用GPT-4等大模型作为裁判，对微调前后的模型生成答案进行盲评打分。
4. 端到端RAG系统指标 ：将微调后的模型接入一个完整的RAG系统，在真实业务数据集上评估其最终答案的准确率（Answer Correctness）和可归因率（Attribution Rate）。

RAGognizer的思想打开了LLM可靠性提升的一扇新窗。它的潜力远不止于事后检测。一个很自然的延伸是 “幻觉抑制生成” 。既然我们能在生成每个token时实时得到其“幻觉风险分数”，那么就可以在解码阶段引入这个分数作为约束。例如，在束搜索（Beam Search）或采样时，给那些归因置信度低的候选token施加惩罚，引导模型生成更多有据可查的内容。这相当于把检测头变成了一个“生成引导器”。

更进一步，这种“感知-控制”的框架可以泛化。检测头不仅可以检测“是否源于上下文”，理论上可以训练它检测任何我们关心的属性，比如“是否符合安全规范”、“是否带有特定风格”、“是否包含敏感信息”。通过多任务学习，我们可以让一个模型在生成的同时，具备多种“自我审查”能力。

当然，这条路还很长。如何构建大规模、高质量的细粒度归因标注数据，如何设计更高效、更精准的检测头架构，如何平衡感知能力与生成效率，都是需要持续探索的问题。但RAGognizer无疑指出了一个明确的方向：让大模型变得更“自知”和“可控”，是将其可靠地应用于关键领域的必经之路。从被动地事后纠错，到主动地过程控制，这才是提升LLM可信度的治本之策。