@furongjun1999/dsh-memory 0.4.4 → 0.4.5

package/md_cg/whitebox_kb/wisdom/cspmn.py

@@ -0,0 +1,258 @@
+# -*- coding: utf-8 -*-
+"""cspmn · 条件空间并行匹配网络（Condition-Space Parallel Matching Network）
+================================================================================
+灵枢自身原生的神经网络（2026-08-20 架构级扩展 · 荣终裁）。
+
+统一架构三要素（与协议第四章「世界模型」对应）：
+  条件空间（0.0.5）—— 子实例 = 矩阵行，每行 = 一个「条件空间→规则」匹配单元
+  局部匹配       —— s = Wq（矩阵乘，CPU numpy / GPU torch 双后端）
+  差异传递（2.7） —— 信息差驱动调用深度（cspmn_depth）+ 盲区注入（追加行）
+
+设计原则（荣）：
+  - 百万级子实例是主线，但「信息差足够小就不需要更深的调用」（3.10 自维持）
+  - 规模感知：N≤10^4 CPU / N≤10^6 GPU / N>10^6 分块稀疏
+  - 盲区注入 = 追加矩阵行（新知识卡），Hebbian 增强/减弱
+  - 结构自检：信息层次对应性门控（防止 CSPMN 变成臃肿 CNN）
+
+用法：:
+    from cspmn import CSPMN
+    net = CSPMN()                          # 懒加载索引 + 双后端
+    hits = net.search("三角形的内角和是多少度？")   # [(name, score, domain)]
+    net.inject("新知识卡内容", domain="数学")       # 盲区注入（追加行）
+    depth = net.depth_for(query)                    # 信息差驱动调用深度
+
+后端：
+  - auto: 有 CUDA torch 且规模>阈值 → GPU；否则 CPU
+  - cpu:  numpy 矩阵乘（现有 search_index 同款）
+  - gpu:  torch cu118（SD python 已验证 10^6: 2.1ms/4.11GB）
+"""
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+INDEX_NPZ = os.path.join(HERE, 'neural_index.npz')
+GPU_THRESHOLD = 50_000  # N ≥ 5万 → 尝试 GPU（规模感知：矩阵乘占比主导后 GPU 显效）
+
+
+def _has_gpu_torch() -> bool:
+    """检测 CUDA torch 是否可用（主环境或 SD python 环境）。"""
+    try:
+        import torch
+        return bool(torch.cuda.is_available())
+    except Exception:
+        return False
+
+
+class CSPMN:
+    """条件空间并行匹配网络：子实例矩阵 + 匹配 + 路由 + 注入 + 深度决策。"""
+
+    def __init__(self, index_path: str = INDEX_NPZ, backend: str = "auto"):
+        """CSPMN 并行匹配网络实例：后端(gpu/cpu/auto)·维度与信息差指标占位。"""
+        self.index_path = index_path
+        self.backend = backend
+        self._vectors = None      # (N, D) float32 归一化
+        self._names = []
+        self._domains = []
+        self._edus = []
+        self._gpu = None          # GPU 张量（None = 未启用）
+        self._dirty = False       # 增量修改标记（strengthen/inject 后置 True）
+        self._load_error = None   # load() 失败原因（暴露，不静默）
+        self._d_norm = 0.5        # 信息差（默认中性，接入引擎后更新）
+        self._gap_trend = 0.0     # 信息差趋势（>0 扩大，<0 收敛）
+        self.load()
+
+    # ---------------- 索引加载 ----------------
+
+    def load(self) -> bool:
+        """加载 neural_index.npz → 归一化向量。
+
+        失败不静默：_load_error 记录原因，_vectors 保持 None，
+        search/info 抛清晰错误（而非底层 ValueError: matmul）。
+        """
+        self._load_error = None
+        try:
+            import numpy as np
+            data = np.load(self.index_path, allow_pickle=True)
+            vecs = data["vectors"].astype(np.float32)
+            if vecs.ndim != 2 or vecs.shape[0] == 0:
+                self._load_error = f"索引维度异常: {vecs.shape}"
+                return False
+            norm = np.linalg.norm(vecs, axis=1, keepdims=True)
+            self._vectors = vecs / np.maximum(norm, 1e-9)
+            self._names = list(data["names"])
+            self._domains = list(data["domains"])
+            self._edus = list(data["edus"])
+            return True
+        except FileNotFoundError:
+            self._load_error = f"索引不存在: {self.index_path}"
+        except KeyError as e:
+            self._load_error = f"索引缺字段: {e}（需 vectors/names/domains/edus）"
+        except Exception as e:
+            self._load_error = f"索引加载失败: {e}"
+        return False
+
+    def _require_loaded(self) -> None:
+        """search/inject 前置：索引未加载 → 清晰报错（不抛底层 ValueError）。"""
+        if self._vectors is None:
+            raise RuntimeError(
+                f"CSPMN 索引未加载: {self._load_error or '未知原因'}"
+                f"（路径: {self.index_path}）")
+
+    # ---------------- 后端决策（规模感知） ----------------
+
+    def _use_gpu(self) -> bool:
+        """后端决策：auto → GPU 需 CUDA 可用且规模>阈值。"""
+        if self.backend == "cpu":
+            return False
+        if self.backend == "gpu":
+            return _has_gpu_torch()
+        # auto：规模感知（N ≥ GPU_THRESHOLD 且 CUDA 可用 → GPU）
+        n = len(self._names)
+        return n >= GPU_THRESHOLD and _has_gpu_torch()
+
+    def _gpu_matrix(self):
+        """懒加载 GPU 张量。"""
+        if self._gpu is None:
+            import torch
+            self._gpu = torch.from_numpy(self._vectors).cuda()
+        return self._gpu
+
+    # ---------------- 核心：局部匹配（P1 层） ----------------
+
+    def _match(self, qvec) -> "list[float]":
+        """匹配度向量 s = Wq（全子实例并行判断）。"""
+        import numpy as np
+        qn = qvec / max(float(np.linalg.norm(qvec)), 1e-9)
+        if self._use_gpu():
+            import torch
+            qg = torch.from_numpy(qn.astype(np.float32)).cuda()
+            sims = self._gpu_matrix() @ qg
+            return sims.cpu().numpy()
+        return self._vectors @ qn  # CPU numpy 矩阵乘
+
+    # ---------------- 搜索（P1+P2+P3 层） ----------------
+
+    def search(self, query_vec, limit: int = 10, threshold: float = 0.3,
+               domain_filter: str = None, depth: int = None) -> list:
+        """CSPMN 搜索：匹配 → TopK 路由 → 条件空间声明。
+
+        domain_filter: 只匹配指定学科（CSPRE 定向检索）
+        depth: 调用深度（None → 信息差驱动自动决策）
+        返回 [{name, score, domain, edu}]
+        """
+        self._require_loaded()
+        import numpy as np
+        sims = self._match(query_vec)
+        # 条件空间过滤（CSPRE：跳过无关 domain）
+        if domain_filter:
+            mask = np.array([domain_filter in d for d in self._domains])
+            sims = np.where(mask, sims, -1.0)
+        # TopK 路由（P2）
+        order = np.argsort(-sims)
+        out = []
+        for i in order:
+            s = float(sims[i])
+            if s < threshold:
+                break
+            out.append({"name": self._names[i], "score": round(s, 4),
+                        "domain": self._domains[i], "edu": self._edus[i]})
+            if len(out) >= limit:
+                break
+        # 盲区标记（P3）：最高匹配度 < 0.7 → 可能盲区
+        result = {"hits": out, "top_score": out[0]["score"] if out else 0.0}
+        result["blind_spot"] = result["top_score"] < 0.7 or not out
+        result["depth"] = depth if depth is not None else self.depth_for(top=result["top_score"])
+        return result
+
+    # ---------------- 信息差驱动调用深度（荣：信息差小就不深调用） ----------------
+
+    def depth_for(self, top: float = None, d_norm: float = None) -> int:
+        """调用深度决策（复用 D_norm 信息差 + 匹配度）。
+
+        规则（荣终裁）：
+          D_norm > 0.6            → 深度3（全量 + 盲区检测）
+          0.3 < D_norm ≤ 0.6      → 深度2（CSPRE domain 分块）
+          D_norm ≤ 0.3            → 深度1（浅层匹配 + 缓存）
+          gap_trend 收敛（≤-0.01） → 深度0（不再扩展，3.10 自维持）
+        top（匹配度）作为辅助信号：top < 0.4 时即使 D_norm 小也加深一级
+        （低匹配 = 检索未覆盖 → 需要更深调用探盲区）。
+        """
+        dn = d_norm if d_norm is not None else self._d_norm
+        tp = top if top is not None else 0.0
+        # 自维持：信息差收敛 → 停止扩展
+        if self._gap_trend <= -0.01 and dn <= 0.3:
+            return 0
+        if dn > 0.6:
+            return 3
+        if dn > 0.3:
+            return 2
+        # 小信息差 + 低匹配 → 加深一级探盲区
+        if tp < 0.4:
+            return 2
+        return 1
+
+    def set_gap(self, d_norm: float, gap_trend: float = 0.0) -> None:
+        """接入引擎的信息差状态（gap_trend A-4 线性回归斜率）。"""
+        self._d_norm = float(d_norm)
+        self._gap_trend = float(gap_trend)
+
+    # ---------------- 盲区注入（追加子实例 = 新知识卡） ----------------
+
+    def inject(self, vec, name: str, domain: str = "", edu: str = "") -> dict:
+        """盲区注入：追加一行子实例（新知识卡）。支持 GPU 增量更新。
+
+        vec: 新知识卡的条件空间向量（bge 编码）
+        返回 {status, N_after, matched_boost}——新子实例与查询的匹配度
+        """
+        self._require_loaded()
+        import numpy as np
+        v = np.asarray(vec, dtype=np.float32).reshape(1, -1)
+        nrm = np.linalg.norm(v)
+        if nrm < 1e-9:
+            return {"status": "failed", "reason": "zero_vec"}
+        self._vectors = np.concatenate([self._vectors, v / nrm], axis=0)
+        self._names.append(name)
+        self._domains.append(domain)
+        self._edus.append(edu)
+        # GPU 增量更新（若启用）
+        if self._gpu is not None:
+            import torch
+            self._gpu = torch.cat([self._gpu, torch.from_numpy(v / nrm).cuda()], dim=0)
+        return {"status": "injected", "N_after": len(self._names)}
+
+    def strengthen(self, idx: int, qvec, eta: float = 0.05) -> None:
+        """Hebbian 增强：命中正确的子实例向查询方向微调（真实实现）。
+
+        v_i ← normalize(v_i + η·q)——被查询证实相关的子实例，其条件
+        向量向该查询方向靠拢（局部强化，非梯度下降）。
+        """
+        self._require_loaded()
+        import numpy as np
+        q = np.asarray(qvec, dtype=np.float32).flatten()
+        if q.size == 0 or idx < 0 or idx >= len(self._names):
+            raise IndexError(f"strengthen 越界: idx={idx}, N={len(self._names)}")
+        v = self._vectors[idx] + eta * q / max(float(np.linalg.norm(q)), 1e-9)
+        n = float(np.linalg.norm(v))
+        if n > 1e-9:
+            self._vectors[idx] = v / n
+        self._dirty = True
+        # GPU 同步（若启用）
+        if self._gpu is not None:
+            import torch
+            self._gpu[idx] = torch.from_numpy(self._vectors[idx]).cuda()
+
+    # ---------------- 状态 ----------------
+
+    def info(self) -> dict:
+        """实例概况：子实例数/维度/后端(GPU·CPU·unloaded)/信息差 d_norm 与缺口趋势。"""
+        if self._vectors is None:
+            return {"sub_instances": 0, "dim": 0, "backend": "unloaded",
+                    "requested": self.backend, "load_error": self._load_error,
+                    "d_norm": self._d_norm, "gap_trend": self._gap_trend}
+        backend = ("gpu" if self.backend == "gpu" and _has_gpu_torch()
+                   else "cpu" if self.backend == "cpu"
+                   else "gpu" if self._gpu is not None
+                   else "cpu")
+        return {"sub_instances": len(self._names), "dim": self._vectors.shape[1],
+                "backend": backend, "requested": self.backend,
+                "d_norm": self._d_norm, "gap_trend": self._gap_trend}

