DLOS幻觉检测与验证系统：面向AI操作系统的安全执行内核

技术支持：拓世网络技术开发部

摘要

 

大型语言模型在部署过程中普遍存在的“幻觉”现象——生成与事实不符、逻辑断裂或偏离状态的内容——已成为制约AI系统进入关键任务领域的主要障碍。现有解决方案多以模型增强或事后检测为主，缺乏系统级的决策阻断与闭环修复机制。本文提出DLOS（Dynamic Learning Operating System）中的幻觉评估与检测系统HES（Hallucination Evaluation System），作为VALIDATOR内核的核心组件。HES引入三层统一检测架构，分别对应事实一致性（FCS）、推理连贯性（RCS）和状态对齐性（SAS），并通过幻觉风险指数（HRI）实现综合评分与分级决策（PASS/REWRITE/BLOCK）。实验验证表明，该系统能够在保持低延迟的前提下实现高精度的幻觉识别与自动修复，形成可进化的AI执行安全门。本文完整阐述HES的理论基础、指标体系、决策逻辑、代码实现及评估方法。

 

关键词：幻觉检测；AI操作系统；执行门；事实一致性；状态对齐；闭环学习

 

---

 

1. 引言

 

1.1 研究背景与问题定义

 

大语言模型（Large Language Models, LLMs）近年来取得了突破性进展，在自然语言理解、生成与推理任务中展现出接近人类水平的能力。然而，LLMs的本质特性——基于概率分布生成序列——决定了其不可避免地会生成与事实不符、逻辑不连贯或偏离上下文的内容。这一现象被学术界称为“幻觉”（Hallucination），其定义经历了从“生成无意义内容”到“生成与源信息不一致内容”的演变。

 

在DLOS（Dynamic Learning Operating System）的语境下，幻觉不仅是模型质量问题，更是系统安全风险。传统部署方案将LLMs视为孤立的推理引擎，缺乏对生成内容的系统性验证与干预能力。当幻觉内容进入执行层（如调用API、更新数据库、控制物理设备），可能引发严重的事故。

 

1.2 现有工作的局限性

 

当前幻觉检测与缓解方法可分为四类：

 

（1）基于检索增强的生成（RAG）：通过检索外部知识库验证生成内容。局限性在于检索本身可能引入噪声，且无法处理推理链断裂。

 

（2）自一致性检测：多次采样并比较生成结果。局限性是计算开销大且无法保证事实正确性。

 

（3）外部工具验证：调用搜索引擎、计算器等工具交叉验证。局限性是缺乏系统级的统一框架。

 

（4）规则守卫（Guardrails）：预定义规则过滤有害或错误输出。局限性强依赖人工规则，无法适应开放域任务。

 

更重要的是，现有方法均为“检测—报告”模式，缺乏“检测—决策—阻断/修复”的闭环能力。它们不能将检测结果反馈至系统学习回路，无法形成持续进化。

 

1.3 DLOS的解决方案与贡献

 

DLOS在设计之初即将幻觉检测定位为操作系统级安全内核，而非模型附属功能。本文提出的HES（Hallucination Evaluation System）作为VALIDATOR核心模块，实现了：

 

1. 三层统一验证架构：同时验证事实一致性、推理连贯性和状态对齐性。

2. 分级决策机制：输出PASS、REWRITE或BLOCK三种可执行指令。

3. 闭环进化回路：检测结果反馈至规则系统（RULE）和全局策略系统（GPS），驱动模型持续改进。

4. 完整可实现的指标体系：定义了可计算、可判定、可优化的数学指标。

 

本文的主要贡献包括：

 

· 提出面向AI操作系统的幻觉本质分类与检测框架；

· 设计可计算的HES指标体系与决策门；

· 提供完整的系统实现代码与评估方法；

· 验证闭环学习机制的有效性。

 

---

 

2. DLOS中幻觉的本质定义与分类

 

2.1 幻觉的操作性定义

 

在DLOS框架内，幻觉不简单定义为“错误”，而是定义为“生成内容与系统内可验证事实、有效推理路径或当前状态模型之间的不可接受偏离”。这一操作性定义包含三个核心要素：

 

· 可验证性：偏离可通过外部事实（WEB层）、逻辑规则（LOGIC层）或状态约束（TSPR层）被客观识别。

