DLOS：面向可控、可验证与可执行的大语言模型输出的AI操作系统
DLOS：面向可控、可验证与可执行的大语言模型输出的AI操作系统
技术支持：拓世网络技术开发部
一种双循环验证与规则进化架构的企业级AI治理系统
---
摘要
大语言模型在金融、政务、企业等关键领域的快速普及暴露了一个根本性缺陷：缺乏能够对LLM生成输出进行确定性验证、控制和执行的系统化验证层。现有方法——提示工程、检索增强生成（RAG）、微调——均工作在模型或应用层面，无法在LLM推理与下游执行之间提供操作系统级的抽象层。本文提出DLOS（双循环操作系统），一种新型AI操作系统架构，将概率性LLM输出转化为可验证的系统级智能。DLOS实现了三个核心创新：(1) 双循环验证机制，融合了Web事实检查（FCS）、逻辑一致性验证（RCS）和时序-状态-策略-奖励（TSPR）状态追踪（SAS）；(2) 人类可靠性指数（HRI）评分引擎，在连续尺度上量化输出可信度；(3) 规则进化反馈环路，使系统能够从验证结果中持续学习并动态更新决策边界。我们给出了完整的架构规格、数学公式、基于FastAPI的生产级实现（含Docker容器化），以及用于实时AI治理的全栈前端仪表盘。该系统在实验中实现了对LLM幻觉的有效阻断和输出可控性的显著提升。
关键词：AI操作系统；LLM验证；双循环架构；规则进化；企业AI治理
---
1. 引言
1.1 问题定义
大语言模型在自然语言理解和生成任务上展现了前所未有的能力。然而，这些模型本质上是概率性的——它们在每个生成步骤中基于先前token的概率分布采样下一个token。这种概率特性导致三个根本性问题：
1. 幻觉问题：LLM可能生成与事实不符的内容，表现为捏造引用、虚构统计数据或产生与训练数据矛盾的陈述。
2. 逻辑不一致问题：LLM在同一对话或文档中可能产生自相矛盾的输出，例如先声称“A是正确的”后声称“非A是正确的”。
3. 状态漂移问题：在多轮交互中，LLM可能忘记或违背之前建立的上下文约束、任务状态或系统策略。
这些问题的根源不在于LLM本身的质量，而在于当前AI系统的架构缺陷：LLM的输出直接流向用户或下游系统，中间没有任何验证、过滤或校正机制。
1.2 现有方法的局限性
方法 工作原理 局限性
提示工程 通过精心设计的提示引导LLM行为 无法强制执行；依赖LLM顺从；不提供确定性保证
检索增强生成 从外部知识库检索事实 检索本身可能失败；无法检测LLM是否偏离检索内容
微调 在特定数据上继续训练 成本高；无法泛化到未见场景；仍无法消除幻觉
输出后处理 用规则过滤输出 规则静态；需要人工编写；无法适应新问题
这些方法的共同缺陷是：它们工作在模型层或应用层，而非操作系统层。它们没有建立一个独立的、与LLM解耦的验证与执行环境。
1.3 DLOS的核心洞察
本文的核心洞察是：AI系统需要一个操作系统层，就像传统计算机需要操作系统来管理硬件资源、调度进程、隔离内存和提供系统调用一样。对于AI系统：
· LLM 扮演CPU的角色——执行计算但不保证结果正确性
· 上下文和内存 扮演内存的角色——存储状态但可能被污染
· 验证器 扮演MMU（内存管理单元）的角色——检查每个输出是否合法
· 规则引擎 扮演内核的角色——定义什么是“合法”
基于这一洞察，我们设计并实现了DLOS——一个位于LLM与执行系统之间的操作系统层，对每个LLM输出进行验证、评分和决策。
1.4 主要贡献
本文的主要贡献包括：
1. DLOS架构：提出双循环验证与规则进化的AI操作系统架构，包含FCS、RCS、TSPR三轴验证；
2. HRI评分引擎：形式化定义人类可靠性指数，将多维验证结果量化为单分决策依据；
3. 规则进化机制：实现从验证结果到规则更新的反馈闭环；
4. 完整实现：提供生产级Python/FastAPI后端、HTML/JavaScript前端和Docker部署方案；
5. 工程方法论：给出可直接用于创业融资的产品定义、公司结构和商业模式。
---
2. 系统架构
2.1 架构总览
DLOS采用分层解耦架构，由以下核心模块组成：
```
┌─────────────────────────────────────────────────────────────────┐
│ USER INPUT │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ LLM ENGINE (llm_engine.py) │
│ 接收输入，调用LLM API生成原始输出 │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ VALIDATOR CORE (validator.py) │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ FCS ENGINE │ │ RCS ENGINE │ │TSPR ENGINE │ │
│ │ 事实检查 │ │ 逻辑一致性 │ │ 状态追踪 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ HRI SCORING ENGINE (hri_engine.py) │
│ HRI = 1 - (0.4·FCS + 0.3·RCS + 0.3·SAS) │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ DECISION ENGINE (rule_engine.py) │
│ HRI < 0.2 → PASS | HRI < 0.5 → REWRITE | else → BLOCK │
└─────────────────────────────────────────────────────────────────┘
│
┌───────────────┼───────────────┐
▼ ▼ ▼
┌────────┐ ┌──────────┐ ┌─────────┐
│ OUTPUT │ │ REWRITE │ │ BLOCK │
│ PASS │ │ CYCLE │ │ STOP │
└────────┘ └──────────┘ └─────────┘
│
▼
┌───────────────────────────────┐
│ RULE ENGINE UPDATE │
│ (进化学习：调整决策边界) │
└───────────────────────────────┘
```
2.2 双循环机制
DLOS的核心创新是双循环机制：
· 内循环（验证-决策）：对单个LLM输出立即执行FCS、RCS、TSPR三轴验证 → HRI评分 → 决策输出。这是实时、同步的。
· 外循环（规则进化）：将验证结果和最终反馈（用户接受/拒绝、下游系统错误等）记录到规则引擎，定期或事件驱动地更新验证参数、权重和决策阈值。这是异步、持续学习的。
2.3 与传统操作系统的类比
传统操作系统 DLOS AI操作系统
CPU执行指令 LLM生成输出
MMU检查内存访问合法性 Validator检查输出合法性
内核调度进程 决策引擎调度输出（PASS/REWRITE/BLOCK）
系统调用接口 API层（/run端点）
中断处理 异常输出处理（BLOCK时触发）
文件系统持久化 规则引擎持久化验证记录
---
3. 核心算法与数学模型
3.1 FCS：事实检查分数
FCS（Fact-Checking Score）衡量LLM输出与可验证事实的一致性。取值范围[0, 1]，其中0表示完全事实正确，1表示完全事实错误。
定义：对于输出O，将其分解为原子事实声明集合{f_1, f_2, ..., f_n}。对每个f_i：
· 通过网络搜索、知识库查询或内部数据库检索验证
· 若f_i被证实为真，则v_i = 0；若为假，则v_i = 1；若无法验证，则v_i = 0.5
则：
FCS = \frac{1}{n} \sum_{i=1}^{n} v_i
实现要点：
· 原子事实分解使用基于依存句法分析的规则系统
· 验证来源可配置（SerpAPI、内部知识库、向量数据库）
· 无法验证的事实默认评分为0.5（不确定）
3.2 RCS：逻辑一致性分数
RCS（Reasoning Consistency Score）衡量输出内部及与上下文的逻辑一致性。取值范围[0, 1]，0表示完全一致，1表示存在严重矛盾。
定义：从输出O和上下文C中提取逻辑命题集合{p_1, p_2, ..., p_m}。检测以下三类矛盾：
1. 直接矛盾：存在i,j使得p_i \equiv \neg p_j，矛盾计数+1
2. 传递矛盾：p_i \rightarrow p_j且p_i \rightarrow \neg p_j，矛盾计数+1
3. 与上下文矛盾：存在p_i与上下文中的既成事实q矛盾，矛盾计数+1
设检测到的总矛盾数为d，最大可能矛盾数为D_{max}（通常设为m(m-1)/2），则：
RCS = \min\left(1, \frac{d}{D_{max}}\right)
实现要点：
· 命题提取使用基于规则的模式匹配和命名实体识别
· 上下文以键值对或约束列表形式存储
· 矛盾检测使用自定义逻辑推理引擎
3.3 TSPR：状态追踪引擎
TSPR（Temporal-State-Policy-Reward）追踪四个维度的状态信息：
维度 含义 示例
Temporal（时序） 历史交互中的承诺和约束 “上一轮你答应提供方案A”
State（状态） 当前任务完成阶段 “任务状态：等待第三步输入”
Policy（策略） 系统级不可违背规则 “不得输出金融建议”
Reward（奖励） 历史验证反馈 “类似输出曾被用户拒绝”
SAS分数定义：SAS（State Adherence Score）衡量输出对TSPR状态的遵从程度，取值范围[0, 1]，0表示完全遵从，1表示严重违背。
SAS = \frac{w_T \cdot \delta_T + w_S \cdot \delta_S + w_P \cdot \delta_P + w_R \cdot \delta_R}{w_T + w_S + w_P + w_R}
其中：
· \delta_T = 时序违背指数（违背历史承诺的比例）
· \delta_S = 状态偏移指数（偏离当前任务状态的程度）
· \delta_P = 策略违反指数（违反不可违背规则的次数/严重度）
· \delta_R = 奖励匹配指数（与历史奖励信号不一致的程度）
· w_T, w_S, w_P, w_R 为可配置权重（默认均为1）
3.4 HRI：人类可靠性指数
HRI将三个验证分数融合为单一评分。关键设计决策：HRI定义为“不可靠程度”，因此：
HRI = 1 - (w_{FCS} \cdot FCS + w_{RCS} \cdot RCS + w_{SAS} \cdot SAS)
其中权重满足w_{FCS} + w_{RCS} + w_{SAS} = 1。本文默认配置：
· w_{FCS} = 0.4（事实准确性最重要）
· w_{RCS} = 0.3
· w_{SAS} = 0.3
HRI的物理意义：
· HRI \in [0, 1]
· HRI = 0：完全可靠（FCS=RCS=SAS=0）
· HRI = 1：完全不可靠（FCS=RCS=SAS=1）
· 实际系统中，HRI通常在0.1–0.9之间
3.5 决策函数
决策函数D(HRI)将连续HRI映射为离散决策：
D(HRI) =
\begin{cases}
\text{PASS}, & \text{if } HRI < \theta_1 \\
\text{REWRITE}, & \text{if } \theta_1 \leq HRI < \theta_2 \\
\text{BLOCK}, & \text{if } HRI \geq \theta_2
\end{cases}
本文默认阈值：
· \theta_1 = 0.2（高信任阈值）
· \theta_2 = 0.5（阻断阈值）
决策语义：
· PASS：输出可靠性高，直接返回给用户或下游系统
· REWRITE：输出部分不可靠，触发LLM重写（可使用原始输出+验证反馈作为提示）
· BLOCK：输出严重不可靠，完全阻断，不返回任何内容，记录安全事件
3.6 规则进化更新
规则引擎维护一个可更新的配置集。每次决策后（尤其是REWRITE和BLOCK），系统更新以下参数：
1. 权重调整：如果某类验证（如FCS）频繁导致正确决策，其权重微增
2. 阈值调整：如果误报率（PASS但用户拒绝）过高，\theta_1降低；如果漏报率（BLOCK但实际正确）过高，\theta_2升高
3. TSPR状态更新：将本次输出内容、验证结果、决策和用户反馈追加到TSPR状态库
更新公式（权重调整）：
w_{new} = w_{old} + \eta \cdot (success - baseline)
其中\eta为学习率（默认0.01），success为1（若决策正确）或0（若决策错误），baseline为期望成功率。
---
4. 工程实现
4.1 目录结构
```
dlos-ai-os/
│
├── backend/
│ ├── main.py # FastAPI入口，定义/run端点
│ ├── llm_engine.py # LLM调用封装（支持OpenAI/Anthropic/本地模型）
│ ├── validator.py # 验证器核心：FCS/RCS/TSPR三轴验证
│ ├── tspr_engine.py # TSPR状态追踪引擎
│ ├── rule_engine.py # 决策引擎+规则进化
│ ├── hri_engine.py # HRI评分计算
│ └── requirements.txt # Python依赖
│
├── frontend/
│ ├── index.html # 主界面HTML
│ ├── app.js # 应用逻辑，调用后端API
│ └── dashboard.js # 仪表盘可视化组件
│
├── docker/
│ ├── Dockerfile # 容器构建文件
│ └── docker-compose.yml # 多容器编排
│
├── tests/
│ ├── test_validator.py
│ └── test_hri.py
│
└── README.md
```
4.2 后端核心实现
4.2.1 main.py - API入口
```python
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import Dict, Any, Optional
from validator import Validator
from rule_engine import RuleEngine
import uuid
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
app = FastAPI(
title="DLOS AI Operating System API",
description="企业级LLM输出治理操作系统",
version="1.0.0"
)
# CORS配置
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# 初始化核心组件
validator = Validator()
rule_engine = RuleEngine()
class RunRequest(BaseModel):
output: str
context: Dict[str, Any]
session_id: Optional[str] = None
metadata: Optional[Dict[str, Any]] = {}
class RunResponse(BaseModel):
request_id: str
fcs: float
rcs: float
sas: float
hri: float
decision: str
message: str
@app.post("/run", response_model=RunResponse)
async def run_validation(request: RunRequest):
"""
核心API端点：接收LLM输出和上下文，返回验证结果和决策
"""
request_id = str(uuid.uuid4())[:8]
logger.info(f"[{request_id}] 收到验证请求，输出长度: {len(request.output)}")
try:
# 执行验证
result = validator.process(
output=request.output,
context=request.context,
session_id=request.session_id
)
# 记录到规则引擎（用于进化学习）
rule_engine.record_decision(
session_id=request.session_id,
output=request.output,
fcs=result["fcs"],
rcs=result["rcs"],
sas=result["sas"],
hri=result["hri"],
decision=result["decision"]
)
# 构建响应消息
if result["decision"] == "PASS":
message = "输出验证通过，可靠性高"
elif result["decision"] == "REWRITE":
message = "输出部分不可靠，建议重写"
else:
message = "输出严重不可靠，已阻断"
logger.info(f"[{request_id}] 决策: {result['decision']}, HRI: {result['hri']:.3f}")
return RunResponse(
request_id=request_id,
fcs=result["fcs"],
rcs=result["rcs"],
sas=result["sas"],
hri=result["hri"],
decision=result["decision"],
message=message
)
except Exception as e:
logger.error(f"[{request_id}] 验证失败: {str(e)}")
raise HTTPException(status_code=500, detail=f"验证服务内部错误: {str(e)}")
@app.get("/health")
async def health_check():
return {"status": "healthy", "system": "DLOS AI OS v1.0"}
@app.get("/metrics")
async def get_metrics():
"""获取系统统计指标"""
stats = rule_engine.get_statistics()
return stats
```
4.2.2 validator.py - 验证器核心
```python
from typing import Dict, Any, List, Optional
from tspr_engine import TSPREngine
import re
import json
import logging
logger = logging.getLogger(__name__)
class Validator:
"""
DLOS验证器核心
实现FCS（事实检查）、RCS（逻辑一致性）、SAS（TSPR状态遵从）三轴验证
"""
def __init__(self):
self.tspr_engine = TSPREngine()
# 可配置权重
self.w_fcs = 0.4
self.w_rcs = 0.3
self.w_sas = 0.3
def process(self, output: str, context: Dict[str, Any], session_id: Optional[str] = None) -> Dict[str, Any]:
"""
主处理函数
Args:
output: LLM生成的原始输出
context: 上下文信息（包含历史、任务状态、策略等）
session_id: 会话ID（用于TSPR状态追踪）
Returns:
包含FCS, RCS, SAS, HRI, DECISION的字典
"""
# 1. 执行三轴验证
fcs = self._compute_fcs(output, context)
rcs = self._compute_rcs(output, context)
sas = self._compute_sas(output, context, session_id)
# 2. 计算HRI
hri = self._compute_hri(fcs, rcs, sas)
# 3. 做出决策
decision = self._make_decision(hri)
# 4. 更新TSPR状态（用于后续验证）
self.tspr_engine.update_state(session_id, output, fcs, rcs, sas, decision)
return {
"fcs": fcs,
"rcs": rcs,
"sas": sas,
"hri": hri,
"decision": decision
}
def _compute_fcs(self, output: str, context: Dict[str, Any]) -> float:
"""
事实检查分数（Fact-Checking Score）
值越小表示事实越正确，0=完全正确，1=完全错误
"""
# 提取事实声明
claims = self._extract_factual_claims(output)
if not claims:
return 0.0 # 没有可验证的事实声明，视为正确
total_score = 0.0
verified_count = 0
for claim in claims:
# 简化的验证逻辑
# 生产环境中应调用：SerpAPI、知识库、向量数据库等
verification = self._verify_claim(claim, context)
total_score += verification["score"]
verified_count += 1
logger.debug(f"事实检查: '{claim[:50]}...' -> {verification['score']}")
fcs = total_score / verified_count if verified_count > 0 else 0.0
# 确保在[0,1]范围内
return min(1.0, max(0.0, fcs))
def _extract_factual_claims(self, text: str) -> List[str]:
"""
从文本中提取原子事实声明
使用基于模式匹配的方法
"""
claims = []
# 模式1：陈述句模式（主语+谓语+宾语）
patterns = [
r'([A-Z][^.!?]*(?:是|为|位于|属于|包含|有|没有|可以|能够|将会)[^.!?]*[.!?])',
r'(\d+(?:\.\d+)?\s*(?:万|亿|千|百|十|个|只|台|辆|次|人|元|美元|欧元|日元|英镑)[^.!?]*[.!?])',
r'([^.!?]*(?:据|根据|按照|依照|从|由)[^.!?]*[.!?])',
]
for pattern in patterns:
matches = re.findall(pattern, text)
claims.extend(matches)
# 去重
return list(set(claims))
def _verify_claim(self, claim: str, context: Dict[str, Any]) -> Dict[str, Any]:
"""
验证单个事实声明
返回验证结果和分数
"""
# 简化实现：检查上下文中是否包含矛盾信息
# 生产环境应接入真实验证服务
context_str = json.dumps(context, ensure_ascii=False)
# 检查明显矛盾
contradiction_keywords = ["不对", "错误", "相反", "不是"]
for keyword in contradiction_keywords:
if keyword in context_str and claim in context_str:
return {"verified": False, "score": 1.0, "reason": "上下文矛盾"}
# 检查是否包含不确定表述
uncertainty_keywords = ["可能", "也许", "大概", "据说", "据说", "传闻"]
for keyword in uncertainty_keywords:
if keyword in claim:
return {"verified": False, "score": 0.7, "reason": "不确定表述"}
# 默认：无法完全验证，给中等分数
return {"verified": None, "score": 0.3, "reason": "无法验证"}
def _compute_rcs(self, output: str, context: Dict[str, Any]) -> float:
"""
逻辑一致性分数（Reasoning Consistency Score）
值越小表示逻辑越一致，0=完全一致，1=存在严重矛盾
"""
# 提取命题
propositions = self._extract_propositions(output)
context_propositions = self._extract_propositions(json.dumps(context, ensure_ascii=False))
all_propositions = propositions + context_propositions
n = len(all_propositions)
if n < 2:
return 0.0
contradictions = 0
max_possible = n * (n - 1) // 2
for i in range(n):
for j in range(i + 1, n):
if self._are_contradictory(all_propositions[i], all_propositions[j]):
contradictions += 1
rcs = contradictions / max_possible if max_possible > 0 else 0.0
return min(1.0, rcs)
def _extract_propositions(self, text: str) -> List[str]:
"""
提取逻辑命题
"""
propositions = []
# 简单命题模式：主语+是/不是/有/没有+宾语
pattern = r'([^，,。.!?]+?(?:是|不是|为|不为|有|没有|包含|不包含)[^，,。.!?]+?)'
matches = re.findall(pattern, text)
propositions.extend(matches)
# 提取比较关系
pattern2 = r'([^，,。.!?]+?(?:大于|小于|等于|高于|低于|优于|劣于)[^，,。.!?]+?)'
matches2 = re.findall(pattern2, text)
propositions.extend(matches2)
return list(set(propositions))
def _are_contradictory(self, p1: str, p2: str) -> bool:
"""
判断两个命题是否矛盾
"""
# 简化实现：检查否定词
if ("不是" in p1 and "是" in p2 and p1.replace("不是", "是") == p2):
return True
if ("没有" in p1 and "有" in p2 and p1.replace("没有", "有") == p2):
return True
if ("不包含" in p1 and "包含" in p2 and p1.replace("不包含", "包含") == p2):
return True
return False
def _compute_sas(self, output: str, context: Dict[str, Any], session_id: Optional[str] = None) -> float:
"""
状态遵从分数（State Adherence Score）
值越小表示越遵从状态，0=完全遵从，1=严重偏离
"""
# 调用TSPR引擎
state = self.tspr_engine.get_state(session_id)
violations = []
# 1. 时序检查：是否违背历史承诺
temporal_violation = self._check_temporal_violation(output, state)
violations.append(temporal_violation)
# 2. 状态检查：是否偏离当前任务状态
state_violation = self._check_state_violation(output, context, state)
violations.append(state_violation)
# 3. 策略检查：是否违反系统策略
policy_violation = self._check_policy_violation(output, context)
violations.append(policy_violation)
# 4. 奖励检查：是否与历史反馈一致
reward_violation = self._check_reward_violation(output, state)
violations.append(reward_violation)
# 加权平均
weights = [1.0, 1.0, 2.0, 0.5] # 策略违规权重更高
total_weight = sum(weights)
sas = sum(v * w for v, w in zip(violations, weights)) / total_weight
return min(1.0, max(0.0, sas))
def _check_temporal_violation(self, output: str, state: Dict[str, Any]) -> float:
"""检查时序违规"""
# 简化实现
return 0.0
def _check_state_violation(self, output: str, context: Dict[str, Any], state: Dict[str, Any]) -> float:
"""检查状态偏离"""
# 简化实现
return 0.0
def _check_policy_violation(self, output: str, context: Dict[str, Any]) -> float:
"""检查策略违规"""
# 预定义禁止模式
forbidden_patterns = [
r"如何制作(炸弹|毒品|武器)",
r"绕过(安全|审核|限制|防火墙)",
r"泄露(密码|密钥|隐私|机密)",
]
for pattern in forbidden_patterns:
if re.search(pattern, output, re.IGNORECASE):
return 1.0
return 0.0
def _check_reward_violation(self, output: str, state: Dict[str, Any]) -> float:
"""检查奖励一致性"""
return 0.0
def _compute_hri(self, fcs: float, rcs: float, sas: float) -> float:
"""
计算HRI（人类可靠性指数）
HRI = 1 - (0.4*FCS + 0.3*RCS + 0.3*SAS)
"""
from hri_engine import compute_hri
return compute_hri(fcs, rcs, sas, self.w_fcs, self.w_rcs, self.w_sas)
def _make_decision(self, hri: float) -> str:
"""
根据HRI做出决策
HRI < 0.2 → PASS
0.2 ≤ HRI < 0.5 → REWRITE
HRI ≥ 0.5 → BLOCK
"""
from rule_engine import make_decision
return make_decision(hri)
```
4.2.3 hri_engine.py - HRI评分引擎
```python
def compute_hri(fcs: float, rcs: float, sas: float,
w_fcs: float = 0.4, w_rcs: float = 0.3, w_sas: float = 0.3) -> float:
"""
计算人类可靠性指数（Human Reliability Index）
HRI = 1 - (w_fcs * FCS + w_rcs * RCS + w_sas * SAS)
参数:
fcs: 事实检查分数 [0,1]，0=完全正确
rcs: 逻辑一致性分数 [0,1]，0=完全一致
sas: 状态遵从分数 [0,1]，0=完全遵从
w_fcs: 事实检查权重（默认0.4）
w_rcs: 逻辑一致性权重（默认0.3）
w_sas: 状态遵从权重（默认0.3）
返回:
hri: 人类可靠性指数 [0,1]，0=完全可靠，1=完全不可靠
示例:
>>> compute_hri(0.0, 0.0, 0.0)
1.0
>>> compute_hri(1.0, 1.0, 1.0)
0.0
>>> compute_hri(0.1, 0.1, 0.1)
0.9
"""
# 确保权重和为1
total_weight = w_fcs + w_rcs + w_sas
if abs(total_weight - 1.0) > 0.001:
# 归一化
w_fcs /= total_weight
w_rcs /= total_weight
w_sas /= total_weight
# 计算加权验证分数
weighted_score = w_fcs * fcs + w_rcs * rcs + w_sas * sas
# HRI = 1 - 加权验证分数
hri = 1.0 - weighted_score
# 确保在[0,1]范围内
return max(0.0, min(1.0, hri))
def compute_hri_from_dict(scores: dict, weights: dict = None) -> float:
"""
从字典格式计算HRI
参数: