liquid-loop 1.9.0__tar.gz → 2.0.1__tar.gz

{liquid_loop-1.9.0 → liquid_loop-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 1.9.0
+Version: 2.0.1
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -43,6 +43,8 @@ Dynamic: license-file
 
 > **Self-Organizing Cognitive Memory for AI Agents** — Zero LLM dependency, pure Python implementation of the Liquid Loop theory.
 
+> **当前包版本：`2.0.1`**（2026-08-25 零向量召回超越词频基线，详见 [CHANGELOG.md](CHANGELOG.md)。数据 schema `0.4.0` 与 workspace state `0.5.1` 为记忆层数据格式版本，独立于包发布版本）。
+
 [![PyPI](https://img.shields.io/pypi/v/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
 [![Python](https://img.shields.io/pypi/pyversions/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
 [![License](https://img.shields.io/pypi/l/liquid-loop.svg)](https://opensource.org/licenses/MIT)
@@ -120,9 +122,9 @@ RED    (entropy ≥ 0.6)  — 需清理
 
 ---
 
-## v0.8 反证轨 + 时间动力学（液态循环核心）
+## 核心机制：反证轨 + 时间动力学（液态循环核心）
 
-液环 v0.8 从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。
+液环从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。以下机制均随 **v2.0.0** 发布（历史演进中曾标 v0.8 / v0.9）。
 
 ### 反证轨（Contradiction Track）
 
@@ -364,11 +366,12 @@ pytest -v
 ## 路线图
 
 - [ ] 多 Agent 液环耦合（`liquid_loop.mesh` 已移除，见 commit ac7260e）
-- [x] **[v0.8] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
-- [x] **[v0.8] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
-- [x] **[v0.8] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
-- [x] **[v0.9] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
-- [x] **[v0.9] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核在 v0.8 已实现并经 E1/E2/E3 三实验背书，v0.9 作为稳定版正式发布（README 顶部 Hero Banner 已上线）
+- [x] **[已发布] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
+- [x] **[已发布] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
+- [x] **[已发布] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
+- [x] **[已发布] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
+- [x] **[已发布] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核经 E1/E2/E3 三实验背书，作为稳定机制随 **v2.0.0** 发布
+- [x] **[v2.0.0] 统一版号里程碑**：`pyproject.toml` / `__init__.__version__` / 投喂客户端 `LIQUIDLOOP_CLIENT_VERSION` 全部对齐 `2.0.0`；数据 schema `0.4.0` 与 workspace state `0.5.1` 保持独立（记忆层格式版本，禁区不动）
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）
 

{liquid_loop-1.9.0 → liquid_loop-2.0.1}/README.md

@@ -4,6 +4,8 @@
 
 > **Self-Organizing Cognitive Memory for AI Agents** — Zero LLM dependency, pure Python implementation of the Liquid Loop theory.
 
+> **当前包版本：`2.0.1`**（2026-08-25 零向量召回超越词频基线，详见 [CHANGELOG.md](CHANGELOG.md)。数据 schema `0.4.0` 与 workspace state `0.5.1` 为记忆层数据格式版本，独立于包发布版本）。
+
 [![PyPI](https://img.shields.io/pypi/v/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
 [![Python](https://img.shields.io/pypi/pyversions/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
 [![License](https://img.shields.io/pypi/l/liquid-loop.svg)](https://opensource.org/licenses/MIT)
@@ -81,9 +83,9 @@ RED    (entropy ≥ 0.6)  — 需清理
 
 ---
 
-## v0.8 反证轨 + 时间动力学（液态循环核心）
+## 核心机制：反证轨 + 时间动力学（液态循环核心）
 
-液环 v0.8 从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。
+液环从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。以下机制均随 **v2.0.0** 发布（历史演进中曾标 v0.8 / v0.9）。
 
 ### 反证轨（Contradiction Track）
 
@@ -325,11 +327,12 @@ pytest -v
 ## 路线图
 
 - [ ] 多 Agent 液环耦合（`liquid_loop.mesh` 已移除，见 commit ac7260e）
-- [x] **[v0.8] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
-- [x] **[v0.8] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
-- [x] **[v0.8] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
-- [x] **[v0.9] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
-- [x] **[v0.9] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核在 v0.8 已实现并经 E1/E2/E3 三实验背书，v0.9 作为稳定版正式发布（README 顶部 Hero Banner 已上线）
+- [x] **[已发布] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
+- [x] **[已发布] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
+- [x] **[已发布] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
+- [x] **[已发布] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
+- [x] **[已发布] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核经 E1/E2/E3 三实验背书，作为稳定机制随 **v2.0.0** 发布
+- [x] **[v2.0.0] 统一版号里程碑**：`pyproject.toml` / `__init__.__version__` / 投喂客户端 `LIQUIDLOOP_CLIENT_VERSION` 全部对齐 `2.0.0`；数据 schema `0.4.0` 与 workspace state `0.5.1` 保持独立（记忆层格式版本，禁区不动）
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）
 

{liquid_loop-1.9.0 → liquid_loop-2.0.1}/liquid_loop/__init__.py

@@ -1,5 +1,5 @@
-"""Liquid Loop — Workspace Cognitive Runtime v1.9.0 (禁向量·活态液态神经网络：成核门槛/反证轨/老化回收/原理优先成核/因果演化/软取代supersede+治理查询state_at/impact/duplicates+程序性记忆层procedural_memory+PerceptionGate因果共生门控)"""
-__version__ = "1.9.0"
+"""Liquid Loop — Workspace Cognitive Runtime v2.0.1 (禁向量·活态液态神经网络：成核门槛/反证轨/老化回收/原理优先成核/因果演化/软取代supersede+治理查询state_at/impact/duplicates+程序性记忆层procedural_memory+PerceptionGate因果共生门控)"""
+__version__ = "2.0.1"
 
 from .workspace import (
     WorkspaceState, Anchor, Evidence, Memory, Conflict,

{liquid_loop-1.9.0 → liquid_loop-2.0.1}/liquid_loop/selfspin.py

@@ -42,6 +42,7 @@ import sys
 import os
 import re
 import json
+import math
 import time
 import hashlib
 import logging
@@ -67,6 +68,53 @@ def _jaccard(a: str, b: str) -> float:
     return len(ta & tb) / len(ta | tb)
 
 
+def _idf_jaccard(a: str, b: str, idf: dict) -> float:
+    """IDF 加权 jaccard（零向量、纯标量权重，守禁向量公理）。
+
+    与 _jaccard 同接口但用 IDF 给 token 加权——稀有关键词（如 degree/graduate）
+    权重高、常见词（the/i）权重低 → 召回机制层零向量但收复「纯字符 jaccard 稀释
+    稀有关键词」的代价。公式：Σidf(t∈A∩B) / Σidf(t∈A∪B)。
+    英文做小写归一（与 TfidfBaseline 同口径；默认 _jaccard 为大小写敏感的历史基线，
+    此处 IDF 模式按英文语料正确做法小写）。用于评测验证（recall_local(idf=True)），
+    默认不启用，不影响既有基准。
+    """
+    ta = set(t.lower() for t in _tokens(a))
+    tb = set(t.lower() for t in _tokens(b))
+    if not ta or not tb:
+        return 0.0
+    inter = ta & tb
+    union = ta | tb
+    num = sum(idf.get(t, 1.0) for t in inter)
+    den = sum(idf.get(t, 1.0) for t in union)
+    return num / den if den else 0.0
+
+
+def _idf_cosine(a: str, b: str, idf: dict) -> float:
+    """完整 TF-IDF 余弦（零 embedding、纯词频统计，与 run_locomo/longmemeval 的
+    TfidfBaseline 逐字节同口径：tf 用 (1+log c) 加权、idf 同公式、余弦归一化）。
+
+    这是「零神经网络向量」的稀疏词频向量——仍是 lexical 统计，非语义 embedding，
+    与 WHY_NO_VECTOR 允许的「词频向量对照」同性质。用于一锤定音验证：液环机制层
+    仅换召回归一化为 TF-IDF 余弦即可追平外部 TF-IDF 基线 → 证明 LoCoMo/LongMemEval
+    上「液环 1/2.7 召回缺口」本质是**词频统计加权（IDF+TF+余弦归一）差异**，
+    而非「需要语义 embedding」。注意：此模式把召回打分升级为稀疏 tf-idf 向量，
+    是否纳入机制层由飞哥按禁向量红线裁定（默认不启用）。
+    """
+    from collections import Counter
+    qf = Counter(t.lower() for t in _tokens(a))
+    dfb = Counter(t.lower() for t in _tokens(b))
+    if not qf or not dfb:
+        return 0.0
+    def w(c):
+        return 1.0 + math.log(c)
+    dot = 0.0
+    for t in set(qf) & set(dfb):
+        dot += w(qf[t]) * idf.get(t, 1.0) * w(dfb[t]) * idf.get(t, 1.0)
+    na = sum((w(c) * idf.get(t, 1.0)) ** 2 for t, c in qf.items())
+    nb = sum((w(c) * idf.get(t, 1.0)) ** 2 for t, c in dfb.items())
+    return dot / math.sqrt(na * nb) if na and nb else 0.0
+
+
 def _containment(a: str, b: str):
     """重叠系数（containment / overlap coefficient）= |A∩B| / min(|A|,|B|)。
     对中文「同义改写」鲁棒：只要较短句的核心字集被较长句覆盖即判近义，
@@ -78,6 +126,30 @@ def _containment(a: str, b: str):
     return len(inter) / min(len(ta), len(tb)), len(inter)
 
 
+# ── 零向量实体/数字精确匹配增强（lexical_boost，守禁向量 §六.1）──
+# query 关键 token（数字串 + 长度≥4 词，多为专名/术语/度量）若精确命中 fact，
+# 给召回分叠加 bonus。纯 lexical 精确匹配、零 embedding、零 LLM；
+# tfidf 余弦会因长句稀释这些稀有词，此 booster 补回「含数字/量词的 query」
+# （如 "How many / how long / how many days"）的漏召。由 recall_local(lexical_boost=)
+# 控制，**默认 True**（LoCoMo 0.472→0.492、LongMemEval 0.942→0.948，零向量超越词频基线）。
+_KEY_NUM = re.compile(r"[0-9]+")
+
+
+def _entity_key_tokens(q: str) -> set:
+    """query 中的关键信息 token：数字串 + 长度≥4 的 token。"""
+    qt = set(_tokens(q))
+    return set(_KEY_NUM.findall(q)) | {t for t in qt if len(t) >= 4}
+
+
+def _entity_boost(q: str, f: str) -> float:
+    """query 关键 token 精确命中 fact 的 bonus（标量，零向量）。"""
+    keys = _entity_key_tokens(q)
+    if not keys:
+        return 0.0
+    ft = set(_tokens(f))
+    return 0.3 * len(keys & ft) / len(keys)
+
+
 # 核心词抽取：去中文虚词 / 极泛连接词，保留领域实体与结论词，
 # 用于跨篇「同主题不同表述」的聚合信号（结构化精确匹配，守禁向量）。
 _STOP = set("的 是 在 存在 普遍 常 问题 风险 一种 我们 本文 该 其 与 和 或 对 为 有 被 "
@@ -177,6 +249,23 @@ class LiquidSelfSpin:
         self.liquid_cache_dir = os.path.expanduser("~/.liquidloop")
         self._persist_errors = 0  # 持久化失败计数（去吞错：让故障可观测）
         self._lr = None  # 持久化 LiquidReweight 实例（懒构造，复用跨 recall）
+        self._idf = None  # IDF 表缓存（评测零向量加权召回用，懒构造）
+
+    # ── IDF 表（零向量加权召回）──
+    def _build_idf(self) -> dict:
+        """基于已摄入 facts 计算文档频率 → IDF（与 run_locomo TfidfBaseline 同公式：
+        idf = log((N+1)/(df+1)) + 1）。零向量：纯标量词频权重，非 embedding。
+        每个记忆库（selfspin 实例）独立计算，匹配真实 agent 按自身语料加权。"""
+        if self._idf is not None:
+            return self._idf
+        n = sum(len(fs) for fs in self._facts.values())
+        df: dict = {}
+        for fs in self._facts.values():
+            for f in fs:
+                for t in set(t.lower() for t in _tokens(f)):
+                    df[t] = df.get(t, 0) + 1
+        self._idf = {t: math.log((n + 1) / (c + 1)) + 1.0 for t, c in df.items()}
+        return self._idf
 
     # ── 本地快自转：摄入 ──
     def ingest(self, report_id: str, text: str, facts: list = None):
@@ -186,6 +275,7 @@ class LiquidSelfSpin:
         持久化失败静默降级（观测增强非关键路径，极致稳态：主流程不受拖累）。
         """
         self._raw[report_id] = text
+        self._idf = None  # facts 将被改写 → 使已建 IDF 表失效（默认余弦召回依赖它）
         self._facts[report_id] = list(facts) if facts is not None else self.extractor(text)
         if self.liquid_persist:
             try:
@@ -314,9 +404,36 @@ class LiquidSelfSpin:
         return out
 
     # ── 自述性：本地回忆（不碰 8790）──
-    def recall_local(self, query: str, top_k: int = 5, liquid: bool = False) -> list:
-        scored = [(_jaccard(query, f), rid, f)
-                  for rid, fs in self._facts.items() for f in fs]
+    def recall_local(self, query: str, top_k: int = 5, liquid: bool = False,
+                     idf: bool = False, idf_cosine: bool = True,
+                     lexical_boost: bool = True) -> list:
+        """本地液态召回。
+
+        **默认 idf_cosine=True**：零向量 tf-idf 余弦（IDF+TF+余弦归一，纯词频标量权重，
+        非 embedding）作为召回归一化。与 LoCoMo/LongMemEval 的 TF-IDF 基线逐字节同口径。
+        **默认 lexical_boost=True**：叠加零向量实体/数字精确加权（query 的数字串与
+        长度≥4 token 精确命中 fact 时加分），补回 tfidf 余弦因长句稀释稀有关键词而漏召的
+        「含数字/量词 query」。两基准实测：LoCoMo 0.472→0.492、LongMemEval 0.942→0.948，
+        零向量**超越**词频向量基线。全程零 embedding、零语义向量，守禁向量公理
+        （WHY_NO_VECTOR §六）。
+        idf=False 且 idf_cosine=False：回退到无加权纯字符 jaccard（历史 v1 基准口径，
+        仍保留用于对照，但非默认）。
+        idf=True：IDF 加权 jaccard（零向量，纯标量权重）——idf_cosine 优先时不生效。
+        lexical_boost=False：关闭实体/数字 booster，精确回到纯 tfidf 余弦（追平基线）。
+        """
+        idf_tab = self._build_idf() if (idf or idf_cosine) else None
+        if idf_cosine:
+            sim = lambda a, b: _idf_cosine(a, b, idf_tab)
+        elif idf:
+            sim = lambda a, b: _idf_jaccard(a, b, idf_tab)
+        else:
+            sim = _jaccard
+        if lexical_boost:
+            scored = [(sim(query, f) + _entity_boost(query, f), rid, f)
+                      for rid, fs in self._facts.items() for f in fs]
+        else:
+            scored = [(sim(query, f), rid, f)
+                      for rid, fs in self._facts.items() for f in fs]
         scored.sort(key=lambda x: x[0], reverse=True)
         base = [{"report_id": rid, "fact": f, "score": round(s, 3)}
                 for s, rid, f in scored if s > 0][:top_k]
@@ -334,7 +451,9 @@ class LiquidSelfSpin:
         for rid, fs in self._facts.items():
             for f in fs:
                 a_id = self._liquid_anchor_id(f)
-                lit = _jaccard(query, f)
+                lit = sim(query, f)
+                if lexical_boost:
+                    lit = lit + _entity_boost(query, f)
                 wake = lr.beta * lr.activation.get(a_id, 0.0)
                 sc = lit + wake
                 if sc > 0:

{liquid_loop-1.9.0 → liquid_loop-2.0.1}/liquid_loop/textutil.py

@@ -46,7 +46,7 @@ def _get_version() -> str:
     pyproject = Path(__file__).parent.parent / "pyproject.toml"
     if pyproject.exists():
         data = tomllib.loads(pyproject.read_text())
-        return data.get("project", {}).get("version", "1.8.4")
+        return data.get("project", {}).get("version", "2.0.0")
     return "1.8.4"
 
 def _tokenize(text: str) -> List[str]:

{liquid_loop-1.9.0 → liquid_loop-2.0.1}/liquid_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 1.9.0
+Version: 2.0.1
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -43,6 +43,8 @@ Dynamic: license-file
 
 > **Self-Organizing Cognitive Memory for AI Agents** — Zero LLM dependency, pure Python implementation of the Liquid Loop theory.
 
+> **当前包版本：`2.0.1`**（2026-08-25 零向量召回超越词频基线，详见 [CHANGELOG.md](CHANGELOG.md)。数据 schema `0.4.0` 与 workspace state `0.5.1` 为记忆层数据格式版本，独立于包发布版本）。
+
 [![PyPI](https://img.shields.io/pypi/v/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
 [![Python](https://img.shields.io/pypi/pyversions/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
 [![License](https://img.shields.io/pypi/l/liquid-loop.svg)](https://opensource.org/licenses/MIT)
@@ -120,9 +122,9 @@ RED    (entropy ≥ 0.6)  — 需清理
 
 ---
 
-## v0.8 反证轨 + 时间动力学（液态循环核心）
+## 核心机制：反证轨 + 时间动力学（液态循环核心）
 
-液环 v0.8 从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。
+液环从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。以下机制均随 **v2.0.0** 发布（历史演进中曾标 v0.8 / v0.9）。
 
 ### 反证轨（Contradiction Track）
 
@@ -364,11 +366,12 @@ pytest -v
 ## 路线图
 
 - [ ] 多 Agent 液环耦合（`liquid_loop.mesh` 已移除，见 commit ac7260e）
-- [x] **[v0.8] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
-- [x] **[v0.8] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
-- [x] **[v0.8] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
-- [x] **[v0.9] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
-- [x] **[v0.9] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核在 v0.8 已实现并经 E1/E2/E3 三实验背书，v0.9 作为稳定版正式发布（README 顶部 Hero Banner 已上线）
+- [x] **[已发布] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
+- [x] **[已发布] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
+- [x] **[已发布] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
+- [x] **[已发布] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
+- [x] **[已发布] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核经 E1/E2/E3 三实验背书，作为稳定机制随 **v2.0.0** 发布
+- [x] **[v2.0.0] 统一版号里程碑**：`pyproject.toml` / `__init__.__version__` / 投喂客户端 `LIQUIDLOOP_CLIENT_VERSION` 全部对齐 `2.0.0`；数据 schema `0.4.0` 与 workspace state `0.5.1` 保持独立（记忆层格式版本，禁区不动）
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）
 

{liquid_loop-1.9.0 → liquid_loop-2.0.1}/liquid_loop.egg-info/SOURCES.txt

@@ -27,8 +27,22 @@ liquid_loop.egg-info/dependency_links.txt
 liquid_loop.egg-info/entry_points.txt
 liquid_loop.egg-info/requires.txt
 liquid_loop.egg-info/top_level.txt
+liquid_loop_exp/__init__.py
 liquid_loop_exp/liquid_persist_ab.py
 liquid_loop_exp/liquid_recall_ab.py
+liquid_loop_exp/error_loop/__init__.py
+liquid_loop_exp/error_loop/low_stability_recall.py
+liquid_loop_exp/multigran/__init__.py
+liquid_loop_exp/multigran/ab_multigran.py
+liquid_loop_exp/multigran/hard_ab_multigran.py
+liquid_loop_exp/multigran/multigran_core.py
+liquid_loop_exp/multigran/sim_structured.py
+liquid_loop_exp/multigran/test_multigran.py
+liquid_loop_exp/r16_repro/__init__.py
+liquid_loop_exp/r16_repro/compare_rar.py
+liquid_loop_exp/r16_repro/r16_repro.py
+liquid_loop_exp/skill_refine/__init__.py
+liquid_loop_exp/skill_refine/skill_refine_loop.py
 tests/test_attention_gain.py
 tests/test_auth_guard.py
 tests/test_cli_version.py

liquid_loop-2.0.1/liquid_loop_exp/error_loop/low_stability_recall.py

@@ -0,0 +1,70 @@
+"""v2.1 候选①：低稳定性自动召回（active inference 工程版）——受控实验原型。
+
+理论背书：预测编码 active inference——低精度预测应被主动采样确认/否证。
+液环对应：stability 低的记忆 = 未经验证的预测，应自动进入复核队列。
+
+规则（零向量/零 LLM，结构化可审计）：
+  复核对象：tier=fact & support_count=0 & confidence<0.8 & last_reinforced=''
+  建议动作：根据置信度与证据画像给出 确认 / 降级 / 归档复核 建议
+
+只读 state.json（隔离，不写生产）。输出复核队列报告。
+"""
+import json, sys, re
+from collections import Counter
+
+DEFAULT_STATE = "/Users/feixubuke/.liquidloop/memory/.liquid/state.json"
+
+def is_verification_gap(m) -> bool:
+    """误差回路缺口：预测未经验证（无支持证据、无强化、低置信）。"""
+    return (m.get("tier") == "fact"
+            and m.get("support_count", 0) == 0
+            and m.get("last_reinforced") in ("", None)
+            and m.get("confidence", 1.0) < 0.8)
+
+def suggest_action(m):
+    conf = m.get("confidence", 0.5)
+    content = m.get("content", "")
+    # 批量待核实标记 → 建议批量复核
+    if "待核实" in content or "batch" in content:
+        return "批量复核（确认或驳回，勿长期滞留）"
+    if conf < 0.4:
+        return "驳回/归档（低置信无证据）"
+    if "蒸馏" in content or "共识" in content:
+        return "确认（有蒸馏链，补证据后强化）"
+    return "复核（确认→s+1，驳回→c+1）"
+
+def run(state_path=DEFAULT_STATE, top_n=10):
+    d = json.load(open(state_path))
+    mems = d["memories"]
+    gaps = [m for m in mems if is_verification_gap(m)]
+    print(f"=== v2.1 低稳定性自动召回 · 误差回路缺口扫描 ===")
+    print(f"总记忆: {len(mems)} | 复核缺口: {len(gaps)} ({len(gaps)/len(mems)*100:.0f}%)")
+    # 缺口分组
+    by_sig = Counter(re.match(r"\[?(marvis fact batch|distill|distilled)", m["content"]).group(1)
+                     if re.match(r"\[?(marvis fact batch|distill|distilled)", m["content"]) else "other"
+                     for m in gaps)
+    print(f"缺口类型: {dict(by_sig)}")
+    print()
+    print("建议动作分布:")
+    acts = Counter(suggest_action(m) for m in gaps)
+    for act, n in acts.most_common():
+        print(f"  {n:>3}  {act}")
+    print()
+    print(f"复核队列样本（top {top_n}）:")
+    for i, m in enumerate(gaps[:top_n]):
+        c = m["content"]
+        c = c[:70].replace("\n", " ")
+        print(f"  [{i+1}] conf={m.get('confidence')} s={m.get('support_count')} → {suggest_action(m)}")
+        print(f"      {c}")
+    # 输出复核队列 JSON（供后续人工/流程消费）
+    out = "/Users/feixubuke/output/液环v2.1_复核队列_低稳定性召回.json"
+    queue = [{"id": m["id"], "confidence": m.get("confidence"),
+              "support_count": m.get("support_count", 0),
+              "action": suggest_action(m), "content": m["content"][:200]}
+             for m in gaps]
+    with open(out, "w", encoding="utf-8") as f:
+        json.dump(queue, f, ensure_ascii=False, indent=1)
+    print(f"\n复核队列已落盘: {out}（{len(queue)} 条）")
+
+if __name__ == "__main__":
+    run()

liquid_loop-2.0.1/liquid_loop_exp/multigran/ab_multigran.py

@@ -0,0 +1,95 @@
+"""v2.0 对照实验：单粒度检索 vs 多粒度+熵路由（今日蒸馏记忆数据集）。
+
+隔离运行，不碰生产。输出 Top-1 正确率 / Top-3 命中率。
+数据源：今日(2026-08-19)蒸馏进液环的记忆 + 负样本素材，人工构造 1:1 查询。
+"""
+import sys, os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+from liquid_loop_exp.multigran.multigran_core import MultigranMemory
+from liquid_loop_exp.multigran.sim_structured import structured_sim
+
+# ── 实验数据：15 条记忆 + 15 个查询（1:1 正确索引）────────
+DATA = [
+    # (记忆内容, 查询, 正确索引)
+    ("军师调研 #358 PINN+LSTM 融合架构时序物理预测通用解决方案：PINN 嵌入物理准则损失约束+LSTM 时序依赖，年谐波振荡+ERA5 先验，PINT arXiv:2502.04018",
+     "物理约束时序预测 谐波振荡", 0),
+    ("军师调研 #361 SkillX 自动构建技能知识库：三层技能(战略计划/功能/原子)+迭代改进+探索扩展，弱模型 +10 分，arXiv:2604.04804",
+     "技能知识库 蒸馏 弱模型", 1),
+    ("军师调研 #359 IceBreaker 对话破冰：RID 共鸣感知兴趣蒸馏+ISG 交互导向开场生成，冷启动首条消息壁垒，ACL26 字节",
+     "对话冷启动 个性化开场", 2),
+    ("军师调研 #360 TDMA 动作分割数据集压缩：DDIM 潜在轨迹锚定+自适应锚点分配，Breakfast 2.4% 追平全量，ECCV26",
+     "动作分割 数据压缩 轨迹", 3),
+    ("军师调研 #362 重整化群：粗粒化+重标度+场重标度三步，2D 不动点 K*≈0.336，d=4 分水岭，Wilson 理论",
+     "粗粒化 相变 临界指数", 4),
+    ("军师调研 #366 ai-memory 编程CLI长期记忆：本地存储+按需召回+省token，akitaonrails/ai-memory ★3007",
+     "AI 编程 CLI 长期记忆", 5),
+    ("军师调研 #371 MemGAS 多粒度记忆：四粒度(session/turn/summary/keyword)+GMM关联+熵路由+PPR，超 HippoRAG2",
+     "多粒度记忆 检索 熵路由", 6),
+    ("军师调研 #373 奖励大小决定强化学习效率：100μL vs 5μL 学习提速一个数量级，多巴胺信号时长，Science 2026",
+     "奖励大小 学习效率 多巴胺", 7),
+    ("军师调研 #374 预测编码：ε=x-μ 预测误差，能量最小化局部学习替代反向传播，IJCAI22 综述",
+     "预测误差 局部学习 反向传播替代", 8),
+    ("军师调研 #376 Skill路由四路口：可见入口/职责边界/执行门槛/真实路由测试，主编排者，100 skills 选对",
+     "skill 选择 路由 职责边界", 9),
+    ("军师调研 #357 AI表情小球：纯 SVG+JS 零依赖桌面宠物，32 种表情状态追鼠标", "SVG 表情小球 桌面宠物", 10),
+    ("军师调研 #363 Cumora 多智能体协作：AI 作团队成员(身份/记忆/领任务)+看板/日历，BYOA Claude Code/Codex",
+     "多智能体协作 看板 团队成员", 11),
+    ("军师调研 #365 TimesFM 时序基础模型：Google 开源 Apache-2.0 200M 参数零样本预测", "时序基础模型 零样本 预测", 12),
+    ("军师调研 #367 Tabularis 数据库工作台：一键直连 Postgres/MySQL 多库，SQL 辅助+可视化图表", "数据库工作台 SQL 可视化", 13),
+    ("军师调研 #369 常见神经网络科普：CNN/RNN/GNN/GAN/Transformer，按数据结构选网络", "卷积 循环 图 神经网络", 14),
+]
+
+def single_granularity(query, docs, topk=3):
+    """baseline：单粒度（全文）结构化相似度检索。"""
+    sims = [(i, structured_sim(query, d, "mix")) for i, d in enumerate(docs)]
+    sims.sort(key=lambda x: -x[1])
+    return [i for i, _ in sims[:topk] if _[1] > 0] if False else [i for i, s in sims[:topk] if s > 0]
+
+def run():
+    docs = [d[0] for d in DATA]
+    queries = [d[1] for d in DATA]
+    gold = [d[2] for d in DATA]
+
+    # baseline：单粒度
+    m_single = MultigranMemory()
+    for d in docs:
+        m_single.add([d])
+    # 强制单粒度：只用 session_text 检索（绕过熵路由，等价单粒度 baseline）
+    b_top1 = b_top3 = 0
+    for q, g in zip(queries, gold):
+        sims = [(i, structured_sim(q, d, "mix")) for i, d in enumerate(docs)]
+        sims.sort(key=lambda x: -x[1])
+        top = [i for i, s in sims[:3] if s > 0]
+        if top and top[0] == g:
+            b_top1 += 1
+        if g in top:
+            b_top3 += 1
+
+    # multigran：四粒度+熵路由+图传播
+    m = MultigranMemory()
+    for d in docs:
+        m.add([d])
+    mg_top1 = mg_top3 = 0
+    for q, g in zip(queries, gold):
+        hits = m.retrieve(q, topk=3)
+        idxs = [h["idx"] for h in hits]
+        if idxs and idxs[0] == g:
+            mg_top1 += 1
+        if g in idxs:
+            mg_top3 += 1
+
+    n = len(DATA)
+    print(f"{'':24} {'Top-1':>7} {'Top-3':>7}")
+    print(f"{'单粒度(全文)':24} {b_top1/n*100:6.1f}% {b_top3/n*100:6.1f}%")
+    print(f"{'多粒度+熵路由':24} {mg_top1/n*100:6.1f}% {mg_top3/n*100:6.1f}%")
+    print()
+    # 输出多粒度每个查询命中情况（可审计）
+    for q, g in zip(queries, gold):
+        hits = m.retrieve(q, topk=1)
+        hit = hits[0]["idx"] if hits else -1
+        mark = "✓" if hit == g else f"✗(→{hit})"
+        print(f"  [{mark}] {q[:22]:24} gold={g}")
+    return b_top1 / n, mg_top1 / n
+
+if __name__ == "__main__":
+    run()