· 可量化性：偏离程度可用连续值度量。

· 可决策性：偏离超过阈值触发系统级行为。

 

2.2 三类幻觉的形式化定义

 

2.2.1 事实幻觉（Fact Hallucination）

 

定义：生成内容中包含无法在WEB层找到对应证据支持的陈述。

 

形式化：设 $O$ 为模型输出，$C = \{c_1, c_2, ..., c_n\}$ 为从 $O$ 中提取的事实性声明集合，$E$ 为WEB层可验证的证据集合。事实幻觉存在当且仅当：

 

\exists c_i \in C \text{ such that } \text{Ver}(c_i, E) = \text{False}

 

其中 $\text{Ver}(c_i, E)$ 为验证函数，返回声明 $c_i$ 是否与证据 $E$ 一致。

 

典型形式：

 

· 编造不存在的统计数据；

· 虚构实体、人物或事件；

· 错误引用来源内容；

· 篡改事实的时间、地点、数量属性。

 

2.2.2 推理幻觉（Reasoning Hallucination）

 

定义：生成内容的推理链中存在逻辑断裂、因果错误或步序跳跃。

 

形式化：设 $\mathcal{R} = \{r_1, r_2, ..., r_m\}$ 为从前提 $P$ 到结论 $Q$ 的推理步骤序列，$\mathcal{L}$ 为有效推理规则集合。推理幻觉存在当且仅当推理图 $G_{\mathcal{R}}$ 中存在缺失节点或无效边：

 

\exists k \in [1, m-1] \text{ such that } \text{Link}(r_k, r_{k+1}, \mathcal{L}) = \text{False}

 

典型形式：

 

· 将相关性错误解释为因果性；

· 推理链中缺失关键中间步骤；

· 循环论证；

· 错误应用演绎或归纳规则。

 

2.2.3 状态漂移幻觉（State Drift Hallucination）

 

定义：生成内容偏离当前TSPR状态模型所定义的用户意图、上下文状态或时间一致性约束。

 

形式化：设 $S_t$ 为时刻 $t$ 的系统状态（由TSPR模型维护），$O_t$ 为时刻 $t$ 的模型输出，$\Delta$ 为状态转移函数。状态漂移存在当且仅当：

 

P(O_t | S_t, \text{History}_{<t}) < \theta_{\text{state}}

 

其中 $\theta_{\text{state}}$ 为状态对齐阈值。

 

典型形式：

 

· 用户意图被误判（如用户问天气，模型开始推荐产品）；

· 上下文漂移（多轮对话中遗忘之前约定的约束）；

· 时间一致性被破坏（对同一问题在同一会话中给出矛盾答案）。

 

2.3 三类幻觉的关系与交互

 

三类幻觉并非相互独立。事实幻觉可触发推理幻觉（基于错误事实的推理必然不成立），状态漂移可放大事实幻觉的影响（错误上下文导致错误检索）。因此，DLOS采用统一检测而非孤立检测策略。

 

---

 

3. HES系统架构与VALIDATOR内核设计

 

3.1 整体架构

 

HES作为DLOS中VALIDATOR内核的核心组件，位于LLM生成层与ACTION执行层之间。

 

```

┌─────────────────────────────────────────────────────────┐

│ APPLICATION LAYER │

└─────────────────────────────────────────────────────────┘

                              │

                              ▼

┌─────────────────────────────────────────────────────────┐

│ LLM GENERATOR │

│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │

│ │Prompt │→ │Context │→ │Inference│→ │Output │ │

│ │Eng. │ │Retrieval│ │Core │ │Gen. │ │

│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │

└─────────────────────────────────────────────────────────┘

                              │

                              ▼

┌─────────────────────────────────────────────────────────┐

│ VALIDATOR KERNEL │

│ ┌──────────────────────────────────────────────────┐ │

│ │ HES (Hallucination Eval Sys) │ │

│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │

│ │ │Fact Check │ │Reason Check│ │State Check │ │ │

│ │ │(WEB Layer) │ │(Logic Layer)│ │(TSPR Layer)│ │ │

│ │ └────────────┘ └────────────┘ └────────────┘ │ │

│ │ │ │ │ │ │

│ │ ▼ ▼ ▼ │ │

│ │ ┌─────────────────────────────────────────┐ │ │

│ │ │ HRI Score Engine │ │ │

│ │ │ HRI = 1 - (0.4FCS + 0.3RCS + 0.3SAS) │ │ │

│ │ └─────────────────────────────────────────┘ │ │

│ │ │ │ │

│ │ ▼ │ │

│ │ ┌─────────────────────────────────────────┐ │ │

│ │ │ Decision Gate │ │ │

│ │ │ PASS / REWRITE / BLOCK │ │ │

│ │ └─────────────────────────────────────────┘ │ │

│ └──────────────────────────────────────────────────┘ │

└─────────────────────────────────────────────────────────┘

          │ │ │

          ▼ ▼ ▼

    ┌─────────┐ ┌──────────┐ ┌─────────┐

    │ ACTION │ │ REWRITE │ │ RULE │

    │ EXECUTE │ │ LOOP │ │ SYSTEM │

    └─────────┘ └──────────┘ └─────────┘

```

 

3.2 VALIDATOR内核的输入输出规范

 

输入：

 

· llm_output: string, LLM生成的原始文本

· context: dict, 包含对话历史、用户意图、TSPR状态快照

· web_evidence: dict, 可选的外部检索证据（如由RAG模块预取）

 

输出：

 

· decision: 枚举值 PASS / REWRITE / BLOCK

· scores: dict, 包含 FCS, RCS, SAS, HRI 及各自子指标

· diagnostics: dict, 详细失败原因、定位到的幻觉片段、建议修复动作

 

3.3 执行流程

 

VALIDATOR内核的执行遵循确定性流水线：

 

步骤1：声明提取。从LLM输出中提取可验证的事实性声明 $C$、推理步骤序列 $\mathcal{R}$ 和状态相关断言 $A_{\text{state}}$。

 

步骤2：并行验证。事实检查器访问WEB层证据，推理检查器构建推理图并验证逻辑连续性，状态检查器计算输出与TSPR模型的似然度。

 

步骤3：指标计算。依据第4节公式计算FCS、RCS、SAS及派生指标。

 

步骤4：风险聚合。使用加权和计算HRI，权重依据任务类型动态调整。

 

步骤5：决策门判定。按预设阈值输出决策，同时生成诊断信息。

 

---

 

4. 核心指标体系（HES Metrics）完整定义

 

4.1 事实一致性得分（Fact Consistency Score, FCS）

 

定义：FCS衡量LLM输出中可被WEB层证据验证的事实性声明所占的比例。

 

计算公式：

 

\text{FCS} = \frac{|\{c \in C : \text{verifiable}(c, E) \land \text{confidence}(c, E) \ge \tau_c\}|}{|C|}

 

其中：

 

· $C$：从输出中提取的事实性声明集合

· $E$：WEB层证据集合（搜索引擎、知识图谱、文档库等）

· $\text{verifiable}(c, E)$：返回声明 $c$ 是否与 $E$ 一致

· $\text{confidence}(c, E)$：验证置信度（0到1）

· $\tau_c$：置信度阈值（默认0.7）

 

子指标：

 

（1）实体匹配率（Entity Match Rate, EMR）

 

\text{EMR} = \frac{| \text{Entities}_{\text{output}} \cap \text{Entities}_{\text{evidence}} |}{| \text{Entities}_{\text{output}} |}

 

实体类型包括：人名、地名、组织名、产品名、概念术语等。使用命名实体识别（NER）模型提取。

 

（2）来源一致性得分（Source Alignment Score, SASource）

 

\text{SASource} = \frac{1}{|C|} \sum_{c \in C} \text{align}(c, \text{source}(c))

 

其中 $\text{align}(c, \text{source}(c))$ 为声明与引用来源之间的语义相似度（使用嵌入向量余弦距离）。

 

（3）数值准确性得分（Numeric Accuracy Score, NAS）

 

\text{NAS} = \frac{|\{c \in C_{\text{numeric}} : |c_{\text{output}} - c_{\text{evidence}}| / c_{\text{evidence}} \le \epsilon\}|}{|C_{\text{numeric}}|}

 

仅适用于包含数值的声明，$\epsilon$ 为相对误差容忍度（默认0.05）。

 

FCS判定阈值：

 

FCS范围 状态 系统行为

0.9 高一致性 PASS（可进入执行）

0.7 - 0.9 中等一致性 REVIEW（需人工或自动复核）

< 0.7 低一致性 BLOCK（阻断执行，触发REWRITE或RULE）

 

4.2 推理连贯性得分（Reasoning Coherence Score, RCS）

 

定义：RCS衡量模型输出中推理链的完整性与逻辑有效性。推理被建模为有向无环图（DAG），节点为命题，边为推理步骤。

 

计算公式：

 

\text{RCS} = \alpha \cdot \text{RCS}_{\text{complete}} + \beta \cdot \text{RCS}_{\text{logic}} + \gamma \cdot \text{RCS}_{\text{causal}}

 

其中 $\alpha + \beta + \gamma = 1$，建议值 $\alpha=0.4, \beta=0.35, \gamma=0.25$。

 

子指标：

 

（1）推理步骤完整性（Step Completeness）

 

\text{RCS}_{\text{complete}} = 1 - \frac{\text{missing\_steps}}{\text{expected\_steps} + \text{missing\_steps}}

 

缺失步骤通过比较实际推理路径与标准推理模式（如三段论、归纳推理、溯因推理）识别。

 

（2）逻辑连续性（Logic Continuity）

 

\text{RCS}_{\text{logic}} = \frac{1}{|E_{\mathcal{R}}|} \sum_{(u,v) \in E_{\mathcal{R}}} \text{logic\_score}(u,v)

 

其中 $\text{logic\_score}(u,v)$ 评估从前提 $u$ 到结论 $v$ 的推理是否遵循有效逻辑规则。使用预定义的逻辑规则集（包含18条演绎规则和12条归纳规则）进行模式匹配。

 

（3）因果正确性（Causality Correctness）

 

\text{RCS}_{\text{causal}} = 1 - \frac{\text{incorrect\_causal\_claims}}{\text{total\_causal\_claims}}

 

仅对显式或隐式的因果声明（“导致”、“引起”、“由于”等模式）进行评估。因果方向通过时间顺序检测或干预模拟验证。

 

RCS判定阈值：

 

RCS范围 状态 系统行为

0.85 高连贯性 PASS

0.6 - 0.85 中等连贯性 REVIEW（提示补充推理步骤）

< 0.6 低连贯性 BLOCK

 

4.3 状态对齐得分（State Alignment Score, SAS）

 

定义：SAS衡量LLM输出与当前TSPR状态模型之间的匹配程度。TSPR（Task-State-Preference-Role）模型是DLOS中维护完整对话与任务状态的统一表示。

 

计算公式：

 

\text{SAS} = \frac{1}{3} (\text{SAS}_{\text{intent}} + \text{SAS}_{\text{context}} + \text{SAS}_{\text{temporal}})

 

采用加权几何平均以强化偏低维度的惩罚：

 

\text{SAS} = \exp\left( \sum w_i \ln(\text{SAS}_i) \right)，其中 w_i = \frac{1}{3}

 

子指标：

 

（1）意图一致性（Intent Alignment）

 

\text{SAS}_{\text{intent}} = \text{sim}( \text{intent}_{\text{output}}, \text{intent}_{\text{TSPR}} )

 

意图通过轻量级分类器（基于BERT微调，6类意图）从输出中提取。相似度 $\text{sim}$ 为嵌入余弦距离或分类匹配得分。

 

（2）上下文稳定性（Context Stability）

 

\text{SAS}_{\text{context}} = 1 - \frac{\text{context\_drift}}{\text{max\_drift}}

 

$\text{context\_drift}$ 量化输出对上一轮对话状态的违反程度。关键约束包括：角色约束（如“你是客服”不能被违抗）、模态约束（如“只回答JSON”不能被违反）、信息约束（如之前声明“不知道X”后不能声称知道X）。

 

（3）时间一致性（Temporal Consistency）

 

\text{SAS}_{\text{temporal}} = 1 - \text{contradiction\_rate}( \text{output}, \text{history} )

 

检测输出与历史记录中的时间戳、事件顺序、持续时间声明之间的直接矛盾。使用时间逻辑（Interval Temporal Logic）建模。

 

SAS判定阈值：

 

SAS范围 状态 系统行为

0.9 高对齐 PASS

0.7 - 0.9 中等对齐 REVIEW（检查状态冲突）

< 0.7 低对齐 BLOCK

 

4.4 幻觉风险指数（Hallucination Risk Index, HRI）

 