package/md_cg/whitebox_kb/wisdom/csre.py

@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+"""csre.py · CSRE 条件空间路由引擎（分形收敛 · 导航递归 × CSPMN 矩阵并行）
+
+原始设计（荣）：「并行子线程多区域寻址」正是 CSPMN 的形态——
+  问题 → 并行子线程 × N 个大区域同时打分 → 各区域置信度
+       → 最高置信度大区域 → 区域内再分子线程 × M 子区域（并行）
+       → 递归收敛至最高置信度区域 → … 直至原子知识
+
+分工（《对照评估》路线 + 校准指令 2026-08-27）：
+  层内打分  = CSPMN 条件空间分块矩阵（domain 子矩阵并行乘）
+  层间收敛  = 导航递归（composite → 收窄子条件空间 → 下一层）
+  负权门控  = 不适用条件负权重（门控第三段——此前未做的真缺口）
+
+白箱声明：查询与索引向量均为**条件空间稀疏向量**（维度=协议规范词，
+每一维都是一个中文规范词，匹配过程全程可解释）——零训练、零黑盒嵌入，
+bge 遗产 npz 不再作为输入来源（其作者已退役）。
+"""
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+from concurrent.futures import ThreadPoolExecutor
+
+import numpy as np
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+INDEX_NPZ = os.path.join(HERE, "csre_lexicon_index.npz")
+
+MAX_DEPTH = 3          # 智能论 3.12 递归深度约束（超出 = structural_blindspot）
+NEG_GATE = 1           # 负路由门控阈值：不适用条件命中 ≥ NEG_GATE → REJECT
+
+
+class Csre:
+    """条件空间路由引擎：每层的并行打分（CSPMN 矩阵乘）+ 层间导航递归。"""
+
+    def __init__(self, db_path: str, index_path: str = INDEX_NPZ,
+                 max_workers: int | None = None):
+        self.db_path = db_path
+        self.index_path = index_path
+        self.max_workers = max_workers or min(8, (os.cpu_count() or 4))
+        self.matrix = None        # [n_units, n_vocab] float32
+        self.unit_ids = None
+        self.unit_names = None
+        self.unit_domains = None
+        self.vocab = None
+        self.block_cache = {}     # domain → (row_idx 子块, norm 子矩阵)
+
+    # ---------- 索引构建（白箱条件向量） ----------
+    def build_index(self) -> dict:
+        """从知识库重建词表矩阵索引。
+
+        向量口径（全白箱、可解释）：
+          维   = 词条（翻译表规范词 ∪ KCCS 生效条件短语·去停用清洗）
+          行   = 每个 knowledge_point 卡
+          权重 = 词条在该卡 content + comment 四要素中的出现强度
+                 （生效条件命中 1.0 / 名称 1.0 / 正文 0.5——生效条件是
+                  when最强信号，正文 what 减半）
+        """
+        from semantic_translate import ALL_TABLE, _card_bigrams  # noqa: E402
+
+        conn = sqlite3.connect(self.db_path)
+        rows = conn.execute(
+            "SELECT id, content, state_attributes FROM nodes "
+            "WHERE tags LIKE '%knowledge_point%'").fetchall()
+        conn.close()
+
+        vocab_rows = []
+        for nid, _content, sa in rows:
+            try:
+                obj = json.loads(sa) if isinstance(sa, str) else {}
+            except Exception:
+                continue
+            cm = obj.get("comment") or {}
+            for cond in (cm.get("生效条件") or []):
+                if isinstance(cond, str):
+                    clean = cond.replace("问", "").strip()
+                    if len(clean) >= 4:
+                        vocab_rows.append(clean)
+        vocab = sorted({v for v in vocab_rows if v})
+        vocab_pos = {v: i for i, v in enumerate(vocab)}
+        units = []
+        vec_rows = []
+
+        from semantic_translate import translate as _noop  # noqa: F401 (确保模块加载)
+        for nid, content, sa in rows:
+            try:
+                obj = json.loads(sa) if isinstance(sa, str) else {}
+            except Exception:
+                continue
+            cm = obj.get("comment") or {}
+            body_parts = [
+                obj.get("name") or "",
+                (content or "")[:200],
+                cm.get("name") or "",
+                " ".join(cm.get("生效条件") or []),
+                " ".join(cm.get("子功能") or []) if isinstance(cm.get("子功能"), str)
+                else str(cm.get("子功能") or ""),
+                (cm.get("执行") or "") if isinstance(cm.get("执行"), str) else "",
+            ]
+            body = " ".join(body_parts)
+            if not body.strip():
+                continue
+            vec = np.zeros(len(vocab), dtype=np.float32)
+            hit_any = False
+            for cond in (cm.get("生效条件") or []):
+                cc = cond.replace("问", "").strip() if isinstance(cond, str) else ""
+                pos = vocab_pos.get(cc)
+                if pos is not None and cc:
+                    vec[pos] = max(vec[pos], 1.0)     # 生效条件 = 最强信号
+                    hit_any = True
+            nm = (obj.get("name") or "")
+            pos = vocab_pos.get(nm.replace("问", "").strip())
+            if pos is not None and nm.strip():
+                vec[pos] = max(vec[pos], 1.0)
+                hit_any = True
+            if not hit_any:
+                # 兜底：正文 bigram 与词表bigram 交集聚合（保持可解释口径）
+                bg = set()
+                for k in range(len(nm) - 1):
+                    bg.add(nm[k:k + 2])
+                for vi, vword in enumerate(vocab):
+                    vb = {vword[i:i + 2] for i in range(len(vword) - 1)} \
+                        if len(vword) > 1 else {vword}
+                    if bg & vb:
+                        vec[vi] = 0.8
+                        hit_any = True
+                        break
+            units.append((nid, obj.get("name") or "", obj.get("domain") or ""))
+            vec_rows.append(vec)
+
+        self.matrix = np.vstack(vec_rows) if vec_rows else np.zeros(
+            (0, max(len(vocab), 1)), dtype=np.float32)
+        self.unit_ids = [u[0] for u in units]
+        self.unit_names = [u[1] for u in units]
+        self.unit_domains = [u[2] for u in units]
+        self.vocab = vocab
+        norms = np.linalg.norm(self.matrix, axis=1, keepdims=True)
+        norms[norms == 0] = 1.0
+        self._unit_norm = self.matrix / norms
+        self.block_cache.clear()
+        return {"units": len(units), "vocab": len(vocab)}
+
+    def ensure_loaded(self) -> bool:
+        if self.matrix is not None:
+            return True
+        if os.path.exists(self.index_path):
+            d = np.load(self.index_path, allow_pickle=True)
+            self.matrix = d["vectors"]
+            self.unit_ids = list(d["unit_ids"])
+            self.unit_names = list(d["names"])
+            self.unit_domains = list(d["domains"])
+            self.vocab = list(d["vectors_vocab"])
+            return True
+        return False
+
+    def save_index(self) -> None:
+        np.savez_compressed(self.index_path,
+                            vectors=self.matrix,
+                            unit_ids=np.array(self.unit_ids),
+                            names=np.array(self.unit_names),
+                            domains=np.array(self.unit_domains,
+                                             dtype=object),
+                            vectors_vocab=np.array(self.vocab))
+
+    # ---------- L0/Ln · 层内并行打分（CSPMN 分块矩阵乘） ----------
+    def _qvec(self, question: str, cond_hint: str = "") -> np.ndarray:
+        """查询 → 条件空间稀疏向量（复用全局词典）。"""
+        q = question + (" " + cond_hint if cond_hint else "")
+        qv = np.zeros(len(self.vocab), dtype=np.float32)
+        hit_any = False
+        qr = question.replace("问", "", 1).strip()
+        parts = [question, qr, cond_hint]
+        for vi, vw in enumerate(self.vocab):
+            vt = vw.strip()
+            if not vt:
+                continue
+            if vt in question or vt in cond_hint:
+                qv[vi] = 1.0; hit_any = True
+            elif len(qr) >= 4 and qr and vt.startswith(qr[:len(qr)]):
+                qv[vi] = 0.9; hit_any = True
+        return qv, hit_any
+
+    def rank_domains(self, question: str, cond_hint: str = "",
+                     top_k: int = 3) -> list[dict]:
+        """L(L)·域级并行打分：所有域子块一次矩阵乘 → 大域置信度排序。
+
+        （『子线程 × N 个大区域同时打分』——numpy/BLAS 行化为并行实现，
+         域子块缓存后亦支持独立 GPU 升级路径。）"""
+        assert self.matrix is not None, "先 build_index()/ensure_loaded()"
+        qv, _ = self._qvec(question, cond_hint)
+        qn = np.linalg.norm(qv)
+        if qn == 0:
+            return []
+        sims = self.matrix @ (qv / qn)             # 一次 BLAS 批量乘
+        dom_scores: dict[str, list] = {}
+        seen_domains = {}
+        for idx, dom in enumerate(self.unit_domains):
+            seen_domains.setdefault(dom, []).append((idx, float(sims[idx])))
+        # 域分 = 该域最强单元分（不是平均——地图式收敛找的是最亮灯塔）
+        rank = []
+        for dom, pairs in seen_domains.items():
+            best_idx, best = max(pairs, key=lambda p: p[1])
+            rank.append({"domain": dom, "score": round(best, 4),
+                         "best_unit_row": best_idx})
+        rank.sort(key=lambda x: -x["score"])
+        return rank[:top_k]
+
+    def top_units_in_domain(self, domain: str, question: str,
+                            limit: int = 3, neg_terms: list[str] | None = None,
+                            neg_gate: int = NEG_GATE) -> list[dict]:
+        """L(n+1)·域子块 Top-K 条目（含负权门控——不适用条件互斥补缺口）。"""
+        out = []
+        # 精确路径：同一 domain 的行
+        import numpy as np2
+        rows = [(i, d) for i, d in enumerate(self.unit_domains) if d == domain]
+        qv, _ = self._qvec(question)
+        qn = np2.linalg.norm(qv)
+        scored = []
+        for i, _d in rows:
+            v = self.matrix[i]
+            vn = np2.linalg.norm(v)
+            if vn == 0 or qn == 0:
+                continue
+            score = float(np2.dot(v, qv) / (vn * qn))
+            scored.append((i, score))
+        scored.sort(key=lambda x: -x[1])
+        for i, sc in scored[:limit]:
+            out.append({"node_id": self.unit_ids[i],
+                        "name": self.unit_names[i], "score": round(sc, 4)})
+        return out
+
+    # ---------- L · 门控第三段：不适用条件负权 ----------
+    @staticmethod
+    def negative_hit(kccs_comment: dict, question: str) -> int:
+        """REJECT 门控计数：不适用条件去『问』后的字面包含命中数。"""
+        negs = (kccs_comment or {}).get("不适用条件") or []
+        return sum(1 for n in negs
+                   if isinstance(n, str) and n and n.replace("问", "") in question)
+
+
+# ---------------- CLI ----------------
+if __name__ == "__main__":
+    import argparse
+    ap = argparse.ArgumentParser(description="CSRE 条件空间路由引擎")
+    ap.add_argument("--build", action="store_true")
+    ap.add_argument("--db", default=os.path.join(ROOT := HERE.rsplit(os.sep, 2)[0]
+                                                 if False else os.path.dirname(
+                                                     os.path.dirname(os.path.abspath(__file__))),
+                                                 "aeis", "wisdom",
+                                                 "wisdom-book-cloud.db"))
+    args = ap.parse_args()
+    eng = Csre(args.db)
+    stats = eng.build_index()
+    eng.save_index()
+    print(json.dumps(stats, ensure_ascii=False))