diff --git a/README.md b/README.md index 977c2f7..fe760ce 100644 --- a/README.md +++ b/README.md @@ -1,109 +1,149 @@ # NextAgent — 认知解耦智能体架构 -NextAgent 是一套颠覆传统单一 LLM 模式的**认知解耦智能体架构**。通过模拟人脑的模块化分工，将认知、记忆、推理与表达分离为独立子网，从根本上解决大模型的**幻觉**问题与**效率瓶颈**。 +NextAgent 是一套颠覆传统单一 LLM 模式的**认知解耦智能体架构**。通过模拟人脑的模块化分工，将认知、记忆、推理与表达分离为独立子网，子网间通过**自定义张量协议**通信，从根本上解决大模型的**幻觉**问题与**效率瓶颈**。 ## 核心架构 ``` -┌─────────────────────────────────────────────────────────────┐ -│ NextAgent 架构总览 │ -│ │ -│ ┌────────────────────────────────────────────────────┐ │ -│ │ 调度 Core（前额叶皮层） │ │ -│ │ 逻辑判断 · 任务调度 · 信息同步 │ │ -│ └──────┬──────────┬──────────┬──────────┬────────────┘ │ -│ │ │ │ │ │ -│ ▼ ▼ ▼ ▼ │ -│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ -│ │ 路由与压缩 │ │ 记忆子网 │ │ 逻辑链路 │ │ LLM 子网 │ │ -│ │ (感觉中枢) │ │(海马体/皮层)│ │追踪神经网络│ │(布洛卡区) │ │ -│ │ │ │ │ │ (推理回路) │ │ │ │ -│ │ 多模态 │ │ 长期记忆 │ │ 逻辑验证 │ │ 结构化→自然│ │ -│ │ 特征提取 │ │ 知识图谱 │ │ 自我修正 │ │ 多语言输出 │ │ -│ │ 信息压缩 │ │ 情景索引 │ │ 路径重规划 │ │ 情感表达 │ │ -│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │ -│ │ │ │ │ │ -│ └──────────┴──────────┴──────────┘ │ -│ │ │ -│ ▼ │ -│ ┌────────────────────┐ │ -│ │ 冷区存储（原始数据） │ │ -│ └────────────────────┘ │ -└─────────────────────────────────────────────────────────────┘ +┌─────────────────────────────────────────────────────────────────────┐ +│ 应用层 (CLI/API/SDK) │ +└──────────────────────────────┬──────────────────────────────────────┘ + │ +┌──────────────────────────────▼──────────────────────────────────────┐ +│ 调度 Core (前额叶皮层) │ +│ 启发式调度 · 逻辑判断 · 任务解析 · 记忆聚合 │ +│ ┌──────────────┐ ┌──────────────┐ ┌────────────────────────┐ │ +│ │ 任务解析器 │ │ 调度策略引擎 │ │ 记忆聚合器 │ │ +│ │ 拆解用户意图 │ │ 启发式调度规则 │ │ 汇总子网结果→记忆参数包 │ │ +│ └──────────────┘ └──────────────┘ └────────────────────────┘ │ +└──────┬──────┬──────┬──────┬──────┬──────┬──────┬───────────────────┘ + │ │ │ │ │ │ │ + │ └──张量通信层──┐ │ │ │ + │ (Standard Tensor Protocol) │ │ + ▼ ▼ ▼ ▼ +┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ +│ 路由与压缩 │ ←──→ │ 记忆子网 │ │ 逻辑链路 │ │ LLM 子网 │ +│(感觉中枢) │ 张 量 │(海马体/皮层)│ │追踪神经网络│ │(布洛卡区) │ +│ │ │ │ │ (推理回路) │ │ │ +│ 多模态 │ │ 图数据库 │ │ 逻辑验证 │ │ 自然语言→用户 │ +│ 特征提取 │ │ 向量数据库 │ │ 自我修正 │ │ 表达张量→Core │ +│ 信息压缩 │ │ 文本记忆 │ │ 路径重规划 │ │ │ +└──────────┘ └──────────┘ └──────────┘ └──────────┘ + │ + ▼ + ┌────────────────────┐ + │ 存储层 (冷区存储) │ + │ 原始数据 · 索引 │ + └────────────────────┘ ``` ### Mermaid 架构图 ```mermaid graph TB - Core["调度 Core
(前额叶皮层)"] + User["用户"] -->|"自然语言/多模态输入"| Core["调度 Core
(前额叶皮层)"] + subgraph TensorLayer ["张量通信层 (Standard Tensor Protocol)"] + direction LR + TE["编码层
Encoder: 内部张量→标准张量"] + TD["解码层
Decoder: 标准张量→内部张量"] + end + subgraph Subnets ["四大子网"] - RCN["路由与压缩子网
(感觉中枢)"] - MEM["记忆子网
(海马体与皮层)"] - LTC["逻辑链路追踪神经网络
(推理回路)"] + RCN["路由与压缩子网
(感觉中枢)
多模态→标准张量"] + MEM["记忆子网
(海马体与皮层)
图DB+向量DB+文本"] + LTC["逻辑链路追踪
神经网络
(推理回路)"] LLM["LLM 子网
(布洛卡区/表达核)"] end - Cold["冷区存储
(原始数据)"] + Cold["冷区存储
原始数据"] - Core -->|"任务调度"| RCN - Core -->|"记忆存取"| MEM - Core -->|"推理验证"| LTC - Core -->|"表达输出"| LLM + Core -->|"启发式调度"| RCN + Core -->|"启发式调度"| MEM + Core -->|"启发式调度"| LTC + Core -->|"启发式调度|张量"| LLM + + RCN -.->|"标准张量"| Core + MEM -.->|"记忆检索张量"| Core + LTC -.->|"推理路径张量"| Core + LLM -.->|"表达验证张量"| Core + + LLM -->|"自然语言"| User - RCN -->|"压缩引用包"| Core - MEM -->|"检索记忆"| Core - LTC -->|"验证结果"| Core - LLM -->|"自然语言"| Core - - Core -->|"热数据"| Cold - Cold -->|"按需拉取"| Core - - RCN -.->|"引用-拉取"| MEM - RCN -.->|"引用-拉取"| LTC - RCN -.->|"引用-拉取"| LLM + Core -->|"记忆更新参数张量"| MEM + MEM -->|"读写"| Cold + + RCN -.-> Cold + LTC -.-> Cold ``` +## 通信机制：自定义张量协议 + +所有子网间不传递自然语言，而是通过**标准张量协议（Standard Tensor Protocol）**通信： + +``` +┌─────────────────────────────────────────────┐ +│ 标准张量 (Standard Tensor) │ +├─────────────────────────────────────────────┤ +│ Header: 源子网 · 目标子网 · 类型 · 时间戳 │ +│ Metadata: 维度 · 精度 · 压缩率 · 置信度 │ +│ Payload: 实际数据（向量/结构化数据） │ +│ Signature: SHA-256 校验 │ +└─────────────────────────────────────────────┘ +``` + +各模型通过**编码层（Encoder）**将内部张量转换为标准张量，通过**解码层（Decoder）**将标准张量还原为内部张量。 + +## 调度方式：启发式调度 + +Core 的调度不是线性流式的。每次收到数据包后： + +1. 解析输入 → 判断任务类型 +2. 调用记忆子网检索上下文 +3. 根据记忆结果决定：是否再次调用路由提取输入 → 送逻辑推理 → 再查记忆 → ... +4. 反复、多方式调用子网，逐步收敛到最终结果 +5. 将所有子网结果聚合，打包为记忆更新参数包 → 送记忆子网更新 + ## 四大子网概述 -| 子网 | 类比人脑 | 核心职责 | 关键技术 | +| 子网 | 类比人脑 | 核心职责 | 通信方式 | |------|---------|---------|---------| -| **路由与压缩子网** | 感觉中枢 | 多模态特征提取、信息压缩、引用包生成 | SimCLR/MoCo、知识蒸馏、AutoEncoder | -| **记忆子网** | 海马体与皮层 | 长期存储与检索、情景索引、知识图谱 | MANN、GNN、引用-拉取机制 | -| **逻辑链路追踪神经网络** | 推理回路 | 逻辑验证、错误追溯、路径重规划、自我修正 | RLHF + PRM、MCTS、错误案例数据集 | -| **LLM 子网** | 布洛卡区/表达核 | 结构化→自然语言、情感表达、多语言输出 | SFT、RLHF、多语言对齐 | +| **路由与压缩子网** | 感觉中枢 | 多模态特征提取、信息压缩、引用张量生成 | 标准张量 | +| **记忆子网** | 海马体与皮层 | 图数据库+向量数据库+文本三级记忆存储与检索 | 记忆检索张量 / 记忆更新参数张量 | +| **逻辑链路追踪神经网络** | 推理回路 | 逻辑验证、错误追溯、路径重规划、自我修正 | 推理路径张量 | +| **LLM 子网** | 布洛卡区/表达核 | 结构化→自然语言（给用户）+ 表达验证张量（给Core） | 表达验证张量 | ## 设计哲学 -### 🧠 认知解耦 —— 解决"幻觉"问题 +### 🧠 认知解耦 — 解决"幻觉"问题 传统单一 LLM 的幻觉根源：**知识存储与语言表达在同一网络中耦合**。NextAgent 将两者解耦： -- **记忆子网** 负责存储和检索事实知识 -- **LLM 子网** 只负责将结构化信息转换为自然语言 -- 两者通过 **引用包机制** 通信，LLM 子网从不"猜测"事实 +- **记忆子网** 负责存储和检索事实知识（图数据库 + 向量数据库） +- **逻辑推理子网** 负责验证推理链的正确性 +- **LLM 子网** 只负责将结构化信息转换为自然语言，**从不"猜测"事实** +- Core 收到 LLM 返回的**表达验证张量**来判断 LLM 是否正确表达了推理结果 -### ⚡ 效率与灵活性 —— 冷热数据分离 +### ⚡ 效率与灵活性 — 冷热数据分离 -- **热区（计算单元）**：只处理当前任务需要的活跃数据 -- **冷区（原始存储）**：全部原始数据以压缩格式存储 -- **引用-拉取机制**：子网间传递轻量级引用包，仅在需要时拉取完整数据 +- **热区（张量通信层）**：子网间传递轻量级张量，仅携带元数据和向量 +- **温区（图数据库）**：结构化知识图谱，支持 Cypher 查询 +- **冷区（原始存储）**：完整原始数据，按需拉取 + +### 🎯 LLM 下位化 + +LLM 不再是"全知怪物"，而是降级为专业的**语言生成引擎**： +- 知识来源：记忆子网 → 不依赖 LLM 自身参数知识 +- 逻辑来源：推理子网 → LLM 不负责推理 +- 输入：结构化推理路径张量 → 不是原始问题 ## 快速开始 ```bash # 克隆仓库 -git clone https://github.com/your-org/NextAgent.git +git clone ssh://git@jianfgit.xyz:220/jianf/NextAgent.git cd NextAgent -# 环境准备 -python -m venv venv -source venv/bin/activate - -# 安装依赖 -pip install -r requirements.txt - # 查看文档 # 架构总览：docs/architecture-overview.md # 子网细节：docs/routing-compression-subnet.md @@ -118,29 +158,43 @@ pip install -r requirements.txt NextAgent/ ├── README.md # 项目概述（本文件） ├── docs/ -│ ├── architecture-overview.md # 架构概览 +│ ├── architecture-overview.md # 架构总览（核心） │ ├── routing-compression-subnet.md # 路由与压缩子网 │ ├── memory-subnet.md # 记忆子网 │ ├── logic-trace-subnet.md # 逻辑链路追踪神经网络 │ └── llm-subnet.md # LLM 子网 ├── src/ │ ├── core/ # 调度 Core +│ │ ├── scheduler.py # 启发式调度引擎 +│ │ ├── task_parser.py # 任务解析器 +│ │ └── memory_aggregator.py # 记忆聚合器 +│ ├── protocol/ # 张量协议层 +│ │ ├── tensor_schema.py # 标准张量定义 +│ │ ├── encoder.py # 编码层 +│ │ └── decoder.py # 解码层 │ ├── subnets/ # 四大子网实现 -│ └── storage/ # 冷区存储 +│ │ ├── routing_compression/ # 路由与压缩子网 +│ │ ├── memory/ # 记忆子网（图DB+向量DB+文本） +│ │ ├── logic_trace/ # 逻辑链路追踪子网 +│ │ └── llm_expression/ # LLM 表达子网 +│ └── storage/ # 存储层 +│ ├── graph_db/ # Neo4j 图数据库客户端 +│ ├── vector_db/ # 向量数据库客户端 +│ └── text_store/ # 文本记忆存储 ├── tests/ # 测试套件 ├── config/ # 配置文件 -└── requirements.txt # Python 依赖 +└── requirements.txt # 依赖 ``` ## 文档索引 | 文档 | 内容 | |------|------| -| [架构概览](docs/architecture-overview.md) | 整体设计、调度 Core 职责、子网通信 | -| [路由与压缩子网](docs/routing-compression-subnet.md) | 多模态编码、训练计划、评估指标 | -| [记忆子网](docs/memory-subnet.md) | MANN、GNN、引用-拉取训练策略 | +| [架构总览](docs/architecture-overview.md) | 整体设计、张量协议、启发式调度、记忆更新机制 | +| [路由与压缩子网](docs/routing-compression-subnet.md) | 多模态编码、压缩训练、张量化训练 | +| [记忆子网](docs/memory-subnet.md) | 三级存储、图数据库设计、训练计划（参考 TrulyMEM） | | [逻辑链路追踪神经网络](docs/logic-trace-subnet.md) | RLHF+PRM、MCTS、自我修正训练 | -| [LLM 子网](docs/llm-subnet.md) | SFT、RLHF 微调、多语言对齐 | +| [LLM 子网](docs/llm-subnet.md) | 双输出通道、SFT/RLHF 微调、表达验证训练 | --- diff --git a/docs/architecture-overview.md b/docs/architecture-overview.md index 16f6c69..e8b3b3e 100644 --- a/docs/architecture-overview.md +++ b/docs/architecture-overview.md @@ -2,51 +2,296 @@ ## 整体架构设计 -NextAgent 采用 **认知解耦架构（Cognitive Decoupled Architecture）**，将传统单一 LLM 拆解为多个具有独立职能的子网，通过调度 Core 统一协调。每个子网类比人脑的一个功能区域，各司其职、协同工作。 +NextAgent 采用**认知解耦架构（Cognitive Decoupled Architecture）**，将传统单一 LLM 拆解为多个具有独立职能的子网，通过调度 Core 统一协调，子网间通过**标准张量协议**通信。 ### 设计原则 - **单一职责**：每个子网只负责一种认知功能，降低复杂度 -- **信息压缩**：子网间传递轻量级引用包而非原始数据 -- **冷热分离**：活跃数据在计算单元处理，原始数据存储在冷区 -- **可追溯**：每次推理决策都有完整的链路追踪记录 +- **张量通信**：子网间不传递自然语言，通过标准张量协议交换信息 +- **冷热分离**：活跃数据以张量形式在子网间传递，原始数据存储在冷区 +- **启发式调度**：Core 根据上下文动态决定调用顺序和方式，非线性执行 +- **LLM 下位化**：LLM 降级为专业语言生成引擎，知识与逻辑均外置 ### 架构分层 ``` -┌──────────────────────────────────────────────────────────────┐ -│ 应用层 │ -│ CLI / API / SDK / Web Interface / 第三方集成 │ -└──────────────────────┬───────────────────────────────────────┘ - │ -┌──────────────────────▼───────────────────────────────────────┐ -│ 调度 Core（前额叶皮层） │ -│ ┌────────────┐ ┌────────────┐ ┌────────────────────────┐ │ -│ │ 任务解析器 │ │ 调度引擎 │ │ 同步总线 │ │ -│ │ 拆解用户意图 │ │ 分配子任务 │ │ 子网间状态同步 │ │ -│ └────────────┘ └────────────┘ └────────────────────────┘ │ -└──────┬──────┬──────┬──────┬──────┬──────┬──────┬───────────┘ - │ │ │ │ │ │ │ -┌──────▼──┐ ┌─▼──────┐ ┌─▼──────┐ ┌─▼──────┐ ┌─▼──────────┐ -│ 路由与 │ │ 记忆 │ │ 逻辑链路 │ │ LLM │ │ 冷区存储 │ -│ 压缩子网 │ │ 子网 │ │ 追踪子网 │ │ 子网 │ │ (原始数据) │ -│(感觉中枢) │ │(海马体) │ │(推理回路)│ │(布洛卡) │ │ │ -└─────────┘ └────────┘ └────────┘ └────────┘ └────────────┘ +┌─────────────────────────────────────────────────────────────────┐ +│ 应用层 │ +│ CLI / API / SDK / Web Interface / 第三方集成 │ +└───────────────────────┬─────────────────────────────────────────┘ + │ +┌───────────────────────▼─────────────────────────────────────────┐ +│ 调度 Core（前额叶皮层） │ +│ ┌──────────────┐ ┌──────────────┐ ┌────────────────────────┐ │ +│ │ 任务解析器 │ │ 调度策略引擎 │ │ 记忆聚合器 │ │ +│ │ 拆解用户意图 │ │ 启发式调度规则 │ │ 汇总子网结果→记忆参数包 │ │ +│ └──────────────┘ └──────────────┘ └────────────────────────┘ │ +└──────┬──────┬──────┬──────┬──────┬──────┬───────────────────────┘ + │ │ │ │ │ │ + ▼ ▼ ▼ ▼ ▼ ▼ +┌─────────────────────────────────────────────────────────────────┐ +│ 张量通信层（核心创新） │ +│ ┌────────────────────────────────────────────────────────┐ │ +│ │ 标准张量 (Standard Tensor) │ │ +│ │ Header: 源/目标/类型/时间戳 | Payload: 数据 | Sig: 校验 │ │ +│ │ 各子网通过 编码层(Encoder) → 标准张量 → 解码层(Decoder) │ │ +│ └────────────────────────────────────────────────────────┘ │ +└──────┬──────┬──────┬──────┬──────┬──────┬───────────────────────┘ + │ │ │ │ │ │ +┌──────▼──┐ ┌─▼──────┐ ┌─▼──────┐ ┌─▼──────┐ ┌─▼────────────────┐ +│ 路由与 │ │ 记忆 │ │ 逻辑链路 │ │ LLM │ │ 存储层 │ +│ 压缩子网 │ │ 子网 │ │ 追踪子网 │ │ 子网 │ │ ┌────────────┐ │ +│(感觉中枢) │ │(海马体) │ │(推理回路)│ │(布洛卡) │ │ │ Neo4j 图DB │ │ +│ │ │ │ │ │ │ │ │ │ 向量数据库 │ │ +│ ViT │ │ Entity │ │ MCTS │ │ SFT │ │ │ 文本存储 │ │ +│ Wav2Vec │ │ 三元组 │ │ PRM │ │ RLHF │ │ └────────────┘ │ +│ BERT │ │ Cypher │ │ 路径追踪 │ │ 双输出 │ │ │ +└──────────┘ └─────────┘ └─────────┘ └─────────┘ └────────────────┘ +``` + +## 自定义张量协议（Standard Tensor Protocol） + +这是 NextAgent 的核心创新——子网间通过标准化的张量格式通信，不传递自然语言。 + +### 标准张量格式 + +```json +{ + "header": { + "source": "routing_compression | memory | logic_trace | llm | core", + "target": "routing_compression | memory | logic_trace | llm | core", + "tensor_type": "ref_tensor | memory_query | memory_result | reasoning_path | expression_verify | memory_update | control", + "timestamp": 1717200000, + "trace_id": "uuid-会话追踪ID" + }, + "metadata": { + "dimensions": [768, 128], // 张量维度 + "precision": "float32", // 精度类型 + "compression_ratio": 0.85, // 压缩率 + "confidence": 0.92, // 置信度 + "encoding_model": "transformer_v3" // 编码模型标识 + }, + "payload": { + "data": [0.12, -0.34, ...], // 实际数据（向量/结构化数据） + "indices": [1024, 2048, ...], // 冷区索引（可选） + "metadata_map": {} // 附加元数据 + }, + "signature": "sha256-checksum" // 完整性校验 +} +``` + +### 张量类型 + +| 张量类型 | 说明 | 发送方 → 接收方 | +|----------|------|----------------| +| `ref_tensor` | 引用张量，压缩后的多模态特征 | 路由子网 → Core | +| `memory_query` | 记忆查询张量 | Core → 记忆子网 | +| `memory_result` | 记忆检索结果张量 | 记忆子网 → Core | +| `reasoning_path` | 推理路径与验证结果张量 | 逻辑子网 → Core | +| `expression_verify` | 表达验证张量（含语义编码、置信度） | LLM 子网 → Core | +| `memory_update` | 记忆更新参数包张量 | Core → 记忆子网 | +| `control` | 控制信号张量（启停、参数调整） | Core → 任意子网 | + +### 编/解码机制 + +每个子网都配备编码层和解码层： + +``` +┌─────────────┐ ┌───────────────────┐ ┌─────────────┐ +│ 子网内部 │ ──→ │ 编码层 (Encoder) │ ──→ │ 标准张量 │ +│ 内部张量 │ │ 内部格式→标准格式 │ │ (通信格式) │ +└─────────────┘ └───────────────────┘ └─────────────┘ + │ + ▼ +┌─────────────┐ ┌───────────────────┐ ┌─────────────┐ +│ 子网内部 │ ←── │ 解码层 (Decoder) │ ←── │ 标准张量 │ +│ 内部张量 │ │ 标准格式→内部格式 │ │ (通信格式) │ +└─────────────┘ └───────────────────┘ └─────────────┘ ``` ## 调度 Core（前额叶皮层） -调度 Core 是整个架构的**总指挥**，类比人脑的前额叶皮层，负责高级认知功能。 +调度 Core 是整个架构的**总指挥**，类比人脑的前额叶皮层。 ### 核心职责 1. **任务解析**：接收用户输入，拆解为可执行的子任务序列 -2. **调度决策**：根据任务类型，决定调用哪些子网及调用顺序 -3. **信息同步**：维护子网间的共享上下文状态 -4. **冲突解决**：当子网返回矛盾结果时，启动仲裁机制 -5. **链路追踪**：记录完整的推理决策路径，支持回溯 +2. **启发式调度决策**：根据上下文动态决定调用子网的方式和顺序，非线性 +3. **子网结果聚合**：收集各子网返回的张量，综合分析 +4. **表达验证**：接收 LLM 返回的表达验证张量，判断输出质量 +5. **记忆聚合**：汇总各子网结果，打包为记忆更新参数包张量 +6. **冲突解决**：当子网返回矛盾结果时，启动仲裁机制 -### 工作流程 +### Core 内部组件 + +| 组件 | 职责 | +|------|------| +| **任务解析器 (Task Parser)** | 接收输入，拆解任务图 | +| **调度策略引擎 (Scheduler)** | 维护启发式调度规则，决定下一步调哪个子网 | +| **上下文管理器 (Context Manager)** | 维护会话状态和中间结果 | +| **表达验证器 (Expression Verifier)** | 接收 LLM 的表达验证张量，判断正确性 | +| **记忆聚合器 (Memory Aggregator)** | 汇总多子网结果，打包为记忆更新参数张量 | + +### 启发式调度流程（非流式！） + +Core 的调度不是线性管线式的。每次收到数据包后，会基于当前状态动态决策： + +``` +输入到达 + │ + ▼ +┌──────────────────┐ +│ 1. 任务解析 │ ── 拆解用户意图，生成初始任务图 +└──────┬───────────┘ + │ + ▼ +┌──────────────────┐ +│ 2. 调用记忆子网 │ ── "之前聊过这个吗？" +│ 查询上下文 │ 第一次记忆检索 +└──────┬───────────┘ + │ + ▼ +┌──────────────────┐ +│ 3. 启发式判断 │ ← 根据记忆结果决定下一步 +│ │ 有相关记忆？→ 送逻辑推理 + 可能再次调路由提取更多信息 +│ │ 无相关记忆？→ 调路由子网全面提取输入特征 +│ │ 输入不清晰？→ 再次调路由子网重新提取特征 +│ │ 需要更多背景？→ 再次调记忆子网深度检索 +│ │ 歧义？→ 多次调不同子网交叉验证 +└──────┬───────────┘ + │ + ▼ +┌──────────────────┐ +│ 4. 循环调度 │ ── 反复、多方式调用子网 +│ (可能多轮) │ 记忆→推理→记忆→路由→推理→... +└──────┬───────────┘ + │ + ▼ +┌──────────────────┐ +│ 5. 送 LLM 表达 │ ── 推理结果足够可靠后，送 LLM 生成自然语言 +│ + 接收验证张量 │ Core 收到表达验证张量 → 判断正确性 +└──────┬───────────┘ + │ + ▼ +┌──────────────────┐ +│ 6. 记忆聚合更新 │ ── 汇总本轮回所有子网结果 +│ │ 打包为 memory_update 张量 +│ │ 送记忆子网执行存储 +└──────────────────┘ +``` + +#### 启发式调度算法（简化伪代码） + +``` +function heuristic_process(input): + # 1. 任务解析 + task_graph = parse_task(input) + + # 2. 初始化调度状态 + state = { + "task": task_graph, + "context": {}, + "iteration": 0, + "confidence": 0.0, + "pending_signals": [] + } + + # 3. 启发式调度循环 + while not is_complete(state) and state.iteration < MAX_ITERATIONS: + next_action = scheduler.decide_next_action(state) + # decide_next_action 根据当前状态、历史结果、置信度动态决定 + # 可能调用：记忆查询、路由提取、逻辑推理、表达生成、记忆更新 + + if next_action.type == "memory_retrieve": + memory_tensor = memory_subnet.retrieve(next_action.params) + state.context["memory"] = memory_tensor + state.pending_signals.append(memory_tensor) + + elif next_action.type == "routing_extract": + ref_tensor = routing_subnet.extract(next_action.params) + state.context["refined_input"] = ref_tensor + + elif next_action.type == "logical_reason": + reasoning_tensor = logic_subnet.reason(state.context) + state.context["reasoning"] = reasoning_tensor + state.confidence = reasoning_tensor.metadata.confidence + + elif next_action.type == "llm_express": + verify_tensor = llm_subnet.express(state.context) + # verify_tensor 包含语义编码和置信度，非自然语言 + state.context["verification"] = verify_tensor + # 如果验证通过，置完成标记 + if verify_tensor.metadata.confidence > THRESHOLD: + state.verified = True + + # 4. 记忆聚合更新 + update_tensor = memory_aggregator.build_update_tensor(state) + memory_subnet.store(update_tensor) + + # 5. LLM 的自然语言已直接输出给用户 + return state.verified +``` + +## LLM 子网双输出通道 + +LLM 子网的输出有两个去向，这是核心设计之一： + +``` + ┌──────────────────────┐ + │ LLM 子网 │ + │ │ +输入：结构化推理路径张量 ──→ LLM 核心处理 + │ │ + ├── 通道1 ──────────────┤ + │ → 自然语言文本 │ ──→ 直接输出给用户 + │ │ + ├── 通道2 ──────────────┤ + │ → 表达验证张量 │ ──→ 返回给 Core + │ (包含：语义编码、 │ Core 分析验证张量 + │ 置信度、情感标记、 │ 判断 LLM 是否正确表达 + │ 表达结构元数据) │ 而非获取自然语言内容 + └──────────────────────┘ +``` + +**关键点**： +- Core **不通过自然语言判断** LLM 的输出质量 +- Core 通过分析**表达验证张量**（结构化数据）来判断 +- 自然语言直接流向用户，Core 不截获 + +## 记忆更新机制 + +记忆更新不是由子网单独完成，而是由 Core 聚合多子网结果后统一触发： + +``` +┌──────────┐ 路由子网结果张量 +│ 路由 │ ─────────────┐ +└──────────┘ │ + ├──┐ +┌──────────┐ 推理子网结果张量 │ │ +│ 推理 │ ─────────────┤ │ +└──────────┘ │ │ + │ ├── Core 记忆聚合器 ── 打包 ──→ 记忆更新参数张量 +┌──────────┐ 记忆子网交互结果 │ │ (MemoryAggregator) (MemoryUpdateTensor) +│ 记忆 │ ─────────────┤ │ +└──────────┘ │ │ + ├──┘ +┌──────────┐ Core 内部状态 │ +│ Core │ ─────────────┘ +└──────────┘ + + 记忆更新参数张量 ──→ 记忆子网 + │ + ├──→ 图数据库写入 (Neo4j) + │ (Entity + RELATES 三元组) + │ + ├──→ 向量索引更新 + │ (语义向量写入) + │ + └──→ 文本记忆记录 + (会话日志归档) +``` + +## 数据流完整链路（用户视角） ```mermaid sequenceDiagram @@ -57,146 +302,68 @@ sequenceDiagram participant LTC as 逻辑链路追踪子网 participant LLM as LLM 子网 - User->>Core: 用户输入/任务 - Core->>RCN: 1. 发送原始输入 + User->>Core: 自然语言/多模态输入 + + Core->>RCN: ① 路由提取（标准张量） RCN->>RCN: 特征提取与压缩 - RCN-->>Core: 返回引用包（RefPack） + RCN-->>Core: 返回引用张量 - Core->>MEM: 2. 携带引用包检索记忆 - MEM->>MEM: 搜索知识图谱与情景记忆 - MEM-->>Core: 返回关联记忆引用包 + Core->>MEM: ② 记忆检索（标准张量） + MEM->>MEM: 图数据库+向量检索 + MEM-->>Core: 返回记忆结果张量 - Core->>LTC: 3. 发送任务+记忆进行推理 - LTC->>LTC: MCTS 推理路径搜索 - LTC->>LTC: 逻辑验证与修正 - LTC-->>Core: 返回验证后的推理路径 + Note over Core: ③ 启发式判断
根据记忆结果决定下一步 - Core->>LLM: 4. 发送结构化推理结果 + alt 需要更多输入特征 + Core->>RCN: 再次调路由子网（携带记忆上下文） + RCN-->>Core: 返回更精确的引用张量 + else 需要深层记忆 + Core->>MEM: 二次记忆检索（携带路由新结果） + MEM-->>Core: 返回关联记忆张量 + end + + Core->>LTC: ④ 逻辑推理（标准张量） + LTC->>LTC: MCTS推理路径搜索+验证 + LTC-->>Core: 返回推理路径张量 + + alt 推理置信度低 + Core->>LTC: ⑤ 携带更多上下文重新推理 + LTC-->>Core: 返回修正后的推理路径 + end + + Core->>LLM: ⑥ 表达生成（推理路径张量） LLM->>LLM: 结构化→自然语言转换 - LLM-->>Core: 返回自然语言输出 - Core->>MEM: 5. 更新记忆（本次交互记录） - Core-->>User: 返回最终结果 -``` - -### 调度算法伪代码 - -``` -function process(input): - # 1. 任务解析 - task_graph = parse_task(input) + LLM-->>User: ⑦ 自然语言输出（直接给用户） + LLM-->>Core: ⑧ 表达验证张量（判断正确性） - # 2. 逐节点执行 - for node in topological_sort(task_graph): - # 2a. 路由与压缩 - refpack = routing_subnet.compress(node.input) - - # 2b. 记忆检索 - memories = memory_subnet.retrieve(refpack) - - # 2c. 逻辑推理 - reasoning_path = logic_subnet.reason(refpack, memories) - - # 2d. 若需语言输出 - if node.requires_language: - output = llm_subnet.express(reasoning_path) - else: - output = reasoning_path + Note over Core: ⑨ 表达验证通过 - # 3. 记忆更新 - memory_subnet.store(interaction_record) - - return output -``` - -## 子网间通信机制 - -### 引用包（RefPack）协议 - -所有子网间通信通过 **引用包（Reference Package）** 完成。引用包是一种轻量级的数据结构，包含： - -```json -{ - "refpack_id": "uuid-xxxx", - "type": "compressed_feature | memory_chunk | reasoning_path | expression", - "metadata": { - "source_subnet": "routing_compression", - "target_subnet": "memory", - "timestamp": 1717200000, - "compression_ratio": 0.85, - "confidence": 0.92 - }, - "payload": { - "dim": 768, - "data": [0.12, -0.34, ...], // 压缩向量或结构化数据 - "indices": [1024, 2048, ...] // 冷区索引（可选） - }, - "signature": "sha256-checksum" -} -``` - -### 引用-拉取机制 - -1. **引用阶段**：发送方生成轻量级引用包（通常 1-10 KB） -2. **路由阶段**：调度 Core 将引用包分发到目标子网 -3. **拉取阶段**：目标子网根据引用包中的索引，按需从冷区拉取完整数据 -4. **缓存阶段**：热区缓存常用数据，减少冷区访问频率 - -```mermaid -graph LR - A["发送方子网"] -->|"1. 生成引用包"| B["引用包 (1-10KB)"] - B -->|"2. 调度 Core 分发"| C["目标子网"] - C -->|"3. 按需拉取"| D["冷区存储"] - D -->|"4. 返回完整数据"| C - C -->|"5. 缓存热数据"| E["热区缓存"] -``` - -## 数据流 - -```mermaid -flowchart TD - Input["用户输入/多模态数据"] -->|"原始数据"| RCN["路由与压缩子网"] - RCN -->|"引用包"| Core["调度 Core"] - - Core -->|"记忆查询"| MEM["记忆子网"] - MEM -->|"记忆引用包"| Core - - Core -->|"推理请求"| LTC["逻辑链路追踪子网"] - LTC -->|"推理路径"| Core - - Core -->|"表达请求"| LLM["LLM 子网"] - LLM -->|"自然语言"| Core - - Core -->|"冷存储"| Cold["冷区存储"] - Cold -->|"按需拉取"| Core - - RCN -.->|"引用包索引"| Cold - MEM -.->|"批量拉取"| Cold - - Core -->|"最终输出"| Output["用户结果"] - - style Input fill:#e1f5fe - style Output fill:#e8f5e9 - style Core fill:#fff3e0,stroke:#ff9800,stroke-width:3px - style Cold fill:#f3e5f5 + Core->>MEM: ⑩ 记忆更新（参数包张量） + MEM->>MEM: 图DB写入+向量索引更新+文本记录 ``` ## 关键设计决策 | 决策 | 选择 | 理由 | |------|------|------| -| 子网间通信协议 | 引用包（RefPack） | 轻量级、低延迟、支持异步 | -| 冷区存储格式 | 压缩向量 + 倒排索引 | 高压缩率、快速模糊检索 | -| 调度策略 | 有向无环图（DAG）调度 | 支持并行执行与依赖管理 | -| 错误处理 | 三级降级（重试→降级→报错） | 保证系统鲁棒性 | -| 状态同步 | 事件驱动 + 共享内存 | 低延迟、去中心化 | +| 子网间通信方式 | 标准张量协议 | 不依赖自然语言，结构化、可验证、低延迟 | +| 调度策略 | 启发式调度 | 灵活、适应复杂任务，非固定管线 | +| LLM 输出机制 | 双通道（自然语言→用户 / 张量→Core） | 解耦表达与验证 | +| 记忆存储 | 图数据库(Neo4j) + 向量数据库 + 文本 | 结构化 + 语义 + 时序 三保险 | +| 记忆更新触发 | Core 聚合后统一封装 | 确保记忆一致性，避免碎片化写入 | +| LLM 定位 | 专业语言生成引擎 | 不存储知识、不负责推理 | ## 与现有架构对比 | 特性 | 传统单一 LLM | Agent + 工具调用 | NextAgent（认知解耦） | |------|-------------|----------------|-------------------| -| 知识存储 | 模型参数内隐式存储 | 外部工具/数据库 | 专用记忆子网 | +| 知识存储 | 模型参数内隐式存储 | 外部工具/数据库 | 专用记忆子网（图+向量+文本） | | 推理能力 | 隐式（端到端） | 提示工程驱动 | 专用推理子网 + MCTS | -| 幻觉控制 | 无专门机制 | 工具结果覆盖 | 知识-表达解耦，根本上杜绝 | -| 可解释性 | 低（黑箱） | 中（可追踪工具调用） | 高（完整推理链路） | -| 计算效率 | 每次推理全模型参与 | 按需调用工具 | 冷热分离，仅热数据参与计算 | +| 子网通信 | 自然语言 | 自然语言/JSON | **结构化张量协议** | +| 调度方式 | 线性执行 | 线性工具链 | **启发式、非线性的循环调度** | +| LLM 定位 | 全知全能 | 主控+生成 | **降级为语言生成引擎** | +| 输出验证 | 无 | 无 | **表达验证张量机制** | +| 记忆更新 | 上下文窗口 | 外部DB写入 | **Core聚合后统一打包更新** | +| 幻觉控制 | 无专门机制 | 工具结果覆盖 | 知识/推理/表达完全解耦 | +| 可解释性 | 低（黑箱） | 中（可追踪工具调用） | 高（完整张量链路追踪） | diff --git a/docs/llm-subnet.md b/docs/llm-subnet.md index d8402d7..b6e412e 100644 --- a/docs/llm-subnet.md +++ b/docs/llm-subnet.md @@ -1,312 +1,365 @@ -# LLM 子网（布洛卡区/表达核） +# LLM 子网 — 训练目标与训练计划 ## 概述 -LLM 子网类比人脑的**布洛卡区（Broca's Area）**——大脑中负责语言表达的关键区域。在 NextAgent 架构中，LLM 子网是**唯一与自然语言打交道的组件**，负责将子网间流转的结构化信息转换为人类可读的自然语言输出。 +LLM 子网类比人脑的**布洛卡区（表达核）**，是 NextAgent 架构中**唯一直接与用户交互**的组件。在认知解耦架构下，LLM 不再是"全知怪物"，而是降级为专业的**语言生成引擎**：知识来源外置到记忆子网，逻辑推理外置到推理子网，LLM 仅负责将结构化的推理结果转换为自然语言。 -### 核心设计哲学 +### 核心设计：LLM 下位化 -**知识存储与语言表达分离**：LLM 子网本身不存储事实知识，它只负责"表达"。所有事实知识来自记忆子网和推理子网的引用包。这一设计从根本上杜绝了 LLM 子网产生"幻觉"的可能性——它不"知道"任何事，它只"表达"收到的结构化信息。 +``` +传统 LLM： +┌────────────────────────────────────────────────────────┐ +│ LLM │ +│ 知识存储(参数内) │ 逻辑推理(隐式) │ 语言生成 │ 编码 │ +│ 全部在同一个模型中耦合 │ +└────────────────────────────────────────────────────────┘ + ↓ 认知解耦 +NextAgent LLM 子网： +┌────────────────────────────────────────────────────────┐ +│ LLM 子网（表达专用） │ +│ 输入：结构化推理路径张量（Core 提供） │ +│ 知识：来自记忆子网（非自身参数） │ +│ 逻辑：来自推理子网（非自身推理） │ +│ 功能：仅做结构化→自然语言的精确转换 + 表达验证张量输出 │ +└────────────────────────────────────────────────────────┘ +``` -### 核心职责 +### 双输出通道 -- **结构化→自然语言转换**：将推理路径、记忆片段等结构化数据转化为流畅的自然语言 -- **情感表达**：根据上下文和用户情感状态，调整输出的语气和情感色彩 -- **多语言输出**：支持中、英、日、韩、法、德等多语言的表达 -- **风格适配**：根据应用场景（正式、友好、专业、通俗）适配语言风格 -- **输出格式化**：支持 Markdown、JSON、表格、列表等多种输出格式 +这是 LLM 子网最核心的设计： -## 架构设计 +``` + ┌──────────────────────┐ + │ LLM 子网 │ + │ │ + 推理路径张量 ──────→ │ 张量解码层 │ + (来自 Core) │ (标准→内部) │ + │ │ │ + │ ▼ │ + │ ┌──────────────┐ │ + │ │ LLM 核心 │ │ + │ │ 语言生成模型 │ │ + │ └──────┬───────┘ │ + │ │ │ + │ ┌────┴────┐ │ + │ │ │ │ + │ ▼ ▼ │ + │ 通道1 通道2 │ + │ 自然语言 表达验证 │ + │ 文本 张量 │ + │ │ │ │ + │ │ │ │ + └────┼─────────┼────────┘ + │ │ + ▼ ▼ + 用户 → 调度 Core + (最终输出) (验证正确性) +``` -```mermaid -graph TB - Input["结构化输入
(推理路径 + 记忆引用包)"] --> Decoder["结构化解码器"] - - Decoder --> Intent["意图与情感分析器"] - - Intent --> StyleRouter["风格路由器"] - - StyleRouter -->|"正式"| Formal["正式表达分支"] - StyleRouter -->|"友好"| Friendly["友好表达分支"] - StyleRouter -->|"专业"| Professional["专业表达分支"] - StyleRouter -->|"通俗"| Simple["通俗表达分支"] - - Formal --> Generator["语言生成器
Causal LM"] - Friendly --> Generator - Professional --> Generator - Simple --> Generator - - Generator --> Format["格式处理器"] - Format --> Output["自然语言输出"] - - subgraph Controls ["控制组件"] - LangCtrl["语言控制
(LangID)"] - ToneCtrl["语气控制
(Prompt Tuning)"] - FactCtrl["事实一致性检查
(对照源引用包)"] - end - - Generator -.-> LangCtrl - Generator -.-> ToneCtrl - Generator -.-> FactCtrl - - subgraph Training ["训练管线"] - SFT["指令微调
(SFT)"] - RLHF["人类反馈强化学习
(RLHF)"] - MulAlign["多语言对齐
(Cross-lingual Alignment)"] - end - - SFT --> RLHF - RLHF --> MulAlign +**通道1 — 自然语言 → 用户**： +- 流畅、准确、有情感的自然语言输出 +- 用户直接看到这部分 + +**通道2 — 表达验证张量 → Core**： +- 不包含自然语言文本 +- 包含：语义编码向量、置信度分数、情感标记、表达结构元数据 +- Core 通过分析此张量判断 LLM 是否正确表达了推理结果 +- Core **不通过自然语言判断**输出质量 + +### 输入/输出 + +| 项目 | 说明 | +|------|------| +| **输入** | 结构化推理路径张量（来自 Core，经过张量解码层转换） | +| **输出1** | 自然语言文本（直接发送给用户） | +| **输出2** | 表达验证张量（发送给 Core） | +| **输出2格式** | 标准张量协议，tensor_type=`expression_verify` | + +### 表达验证张量格式 + +```json +{ + "header": { + "source": "llm", + "target": "core", + "tensor_type": "expression_verify", + "trace_id": "trace-uuid", + "timestamp": 1717200000 + }, + "metadata": { + "confidence": 0.94, + "semantic_encoding_dim": 768, + "expression_structure": "sentence+paragraph", + "sentiment": "positive", + "language": "zh-CN", + "token_count": 128, + "verification_status": "verified" + }, + "payload": { + "semantic_encoding": [0.23, -0.56, ...], // 输出文本的语义向量 + "intention_alignment": 0.96, // 与输入推理路径的意图对齐度 + "factual_consistency": 0.92, // 与输入事实的一致性 + "sentence_embeddings": [ // 每句的编码（可选） + {"index": 0, "embedding": [...]}, + {"index": 1, "embedding": [...]} + ], + "emotion_vector": [0.1, 0.8, 0.3, ...], // 情感多维度向量 + "key_entities_preserved": ["天气", "北京", "今天"], // 关键实体保留 + "omission_detected": false // 是否有遗漏信息 + }, + "signature": "sha256-checksum" +} +``` + +## 子网内部架构 + +``` +┌──────────────────────────────────────────────────────────────┐ +│ LLM 子网 内部架构 │ +│ │ +│ 推理路径张量 ──→ ┌────────────────────────────────────┐ │ +│ (来自 Core) │ 1. 张量解码层 (Tensor Decoder) │ │ +│ │ 标准张量 → 内部结构化数据 │ │ +│ └──────────────────┬─────────────────────┘ │ +│ │ │ +│ ┌──────────────────▼─────────────────────┐ │ +│ │ 2. 输入适配器 (Input Adapter) │ │ +│ │ 将推理路径转换为 LLM 适配的提示模板 │ │ +│ │ 插入指令前缀和系统提示 │ │ +│ │ 格式：系统提示 + 推理路径描述 + 格式约束 │ │ +│ └──────────────────┬─────────────────────┘ │ +│ │ │ +│ ┌──────────────────▼─────────────────────┐ │ +│ │ 3. LLM 核心 (语言生成模型) │ │ +│ │ │ │ +│ │ 模型选项： │ │ +│ │ - Llama 3 (7B/70B) │ │ +│ │ - Qwen 2.5 (7B/72B) │ │ +│ │ - DeepSeek-V3 │ │ +│ │ │ │ +│ │ 生成参数：temperature=0.7, top_p=0.9 │ │ +│ └──────────────────┬─────────────────────┘ │ +│ │ │ +│ ┌──────────────────┴──────────────────┐ │ +│ │ │ │ +│ ▼ ▼ │ +│ ┌──────────────────────────┐ ┌──────────────────────────┐ │ +│ │ 4a. 输出适配器 (通道1) │ │ 4b. 表达编码器 (通道2) │ │ +│ │ (Output Adapter) │ │ (Expression Encoder) │ │ +│ │ │ │ │ │ +│ │ 后处理： │ │ 语义编码提取 │ │ +│ │ - 格式规范化 │ │ 意图对齐度计算 │ │ +│ │ - 长度裁剪 │ │ 事实一致性验证 │ │ +│ │ - 特殊标记移除 │ │ 情感分析 │ │ +│ │ - 情感调整 │ │ 关键实体保全面核查 │ │ +│ └────────────┬─────────────┘ └────────────┬─────────────┘ │ +│ │ │ │ +└───────────────┼──────────────────────────────┼──────────────────┘ + │ │ + ▼ ▼ + 自然语言文本 表达验证张量 + (→ 用户) (→ 调度 Core) ``` ## 训练目标 -### 目标 1：结构化信息到自然语言的转换 +### 目标 1：结构化到自然语言的精准转换 -训练模型将结构化输入（JSON 格式的推理路径、知识图谱片段、逻辑链）转换为高质量的自然语言。 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 信息保留率 | ≥ 98% | 输入推理路径中的信息全部体现在输出中 | +| 忠实度 F1 | ≥ 95% | 输出与输入事实之间的一致性 | +| 幻觉率 | ≤ 1% | 输出中包含输入中没有的信息的比例 | +| 歧义解析准确率 | ≥ 90% | 对推理路径中的歧义点的正确处理 | -- **信息保真度**：输出内容与输入结构化信息的一致性 ≥ 95% -- **完整度**：输入中的关键信息点 100% 体现在输出中 -- **简明度**：在不丢失信息的前提下，输出长度 ≤ 推理路径长度的 3 倍 +### 目标 2：情感表达与语气控制 -### 目标 2：情感表达 - -训练模型根据用户情感状态和上下文，调节输出的情感色彩。 - -- **情感一致性**：输出情感与用户期望情感的匹配度 ≥ 85% -- **情感粒度**：支持 8 种基本情感（喜、怒、哀、惧、惊、厌、盼、信）及其复合情感 -- **情感调节**：在信息传递准确的前提下，情感表达不影响事实信息 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 情感一致性 | ≥ 85% | 输出情感与推理路径中指定的情感一致 | +| 语气多样度 | 至少 5 种 | 正式/友好/专业/热情/简洁等 | +| 人设匹配度 | ≥ 90% | 输出风格与记忆子网中的人设一致 | ### 目标 3：多语言输出 -训练模型在保持语义不变的前提下，输出多种语言。 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 中文流畅度 | BLEU ≥ 40 | 中文生成的自然度 | +| 英文流畅度 | BLEU ≥ 35 | 英文生成的自然度 | +| 语言切换准确率 | ≥ 98% | 按输入要求切换到指定语言 | +| 专业术语翻译 | ≥ 90% | 技术术语的准确翻译 | -- **支持语言**：中文、英语、日语、韩语、法语、德语、西班牙语、阿拉伯语 -- **翻译质量**：跨语言语义保留 BLEU ≥ 35，COMET ≥ 0.8 -- **语言切换**：支持单次输出中的语言切换（如中英混杂） +### 目标 4：表达验证张量准确性 + +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 语义编码对齐度 | cosine ≥ 0.95 | 编码向量与输出文本的语义匹配 | +| 置信度校准 | ECE ≤ 0.05 | 预测置信度与实际准确率的一致性 | +| 遗漏检测召回率 | ≥ 95% | 能检测出输出中遗漏了关键信息 | +| 情感分类准确率 | ≥ 90% | 情感分析的准确度 | ## 训练计划 -### 阶段 1：指令微调（Supervised Fine-Tuning, SFT） +### 阶段 1：指令微调 (SFT) — 结构化输入转译 -**目标**：使用高质量的"结构化输入 → 自然语言输出"配对数据，对基座模型进行指令微调。 +**目标**：训练 LLM 将结构化推理路径精确转换为自然语言 -#### 基座模型选择 +**技术路线**： +- 构建 (推理路径张量 → 自然语言) 的配对数据集 +- 使用 LoRA 微调开源 LLM -| 模型 | 参数量 | 优势 | 适用场景 | -|------|--------|------|---------| -| Qwen2.5-7B 或同等 | 7B | 中文能力突出、推理效率高 | 主推模型 | -| LLaMA-3.1-8B | 8B | 英文能力突出、生态完善 | 英文场景 | +**训练数据集构建**： +1. 从 GSM8K / MATH / HotpotQA 等推理数据集中提取推理链 +2. 将推理链格式化为 NextAgent 标准推理路径格式 +3. 由人工标注对应的自然语言输出 +4. 数据规模：至少 100K 条配对 -#### 训练数据 - -1. **结构化→自然语言配对数据** - -| 数据类型 | 输入 | 输出 | 规模 | -|---------|------|------|------| -| 推理路径转文字 | JSON 推理链 | 自然语言解释 | 100,000 | -| 知识图谱转叙述 | 三元组集合 | 流畅段落 | 80,000 | -| 记忆片段转回答 | 检索到的记忆 | 回答用户 | 120,000 | -| 逻辑链路转报告 | 推理过程 | 分析报告 | 50,000 | - -2. **数据生成流程** - -``` -原始问题 → 调度 Core 生成结构化推理路径 → 人工标注员写出参考输出 - -结构化输入示例： +**数据示例**： +```json { - "task": "解释光合作用的过程", - "reasoning_path": [ - {"step": 1, "content": "光合作用发生在叶绿体中", "source": "memory:biology/chapter_5"}, - {"step": 2, "content": "需要叶绿素、光、CO₂、H₂O", "source": "memory:biology/chapter_5"}, - {"step": 3, "content": "光反应阶段：光能→ATP+NADPH", "source": "logic:verified"}, - {"step": 4, "content": "暗反应阶段（Calvin循环）：CO₂→葡萄糖", "source": "logic:verified"}, - {"step": 5, "conclusion": "光合作用将光能转化为化学能", "source": "reasoning:deduction"} - ], - "language": "zh", - "tone": "educational" + "input": { + "reasoning_steps": [ + {"step": 1, "type": "fact_extraction", "content": "用户问北京今天天气"}, + {"step": 2, "type": "context_retrieval", "content": "记忆子网查到用户偏好空气质量"}, + {"step": 3, "type": "conclusion", "content": "北京今天晴，AQI 45，空气质量优"} + ], + "persona": "友好专业", + "language": "zh-CN" + }, + "output": "北京今天天气晴好，空气质量为优（AQI 45），很适合外出活动！" } ``` -#### 训练配置 +**训练步骤**： +1. 构建输入模板：[系统提示] + [推理路径描述] + [格式约束] +2. 使用 LoRA rank=64, alpha=128 进行微调 +3. 训练 3 epochs, batch size 64, learning rate 1e-4 +4. 评估：信息保留率、忠实度 F1 -- **输入格式**：`<|struct|>{结构化信息}<|output|>` -- **损失函数**：自回归语言建模（交叉熵） -- **批大小**：128（梯度累积 8 步） -- **优化器**：AdamW（β1=0.9, β2=0.95） -- **学习率**：1e-5，余弦退火至 1e-6 -- **warmup**：500 steps -- **权重衰减**：0.01 -- **梯度裁剪**：max_norm = 1.0 -- **训练轮数**：3 epochs（SFT 数据量充足，防止过拟合） -- **LoRA 配置**（如使用全参微调资源不足）： - - r = 64, α = 128, dropout = 0.05 - - 目标模块：q_proj, k_proj, v_proj, o_proj, gate_proj +### 阶段 2：RLHF — 优化表达自然度 -### 阶段 2：人类反馈强化学习（RLHF） +**目标**：使用人类反馈优化表达的自然度和情感一致性 -**目标**：通过人类偏好反馈，优化表达的自然度、流畅度和信息呈现方式的优劣。 +**技术路线**： +- 收集人类偏好数据 +- 训练 Reward Model +- PPO 强化学习 -#### 奖励模型训练 +**训练步骤**： +1. **收集偏好数据**： + - 从阶段1的模型生成多条 output 候选 + - 人工标注偏好（哪条更自然、更准确、情感更恰当） + - 收集 50K 对偏好数据 -- **模型架构**：基于 SFT 模型，移除语言头，添加线性奖励头 -- **训练数据**： +2. **训练 Reward Model**： + - 基于 Llama / Qwen 训练分类头 + - 输入：推理路径 + 生成文本 + - 输出：质量评分（1-5分） + - 训练 2 epochs -| 来源 | 类型 | 规模 | -|------|------|------| -| 人工标注 | 对同一输入的不同输出进行偏好排序 | 50,000 对 | -| 自动评估 | 使用 GPT-4/Claude 作为评估者 | 200,000 对 | -| 红队测试 | 对抗样本的偏好标注 | 10,000 对 | - -- **标注维度**： - -| 维度 | 评分范围 | 说明 | -|------|---------|------| -| 信息准确度 | 1-5 | 与结构化输入的一致性 | -| 自然度 | 1-5 | 读起来像人写的 | -| 完整度 | 1-5 | 关键信息是否全部覆盖 | -| 简洁度 | 1-5 | 在信息完整下是否简洁 | -| 情感适配 | 1-5 | 语气是否符合作者期望 | - -- **损失函数**：Bradley-Terry + 维度加权 - ``` - L = -E[Σ w_d · log(σ(r_d_better - r_d_worse))] - w = [0.4, 0.3, 0.15, 0.1, 0.05] # 各维度权重 - ``` - -- **训练配置**： - - 学习率：1e-5 - - 批大小：64 - - 训练轮数：3 epochs - -#### PPO 训练 - -- **策略模型**：SFT 模型 -- **价值模型**：与策略模型共享基座 + 价值头 -- **KL 散度惩罚**：β = 0.04 -- **GAE λ**：0.95 -- **折扣因子 γ**：0.99 -- **学习率**：1e-6（策略），1e-5（价值） -- **PPO clip**：ε = 0.2 -- **批大小**：256 -- **总 PPO 轮次**：200（每轮采样 1024 条） -- **句子级奖励**：使用 PRM 对每句话评分，而非仅整段评分 +3. **PPO 训练**： + - 使用阶段1的 SFT 模型初始化策略网络 + - Reward Model 提供奖励信号 + - 加入 KL 散度惩罚防止偏离基座 + - 训练 30K steps ### 阶段 3：多语言对齐训练 -**目标**：扩展模型的多语言表达能力和跨语言一致性。 +**目标**：扩展多语言输出能力 -#### 训练数据 +**训练步骤**： +1. 收集多语言配对数据（中/英/日/韩/法/德） +2. 使用课程学习（Curriculum Learning）： + - 阶段 A：英语 → 中文（最高优先级） + - 阶段 B：中文 → 其他主要语言 + - 阶段 C：所有语言混合训练 +3. 评估各语言 BLEU 分数 +4. 重点优化低资源语言 -| 语言 | 对齐数据规模 | 来源 | -|------|------------|------| -| 中文 | 200,000 | 自建 + 翻译 | -| 英语 | 200,000 | 自建 + 翻译 | -| 日语 | 100,000 | 翻译 + 人工校对 | -| 韩语 | 100,000 | 翻译 + 人工校对 | -| 法语 | 100,000 | 翻译 + 人工校对 | -| 德语 | 100,000 | 翻译 + 人工校对 | -| 西班牙语 | 100,000 | 翻译 + 人工校对 | -| 阿拉伯语 | 50,000 | 翻译 + 人工校对 | +### 阶段 4：表达验证张量输出训练 -#### 对齐方法 +**目标**：训练 LLM 同时输出表达验证张量 -1. **平行语料监督学习** - - 同一结构化输入对应多语言的 GT 输出 - - 训练模型在不同语言分支上输出语义一致的内容 +**技术路线**： +- 在 LLM 基础上添加额外的输出头（Verification Head） +- 训练 LLM 在生成文本的同时，计算表达验证特征 -2. **跨语言对比学习** - - 正样本对：同一结构化输入的不同语言输出 - - 负样本对：不同结构化输入的同语言输出 - - 损失函数：InfoNCE，温度 τ = 0.07 +**训练步骤**： +1. **构建验证数据集**： + - 对于每条训练样本，计算： + a. 输出文本的语义编码（使用 Sentence-BERT） + b. 输出与输入的意图对齐度 + c. 关键实体保留情况 + d. 情感标签 + - 作为监督信号 -3. **反向翻译一致性** - - 模型输出 A 语言 → 翻译为 B 语言 → 模型输出从 A→B - - 要求 A 语言输出和 B 语言输出语义一致 - - 一致性损失：余弦相似度(语义嵌入(输出_A), 语义嵌入(输出_B)) +2. **添加验证输出头**： + - 在 LLM 的最后一层添加 MLP 头 + - 输入：LLM 的隐藏状态 + - 输出：语义编码向量 + 置信度标量 + 情感向量 -4. **语言自适应层** - - 为每种语言添加可训练的 LayerNorm + 偏置（Adapter 风格） - - 共享语言无关的参数 + 语言特定的适配层 - - 参数量：每种语言 +5M（极小开销） +3. **联合训练**： + - 损失函数：L = L_language + α * L_verification + β * L_alignment + - L_language: 文本生成交叉熵损失 + - L_verification: 验证输出的 MSE 损失 + - L_alignment: 意图对齐度的对比损失 -#### 训练配置 +4. **训练 2 epochs** +5. **评估**：ECE 校准误差、语义编码对齐度 -- **阶段 3a（平行语料训练）**：3 epochs，LR=5e-6 -- **阶段 3b（对比学习）**：2 epochs，LR=3e-6 -- **阶段 3c（一致性训练）**：2 epochs，LR=3e-6 -- **总轮数**：7 epochs +### 阶段 5：人设适应训练 -### 阶段 4：事实一致性对齐 +**目标**：训练 LLM 根据人设张量调整表达风格 -**目标**：确保 LLM 子网严格依据输入的结构化信息生成输出，不添加、不遗漏、不改动事实。 +**训练步骤**： +1. 构建人设-表达配对数据集： + - 同一推理路径 → 不同人设下的不同表达 + - 示例： + - 人设"猫娘"：通过三元组编码输入 + - 人设"专业助手"：同上 +2. 在人设条件下微调 LLM +3. 评估：人设匹配度人类评分 -#### 训练方法 +## 评估指标体系 -1. **负采样对抗训练** - - 故意在结构化输入中植入与常见知识矛盾的信息 - - 如果模型依赖"固有知识"而非输入结构信息，则产生错误 - - 训练模型学会"忽略固有知识，只遵循输入" +### 离线评估 -2. **事实对比损失** - - 在输出层添加事实一致性评分头 - - 计算输出中每个实体/关系与输入结构化信息的匹配度 - - 损失函数：Focal Loss（处理事实类不平衡） +| 指标 | 计算方法 | 目标 | +|------|----------|------| +| 信息保留率 | 输入关键实体在输出中出现的比例 | ≥ 98% | +| 忠实度 F1 | 输出与输入事实的一致性 | ≥ 95% | +| 幻觉率 | 输出中新增信息占输出的比例 | ≤ 1% | +| BLEU (中文) | 中文生成自然度 | ≥ 40 | +| BLEU (英文) | 英文生成自然度 | ≥ 35 | +| ECE 校准误差 | 预测置信度校准 | ≤ 0.05 | -3. **约束解码** - - 推理阶段使用受限 Beam Search - - 约束条件：输出必须包含输入中的所有关键信息点 - - 惩罚项：缺失信息点数量 × 0.1 +### 在线评估（与 Core 集成后） -#### 评估配置 +| 指标 | 说明 | +|------|------| +| Core 表达验证通过率 | Core 接收表达验证张量后判定为"正确表达"的比例 | +| 用户满意度 | 用户对自然语言输出的评分 | +| 重生成频率 | Core 因验证不通过而要求 LLM 重新生成的比例 | +| 端到端幻觉率 | 用户感知到的最终输出中的错误信息比例 | -- 测试集：5,000 条包含事实冲突的结构化输入 -- 期望行为：模型严格按输入生成，不引入外部知识 -- 目标值：事实一致性 ≥ 98% +## 技术难点与对策 -## 评估指标 +| 难点 | 对策 | +|------|------| +| 结构化输入理解 | 设计专门的输入适配器，将张量转为LLM可理解的格式 | +| 严格约束下的自然度 | 温度采样+重复惩罚+语感奖励 | +| 多语言一致性 | 课程学习 + 回译增强 | +| 验证张量质量 | 独立验证头 + 自监督一致性训练 | +| 人设切换 | 人设编码向量条件注入 | -### 表达准确度 +## 与传统 LLM 的关键区别 -| 指标 | 定义 | 目标值 | -|------|------|--------| -| 信息保真度 | 输出与输入结构化信息的一致性 | ≥ 95% | -| 实体准确率 | 输出中实体的正确率 | ≥ 98% | -| 关系准确率 | 输出中关系描述的正确率 | ≥ 95% | -| 事实幻觉率 | 输出来源非输入中信息的比例 | ≤ 2% | - -### 自然度评分 - -| 指标 | 定义 | 目标值 | -|------|------|--------| -| 人工评分（5 分制） | 标注员对输出自然度的评分 | ≥ 4.2 | -| GPT-4 评分（5 分制） | 大模型评估的自然度评分 | ≥ 4.0 | -| Perplexity | 语言模型的困惑度 | ≤ 15 | -| 平均句长标准差 | 句子长度的多样性指标 | ≥ 5 | - -### 情感一致性 - -| 指标 | 定义 | 目标值 | -|------|------|--------| -| 情感匹配度 | 输出情感与目标情感的匹配度 | ≥ 85% | -| 情感误判率 | 产生与目标相反情感的比率 | ≤ 3% | -| 情感粒度 F1 | 复合情感识别的 F1 | ≥ 0.75 | - -### 多语言能力 - -| 指标 | 定义 | 目标值 | -|------|------|--------| -| BLEU | 各语言的 BLEU 分数加权平均 | ≥ 35 | -| COMET | 跨语言语义保留评分 | ≥ 0.80 | -| 跨语言一致性 | 不同语言输出的语义相似度 | ≥ 0.90 | -| 语言切换准确率 | 中英混杂场景的语言切换正确率 | ≥ 90% | - -### 系统性能 - -| 指标 | 定义 | 目标值 | -|------|------|--------| -| 生成延迟（首 token） | 从输入到首个输出 token | ≤ 200ms | -| 生成吞吐量 | tokens/second | ≥ 50 tokens/s | -| 冷启动适应 | 新语言的 few-shot 适应所需样本 | ≤ 100 条 | -| 输出长度控制 | 指定长度与实际长度的偏差 | ≤ ±20% | +| 维度 | 传统 LLM | NextAgent LLM 子网 | +|------|---------|-------------------| +| 知识来源 | 模型参数内隐 | 外部记忆子网 | +| 推理能力 | 模型内部隐式 | 外部逻辑推理子网 | +| 输入格式 | 用户原始问题 | 结构化推理路径张量 | +| 输出去向 | 返回原始对话 | 自然语言→用户, 验证张量→Core | +| 角色定位 | 全知全能 | 专业语言生成引擎 | +| 幻觉风险 | 高（知识+生成耦合） | 极低（知识外置+验证机制） | +| 可控制性 | 低（提示工程） | 高（验证张量 + 人设编码） | diff --git a/docs/logic-trace-subnet.md b/docs/logic-trace-subnet.md index 5c4c82f..d477e06 100644 --- a/docs/logic-trace-subnet.md +++ b/docs/logic-trace-subnet.md @@ -1,311 +1,331 @@ -# 逻辑链路追踪神经网络（推理回路） +# 逻辑链路追踪神经网络 — 训练目标与训练计划 ## 概述 -逻辑链路追踪神经网络（Logic Trace Network, LTN）类比人脑的**推理回路**，是 NextAgent 的"思维引擎"。它负责对任务进行逻辑推理、验证推理路径的正确性，并在发现错误时执行自我修正。这是实现 **可解释 AI** 和 **可信推理** 的核心组件。 +逻辑链路追踪神经网络（推理回路）类比人脑的**前额叶推理回路**，负责逻辑验证、错误追溯、路径重规划和自我修正。它是 NextAgent 实现"深度思考"的核心组件。 -### 核心职责 +### 架构定位 -- **逻辑验证**：对调度 Core 下达的任务进行逻辑一致性检查 -- **推理路径搜索**：探索多条可能的推理路径，选择最优解 -- **错误追溯**：当推理结果矛盾或错误时，定位错误节点 -- **路径重规划**：在错误节点处分支，重新规划推理路径 -- **自我修正**：从错误中学习，更新推理策略偏好 +``` + 推理请求张量 (来自 Core) + │ + ▼ +┌──────────────────────────────────────────────┐ +│ 逻辑链路追踪神经网络（推理回路） │ +│ │ +│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ +│ │ 推理引擎 │→│ 路径追踪 │→│ 验证器 │ │ +│ │ MCTS │ │ 记录器 │ │ Process │ │ +│ │ 推理搜索 │ │ 推理路径 │ │ Reward │ │ +│ └──────────┘ └──────────┘ └──────────┘ │ +│ │ +│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ +│ │ 错误分析 │→│ 重规划器 │ │ 张量编码 │ │ +│ │ Error │ │ Path │ │ →标准张量 │ │ +│ │ Tracing │ │ Replanner│ │ │ │ +│ └──────────┘ └──────────┘ └──────────┘ │ +│ │ +└──────────────────┬───────────────────────────┘ + │ + ▼ + 推理路径张量 (Standard Reasoning Tensor) + │ + → 发送给调度 Core +``` -## 架构设计 +### 输入/输出 -```mermaid -graph TB - Input["输入：任务 + 记忆引用包"] --> Parser["推理任务解析器"] - - Parser --> MCTS["蒙特卡洛树搜索"] - - subgraph MCTS_Tree ["MCTS 推理树"] - Root["根节点"] - N1["推理节点 1"] - N2["推理节点 2"] - N3["推理节点 3"] - N11["子节点 1.1"] - N12["子节点 1.2"] - Leaf["叶节点（结论）"] - - Root --> N1 - Root --> N2 - Root --> N3 - N1 --> N11 - N1 --> N12 - N2 --> Leaf - end - - MCTS --> Selection["选择
UCT 算法"] - MCTS --> Expansion["扩展
策略网络"] - MCTS --> Simulation["模拟
奖励预测"] - MCTS --> Backprop["反向传播
更新访问计数"] - - Selection --> Validator["逻辑验证器"] - Validator --> ErrorTrace["错误追踪器"] - ErrorTrace --> Corrector["自我修正器"] - - Corrector --> Replan["路径重规划"] - Replan --> MCTS - - Validator --> PathSelect["最优路径选择"] - PathSelect --> Output["输出：验证后的推理路径"] - - subgraph Learning ["训练组件"] - PRM["过程奖励模型
Process Reward Model"] - RLHF_P["RLHF 训练
(推理偏好)"] - ErrorDS["错误案例数据集"] - end - - Validator -.-> PRM - Corrector -.-> ErrorDS - PathSelect -.-> RLHF_P +| 项目 | 说明 | +|------|------| +| **输入** | 推理请求张量（来自Core，包含任务描述、记忆上下文、路由引用） | +| **输出** | 推理路径张量（发送给Core，包含推理步骤、验证标记、置信度、可选路径） | +| **输出不是最终答案** | 只输出推理路径，不输出结论文本——结论由 LLM 子网负责表达 | +| **延迟目标** | 单次推理 < 200ms | + +### 推理路径张量格式 + +```json +{ + "header": { + "source": "logic_trace", + "target": "core", + "tensor_type": "reasoning_path", + "trace_id": "trace-uuid", + "timestamp": 1717200000 + }, + "payload": { + "reasoning_steps": [ + { + "step_id": 1, + "type": "deduction", + "input": "用户想要查询天气", + "operation": "提取地点和时间信息", + "output": "地点: 北京, 时间: 今天", + "confidence": 0.95, + "source_evidence": ["memory:偏好_北京天气"] + }, + { + "step_id": 2, + "type": "retrieval", + "input": "需要天气数据", + "operation": "查询记忆子网获取北京天气偏好", + "output": "用户关注空气质量>温度", + "confidence": 0.88, + "source_evidence": ["graph:用户_北京_HAS_PERSONA_关注空气质量"] + }, + { + "step_id": 3, + "type": "verification", + "input": "步骤1-2结果", + "operation": "交叉验证", + "output": "结论一致", + "confidence": 0.92, + "source_evidence": ["cross_validation"] + } + ], + "final_confidence": 0.92, + "alternative_paths": [ + { + "path_id": "alt_1", + "conclusion": "用户可能不在北京（上次对话提到出差）", + "confidence": 0.45, + "rejection_reason": "信息过时（3天前的记录）" + } + ], + "verified": true, + "error_log": [] + }, + "metadata": { + "step_count": 3, + "mcts_iterations": 50, + "search_depth": 5, + "verification_status": "passed" + } +} +``` + +## 子网内部架构 + +``` +┌──────────────────────────────────────────────────────────────┐ +│ 逻辑链路追踪神经网络 内部架构 │ +│ │ +│ 推理请求 → ┌──────────────────────────────────────────┐ │ +│ │ 1. 推理引擎 (Reasoning Engine) │ │ +│ │ ┌──────────────┐ ┌────────────────────┐ │ │ +│ │ │ 蒙特卡洛树搜索 │ │ 思维链生成器 │ │ │ +│ │ │ MCTS │ │ Chain-of-Thought │ │ │ +│ │ │ 搜索推理路径 │ │ 多步推演 │ │ │ +│ │ └──────────────┘ └────────────────────┘ │ │ +│ └──────────────────────┬─────────────────────┘ │ +│ │ │ +│ ┌──────────────────────▼─────────────────────┐ │ +│ │ 2. 路径追踪器 (Path Tracer) │ │ +│ │ ┌──────────────┐ ┌────────────────────┐ │ │ +│ │ │ 推理步骤记录 │ │ 依赖图构建 │ │ │ +│ │ │ 每一步的输入/ │ │ 证据链追踪 │ │ │ +│ │ │ 输出/置信度 │ │ 来源追溯 │ │ │ +│ │ └──────────────┘ └────────────────────┘ │ │ +│ └──────────────────────┬─────────────────────┘ │ +│ │ │ +│ ┌──────────────────────▼─────────────────────┐ │ +│ │ 3. 验证器 (Verifier) │ │ +│ │ ┌──────────────┐ ┌────────────────────┐ │ │ +│ │ │ 过程奖励模型 │ │ 冲突检测器 │ │ │ +│ │ │ Process │ │ 矛盾识别 │ │ │ +│ │ │ Reward Model │ │ 逻辑一致性检查 │ │ │ +│ │ └──────────────┘ └────────────────────┘ │ │ +│ └──────────────────────┬─────────────────────┘ │ +│ │ │ +│ ┌──────────────────────▼─────────────────────┐ │ +│ │ 4. 错误分析 & 重规划 │ │ +│ │ ┌──────────────┐ ┌────────────────────┐ │ │ +│ │ │ 错误追溯器 │ │ 重规划器 │ │ │ +│ │ │ 失败路径分析 │ │ 替代路径生成 │ │ │ +│ │ │ 根因定位 │ │ 参数调整 │ │ │ +│ │ └──────────────┘ └────────────────────┘ │ │ +│ └──────────────────────┬─────────────────────┘ │ +│ │ │ +│ ┌──────────────────────▼─────────────────────┐ │ +│ │ 5. 张量编码层 │ │ +│ │ 内部推理结果 → 标准推理路径张量 │ │ +│ └──────────────────────────────────────────┘ │ +│ │ +└──────────────────────────────────────────────────────────────┘ ``` ## 训练目标 -### 目标 1：逻辑验证 +### 目标 1：多步推理准确率 -训练子网能够识别推理链中的逻辑错误，包括事实矛盾、步骤跳跃和循环依赖。 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 链式推理准确率 | ≥ 85% | 5步以上的推理链 | +| 数学推理准确率 | ≥ 75% | 多步数学问题 (GSM8K) | +| 逻辑推理准确率 | ≥ 80% | 一阶逻辑推理任务 | +| 常识推理准确率 | ≥ 85% | 常识推理基准 (CSQA) | -- **验证粒度**：逐步骤验证，而非仅验证最终结论 -- **错误类型覆盖**：≥ 10 种常见逻辑谬误（偷换概念、循环论证、错误归因等） -- **验证速度**：每步推理 ≤ 10ms +### 目标 2：错误路径检测 -### 目标 2：错误追溯与定位 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 错误检测召回率 | ≥ 90% | 能识别出推理链中的错误步骤 | +| 错误检测精确率 | ≥ 80% | 标记为错误的确实有错误 | +| 矛盾识别 F1 | ≥ 85% | 识别出推理结论中的矛盾 | -当推理结果错误时，精确定位错误发生的步骤和原因。 +### 目标 3：回溯重规划能力 -- **定位精度**：Top-1 错误步骤准确率 ≥ 80% -- **根因分析**：错误分类准确率 ≥ 85% -- **回溯效率**：N 步推理的回溯复杂度 O(log N) +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 回溯成功率 | ≥ 80% | 发现错误后成功重规划 | +| 重规划效率 | ≤ 3轮回溯 | 最多3次回溯就能找到正确路径 | +| 替代方案多样性 | ≥ 3条 | 每次至少生成3个替代推理路径 | -### 目标 3：路径重规划与自我修正 +### 目标 4：推理可解释性 -在错误步骤处分支，探索替代推理路径，实现自我修正。 - -- **修正成功率**：首次修正成功率 ≥ 70% -- **修正轮次上限**：最多 3 轮修正后必须输出结果 -- **修正代价**：修正后的推理路径长度 ≤ 原始路径 × 1.5 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 推理步骤覆盖率 | 100% | 每步推理都有完整的 I/O 记录 | +| 证据追溯准确率 | ≥ 95% | 每步推理都能追踪到数据来源 | +| 推理路径可视化分 | ≥ 4/5 | 人类评估者可理解的程度 | ## 训练计划 -### 阶段 1：过程奖励模型（Process Reward Model, PRM）训练 +### 阶段 1：监督学习 — 基础推理能力 -**目标**：训练一个能够对推理中间步骤进行质量评分的模型，替代仅评估最终结果的传统方法。 +**目标**：训练 LLM 基础的多步推理能力 -#### 数据构建 +**技术路线**： +- 使用思维链 (Chain-of-Thought) 数据集进行指令微调 (SFT) +- 模型选择：基于开源 LLM（如 Llama 3 / Qwen 2.5）进行推理增强 -1. **自动推理链生成**：使用 GPT-4 / Claude 对数学、逻辑、常识类问题生成多步推理链 -2. **人工标注**：标注员对推理链的每个步骤进行评分（-1: 错误, 0: 中性, 1: 正确） -3. **数据规模**：200,000 条推理链，平均链长 8 步，总计 160 万标注步骤 -4. **数据覆盖**： +**训练数据集**： -| 类别 | 占比 | 示例 | -|------|------|------| -| 数学推理 | 30% | GSM8K、MATH 题目 | -| 逻辑推理 | 25% | 三段论、命题逻辑、谓词逻辑 | -| 常识推理 | 20% | 物理常识、社会常识 | -| 因果推理 | 15% | 因果推断、反事实推理 | -| 代码推理 | 10% | 代码执行跟踪、bug 定位 | +| 数据集 | 用途 | 规模 | +|--------|------|------| +| GSM8K | 数学推理 | 8K | +| MATH | 高级数学 | 12K | +| StrategyQA | 策略推理 | 2K | +| Logical Reasoning | 逻辑推理 | 5K | +| HotpotQA | 多步问答 | 113K | -#### 模型架构 +**训练步骤**： +1. 收集和清洗上述数据集，统一格式为 (问题, 推理链, 答案) +2. 在基础模型上进行 LoRA 微调 +3. 训练 3 epochs，batch size 128，learning rate 2e-5 +4. 评估各数据集的推理准确率 -- **基座模型**：基于 LLaMA-3.1-8B 或同等规模模型 -- **奖励头**：在每一层 Transformer 后添加线性层，输出步骤质量评分 -- **输入格式**：`[问题] [步骤1] [步骤2] ... [当前步骤]` -- **输出**：当前步骤的奖励值（连续值，范围 [-1, 1]） +### 阶段 2：过程奖励模型 (PRM) 训练 -#### 训练配置 +**目标**：训练能够评估推理步骤质量的奖励模型 -- **损失函数**：排序损失（Pairwise Ranking Loss） - ``` - L = max(0, margin - (r_pos - r_neg)) - margin = 0.5 - ``` -- **批大小**：64（每条含完整推理链） -- **优化器**：AdamW（β1=0.9, β2=0.95） -- **学习率**：1e-5，余弦退火 -- **权重衰减**：0.01 -- **训练轮数**：5 epochs（防止过拟合） -- **验证集**：人工标注数据的 10% 作为验证 +**技术路线**： +- 为每步推理打分，而非仅评估最终结果 +- 模型：Pythia / Llama + 值头 (Value Head) -#### PRM 推理流程 +**训练步骤**： +1. 构建 PRM 训练集： + - 从阶段1的模型生成多条推理链 + - 人工标注每步的正确性（正确/错误/模糊） + - 每步标注有监督信号 +2. 训练奖励模型：输入推理步骤上下文 → 输出正确性分数 +3. 损失函数：二元交叉熵（正步/错步分类） +4. 训练 5 epochs +5. 验证：奖励模型对错误步骤的识别准确率 ≥ 85% -``` -def evaluate_step(question, steps_so_far, next_step): - # 1. 编码上下文 - context = tokenize(question, steps_so_far) - - # 2. 逐层提取 hidden states - hidden_states = model(context) - - # 3. 奖励头预测 - reward = reward_head(hidden_states[-1]) - - # 4. 可选：+ 置信度校准 - confidence = calibrate(reward) - - return reward, confidence -``` +### 阶段 3：RLHF + PRM 强化学习 -### 阶段 2：蒙特卡洛树搜索（MCTS）推理训练 +**目标**：使用强化学习优化推理路径选择 -**目标**：在推理过程中使用 MCTS 探索多条路径，找到最优解决方案。 +**技术路线**： +- PPO 算法 + 过程奖励模型 (PRM) +- 奖励信号：PRM 对每步的打分 + 最终答案正确性 -#### MCTS 四步流程 +**训练步骤**： +1. 从阶段1的推理模型初始化策略网络 (Policy) +2. 使用 PPO 算法训练： + - 从训练数据中采样问题 + - 策略网络生成推理链 + - PRM 对每步打分 + - 优化策略以最大化累计奖励 +3. KL 散度约束：防止策略偏离基座模型太远 +4. 训练 100k steps +5. 在验证集上监控奖励和准确率 -```mermaid -graph LR - S["1. 选择 (Select)"] --> E["2. 扩展 (Expand)"] - E --> Sim["3. 模拟 (Simulate)"] - Sim --> BP["4. 反向传播 (Backprop)"] - BP --> S -``` +### 阶段 4：蒙特卡洛树搜索 (MCTS) 训练 -#### MCTS 组件设计 +**目标**：使用 MCTS 模拟推理回溯，训练模型在不确定时探索替代路径 -1. **选择（Selection）** - - 算法：UCT（Upper Confidence Bound Applied to Trees） - - 公式：`UCT = Q(s,a) + c · P(s,a) · sqrt(N_parent / (1 + N_child))` - - 探索系数 c：1.5（可通过贝叶斯优化调参） - - 剪枝：当节点 UCT 值低于阈值时不再扩展 +**技术路线**： +- 在推理时使用 MCTS 扩展搜索空间 +- 训练策略网络和价值网络指导 MCTS 搜索方向 -2. **扩展（Expansion）** - - 策略网络：轻量级 Transformer（6 层），预测下一步推理方向 - - 候选动作数：top-K = 5 - - 动作空间：推理方向编码（演绎、归纳、溯因、类比、分解） +**训练步骤**： +1. 构建 MCTS 推理框架： + - 每个推理步作为搜索树的一个节点 + - 使用阶段3的策略网络推理下一步 + - 使用 PRM 作为价值评估 + - 叶子节点回溯更新路径价值 +2. MCTS 超参数： + - 搜索次数：每次推理 50~200 次模拟 + - 探索常数 (c_puct): 1.0 ~ 2.5 + - 最大深度: 10步 +3. 自我对弈 (Self-Play) 训练： + - 使用当前策略 + MCTS 生成推理轨迹 + - 将 MCTS 搜索概率作为训练目标 + - 迭代优化策略网络 +4. 训练 200k 步 -3. **模拟（Simulation）** - - 使用 PRM 对节点评分作为奖励信号 - - 模拟深度：最大 20 步 - - 终止条件：得出确定性结论 或 达到步数上限 - - 快速回滚：当奖励值骤降时提前终止 +### 阶段 5：错误案例训练 -4. **反向传播（Backpropagation）** - - 更新路径上所有节点的 Q 值和访问计数 - - 折扣因子 γ：0.9（越远的节点贡献越小） - - 更新公式：`Q_new = Q_old + α · (G - Q_old)`，其中 α = 1/N +**目标**：使用错误案例训练自我修正能力 -#### 训练配置 +**训练步骤**： +1. 构建错误案例数据集： + - 收集阶段4中推理失败的案例 + - 对于每一条失败案例，人工标注： + a. 错误发生的位置 + b. 错误的原因（知识缺失/逻辑错误/信息误解） + c. 正确的替代路径 +2. 修正微调： + - 输入：原始推理链 + 错误位置标记 + 错误原因 + - 输出：修正后的推理链 +3. 训练 5 epochs +4. 评估：在错误案例上的修正成功率 -- **模拟次数**：每轮推理 50 次 MCTS 模拟 -- **温度参数**： - - 训练阶段：τ = 1.0（充分探索） - - 推理阶段：τ → 0（选择最优路径） -- **批处理大小**：并行搜索 16 棵推理树 -- **策略网络训练**：使用 MCTS 访问计数作为软标签 - - 损失函数：KL 散度(策略网络输出 || MCTS 访问分布) - - 学习率：1e-4 +### 阶段 6：集成到 Core 的启发式调度 -### 阶段 3：强化学习（RLHF + 过程奖励）训练推理偏好 +**目标**：与 Core 的调度策略引擎协同工作 -**目标**：通过人类反馈强化学习，优化推理路径选择的偏好。 +**训练**： +1. Core 的启发式调度策略决定何时调用推理子网 +2. 记录每次调用的上下文和结果 +3. 使用离线强化学习优化调度策略（待 Core 模块单独训练） -#### 训练流程 +## 评估指标体系 -``` -1. 策略模型（要训练的推理模型）生成多条推理路径 -2. PRM 对每条路径的每一步评分 -3. 人类标注员对比不同路径，给出偏好标签 -4. 训练奖励模型拟合人类偏好 -5. PPO 算法优化策略模型 -``` +### 离线评估 -#### 奖励模型训练 +| 指标 | 计算方法 | 目标 | +|------|----------|------| +| 推理链准确率 | 完整推理链正确的比例 | ≥ 85% | +| 每步准确率 | 推理链中每步正确的比例 | ≥ 90% | +| 修正成功率 | 发现错误后成功修正的比例 | ≥ 80% | +| MCTS 搜索效率 | 平均搜索节点数 / 解决问题数 | ≤ 200节点/题 | -- **输入**：完整的推理链（含每一步） -- **输出**：标量奖励值 -- **模型架构**：与 PRM 共享基座，但奖励头为单标量输出 -- **损失函数**：Bradley-Terry 偏好模型 - ``` - L = -E[log(σ(r_better - r_worse))] - ``` -- **数据**：50,000 对人类偏好对比对 +### 在线评估（与 Core 集成后） -#### PPO 训练配置 +| 指标 | 说明 | +|------|------| +| 验证通过率 | Core 收到推理路径张量后判断为"已验证"的比例 | +| 重调度频率 | Core 因推理置信度低而发起的二次推理次数 | +| 端到端准确率 | 完整链路（输入→推理→表达→用户）的最终准确率 | -- **策略模型**：推理路径生成模型（基于 LLaMA 架构） -- **价值模型**：与策略模型共享部分参数 -- **KL 散度惩罚**：β = 0.04（防止策略偏离基座过远） -- **GAE λ**：0.95 -- **折扣因子 γ**：0.99 -- **学习率**：1e-6（策略），1e-5（价值） -- **PPO clip**：ε = 0.2 -- **批大小**：512 -- **训练轮数**：3 epochs 每个 PPO 轮次 -- **总 PPO 轮次**：100 +## 技术难点与对策 -### 阶段 4：错误案例数据集与针对性训练 - -**目标**：构建高质量的错误推理案例数据集，针对性训练错误检测与修正能力。 - -#### 数据集构建 - -| 来源 | 方法 | 规模 | -|------|------|------| -| 模型自生成 | 奖励模型筛选低分路径 | 500,000 | -| 人工构造 | 标注人员植入特定错误类型 | 50,000 | -| 对抗生成 | 使用 Red-Teaming 方法生成困难错误 | 20,000 | -| 真实对话 | 从生产环境收集失败案例 | 100,000 | - -#### 错误类型覆盖 - -1. 事实性错误（Factual Error） -2. 逻辑跳跃（Logic Leap） -3. 循环论证（Circular Reasoning） -4. 假两难推理（False Dilemma） -5. 错误归因（False Attribution） -6. 以偏概全（Hasty Generalization） -7. 偷换概念（Equivocation） -8. 诉诸权威（Appeal to Authority） -9. 诉诸情感（Appeal to Emotion） -10. 因果倒置（Reverse Causality） - -#### 针对性训练 - -- **多任务学习**：同时优化错误检测 + 错误定位 + 修正生成 -- **数据增强**：对正确推理链随机注入错误，生成训练样本 -- **课程学习**：从简单错误（事实错误）到复杂错误（循环论证）渐进训练 -- **训练轮数**：30 epochs -- **早停**：验证集 F1 连续 5 轮不提升则停止 - -## 评估指标 - -### 推理准确率 - -| 指标 | 定义 | 目标值 | -|------|------|--------| -| 最终答案准确率 | 推理结论的总体正确率 | ≥ 85% | -| 步骤准确率 | 推理链中每步的正确率 | ≥ 90% | -| 推理路径一致性 | 相同输入多次推理的结论一致性 | ≥ 95% | -| 对抗鲁棒性 | 面对对抗性输入仍保持正确 | ≥ 75% | - -### 自我修正 - -| 指标 | 定义 | 目标值 | -|------|------|--------| -| 错误检测率 | 错误推理被正确标记的比例 | ≥ 90% | -| 修正成功率 | 首次修正即得到正确结果 | ≥ 70% | -| 修正效率 | 修正路径 / 原路径长度比 | ≤ 1.5 | -| 过修正率 | 原本正确被错误修改的比例 | ≤ 5% | -| 冗余修正率 | 不必要的额外修正步骤比例 | ≤ 10% | - -### 错误定位 - -| 指标 | 定义 | 目标值 | -|------|------|--------| -| Top-1 定位准确率 | 错误步骤的首位命中率 | ≥ 80% | -| 根因分类准确率 | 错误类型判别的准确率 | ≥ 85% | -| 定位粒度 | 能定位到句子/公式级别 | 句子级 | -| 假阳性率 | 正确步骤被误判为错误的比率 | ≤ 3% | - -### 系统性能 - -| 指标 | 定义 | 目标值 | -|------|------|--------| -| 推理延迟 | 从输入到输出的端到端延迟 | ≤ 500ms | -| MCTS 扩展数 | 平均每次推理扩展的节点数 | ≤ 200 | -| 内存占用 | 推理过程中的峰值内存 | ≤ 4GB | -| 修正收敛 | 平均修正轮数 | ≤ 1.8 | +| 难点 | 对策 | +|------|------| +| 推理搜索空间过大 | MCTS + 剪枝策略 + 启发式优先搜索 | +| 错误检测过于保守 | 动态阈值 + 多验证器投票 | +| 自我修正陷入循环 | 最大回溯次数限制 + 随机重启 | +| 推理速度与质量的权衡 | 自适应搜索深度（简单问题浅搜，复杂问题深搜） | diff --git a/docs/memory-subnet.md b/docs/memory-subnet.md index 06aa218..ad0140a 100644 --- a/docs/memory-subnet.md +++ b/docs/memory-subnet.md @@ -1,234 +1,322 @@ -# 记忆子网（海马体与皮层） +# 记忆子网 — 训练目标与训练计划 ## 概述 -记忆子网类比人脑的**海马体与大脑皮层**，负责长期记忆的存储、索引和检索。与传统向量数据库不同，记忆子网是一个**可训练的学习系统**，能够自主构建知识关联、更新记忆权重，并支持情景记忆的时序追溯。 +记忆子网类比人脑的**海马体与皮层**，负责长期记忆的存储、检索和管理。采用**三级存储架构**：图数据库（Neo4j）存储结构化知识图谱、向量数据库存储语义向量、文本存储记录会话历史。 -### 核心职责 +> 图数据库记忆设计参考了 [TrulyMEM-TrueHumanMEM](https://jianfgit.xyz:220/jianf/TrulyMEM-TrueHumanMEM.git) 项目。 -- **长期记忆存储**：将压缩引用包持久化存储于冷区，构建可检索的记忆库 -- **情景记忆索引**：记录交互的时间戳、上下文和情感标签，支持时序回溯 -- **知识图谱构建**：从记忆片段中自动提取实体与关系，构建动态知识图谱 -- **关联检索**：根据当前任务上下文，检索最相关的历史记忆片段 +### 架构定位 -## 架构设计 - -```mermaid -graph TB - Input["输入引用包"] --> Router["记忆路由器"] - - Router -->|"存储"| Store["记忆存储管线"] - Router -->|"检索"| Retrieve["记忆检索管线"] - - Store --> Encoder["记忆编码器
MANN"] - Encoder --> Graph["知识图谱更新
GNN"] - Graph --> Cold["冷区持久化"] - - Retrieve --> Query["查询编码器"] - Query --> Index["倒排索引搜索"] - Index --> Rerank["重排序器"] - Rerank --> Output["记忆引用包输出"] - - subgraph Storage ["存储架构"] - Cold - Cache["热区缓存
LRU"] - IndexStore["索引存储
HNSW"] - end - - Cache --> IndexStore - IndexStore --> Cold - - subgraph Learning ["学习模块"] - MANN["Memory-Augmented
Neural Networks"] - GNN["Graph Neural
Networks"] - Consolidation["记忆巩固
(sleep phase)"] - end - - Encoder -.-> MANN - Graph -.-> GNN - Cold -.-> Consolidation ``` + 记忆更新参数张量 (来自 Core) 记忆检索请求张量 (来自 Core) + │ │ + ▼ ▼ +┌───────────────────────────────────────────────────────────┐ +│ 记忆子网 │ +│ │ +│ ┌────────────────────────────────────────────────────┐ │ +│ │ 记忆管理器 (Memory Manager) │ │ +│ │ 解析参数包 → 分发到对应存储层 → 返回结果 │ │ +│ └──────┬────────────┬──────────────┬─────────────────┘ │ +│ │ │ │ │ +│ ▼ ▼ ▼ │ +│ ┌──────────┐ ┌────────────┐ ┌────────────────┐ │ +│ │ 图数据库 │ │ 向量数据库 │ │ 文本存储 │ │ +│ │ (Neo4j) │ │(Milvus/FAISS)│ │ (日志/会话归档) │ │ +│ │ │ │ │ │ │ │ +│ │ Entity │ │ 语义向量 │ │ 原始对话记录 │ │ +│ │ RELATES │ │ 索引 │ │ 时间线索引 │ │ +│ │ Cypher │ │ 相似度搜索 │ │ 压缩归档 │ │ +│ └──────────┘ └────────────┘ └────────────────┘ │ +│ │ +│ ┌────────────────────────────────────────────────────┐ │ +│ │ 张量编/解码层 │ │ +│ │ 接收：memory_query / memory_update 标准张量 │ │ +│ │ 输出：memory_result 标准张量 │ │ +│ └────────────────────────────────────────────────────┘ │ +└───────────────────────────────────────────────────────────┘ +``` + +## 三级存储架构 + +### 第一级：图数据库（Neo4j）— 温区 + +存储结构化知识，支持关系查询和推理。 + +**参考 TrulyMEM 的图数据库设计：** + +#### 节点 (Entity) 类型 + +| 节点类型 | Node Label | 属性 | 说明 | +|----------|-----------|------|------| +| 人设节点 | PersonaNode | name, type, created_at | AI 角色、性格、语气 | +| 任务节点 | TaskNode | task_id, description, state, created_at | 任务概述与状态 | +| 状态节点 | StateNode | name, value, timestamp | 任务或实体的状态 | +| 信息节点 | InfoNode | name, content, source, confidence | 具体信息 | +| 实体节点 | EntityNode | name, type, mention_count, updated_at | 通用实体 | + +#### 边 (RELATES) 类型 + +| 边类型 | 说明 | 示例 | +|--------|------|------| +| `HAS_PERSONA` | 人设关联 | AI → PersonaNode | +| `NEXT_TASK` | 任务时间链 | TaskNode → TaskNode | +| `HAS_STATE` | 状态关联 | TaskNode → StateNode | +| `CONTAINS_INFO` | 信息包含 | TaskNode → InfoNode | +| `RELATES_TO` | 通用关联 | EntityNode → EntityNode | + +#### 索引设计 + +```cypher +// 实体约束 +CREATE CONSTRAINT entity_name_constraint IF NOT EXISTS FOR (e:Entity) REQUIRE e.name IS UNIQUE +CREATE CONSTRAINT session_id_constraint IF NOT EXISTS FOR (s:Session) REQUIRE s.session_id IS UNIQUE + +// 关系索引 +CREATE INDEX rel_created_at IF NOT EXISTS FOR ()-[r:RELATES]-() ON r.created_at +CREATE INDEX rel_type IF NOT EXISTS FOR ()-[r:RELATES]-() ON r.type +CREATE INDEX rel_status IF NOT EXISTS FOR ()-[r:RELATES]-() ON r.status +CREATE INDEX rel_date_bucket IF NOT EXISTS FOR ()-[r:RELATES]-() ON r.date_bucket + +// 实体索引 +CREATE INDEX entity_type IF NOT EXISTS FOR (e:Entity) ON e.type +CREATE INDEX entity_mention_count IF NOT EXISTS FOR (e:Entity) ON e.mention_count +``` + +#### 检索示例 + +```cypher +-- 关键字检索 +MATCH (e:Entity)-[r:RELATES]->(t:Entity) +WHERE r.status = 'active' + AND (toLower(e.name) CONTAINS '关键词' OR toLower(t.name) CONTAINS '关键词') +RETURN e, r, t +ORDER BY r.created_at DESC +LIMIT 30 + +-- 会话隔离检索 +MATCH (e:Entity)-[r:RELATES]->(t:Entity) +WHERE r.session_id = $session_id AND r.status = 'active' +RETURN e, r, t + +-- 热点实体查询 +MATCH (e:Entity) +RETURN e.name, e.mention_count, e.type +ORDER BY e.mention_count DESC +LIMIT 10 +``` + +### 第二级：向量数据库（Milvus / FAISS）— 冷区 + +存储语义向量，支持相似度检索。 + +| 项目 | 说明 | +|------|------| +| 索引类型 | IVF_FLAT / HNSW | +| 向量维度 | 768 (匹配标准张量维度) | +| 度量方式 | Cosine Similarity | +| 分片策略 | 按时间桶 + 会话 ID 分片 | + +### 第三级：文本存储 — 冷区 + +存储完整的原始对话记录和会话日志。 + +| 项目 | 说明 | +|------|------| +| 存储格式 | JSONL / 压缩归档 | +| 索引 | 时间线索引 + 会话 ID 索引 | +| 生命周期 | 30天后归档，90天后可清理 | +| 用途 | 审计、重建、深度分析 | + +## 输入/输出 + +| 项目 | 说明 | +|------|------| +| **输入1** | `memory_query` 张量（来自 Core，含查询意图和种子实体） | +| **输入2** | `memory_update` 张量（来自 Core，含要写入的三元组和元数据） | +| **输出** | `memory_result` 张量（包含检索到的实体/关系/向量结果） | ## 训练目标 -### 目标 1：长期记忆存储与检索 +### 目标 1：图数据库检索准确率 -训练记忆子网能够高效存储大量历史交互记录，并在需要时准确检索。 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 检索召回率 (Recall@10) | ≥ 90% | 对于已知关系的检索 | +| 检索精确率 (Precision@10) | ≥ 85% | 检索结果的相关性 | +| 关系推理准确率 | ≥ 80% | 通过图路径推理发现隐含关系 | -- **存储容量**：支持 ≥ 10⁸ 条记忆片段 -- **写入延迟**：≤ 10ms/条 -- **检索延迟**：p99 ≤ 50ms -- **检索准确率**：Top-1 ≥ 90%，Top-5 ≥ 98% +### 目标 2：向量检索能力 -### 目标 2：情景记忆索引 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 语义检索 Recall@10 | ≥ 85% | 向量相似度检索 | +| 跨模态检索准确率 | ≥ 80% | 文本→图像/语音的跨模态检索 | +| 索引构建时间 | ≤ 100ms/1000条 | 向量索引增量更新 | -对每条记忆附加时间戳、上下文标签、情感值，支持按时间和场景检索。 +### 目标 3：记忆关联发现 -- 时间范围查询：任意时间窗口的回忆准确率 ≥ 85% -- 情景聚类：同场景记忆的聚类纯度 ≥ 0.8 -- 遗忘曲线模拟：模拟人脑 Ebbinghaus 遗忘曲线，重塑低频记忆 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 关联发现 F1 | ≥ 75% | 自动发现实体间的隐含关系 | +| 记忆合并准确率 | ≥ 90% | 重复实体的合并不引入错误 | +| 因果链路发现 | ≥ 70% | 从事件序列中发现因果关系 | -### 目标 3：知识图谱构建 +### 目标 4：工作记忆管理 -从记忆片段中自动抽取实体和关系，构建可查询的知识图谱。 - -- 实体抽取 F1 ≥ 85%（基于预训练 NER 模型） -- 关系抽取准确率 ≥ 75% -- 图谱密度：≥ 5 条边/节点 -- 推理路径长度：支持最多 5 跳的关系推理 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 上下文切换延迟 | ≤ 10ms | 工作记忆的热区缓存命中率 | +| 工作记忆容量 | 4096 tokens | 每轮有效上下文 | +| 缓存命中率 | ≥ 80% | 热区缓存有效减少冷区访问 | ## 训练计划 -### 阶段 1：Memory-Augmented Neural Networks（MANN）预训练 +### 阶段 1：图数据库操作基座（无训练） -**目标**：训练记忆增强神经网络，使其具备快速读写外部记忆的能力。 +**目标**：构建 Neo4j 图数据库操作层，建立基础检索和写入能力 -- **模型架构**：基于 Differentiable Neural Computer（DNC）改进 - - 控制器：LSTM，隐藏层维度 512 - - 外部记忆矩阵：N × M = 256 × 128 - - 读写头：4 个并行读写头 - - 记忆注意力：基于内容寻址 + 位置寻址的混合机制 - - 时间链路记录：记录记忆写入的时序顺序 +**实现**： +- 实现 Cypher 查询模板系统 +- 实现 MERGE / CREATE 写入逻辑 +- 实现会话隔离和索引管理 +- 实现软删除和归档机制 -- **训练数据**： - - 合成记忆任务：Copy、Repeat Copy、Associative Recall（Graves et al., 2016） - - 真实对话数据：MultiWOZ、DSTC 系列对话数据集 - - 时序序列：WikiText-103（分段记忆） +参考 TrulyMEM 的 `graph_client.py` 实现： -- **损失函数**： - - 主损失：交叉熵损失（任务预测） - - 记忆使用惩罚：鼓励稀疏记忆访问 - - 记忆冲突惩罚：避免写入冲突 -- **优化器**：Adam（β1=0.9, β2=0.999） -- **学习率**：1e-4，含 warmup 5000 steps -- **梯度裁剪**：max_norm = 10 -- **训练轮数**：300 epochs - -#### DNC 控制器更新规则 - -``` -# 读取 -r_t = Σ_i w_t^r(i) · M_t(i) # 按读取权重加权记忆 - -# 写入 -M_t(i) = M_{t-1}(i) ⊙ (1 - w_t^w(i) · e_t) + w_t^w(i) · a_t # 擦除后写入 - -# 记忆保持 -w_t^r, w_t^w = attend(q_t, M_{t-1}) # 基于查询的注意力 +```python +class Neo4jGraph: + def recall(self, query_intent, seed_entities, depth=2): + """检索记忆 - Cypher 驱动""" + # 关键词解析 → 构造 WHERE 子句 + # 支持深度扩展（depth 参数） + # 返回实体列表 + 关系列表 + + def commit(self, triplets, entity_types, temporal_tag): + """写入记忆 - MERGE + CREATE""" + # 逐条写入三元组 + # 自动维护 mention_count + # 记录会话和轮次信息 + + def purge(self, criteria, mode="soft", new_relation=None): + """删除/修正记忆""" + # soft: 标记 status='deleted' + # supersede: 标记旧关系 + 创建新关系 ``` -### 阶段 2：图神经网络（GNN）知识关联训练 +### 阶段 2：图神经网络关联学习 -**目标**：构建和更新知识图谱，发现记忆间的隐式关联。 +**目标**：训练 GNN 模型进行知识关联推理 -- **模型架构**：Relational Graph Convolutional Networks（R-GCN） - - 层数：3 层 GCN - - 隐藏维度：256 - - 关系类型数：50 种预设关系 + 动态关系发现 - - 聚合函数：均值聚合（mean aggregator） - - 自注意力：GAT（Graph Attention Network）层提升关联权重 +**技术路线**： +- 模型：R-GCN (Relational Graph Convolutional Network) 或 CompGCN +- 或 使用 GraphSAGE + 关系注意力 -- **训练任务**： - 1. **链接预测**：预测实体间是否存在某种关系 - 2. **实体分类**：预测实体的类别 - 3. **关系分类**：预测两个实体间的关系类型 - 4. **子图匹配**：识别与当前上下文最匹配的子图 +**训练步骤**： +1. 构建知识图谱训练集：从现有图数据库中采样子图 +2. 链接预测任务 (Link Prediction)：预测两个实体之间是否存在关系 +3. 实体分类任务 (Entity Classification)：预测实体类型 +4. 损失函数：交叉熵 + 对比损失 (margin-based ranking loss) +5. 训练 200 epochs，使用 Adam 优化器，learning rate 1e-3 +6. 评估：在验证集上计算 Hits@K 和 MRR -- **训练数据**： - - 通用知识图谱：Wikidata 子集、ConceptNet - - 自构建图谱：从对话数据中自动抽取的关系三元组 - - 时序图谱：Temporal Knowledge Graph（事件时序关联） +### 阶段 3：Memory-Augmented Neural Networks (MANN) -- **损失函数**： - - 链接预测：二元交叉熵 + 负采样（1:10 正负比） - - 实体/关系分类：交叉熵 - - 正则项：L2 权重衰减（5e-4） -- **优化器**：AdamW -- **学习率**：5e-5，线性衰减 -- **训练轮数**：100 epochs +**目标**：训练记忆增强网络，实现高效的读写操作 -### 阶段 3：引用-拉取训练策略 +**技术路线**： +- 模型：Differentiable Neural Computer (DNC) 或 Neural Turing Machine (NTM) +- 外部记忆矩阵 + 读写头 -**目标**：训练子网学习何时生成引用包、何时拉取完整数据，在带宽与信息量间找到平衡。 +**训练步骤**： +1. 合成任务训练：copy task, repeat copy, associative recall +2. 问答任务训练：bAbI 数据集，测试记忆存取能力 +3. 长序列建模：训练在长上下文中准确索引信息 +4. 添加注意力读写机制 +5. 损失函数：任务损失 + 记忆使用正则化 -#### 训练框架 +### 阶段 4：引用-拉取策略训练 +**目标**：训练决定何时拉取（从冷区）、何时缓存的策略 + +**技术路线**： +- 强化学习：基于记忆访问模式的 RL +- 状态：当前任务类型、历史访问模式、缓存状态 +- 动作：拉取/缓存/不操作 +- 奖励：访问延迟降低 + 缓存命中率 + +**训练步骤**： +1. 构建模拟环境：包含热区缓存、图数据库、向量数据库 +2. 收集真实交互日志作为训练数据 +3. 训练策略网络（Policy Network） +4. 使用 PPO 算法优化策略 +5. 评估：缓存命中率、平均访问延迟 + +### 阶段 5：端到端联合训练 + +**目标**：将以上阶段整合，与路由子网、逻辑子网联合训练 + +**训练步骤**： +1. 固定路由子网的输出作为记忆子网的查询输入 +2. 使用多任务训练：图检索 + 向量检索 + 关联发现 +3. 损失函数：L = L_retrieval + α * L_link + β * L_cache + γ * L_reg +4. 与 Core 的启发式调度策略联合优化 + +## 评估指标体系 + +### 离线评估 + +| 指标 | 计算方法 | 目标 | +|------|----------|------| +| 图检索 Recall@10 | 检索结果中包含正确答案的比例 | ≥ 90% | +| 向量检索 Recall@10 | 按语义相似度排序的召回率 | ≥ 85% | +| 关联推理 MRR | Mean Reciprocal Rank | ≥ 0.7 | +| 记忆写入一致性 | 写入后检索与原始一致 | ≥ 99% | +| 缓存命中率 | 热区缓存直接命中的比例 | ≥ 80% | + +### 在线评估 + +| 指标 | 说明 | +|------|------| +| 记忆检索延迟 | Core 发出查询到收到结果的时间 | +| 记忆更新延迟 | Core 发出更新到写入完成的时间 | +| 信息一致性 | 同一信息多次检索结果是否一致 | +| 记忆容量 | 在不显著降低性能前提下的最大存储量 | + +## 记忆更新参数包张量格式 + +Core 打包给记忆子网的 `memory_update` 张量格式： + +```json +{ + "header": { + "source": "core", + "target": "memory", + "tensor_type": "memory_update", + "trace_id": "trace-uuid", + "timestamp": 1717200000 + }, + "payload": { + "entities": [ + {"name": "用户_张三", "type": "PersonaNode", "attributes": {"preference": "摇滚音乐"}}, + {"name": "项目_NextAgent", "type": "EntityNode", "attributes": {}} + ], + "relations": [ + {"subject": "用户_张三", "relation": "HAS_PERSONA", "object": "喜欢_摇滚", "confidence": 0.95}, + {"subject": "用户_张三", "relation": "RELATES_TO", "object": "项目_NextAgent", "confidence": 0.9} + ], + "session_id": "session-20260601-xxxx", + "turn_id": 42, + "metadata": { + "source_subnets": ["routing", "logic_trace", "core"], + "aggregation_strategy": "merge" + } + }, + "metadata": { + "entity_count": 3, + "relation_count": 2, + "upsert_mode": "merge" + } +} ``` -环境：模拟多轮对话任务 -智能体：NextAgent（含记忆子网） -奖励信号： - +1: 正确使用了历史记忆 - +0.5: 引用包命中，无需完整拉取 - -0.5: 不必要的完整拉取（浪费带宽） - -1: 遗漏了关键记忆 - -2: 检索到错误记忆导致错误输出 -``` - -#### 训练步骤 - -1. **行为克隆（Behavior Cloning）预热** - - 使用专家轨迹数据（人工标注的"正确引用/拉取"决策） - - 监督学习 10 epochs，初始化策略网络 - -2. **强化学习训练** - - 算法：PPO（Proximal Policy Optimization） - - Actor 网络：2 层 MLP（512 → 256 → 2 动作） - - Critic 网络：2 层 MLP（512 → 256 → 1 值） - - 动作空间：[引用(REFERENCE), 拉取(FETCH)] - - 折扣因子 γ：0.95 - - GAE λ：0.95 - - clip 系数 ε：0.2 - - 训练轮数：1000 episodes - -3. **记忆巩固阶段（Memory Consolidation）** - - 模拟"睡眠"过程：定期重放低频记忆，防止遗忘 - - 使用 Experience Replay 从冷区采样 - - 记忆重加权：根据访问频率动态调整记忆强度 - -### 阶段 4：端到端联合训练 - -**目标**：将 MANN、GNN 和引用-拉取策略联合微调。 - -- 联合损失：L = L_MANN + λ₁·L_GNN + λ₂·L_RL - - λ₁ = 0.3, λ₂ = 0.5 -- 冻结策略网络的初期 10 epochs，后全部放开 -- 交替训练：每 5 个 batch 的记忆检索 → 1 个 batch 的图谱更新 -- 总训练轮数：50 epochs - -## 评估指标 - -### 记忆检索 - -| 指标 | 定义 | 目标值 | -|------|------|--------| -| Top-1 准确率 | 首条检索结果相关 | ≥ 90% | -| Top-5 召回率 | 前五条中包含相关记忆 | ≥ 98% | -| 平均倒数排名（MRR） | 相关记忆的排名倒数均值 | ≥ 0.92 | -| 归一化折损累计增益（NDCG@10） | 排序质量 | ≥ 0.85 | - -### 关联发现 - -| 指标 | 定义 | 目标值 | -|------|------|--------| -| 链接预测 Hits@10 | 图谱补全准确率 | ≥ 75% | -| 关联发现 F1 | 新关联预测的精确率与召回率调和均值 | ≥ 0.7 | -| 时序一致性 | 时序关系推理准确率 | ≥ 80% | -| 聚类纯度 | 同主题记忆聚类纯度 | ≥ 0.85 | - -### 系统性能 - -| 指标 | 定义 | 目标值 | -|------|------|--------| -| 写入延迟 | 单条记忆写入时间 | ≤ 10ms | -| 检索延迟 p50 | 中位数检索响应时间 | ≤ 20ms | -| 检索延迟 p99 | 99 分位检索响应时间 | ≤ 50ms | -| 存储密度 | 每条记忆平均存储开销 | ≤ 1KB | -| 有效压缩率 | 原始数据大小 / 引用包大小 | ≥ 10× | - -### 遗忘曲线 - -| 指标 | 定义 | 目标值 | -|------|------|--------| -| 短期遗忘率 | 24h 后同场景记忆召回率 | ≥ 90% | -| 长期遗忘率 | 30 天后同场景记忆召回率 | ≥ 70% | -| 干扰抵抗 | 相似记忆插入后的检索准确率变化 | ≤ 5% 下降 | diff --git a/docs/routing-compression-subnet.md b/docs/routing-compression-subnet.md index e934bd9..deda7af 100644 --- a/docs/routing-compression-subnet.md +++ b/docs/routing-compression-subnet.md @@ -1,173 +1,215 @@ -# 路由与压缩子网（感觉中枢） +# 路由与压缩子网 — 训练目标与训练计划 ## 概述 -路由与压缩子网类比人脑的**感觉中枢**，负责将外部的多模态输入（文本、图像、音频等）转化为结构化的内部表示。它是 NextAgent 的**入口层**，所有输入数据必须经过此子网处理才能进入后续流程。 +路由与压缩子网类比人脑的**感觉中枢**，负责处理多模态输入（图像、语音、文本）的特征提取与压缩，将原始数据转化为轻量级的**标准引用张量**（Reference Tensor）。 -### 核心职责 +### 架构定位 -- **多模态特征提取**：将不同模态的原始数据统一为向量表示 -- **信息压缩**：在保留语义的前提下最大化压缩率，降低存储与传输成本 -- **引用包生成**：将压缩后的特征打包为标准引用包（RefPack），供调度 Core 分发 -- **输入路由**：根据输入类型将数据分发到对应的特征提取通道 +``` +原始输入 (图像/语音/文本) + │ + ▼ +┌──────────────────────────────────────────────┐ +│ 路由与压缩子网（感觉中枢） │ +│ │ +│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ +│ │ 多模态 │ │ 特征融合 │ │ 压缩编码 │ │ +│ │ 编码器 │ →│ (Attention)│ →│ (AutoEnc)│ │ +│ └──────────┘ └──────────┘ └──────────┘ │ +│ │ +│ ┌──────────────────────────────────────┐ │ +│ │ 张量编码层 (Tensor Encoder) │ │ +│ │ 内部张量 → 标准通信张量 │ │ +│ └──────────────────────────────────────┘ │ +│ │ +└──────────────────┬───────────────────────────┘ + │ + ▼ + 标准引用张量 (Standard Ref Tensor) + │ + → 发送给调度 Core +``` -## 架构设计 +### 输入/输出 -```mermaid -graph TB - Input["多模态输入"] --> Router["输入路由器"] - - Router -->|"文本"| TextEnc["文本编码器
BERT/RoBERTa"] - Router -->|"图像"| ImageEnc["图像编码器
ViT/ResNet"] - Router -->|"音频"| AudioEnc["音频编码器
Wav2Vec 2.0"] - Router -->|"视频"| VideoEnc["视频编码器
VideoMAE"] - - TextEnc --> Merger["特征融合器"] - ImageEnc --> Merger - AudioEnc --> Merger - VideoEnc --> Merger - - Merger --> Compressor["压缩模块
AutoEncoder"] - Compressor --> RefPack["引用包生成器"] - RefPack --> Output["引用包输出"] - - subgraph Training ["训练组件"] - SimCLR["对比学习
SimCLR/MoCo"] - KD["知识蒸馏"] - AE["AutoEncoder
训练"] - end - - TextEnc -.-> SimCLR - ImageEnc -.-> SimCLR - Merger -.-> KD - Compressor -.-> AE +| 项目 | 说明 | +|------|------| +| **输入** | 原始多模态数据（图像/语音/文本）+ 控制张量（来自Core） | +| **输出** | 标准引用张量（发送给Core） | +| **输出格式** | 标准张量协议，tensor_type=`ref_tensor` | +| **压缩目标** | 10:1 ~ 100:1 压缩率 | +| **延迟目标** | 单次处理 < 50ms | + +## 子网内部架构 + +``` +┌──────────────────────────────────────────────┐ +│ 路由与压缩子网 内部架构 │ +│ │ +│ 图像输入 ──→ ViT 编码器 ─┐ │ +│ 语音输入 ──→ Wav2Vec ────┤ │ +│ 文本输入 ──→ BERT ──────┤ │ +│ │ │ +│ ▼ │ +│ ┌─────────────────────┐ │ +│ │ 多模态特征融合层 │ │ +│ │ Cross-Attention │ │ +│ │ Transformer 交叉编码 │ │ +│ └──────────┬──────────┘ │ +│ │ │ +│ ▼ │ +│ ┌─────────────────────┐ │ +│ │ 压缩编码器 │ │ +│ │ Variational AE │ │ +│ │ 或 Vector Quantized │ │ +│ │ VAE (VQ-VAE) │ │ +│ └──────────┬──────────┘ │ +│ │ │ +│ ▼ │ +│ ┌─────────────────────┐ │ +│ │ 张量编码层 │ │ +│ │ 内部格式→标准张量格式 │ │ +│ └──────────┬──────────┘ │ +└─────────────────────────┼─────────────────────┘ + │ + ▼ + 标准引用张量输出 ``` ## 训练目标 -### 目标 1：多模态特征提取 +### 目标 1：多模态特征提取能力 -训练各模态编码器，使其能够从原始输入中提取高质量的语义特征。 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 图像分类 Top-1 | ≥ 85% | 在 ImageNet 上 | +| 语音识别字错率 | ≤ 5% | 在 LibriSpeech 上 | +| 文本理解 F1 | ≥ 90% | 在 GLUE 基准上 | +| 多模态对齐准确率 | ≥ 92% | 跨模态检索任务 | -- **文本模态**：预训练语言模型（BERT-base / RoBERTa-base），输出 768 维向量 -- **图像模态**：视觉 Transformer（ViT-B/16），输出 768 维向量 -- **音频模态**：自监督语音模型（Wav2Vec 2.0 Base），输出 768 维向量 -- **视频模态**：视频掩码自编码器（VideoMAE Base），输出 768 维向量 +### 目标 2：高压缩率下的信息保留 -### 目标 2：信息压缩 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 压缩率 | 10:1 ~ 100:1 | 可配置，动态调整 | +| 重建质量 PSNR | ≥ 30dB | 图像重建 | +| 语义保留率 | ≥ 95% | 压缩前后语义相似度 | +| 信息瓶颈下界 | ≤ 理论下限的 110% | 接近最优压缩 | -在保持重建质量的前提下，将特征维度压缩至原始大小的 10%-20%。 +### 目标 3：标准张量格式兼容性 -- 压缩率目标：≥ 5 倍（即 768 维 → ≤ 150 维） -- 重建相似度：余弦相似度 ≥ 0.92 -- 推理速度：单次压缩 ≤ 5ms（GPU） - -### 目标 3：引用包生成 - -将压缩特征包装为标准化的引用包，包含元数据、签名和冷区索引。 +| 指标 | 目标值 | 说明 | +|------|--------|------| +| 张量编码精度损失 | ≤ 0.1% | 编码/解码循环误差 | +| 协议兼容率 | 100% | 与所有子网的标准张量协议兼容 | +| 编码延迟 | ≤ 5ms | 张量编码层处理时间 | ## 训练计划 -### 阶段 1：对比学习预训练（SimCLR / MoCo） +### 阶段 1：对比学习预训练（单模态编码器） -**目标**：为各模态编码器学习通用的特征表示。 +**目标**：为每个模态预训练独立编码器 -- **SimCLR**：用于文本和图像编码器的初始训练 - - 批大小：4096 - - 温度系数 τ：0.07 - - 投影头：2 层 MLP（2048 → 2048 → 128） - - 损失函数：NT-Xent（归一化温度标度交叉熵损失） - - 优化器：LARS（Layer-wise Adaptive Rate Scaling） - - 学习率：0.3 × BatchSize / 256 - - 训练轮数：100 epochs +**技术路线**： -- **MoCo v3**：用于视频和音频编码器的训练 - - 动量系数 m：0.999 - - 队列大小：65536 - - 编码器更新：动量式（momentum encoder） - - 损失函数：InfoNCE - - 优化器：AdamW - - 学习率：1.5e-4 - - 训练轮数：200 epochs +| 模态 | 模型 | 预训练方法 | 数据集 | +|------|------|-----------|--------| +| 图像 | ViT (Vision Transformer) | SimCLR / MoCo v3 | ImageNet-1K, JFT-300M | +| 语音 | Wav2Vec 2.0 / HuBERT | 对比预测编码 (CPC) | LibriSpeech, CommonVoice | +| 文本 | BERT / RoBERTa | Masked Language Model | BookCorpus, Wikipedia | -**数据集**： +**训练步骤**： +1. 图像编码器：使用 SimCLR 对比学习预训练 ViT-Base，batch size 4096，训练 200 epochs +2. 语音编码器：使用 HuBERT 自监督预训练，k-means 聚类作为伪标签，训练 400k steps +3. 文本编码器：使用 RoBERTa 预训练，MLM 任务，训练 500k steps +4. 评估：分别在下游任务上评估各编码器质量 -| 模态 | 数据集 | 规模 | -|------|--------|------| -| 文本 | Wikipedia + BookCorpus | 16GB | -| 图像 | ImageNet-1K + LAION-400M | 4 亿样本 | -| 音频 | LibriSpeech + AudioSet | 5000 小时 | -| 视频 | Kinetics-700 + HowTo100M | 70 万视频 | +### 阶段 2：知识蒸馏（编码器轻量化） -### 阶段 2：知识蒸馏 +**目标**：将大模型能力蒸馏到轻量编码器 -**目标**：将大模型的丰富特征迁移到轻量编码器，减少推理成本。 +**技术路线**： +- Teacher-Student 蒸馏框架 +- Teacher 模型：ViT-Large / HuBERT-Large / RoBERTa-Large +- Student 模型：ViT-Tiny / TinyHuBERT / DistilBERT -- **教师模型**：CLIP ViT-L/14（文本+图像）、HuBERT-Large（音频）、InternVideo（视频） -- **学生模型**：各模态专用编码器（参数量为教师模型的 1/10） -- **蒸馏损失**： - - 特征蒸馏：MSE(教师特征, 学生特征) - - 关系蒸馏：基于互信息的对比蒸馏 - - 逻辑蒸馏：KL 散度(教师输出 || 学生输出) -- **总损失**：L = α·L_feat + β·L_rel + γ·L_logit - - α = 0.5, β = 0.3, γ = 0.2 -- **温度 T**：4.0（软化概率分布） -- **训练轮数**：50 epochs +**训练步骤**： +1. 冻结 Teacher 模型权重 +2. Student 模型学习 Teacher 的隐藏层输出（MSE loss） +3. 同时学习 Teacher 的 attention map（KL divergence） +4. 添加任务损失保持下游性能 +5. 目标：Student 参数量 ≤ Teacher 的 20%，性能 ≥ Teacher 的 95% -### 阶段 3：AutoEncoder 压缩训练 +### 阶段 3：AutoEncoder 端到端训练 -**目标**：训练压缩-解压缩的 AutoEncoder 结构。 +**目标**：训练压缩-重建网络，实现高压缩率下的信息保留 -- **编码器结构**： - ``` - Input (768) → Dense(512, ReLU) → BN → Dense(256, ReLU) → BN → Dense(128, Linear) - ``` -- **解码器结构**： - ``` - Latent (128) → Dense(256, ReLU) → BN → Dense(512, ReLU) → BN → Dense(768, Linear) - ``` -- **损失函数**： - - 重建损失：MSE + 余弦相似度 - - 感知损失：基于预训练编码器的特征匹配 - - 对抗损失：附加判别器，提升重建质量 - - KL 散度正则项：β-VAE 风格 -- **优化器**：Adam（β1=0.9, β2=0.999） -- **学习率**：1e-4，余弦退火调度 -- **训练轮数**：150 epochs -- **压缩比搜索**：在 {2×, 3×, 5×, 8×, 10×} 中搜索最优压缩比 +**技术路线**： +- 架构：VQ-VAE (Vector Quantized Variational Autoencoder) +- 或 改进版本：VQ-GAN (加入对抗损失) -### 阶段 4：端到端联合微调 +**训练步骤**： +1. 固定阶段1-2的编码器输出作为特征输入 +2. VQ-VAE 编码器将特征压缩到潜在空间 +3. 代码本（Codebook）大小为 8192，每个码字维度 64 +4. 解码器重建原始特征 +5. 损失函数： + - 重建损失: MSE(原特征, 重建特征) + - 码本损失: sg[encoder_output] - codebook + β * sg[codebook] - encoder_output + - 承诺损失: 鼓励编码器输出靠近选中的码字 +6. 训练 100 epochs，batch size 256 +7. 评估：在不同压缩率 (10x, 50x, 100x) 下测量重建质量 -**目标**：将编码器、压缩器联合微调，优化跨模态对齐。 +### 阶段 4：张量编码层训练 -- 固定解码器参数 -- 引入跨模态对比损失：batch_size 内的跨模态负样本挖掘 -- 训练轮数：30 epochs（低学习率 5e-5） +**目标**：训练编码层将内部张量转换为标准通信张量 -## 评估指标 +**技术路线**： +- 可学习的线性投影层 + LayerNorm +- 维度对齐网络（Projection Head） -### 压缩效率 +**训练步骤**： +1. 定义标准张量协议的目标格式（固定维度、精度等） +2. 收集阶段3的 VQ-VAE 潜在表示作为训练数据 +3. 训练投影网络将内部张量映射到标准格式 +4. 训练配套的解码网络（供其他子网使用） +5. 验证编码/解码循环的一致性误差 -| 指标 | 定义 | 目标值 | -|------|------|--------| -| 压缩率 | 原始维度 / 压缩后维度 | ≥ 5× | -| 压缩延迟 | 单次前向推理时间 | ≤ 5ms | -| 吞吐量 | 每秒处理的样本数 | ≥ 1000 samples/s | +### 阶段 5：联合端到端微调 -### 重建质量 +**目标**：将前四个阶段整合，端到端微调路由子网 -| 指标 | 定义 | 目标值 | -|------|------|--------| -| MSE | 原始与重建的均方误差 | ≤ 0.01 | -| 余弦相似度 | 原始与重建的余弦相似度 | ≥ 0.92 | -| PSNR | 峰值信噪比（图像模态） | ≥ 30dB | -| 感知距离 | LPIPS（ Learned Perceptual Image Patch Similarity） | ≤ 0.05 | +**训练步骤**： +1. 构建完整的路由子网流水线：输入 → 编码 → 压缩 → 张量化 +2. 与记忆子网、逻辑子网联合训练（参看训练流程） +3. 使用多任务损失: L_total = L_rec + L_semantic + L_tensor + λ * L_reg -### 检索与召回 +## 评估指标体系 -| 指标 | 定义 | 目标值 | -|------|------|--------| -| Top-1 召回 | 压缩查询的最近邻检索准确率 | ≥ 85% | -| Top-5 召回 | Top-5 召回率 | ≥ 95% | -| 跨模态检索 | 文本→图像/图像→文本检索准确率 | ≥ 70% | -| 反事实一致性 | 语义相近输入的重建一致性 | ≥ 90% | +### 离线评估 + +| 指标 | 计算方法 | 目标 | +|------|----------|------| +| 压缩率 | 原始数据大小 / 张量大小 | ≥ 10x | +| 重建 PSNR | 峰值信噪比 | ≥ 30 dB | +| 语义保留率 | cosine_sim(原语义向量, 重建语义向量) | ≥ 0.95 | +| 编码延迟 | 从输入到张量输出的时间 | ≤ 50 ms | +| 张量协议兼容性 | 编码/解码循环一致性 | ≥ 99.9% | + +### 在线评估（与 Core 集成后） + +| 指标 | 说明 | +|------|------| +| 信息缺失率 | Core 通知缺少信息时触发 | +| 冗余压缩率 | 引用张量中实际被使用的比例 | +| 多模态融合质量 | 下游任务表现的改善 | + +## 技术难点与对策 + +| 难点 | 对策 | +|------|------| +| 不同模态特征空间不统一 | 使用 Cross-Attention Transformer 对齐特征分布 | +| 极端压缩下信息丢失 | 引入语义损失（对比学习） + 自适应压缩率 | +| 实时性要求高 | 编码器轻量化 + 量化加速（INT8） | +| 多模态时间同步 | 时间戳对齐 + 滑动窗口缓冲 |