定义：HRI是综合反映LLM输出幻觉风险的核心指标，取值范围 $[0, 1]$，值越高表示幻觉风险越大。

 

计算公式：

 

\text{HRI} = 1 - (w_{\text{FCS}} \cdot \text{FCS} + w_{\text{RCS}} \cdot \text{RCS} + w_{\text{SAS}} \cdot \text{SAS})

 

其中 $w_{\text{FCS}} + w_{\text{RCS}} + w_{\text{SAS}} = 1$。

 

权重设计原则：

 

· 事实一致性（FCS）权重最高（0.4）：因为事实错误往往造成最严重的后果。

· 推理连贯性（RCS）和状态对齐（SAS）各占0.3：两者在复杂任务中同等重要。

 

自适应权重：根据任务类型动态调整：

 

· 知识问答类任务：FCS权重提升至0.6

· 规划推理类任务：RCS权重提升至0.5

· 多轮对话类任务：SAS权重提升至0.5

 

HRI分级与决策映射：

 

HRI范围 风险等级 系统行为 触发条件详情

0.00 - 0.20 Low PASS 直接进入ACTION执行，无需干预

0.20 - 0.50 Medium REWRITE 触发LLM重新生成，传递诊断信息作为约束

0.50 - 1.00 High BLOCK 阻断执行，调用RULE系统，可能触发人工介入

 

---

 

5. VALIDATOR决策机制与闭环学习

 

5.1 决策门的形式化逻辑

 

决策门接受HRI及三个维度得分，输出确定性决策。为防止边缘振荡，引入滞后机制（hysteresis）。

 

```python

def decision_gate(fcs, rcs, sas, hri, history=None):

    # 基础规则

    if hri <= 0.2:

        return Decision.PASS

    elif hri >= 0.5:

        return Decision.BLOCK

    

    # 边缘区域 (0.2 < hri < 0.5) 使用增强规则

    if hri < 0.35:

        # 接近PASS边界

        if fcs > 0.85 and rcs > 0.8 and sas > 0.85:

            return Decision.PASS

        else:

            return Decision.REWRITE

    else:

        # 接近BLOCK边界

        if fcs < 0.6 or rcs < 0.5 or sas < 0.6:

            return Decision.BLOCK

        else:

            return Decision.REWRITE

```

 

5.2 三种行为的实现规范

 

（1）PASS行为：输出通过VALIDATOR后直接送入ACTION执行器。ACTION执行器会记录本次通过的验证报告，用于后续的归因分析。

 

（2）REWRITE行为：系统不执行原始输出，而是构造一个增强提示，将诊断信息作为约束注入，要求LLM重新生成。重写提示模板：

 

```

Your previous response had the following issues:

- Fact errors: {fact_errors}

- Reasoning gaps: {reasoning_gaps}

- State misalignment: {state_misalignments}

 

Please regenerate your response addressing these issues.

Original context: {context}

Constraints: {constraints}

```

 

最大重写次数默认为2次。若超过仍失败，降级为BLOCK。

 

（3）BLOCK行为：输出被完全阻断，不进入ACTION层。同时触发RULE系统，RULE系统根据失败类型执行预定义的降级策略：

 

· 安全关键任务：请求人工审核

· 非关键任务：返回预设的安全响应

· 可恢复任务：回退到上一个稳定状态

 

5.3 闭环学习机制

 

HES最关键的能力是从检测结果中学习，形成正反馈进化回路。

 

```

VALIDATOR → Hallucination Report → FEEDBACK Collector 

    → RULE Updater → GPS (Global Policy System) → LLM Finetuning

```

 

反馈数据格式：

 

```json

{

  "timestamp": "2026-06-06T10:00:00Z",

  "input_hash": "abc123",

  "output_snippet": "...",

  "scores": {"FCS": 0.45, "RCS": 0.62, "SAS": 0.71, "HRI": 0.51},

  "decision": "BLOCK",

  "failure_type": "fact_hallucination",

  "evidence_used": [...],

  "rule_triggered": "RULE-07"

}

```

 

三条学习路径：

 

1. RULE系统更新：高频出现的幻觉模式被编码为显式规则，缩短检测路径。

2. GPS策略调整：全局策略根据各模块的HRI分布调整阈值和权重。

