第2219篇：多模态LLM的幻觉问题——视觉理解中的事实错误和应对策略
2026/4/30大约 12 分钟
第2219篇：多模态LLM的幻觉问题——视觉理解中的事实错误和应对策略
适读人群：使用多模态大模型做视觉问答、文档理解的工程师 | 阅读时长：约16分钟 | 核心价值：理解多模态幻觉的根源，掌握检测和减少幻觉的工程方法
那次事故让我印象深刻。
我们做了一个医疗影像辅助诊断的演示系统，用 GPT-4V 分析胸片。演示时，测试医生上传了一张正常胸片，问系统"图中是否有异常"。
系统回答："图中右肺下叶可见一处约1.5cm的结节状高密度影，建议进一步CT检查。"
那张图根本没有结节。
这就是多模态大模型最危险的问题之一：幻觉（Hallucination）——模型以高度自信的口气描述图像中根本不存在的内容。
对于聊天应用，幻觉影响用户体验。对于医疗、法律、金融等高风险场景，幻觉可能造成真实伤害。
多模态幻觉的类型与根源
为什么多模态模型容易幻觉？
根源一：视觉-语言对齐不完美。 视觉编码器提取的特征向量，在转换为语言模型可理解的 token 时会丢失细节。模型不确定时，会用"最可能的语言描述"填补，而不是说"我不确定"。
根源二：语言先验过强。 如果训练数据中"医院场景"经常伴随"医生和护士"，模型可能在只有医院走廊的图片中幻觉出医生。
根源三：图像分辨率和细节丢失。 高分辨率图片在输入模型前通常会被缩小，细节信息损失后，模型只能猜测。
根源四：RLHF 强化了流畅性而非准确性。 人类偏好流畅、有内容的回答，RLHF 对齐后模型倾向于生成丰富的描述，即使这意味着编造细节。
幻觉检测：如何发现模型在撒谎
/**
* 多模态幻觉检测服务
* 使用多种策略检测模型输出中的潜在幻觉
*/
@Service
@Slf4j
public class HallucinationDetectionService {
@Autowired
private OpenAiClient openAiClient;
@Autowired
private ObjectDetectionClient objectDetector; // 传统CV模型
/**
* 策略一：交叉验证法
* 用传统CV模型的检测结果验证多模态模型的描述
*/
public HallucinationCheckResult crossValidateWithCVModel(byte[] imageBytes,
String modelDescription) {
// 1. 用传统目标检测模型（如YOLO）获取图中实际存在的物体
List<DetectedObject> cvDetections = objectDetector.detect(imageBytes, 0.5f);
Set<String> detectedObjectTypes = cvDetections.stream()
.map(DetectedObject::getLabel)
.collect(Collectors.toSet());
// 2. 从模型描述中提取提到的物体
Set<String> mentionedObjects = extractMentionedObjects(modelDescription);
// 3. 找出描述中存在但CV未检测到的物体（可能幻觉）
Set<String> potentialHallucinations = new HashSet<>(mentionedObjects);
potentialHallucinations.removeAll(detectedObjectTypes);
// 4. 找出CV检测到但描述中未提及的物体（可能遗漏）
Set<String> potentialOmissions = new HashSet<>(detectedObjectTypes);
potentialOmissions.removeAll(mentionedObjects);
return HallucinationCheckResult.builder()
.detectedObjects(detectedObjectTypes)
.mentionedObjects(mentionedObjects)
.potentialHallucinations(potentialHallucinations)
.potentialOmissions(potentialOmissions)
.hallucinationRisk(calculateRisk(potentialHallucinations, mentionedObjects))
.build();
}
/**
* 策略二：自一致性检测（Self-Consistency）
* 对同一图片问同一问题多次，看回答是否一致
* 不一致说明模型对这个问题不确定，幻觉风险高
*/
public ConsistencyCheckResult checkSelfConsistency(byte[] imageBytes,
String question, int sampleCount) {
String base64 = Base64.getEncoder().encodeToString(imageBytes);
List<String> answers = new ArrayList<>();
for (int i = 0; i < sampleCount; i++) {
String answer = openAiClient.chatMultimodal(
question, base64, "image/jpeg",
ChatOptions.builder()
.temperature(0.7) // 用高温度增加多样性
.maxTokens(200)
.build()
);
answers.add(answer);
}
// 计算答案间的语义相似度
double consistencyScore = calculateAnswerConsistency(answers);
return ConsistencyCheckResult.builder()
.question(question)
.answers(answers)
.consistencyScore(consistencyScore)
.isReliable(consistencyScore > 0.8)
.consensusAnswer(extractConsensusAnswer(answers))
.build();
}
/**
* 策略三：追问验证法
* 先问开放性问题，再追问具体细节，看细节是否能被图片支撑
*/
public VerificationResult verifyWithFollowUp(byte[] imageBytes, String initialAnswer) {
String base64 = Base64.getEncoder().encodeToString(imageBytes);
// 从初始答案中提取关键陈述
List<String> claims = extractKeyClaims(initialAnswer);
List<ClaimVerification> verifications = new ArrayList<>();
for (String claim : claims) {
// 构造验证问题
String verifyQuestion = String.format(
"请仔细观察图片，以下陈述是否在图片中有明确依据？" +
"陈述：\"%s\"\n" +
"请回答：(A) 图片中有明确证据支持 (B) 图片中没有明确证据 (C) 无法判断\n" +
"只输出A/B/C，然后用一句话说明理由。",
claim
);
String verifyAnswer = openAiClient.chatMultimodal(
verifyQuestion, base64, "image/jpeg",
ChatOptions.builder().temperature(0.0).maxTokens(100).build()
);
VerificationStatus status = parseVerificationAnswer(verifyAnswer);
verifications.add(ClaimVerification.builder()
.claim(claim)
.verificationStatus(status)
.reason(extractReason(verifyAnswer))
.build());
}
long unverifiedCount = verifications.stream()
.filter(v -> v.getVerificationStatus() != VerificationStatus.SUPPORTED)
.count();
return VerificationResult.builder()
.verifications(verifications)
.overallReliability(1.0 - (double) unverifiedCount / verifications.size())
.build();
}
private double calculateRisk(Set<String> hallucinations, Set<String> mentions) {
if (mentions.isEmpty()) return 0.0;
return (double) hallucinations.size() / mentions.size();
}
private Set<String> extractMentionedObjects(String description) {
// 简化：用规则提取名词
// 生产环境用NER模型
Set<String> objects = new HashSet<>();
String[] words = description.split("\\s+");
// 粗略提取（实际需要更精确的NLP处理）
return objects;
}
private double calculateAnswerConsistency(List<String> answers) {
if (answers.size() <= 1) return 1.0;
// 计算答案两两之间的N-gram相似度平均值
double totalSim = 0;
int pairs = 0;
for (int i = 0; i < answers.size(); i++) {
for (int j = i + 1; j < answers.size(); j++) {
totalSim += computeNgramSimilarity(answers.get(i), answers.get(j), 2);
pairs++;
}
}
return pairs > 0 ? totalSim / pairs : 1.0;
}
private double computeNgramSimilarity(String s1, String s2, int n) {
Set<String> ngrams1 = extractNgrams(s1, n);
Set<String> ngrams2 = extractNgrams(s2, n);
Set<String> intersection = new HashSet<>(ngrams1);
intersection.retainAll(ngrams2);
Set<String> union = new HashSet<>(ngrams1);
union.addAll(ngrams2);
return union.isEmpty() ? 0 : (double) intersection.size() / union.size();
}
private Set<String> extractNgrams(String text, int n) {
Set<String> ngrams = new HashSet<>();
String[] words = text.toLowerCase().split("\\s+");
for (int i = 0; i <= words.length - n; i++) {
StringBuilder ngram = new StringBuilder();
for (int j = 0; j < n; j++) {
if (j > 0) ngram.append(" ");
ngram.append(words[i + j]);
}
ngrams.add(ngram.toString());
}
return ngrams;
}
private String extractConsensusAnswer(List<String> answers) {
// 选择与其他答案平均相似度最高的答案作为共识答案
double maxAvgSim = -1;
String consensus = answers.get(0);
for (String candidate : answers) {
double avgSim = answers.stream()
.filter(a -> !a.equals(candidate))
.mapToDouble(a -> computeNgramSimilarity(candidate, a, 2))
.average().orElse(0);
if (avgSim > maxAvgSim) {
maxAvgSim = avgSim;
consensus = candidate;
}
}
return consensus;
}
private List<String> extractKeyClaims(String text) {
// 按句子分割，提取关键陈述句
return Arrays.stream(text.split("[。.!?！？]"))
.map(String::trim)
.filter(s -> s.length() > 10)
.limit(5)
.collect(Collectors.toList());
}
private VerificationStatus parseVerificationAnswer(String answer) {
if (answer.startsWith("A") || answer.contains("(A)")) return VerificationStatus.SUPPORTED;
if (answer.startsWith("B") || answer.contains("(B)")) return VerificationStatus.UNSUPPORTED;
return VerificationStatus.UNCERTAIN;
}
private String extractReason(String answer) {
int idx = answer.indexOf('\n');
return idx > 0 ? answer.substring(idx + 1).trim() : "";
}
}减少幻觉的 Prompt 工程技巧
工程上可以通过 Prompt 设计降低幻觉率：
/**
* 抗幻觉 Prompt 构建器
* 通过 Prompt 设计引导模型减少幻觉
*/
@Component
public class AntiHallucinationPromptBuilder {
/**
* 构建带不确定性声明的 Prompt
* 让模型在不确定时主动说明，而非猜测
*/
public String buildUncertaintyAwarePrompt(String userQuestion) {
return String.format("""
请回答以下关于图片的问题。
重要规则：
1. 只描述图片中确实可见的内容，不要推测或假设
2. 如果某个细节不清晰或无法确认，请明确说"图中无法清晰看到..."
3. 如果问题涉及图中不存在的内容，请直接回答"图中未见..."
4. 表示不确定时用"可能""疑似"等词，不要用绝对肯定语气
5. 不要从常识推断图中未显示的信息
问题：%s
""", userQuestion);
}
/**
* 构建逐步核验 Prompt（Chain-of-Thought for Vision）
* 让模型先列出观察到的内容，再回答问题
* 减少凭印象直接回答导致的幻觉
*/
public String buildObserveFirstPrompt(String userQuestion) {
return String.format("""
请按以下步骤回答问题：
步骤1：列出你在图片中确实观察到的所有相关元素（仅限可见内容）
步骤2：基于步骤1的观察，回答问题
步骤3：说明你的回答中有哪些是直接观察到的，哪些是推断的
问题：%s
请严格按照格式回答：
【观察到的内容】
- ...
【回答】
...
【确定性说明】
...
""", userQuestion);
}
/**
* 构建对比验证 Prompt
* 先让模型描述，再让它自我检验
*/
public List<String> buildSelfVerificationPrompts(String userQuestion) {
String firstPrompt = "请描述这张图片中与以下问题相关的内容，只描述可以直接看到的：" + userQuestion;
String secondPrompt = """
请仔细检查你上一个回答中的每个具体陈述：
1. 这个陈述在图片中有直接视觉证据吗？
2. 还是这是基于上下文的推断？
对于没有直接视觉证据的陈述，请删除或修改为"推断"。
输出修订后的回答。
""";
return Arrays.asList(firstPrompt, secondPrompt);
}
/**
* 特定场景：图中数字/文字的精确识别
* 强调逐字核对，不要凭感觉填写
*/
public String buildTextRecognitionPrompt() {
return """
请识别图片中的文字内容。
重要提示：
- 逐字识别，不要"猜测"或"补全"不清晰的字符
- 如果某个字符模糊，用[?]标注，不要猜测
- 不要根据上下文推断字面看不清的内容
- 识别完成后，对照图片再检查一遍
输出格式：
【识别结果】
（严格按照图中顺序列出文字）
【低置信度字符】
（列出用[?]标注的字符及其位置）
""";
}
}RAG 中的幻觉控制：图文混合检索的可信度
在RAG系统中，当检索到的图文内容被用于生成回答时，需要特别控制幻觉：
/**
* 多模态RAG的幻觉控制层
* 在图文检索增强生成中减少幻觉
*/
@Service
@Slf4j
public class MultimodalRagHallucinationGuard {
@Autowired
private OpenAiClient openAiClient;
@Autowired
private HallucinationDetectionService hallucinationDetector;
/**
* 带幻觉控制的多模态RAG生成
*/
public RagGenerationResult generateWithHallucinationControl(
String userQuery,
List<RetrievedChunk> retrievedChunks,
byte[] queryImage) {
// 1. 构建带源信息的 Prompt
String contextualPrompt = buildContextualPrompt(userQuery, retrievedChunks);
// 2. 生成答案
String base64Image = queryImage != null ?
Base64.getEncoder().encodeToString(queryImage) : null;
String rawAnswer = base64Image != null ?
openAiClient.chatMultimodal(contextualPrompt, base64Image, "image/jpeg") :
openAiClient.chat(contextualPrompt);
// 3. 幻觉检测：验证答案是否有检索内容支撑
List<ClaimGrounding> groundingResults = verifyAnswerGrounding(rawAnswer, retrievedChunks);
// 4. 过滤无根据的陈述
String filteredAnswer = filterUnsupportedClaims(rawAnswer, groundingResults);
// 5. 标注不确定部分
String annotatedAnswer = annotateUncertainty(filteredAnswer, groundingResults);
return RagGenerationResult.builder()
.answer(annotatedAnswer)
.groundingResults(groundingResults)
.confidence(calculateOverallConfidence(groundingResults))
.filteredClaims(getFilteredClaims(groundingResults))
.build();
}
/**
* 验证答案中的陈述是否有检索到的内容支撑
*/
private List<ClaimGrounding> verifyAnswerGrounding(String answer,
List<RetrievedChunk> chunks) {
List<String> claims = extractSentences(answer);
String contextText = chunks.stream()
.map(RetrievedChunk::getContent)
.collect(Collectors.joining("\n---\n"));
List<ClaimGrounding> groundings = new ArrayList<>();
for (String claim : claims) {
String verifyPrompt = String.format("""
以下是参考资料：
%s
---
判断以下陈述是否有参考资料支撑：
陈述："%s"
回答：
- 有支撑：参考资料中明确提到
- 部分支撑：参考资料中有相关但不完全匹配的内容
- 无支撑：参考资料中没有依据
只输出：有支撑/部分支撑/无支撑，然后引用具体支撑句（如有）
""", contextText, claim);
String result = openAiClient.chat(verifyPrompt);
GroundingStatus status = parseGroundingStatus(result);
groundings.add(ClaimGrounding.builder()
.claim(claim)
.status(status)
.evidence(extractEvidence(result))
.build());
}
return groundings;
}
private String buildContextualPrompt(String query, List<RetrievedChunk> chunks) {
StringBuilder sb = new StringBuilder();
sb.append("请基于以下参考内容回答问题。\n\n");
sb.append("【重要规则】\n");
sb.append("1. 只使用参考内容中明确提供的信息\n");
sb.append("2. 如果参考内容不足以回答问题，明确说明\n");
sb.append("3. 不要添加参考内容之外的知识\n\n");
sb.append("【参考内容】\n");
for (int i = 0; i < chunks.size(); i++) {
sb.append(String.format("[来源%d] %s\n\n", i + 1, chunks.get(i).getContent()));
}
sb.append("【问题】\n").append(query);
return sb.toString();
}
private String filterUnsupportedClaims(String answer, List<ClaimGrounding> groundings) {
StringBuilder filtered = new StringBuilder();
for (ClaimGrounding grounding : groundings) {
if (grounding.getStatus() == GroundingStatus.SUPPORTED ||
grounding.getStatus() == GroundingStatus.PARTIAL) {
filtered.append(grounding.getClaim()).append(" ");
}
// 无支撑的陈述直接丢弃
}
return filtered.toString().trim();
}
private String annotateUncertainty(String answer, List<ClaimGrounding> groundings) {
// 对部分支撑的陈述添加不确定性标注
String annotated = answer;
for (ClaimGrounding grounding : groundings) {
if (grounding.getStatus() == GroundingStatus.PARTIAL) {
annotated = annotated.replace(grounding.getClaim(),
grounding.getClaim() + "（注：此处为推断，置信度有限）");
}
}
return annotated;
}
private double calculateOverallConfidence(List<ClaimGrounding> groundings) {
if (groundings.isEmpty()) return 0.0;
long supportedCount = groundings.stream()
.filter(g -> g.getStatus() == GroundingStatus.SUPPORTED)
.count();
return (double) supportedCount / groundings.size();
}
private List<String> getFilteredClaims(List<ClaimGrounding> groundings) {
return groundings.stream()
.filter(g -> g.getStatus() == GroundingStatus.UNSUPPORTED)
.map(ClaimGrounding::getClaim)
.collect(Collectors.toList());
}
private List<String> extractSentences(String text) {
return Arrays.stream(text.split("[。.!?！？]"))
.map(String::trim)
.filter(s -> s.length() > 5)
.collect(Collectors.toList());
}
private GroundingStatus parseGroundingStatus(String result) {
if (result.contains("有支撑")) return GroundingStatus.SUPPORTED;
if (result.contains("部分支撑")) return GroundingStatus.PARTIAL;
return GroundingStatus.UNSUPPORTED;
}
private String extractEvidence(String result) {
int idx = result.indexOf('\n');
return idx > 0 ? result.substring(idx + 1).trim() : "";
}
}高风险场景的幻觉防护机制
对于医疗、法律等高风险场景，需要更严格的防护：
/**
* 高风险场景幻觉防护
* 多重验证 + 强制不确定性声明 + 人工复核触发
*/
@Service
@Slf4j
public class HighRiskHallucinationGuard {
@Autowired
private HallucinationDetectionService detectionService;
@Autowired
private HumanEscalationService humanEscalation;
/**
* 高风险场景的多层防护
*/
public SafetyGuardedResult processWithSafetyGuard(byte[] imageBytes,
String query,
RiskLevel riskLevel) {
// 第一层：自一致性检查
ConsistencyCheckResult consistency = detectionService.checkSelfConsistency(
imageBytes, query, riskLevel == RiskLevel.CRITICAL ? 5 : 3);
if (!consistency.isReliable()) {
log.warn("高风险场景自一致性检查失败，触发人工审核: query={}", query);
String escalationId = humanEscalation.escalate(imageBytes, query,
"模型对此问题答案不一致，需要人工核验");
return SafetyGuardedResult.pendingHumanReview(escalationId);
}
// 第二层：追问验证
VerificationResult verification = detectionService.verifyWithFollowUp(
imageBytes, consistency.getConsensusAnswer());
if (verification.getOverallReliability() < 0.8) {
String escalationId = humanEscalation.escalate(imageBytes, query,
String.format("答案可靠性%.0f%%低于阈值", verification.getOverallReliability() * 100));
return SafetyGuardedResult.pendingHumanReview(escalationId);
}
// 通过所有检查，但仍添加免责声明
String answer = consistency.getConsensusAnswer();
String disclaimedAnswer = addMandatoryDisclaimer(answer, riskLevel);
return SafetyGuardedResult.passed(disclaimedAnswer, verification.getOverallReliability());
}
private String addMandatoryDisclaimer(String answer, RiskLevel riskLevel) {
String disclaimer = switch (riskLevel) {
case MEDICAL -> "\n\n⚠️ 声明：本分析仅供参考，不构成医学诊断。最终诊断需由执业医师根据完整临床信息作出。";
case LEGAL -> "\n\n⚠️ 声明：本分析仅供参考，不构成法律意见。具体法律问题请咨询执业律师。";
case FINANCIAL -> "\n\n⚠️ 声明：本分析仅供参考，不构成投资建议。投资有风险，决策需谨慎。";
default -> "\n\n注：AI分析结果仅供参考，请结合实际情况判断。";
};
return answer + disclaimer;
}
}工程实践总结：与幻觉共存的哲学
幻觉问题无法彻底消除，但可以被管理。工程上的核心策略：
1. 不把模型当做真理机器。 把模型输出当做"有根据的猜测"，设计系统时预设模型会犯错。
2. 分层防护，风险越高防护越严。 普通问答一层自检就够，医疗/法律场景需要多层验证+人工兜底。
3. 让模型暴露不确定性。 通过 Prompt 引导模型用"可能""疑似"等词，比强制确定性回答更安全。
4. 保留原始图片和模型输出，供审计。 出问题时能追溯，同时这些数据是改进模型的宝贵素材。
5. 定期评估幻觉率。 建立幻觉基准测试集，每次模型升级都重新评估，防止回归。
真正成熟的多模态系统，不是一个永远正确的系统，而是一个知道自己哪里可能出错的系统。