LLM 幻觉检测：用输出一致性检查降低业务风险，别让模型在关键场景胡编
一、客服机器人给用户退了 500 元——模型幻觉的真实代价
某电商客服机器人接到用户提问"我买的东西坏了怎么办"，模型在幻觉状态下编造了一个不存在的退款政策，告诉用户"可以全额退款 500 元"。用户在工单系统里贴出了聊天截图，客服团队不得不按承诺退款。这是模型幻觉在业务场景下的真实代价——不是技术指标上的"准确率下降 2%"，而是实打实的经济损失。
基础设施不需要漂亮话，LLM 的幻觉（Hallucination）问题没有完美的技术解决方案。模型生成的内容本质上是一个概率分布上的采样，任何温度 > 0 的配置下都有概率产生偏离事实的输出。但工程上可以做的是在应用层加一层检测护栏——在模型输出给用户之前，通过一系列可计算的检查手段识别和拦截高风险输出。
输出一致性检查（Self-Consistency Check）是其中性价比最高的方案：对同一个 Prompt，用不同的采样参数或微调策略生成多个候选回复，然后比较它们之间的一致性。如果 5 个候选回复中 3 个说"可以退款 500"，2 个说"不支持退款"，这个回答的一致性得分就是 60%——低于阈值的回答被自动拦截，不展示给用户。
二、输出一致性检查的原理与流程
核心假设是：对于事实性问题（factual questions），模型的多个独立采样应该收敛到相似答案。如果多个采样互相矛盾，说明模型在这个问题上的 confidence 很低，大概率在胡编：
flowchart TD A[用户提问] --> B[Prompt 模板<br/>+ System Prompt] B --> C1[采样 1<br/>temperature=0.3] B --> C2[采样 2<br/>temperature=0.5] B --> C3[采样 3<br/>temperature=0.7] B --> C4[采样 4<br/>temperature=0.9] B --> C5[采样 5<br/>temperature=1.0] C1 --> D[候选回复 1] C2 --> D2[候选回复 2] C3 --> D3[候选回复 3] C4 --> D4[候选回复 4] C5 --> D5[候选回复 5] D & D2 & D3 & D4 & D5 --> E[相似度矩阵计算] E --> F{一致性得分 >= 阈值<br/>默认 0.7?} F -->|是| G[通过检测<br/>返回多数共识回复] F -->|否| H[拦截输出<br/>返回安全兜底回复] H --> I[记录日志<br/>采样 5 次仍不一致 = 高风险] G --> J[正常返回用户]相似度计算：候选回复之间的相似度可以用多种方式衡量。最简单的是基于 token overlap 的 Jaccard 相似度——两个回复的共享 token 数除以总 token 数。更准确的是用 Sentence-BERT 这类轻量 embedding 模型计算语义相似度，能识别同义表达（"可以退款"和"支持退款"在语义上是一致的，但在 token 层面 overlap 很低）。
温度参数的梯度设计：五个采样使用递增的温度（0.3 → 0.5 → 0.7 → 0.9 → 1.0），目的是在"保守采样"和"多样采样"之间做对比。低温度采样倾向于生成模型认为最安全的回答，高温度采样更容易暴露不确定性。如果低温和高温采样结果大相径庭，说明这个问题的答案在模型的概率分布上本身就是分散的——典型的幻觉高风险场景。
兜底策略：一致性检查不通过时，返回的不是"我不知道"，而是预定义的兜底回复。兜底回复分为两类：关键场景（如退款政策、医疗建议）的兜底是"请咨询人工客服"；非关键场景（如闲聊）的兜底是通用安全回复。
三、生产级幻觉检测网关实现
以下 Go 代码实现了一个 LLM 输出一致性检查网关，核心流程是并行多采样 + 语义相似度矩阵计算 + 阈值判定：
package hallucination import ( "context" "fmt" "math" "sort" "strings" "sync" "golang.org/x/sync/errgroup" ) // ConsistencyChecker 输出一致性检测器 type ConsistencyChecker struct { // LLM 调用接口（由外部注入，适配不同模型提供商） llmClient LLMClient // 采样次数（默认 5） numSamples int // 各次采样的温度参数 temperatures []float64 // 一致性阈值（0.0 - 1.0），低于此值判定为幻觉高风险 consistencyThreshold float64 // 关键场景更高的一致性阈值（金融/医疗等） criticalThreshold float64 } // LLMClient 抽象 LLM 调用接口 // 生产环境中可能对接 OpenAI、vLLM、自建推理服务等 type LLMClient interface { // Generate 生成单个回复 // prompt: 完整的 Prompt（System + User） // temperature: 采样温度 Generate(ctx context.Context, prompt string, temperature float64) (string, error) } // ConsistencyResult 一致性检查结果 type ConsistencyResult struct { Passed bool // 是否通过检查 Score float64 // 一致性得分 (0-1) ConsensusAnswer string // 多数共识回复 Candidates []string // 所有候选回复 RiskLevel string // "low" / "medium" / "high" } // NewConsistencyChecker 创建一致性检测器 func NewConsistencyChecker(client LLMClient, numSamples int, baseThreshold, criticalThreshold float64) *ConsistencyChecker { if numSamples < 2 { numSamples = 2 // 至少 2 次采样才有比较意义 } if numSamples > 10 { numSamples = 10 // 上限防滥用 } // 构建温度梯度：从保守到激进 temps := make([]float64, numSamples) for i := 0; i < numSamples; i++ { // 温度范围: 0.3 → 1.0，线性分布 temps[i] = 0.3 + (float64(i) / float64(numSamples-1)) * 0.7 } return &ConsistencyChecker{ llmClient: client, numSamples: numSamples, temperatures: temps, consistencyThreshold: baseThreshold, criticalThreshold: criticalThreshold, } } // Check 执行一致性检查 // prompt: 完整的 Prompt // isCritical: 是否为关键场景（金融/医疗等，使用更高阈值） func (c *ConsistencyChecker) Check(ctx context.Context, prompt string, isCritical bool) (*ConsistencyResult, error) { // 1. 并行多次采样 candidates, err := c.parallelSample(ctx, prompt) if err != nil { return nil, fmt.Errorf("parallel sampling: %w", err) } // 2. 计算候选回复之间的语义相似度矩阵 simMatrix := c.computeSimilarityMatrix(candidates) // 3. 计算一对一致性得分 score := c.computeConsistencyScore(simMatrix) // 4. 确定阈值 threshold := c.consistencyThreshold if isCritical { threshold = c.criticalThreshold } // 5. 判定风险等级 passed := score >= threshold riskLevel := "low" if !passed { if score < threshold*0.5 { riskLevel = "high" } else { riskLevel = "medium" } } // 6. 选择共识回复：取与所有其他回复平均相似度最高的那个 consensus := c.selectConsensus(candidates, simMatrix) return &ConsistencyResult{ Passed: passed, Score: score, ConsensusAnswer: consensus, Candidates: candidates, RiskLevel: riskLevel, }, nil } // parallelSample 并行多次采样，使用 errgroup 管理 goroutine 生命周期 func (c *ConsistencyChecker) parallelSample(ctx context.Context, prompt string) ([]string, error) { results := make([]string, c.numSamples) var mu sync.Mutex g, ctx := errgroup.WithContext(ctx) // 限制并发数为 3，防止打爆 LLM API g.SetLimit(3) for i := 0; i < c.numSamples; i++ { idx := i temp := c.temperatures[i] g.Go(func() error { resp, err := c.llmClient.Generate(ctx, prompt, temp) if err != nil { return fmt.Errorf("sample %d (temp=%.2f): %w", idx, temp, err) } mu.Lock() results[idx] = resp mu.Unlock() return nil }) } if err := g.Wait(); err != nil { return nil, err } return results, nil } // computeSimilarityMatrix 计算候选回复两两之间的相似度矩阵 func (c *ConsistencyChecker) computeSimilarityMatrix(candidates []string) [][]float64 { n := len(candidates) matrix := make([][]float64, n) for i := 0; i < n; i++ { matrix[i] = make([]float64, n) matrix[i][i] = 1.0 // 自相似度为 1 } for i := 0; i < n; i++ { for j := i + 1; j < n; j++ { // 使用 Jaccard 相似度作为轻量级度量 // 生产环境替换为 Sentence-BERT 的余弦相似度 sim := jaccardSimilarity(candidates[i], candidates[j]) matrix[i][j] = sim matrix[j][i] = sim // 对称矩阵 } } return matrix } // computeConsistencyScore 从相似度矩阵计算整体一致性得分 // 策略：所有非对角线元素的平均值 func (c *ConsistencyChecker) computeConsistencyScore(matrix [][]float64) float64 { n := len(matrix) if n <= 1 { return 1.0 } var sum float64 count := 0 for i := 0; i < n; i++ { for j := 0; j < n; j++ { if i != j { sum += matrix[i][j] count++ } } } if count == 0 { return 0 } return math.Round(sum/float64(count)*10000) / 10000 // 保留 4 位小数 } // selectConsensus 选择共识回复：与所有其他回复平均相似度最高的候选 func (c *ConsistencyChecker) selectConsensus(candidates []string, matrix [][]float64) string { n := len(candidates) bestIdx := 0 bestAvg := 0.0 for i := 0; i < n; i++ { var sum float64 count := 0 for j := 0; j < n; j++ { if i != j { sum += matrix[i][j] count++ } } avg := sum / float64(count) if avg > bestAvg { bestAvg = avg bestIdx = i } } return candidates[bestIdx] } // jaccardSimilarity 计算两个文本的 Jaccard 相似度 func jaccardSimilarity(a, b string) float64 { tokensA := tokenize(a) tokensB := tokenize(b) if len(tokensA) == 0 && len(tokensB) == 0 { return 1.0 } // 构建 set A setA := make(map[string]bool, len(tokensA)) for _, t := range tokensA { setA[t] = true } // 计算交集和并集 intersection := 0 setB := make(map[string]bool, len(tokensB)) for _, t := range tokensB { setB[t] = true if setA[t] { intersection++ } } // 并集大小 union := len(setA) for t := range setB { if !setA[t] { union++ } } if union == 0 { return 0 } return float64(intersection) / float64(union) } // tokenize 简单中文分词（基于字符 bigram） // 生产环境替换为 jieba 分词器 func tokenize(text string) []string { // 去除空白字符 text = strings.TrimSpace(text) runes := []rune(text) if len(runes) <= 1 { return []string{text} } // Bigram 分词：对相邻字符对建 token tokens := make([]string, 0, len(runes)-1) for i := 0; i < len(runes)-1; i++ { tokens = append(tokens, string(runes[i:i+2])) } return tokens }网关层集成示例：
package gateway import ( "context" "net/http" ) // HallucinationGuard 幻觉检测网关中间件 type HallucinationGuard struct { checker *hallucination.ConsistencyChecker criticalPaths map[string]bool // 关键业务路径映射 } // NewHallucinationGuard 创建幻觉检测网关 func NewHallucinationGuard(checker *hallucination.ConsistencyChecker) *HallucinationGuard { return &HallucinationGuard{ checker: checker, criticalPaths: map[string]bool{ "/api/refund": true, // 退款相关 "/api/medical": true, // 医疗相关 "/api/finance": true, // 金融相关 }, } } // Handle 处理推理请求，在模型输出后执行一致性检查 func (g *HallucinationGuard) Handle(ctx context.Context, prompt string, path string) (string, error) { isCritical := g.criticalPaths[path] result, err := g.checker.Check(ctx, prompt, isCritical) if err != nil { // 一致性检查本身失败时，降级为直接返回 LLM 原始输出 // 同时在日志中标记采样失败事件 return "", fmt.Errorf("consistency check failed: %w", err) } if !result.Passed { // 一致性检查不通过，返回兜底回复 if isCritical { return "抱歉，我暂时无法准确回答这个问题，建议您联系人工客服获取帮助。", nil } return "抱歉，我没有找到确定的答案，请您换个方式描述问题。", nil } return result.ConsensusAnswer, nil }四、边界权衡与工程代价
计算成本翻 5 倍：一致性检查要求对同一个 Prompt 做 5 次独立推理。如果单次推理耗时 200ms，一致性检查就需要 1 秒。这对于实时对话场景是难以接受的延迟。两个优化方向：并行推理——5 次采样同时发起，总耗时约等于最慢的那次采样（而非 5 次之和）；分级检查——先做两次采样（temperature = 0.3 和 0.9），如果这两次就足够一致（相似度 > 0.9），跳过后续 3 次额外采样，节约 60% 计算。
相似度度量选择：Jaccard 相似度对中文分词质量高度敏感。如果分词器把"可以退款"切成["可", "以", "退", "款"]而把"支持退款"切成["支持", "退款"]，Jaccard 相似度就是 0——即使语义相同。对于中文场景，建议使用 Sentence-BERT 或 text2vec 做语义相似度计算，牺牲一点性能换取准确性。但如果已经有成熟的中文分词器（如 jieba），Jaccard + 同义词扩展也是可行的轻量方案。
幻觉类型的不对称性：输出一致性检查擅长检测"事实型幻觉"（编造不存在的信息），但几乎检测不到"遗漏型幻觉"（该说的没说）。比如用户问"退货需要哪些材料"，模型回答"需要订单号和商品"，遗漏了"还需要退货理由"。5 次采样可能都遗漏了同一条信息，一致性检查通过，但回答仍然不完整。这种场景需要知识库召回验证——用 RAG 检索到的文档片段和模型输出做交叉比对，检查输出中的每个 claim 在知识库中是否有依据。
对创造性任务不适用：写诗、写代码、头脑风暴这类开放性任务天然存在多种合理答案。如果用一致性检查去评判，5 个候选回复互不相同，一致性得分接近 0，但它不是幻觉——只是合理多样性。一致性检查仅适用于有确定性答案的场景（知识问答、政策查询、数据提取），不能用于评判创造性输出。
五、总结
LLM 幻觉检测的输出一致性检查是低成本、高收益的工程护栏：
- 5 次并行采样 + 温度梯度：用 0.3-1.0 的温度梯度生成 5 个候选回复，并行推理控制总耗时在 300ms 以内。
- 语义相似度替代 token overlap：中文场景用 Sentence-BERT 做相似度计算，避免分词偏差导致的误判。
- 分级检查 + 阈值可调：两次采样一致（相似度 > 0.9）就跳过额外采样；一致性阈值默认 0.7，关键场景（金融/医疗）提高到 0.85。
- 明确适用边界：只检查事实型幻觉，不适用于创造性任务。结合 RAG 的知识库比对补齐遗漏型幻觉检测。
用输出一致性检查作为检测护栏，虽然不能消除模型幻觉，但至少能把"胡编出来的退款政策"拦截在展示给用户之前。