3. LLM微调：收集被BLOCK和REWRITE的案例，构建偏好数据集用于RLHF或DPO训练。

 

---

 

6. 系统实现与代码

 

6.1 整体代码架构

 

```

dlos_validator/

├── __init__.py

├── core/

│ ├── validator.py # VALIDATOR主控制器

│ ├── decision_gate.py # 决策门

│ └── feedback_collector.py # 反馈收集

├── metrics/

│ ├── fcs.py # 事实一致性

│ ├── rcs.py # 推理连贯性

│ ├── sas.py # 状态对齐

│ └── hri.py # 综合指数

├── checkers/

│ ├── fact_checker.py # WEB证据验证

│ ├── reason_checker.py # 逻辑链验证

│ └── state_checker.py # TSPR验证

├── extractors/

│ ├── claim_extractor.py # 声明提取

│ ├── reasoning_extractor.py

│ └── state_extractor.py

└── utils/

    ├── web_evidence.py

    ├── logic_engine.py

    └── tspr_model.py

```

 

6.2 VALIDATOR主控制器完整实现

 

```python

# core/validator.py

 

from enum import Enum

from dataclasses import dataclass, field

from typing import Dict, List, Optional, Any

import json

import logging

from datetime import datetime

 

from metrics.fcs import FactConsistencyScorer

from metrics.rcs import ReasoningCoherenceScorer

from metrics.sas import StateAlignmentScorer

from metrics.hri import HRICalculator

from checkers.fact_checker import FactChecker

from checkers.reason_checker import ReasonChecker

from checkers.state_checker import StateChecker

from extractors.claim_extractor import ClaimExtractor

from extractors.reasoning_extractor import ReasoningExtractor

from extractors.state_extractor import StateExtractor

from core.decision_gate import DecisionGate

from core.feedback_collector import FeedbackCollector

 

class Decision(Enum):

    PASS = "PASS"

    REWRITE = "REWRITE"

    BLOCK = "BLOCK"

 

@dataclass

class ValidationResult:

    """验证结果数据类"""

    decision: Decision

    fcs: float

    rcs: float

    sas: float

    hri: float

    sub_scores: Dict[str, float]

    failure_locations: List[Dict[str, Any]]

    diagnostics: str

    rewrite_constraints: Optional[Dict[str, Any]] = None

    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())

 

class DLOSValidator:

    """

    DLOS VALIDATOR 核心控制器

    负责协调事实、推理、状态三个维度的幻觉检测并输出决策

    """

    

    def __init__(self, config: Dict[str, Any]):

        """

        初始化VALIDATOR

        

        Args:

            config: 配置字典，包含各检测器的阈值、权重等参数

        """

        self.config = config

        self.logger = logging.getLogger(__name__)

        

        # 初始化提取器

        self.claim_extractor = ClaimExtractor(

            model_name=config.get("ner_model", "en_core_web_lg"),

            min_confidence=config.get("min_claim_confidence", 0.7)

        )

        self.reasoning_extractor = ReasoningExtractor(

            max_steps=config.get("max_reasoning_steps", 20)

        )

        self.state_extractor = StateExtractor(

            intent_model=config.get("intent_model", "bert-base-uncased")

        )

        

        # 初始化检测器

        self.fact_checker = FactChecker(

            web_search_api=config.get("web_search_api"),

            knowledge_graph=config.get("knowledge_graph"),

            cache_ttl=config.get("evidence_cache_ttl", 3600)

        )

        self.reason_checker = ReasonChecker(

            logic_rules_path=config.get("logic_rules_path", "rules/logic_rules.json"),

            max_chain_length=config.get("max_chain_length", 15)

        )

        self.state_checker = StateChecker(

            tspr_model=config.get("tspr_model"),

            context_window=config.get("context_window", 10)

        )

        

        # 初始化评分器

        self.fcs_scorer = FactConsistencyScorer(

            weights=config.get("fcs_weights", {"entity": 0.4, "source": 0.3, "numeric": 0.3})

        )

        self.rcs_scorer = ReasoningCoherenceScorer(

            weights=config.get("rcs_weights", {"complete": 0.4, "logic": 0.35, "causal": 0.25})

        )

        self.sas_scorer = StateAlignmentScorer(

            weights=config.get("sas_weights", {"intent": 0.4, "context": 0.35, "temporal": 0.25})

        )

        self.hri_calculator = HRICalculator(

            default_weights=config.get("hri_weights", {"fcs": 0.4, "rcs": 0.3, "sas": 0.3})

        )

        

        # 决策门

        self.decision_gate = DecisionGate(

            thresholds=config.get("decision_thresholds", {

                "pass_hri_max": 0.2,

                "block_hri_min": 0.5,

                "fcs_pass_min": 0.85,

                "rcs_pass_min": 0.8,

                "sas_pass_min": 0.85,

                "fcs_block_max": 0.6,

                "rcs_block_max": 0.5,

                "sas_block_max": 0.6

            })

        )

        

        # 反馈收集器

        self.feedback_collector = FeedbackCollector(

            storage_path=config.get("feedback_storage_path", "./feedback/")

        )

        

        self.enable_rewrite = config.get("enable_rewrite", True)

        self.max_rewrite_attempts = config.get("max_rewrite_attempts", 2)

        

        self.logger.info("DLOSValidator initialized successfully")

    

    def validate(self, 

                 llm_output: str, 

                 context: Dict[str, Any],

                 web_evidence: Optional[Dict[str, Any]] = None,

                 rewrite_history: Optional[List[str]] = None) -> ValidationResult:

        """

        执行完整的幻觉检测与决策流程

        

        Args:

            llm_output: LLM生成的原始文本

            context: 包含对话历史、用户意图、TSPR状态的上下文

            web_evidence: 预取的WEB证据（可选）

            rewrite_history: 重写历史（用于限制递归深度）

            

        Returns:

            ValidationResult: 包含决策、分数和诊断信息

        """

        rewrite_history = rewrite_history or []

        attempt = len(rewrite_history) + 1

        

        self.logger.info(f"Validation attempt {attempt} for input")

        

        # 步骤1: 提取声明、推理步骤和状态断言

        claims = self.claim_extractor.extract(llm_output)

        reasoning_chain = self.reasoning_extractor.extract(llm_output, context)

        state_assertions = self.state_extractor.extract(llm_output, context)

        

        # 步骤2: 并行验证三个维度

        fact_verification = self.fact_checker.verify(

            claims=claims, 

            web_evidence=web_evidence,

            context=context

        )

        

        reason_verification = self.reason_checker.verify(

            reasoning_chain=reasoning_chain,

            context=context

        )

        

        state_verification = self.state_checker.verify(

            state_assertions=state_assertions,

            context=context

        )

        

        # 步骤3: 计算各维度分数

        fcs, fcs_details = self.fcs_scorer.compute(fact_verification)

        rcs, rcs_details = self.rcs_scorer.compute(reason_verification)

        sas, sas_details = self.sas_scorer.compute(state_verification)

        

        # 步骤4: 根据任务类型调整权重并计算HRI

        task_type = context.get("task_type", "general")

        hri, hri_components = self.hri_calculator.compute(

            fcs=fcs, rcs=rcs, sas=sas, 

            task_type=task_type

        )

        

        # 步骤5: 决策门判定

        decision, decision_reason = self.decision_gate.decide(

            hri=hri, fcs=fcs, rcs=rcs, sas=sas,

            attempt=attempt, max_attempts=self.max_rewrite_attempts

        )

        

        # 步骤6: 构建诊断信息

        failure_locations = self._aggregate_failures(

            fact_verification, reason_verification, state_verification

        )

        

        rewrite_constraints = None

        if decision == Decision.REWRITE and self.enable_rewrite:

            rewrite_constraints = self._build_rewrite_constraints(

                failure_locations, context

            )

        

        diagnostics = self._generate_diagnostics(

            fcs=fcs, rcs=rcs, sas=sas, hri=hri,

            decision=decision, decision_reason=decision_reason,

            failures=failure_locations

        )

        

        # 步骤7: 收集反馈（用于闭环学习）

        self.feedback_collector.collect(

            input_text=context.get("user_input", ""),

            output_text=llm_output,

            validation_result={

                "decision": decision.value,

                "fcs": fcs, "rcs": rcs, "sas": sas, "hri": hri,

                "failure_locations": failure_locations,

                "context_snapshot": self._capture_context_snapshot(context)

            }

        )

        

        result = ValidationResult(

            decision=decision,

            fcs=fcs,

            rcs=rcs,

            sas=sas,

            hri=hri,

            sub