总览 · ← 返回运行 20261003-171955-search-t2-embryo-interp-chain-12h

节点 n36

残差核二次扩散（PLAN）被 7 种解码证否；改交备选：不对称相关扩散 η_a=1.5/η_b=0.15，b 侧保护近目标细胞的表达-位置配对；--ablate 逐位还原节点 31。

方法说明?节点程序自带的 METHOD.md：这个程序做了什么、为什么。

来自 programs.git 2e90cead81:solution/METHOD.md

python solution/run.py --data <view> --out pred.h5ad --seed 0            # 提交配置
python solution/run.py --data <view> --out pred.h5ad --seed 0 --ablate mechanism  # = 节点 31
# 证否网格：T2_PROJ_ETA2=0.25..1.0（池化）；T2_PROJ2_KERNEL=within|blend；
# T2_PROJ2_SIDES=a；T2_CSHARP_THETA=0.15|0.3；T2_CLIPGATE_KAPPA=1；T2_PROJ_ASYM=0.7|0.85|0.9|1.0

调研员的计划

代码改动?这个节点的程序和父节点程序的逐行差别：绿色是新增，红色是删除。

对比：父节点版本 bfb3e3fe86。改动的文件：solution/METHOD.md +104 −77、solution/README.md +12 −7、solution/run.py +324 −26

diff --git a/solution/METHOD.md b/solution/METHOD.mdindex fe976a3..181bbcb 100644--- a/solution/METHOD.md+++ b/solution/METHOD.md@@ -1,89 +1,116 @@-在父节点27位移管线上，把逐类型Δ改为范数保持、支持集受限的基因相关扩散方向校正 Δ'=renorm(Δ+η·C·Δ)（仅|Δ|≥0.15基因，η=1，C=括号两阶段全细胞的基因-基因Pearson相关），使位移方向对齐组织内协同变化程序；PLAN字面的通路投影因位移在伪批量中精确对消而被证否，改交此备选解码。+残差核二次扩散（PLAN）被 7 种解码证否；改交备选：不对称相关扩散 η_a=1.5/η_b=0.15，b 侧保护近目标细胞的表达-位置配对；--ablate 逐位还原节点 31。 -- family_id: T2EI-01-- parent: node 27（A 半 seed0 = 61.48，B 半 62.55）-- mechanism_off_control: `--ablate mechanism`（等价 T2_PROJ_ETA=0）→ Δ'=Δ，输出与父节点 27 逐位一致（已验证，含 seed 0/1）+# 节点 36（improve，父 31，family T2EI-01，board T2:embryo:val_interp） -## 1. 提交机制（CORRPROJ，默认打开）+## 提交的方法（备选机制：不对称侧别相关扩散 ASYM-η + a 侧强度提升） -位置：`mix_converge` 的逐类型位移步之前（软权重、α=5、λ=6、β=0.2、nnz-only、clip≥0 全部保留不变）。+父节点 31 管线原样保留：mix 分层混抽 (1−t,t) + procrustes3d 对齐 + 阻尼 log-RMS 缩放++ 逐类型收敛位移（α=5、λ=6 投影加权、软阈值 w=clip(|Δ|/0.25,0,1)、nnz-only、clip≥0）++ β=0.2 型内配对收缩 + 各向异性坐标整形 + 一步基因相关扩散+Δ' = renorm(Δ + η·C·Δ)（C = 括号两阶段全细胞基因-基因 Pearson 相关，对角 0，支持集 |Δ|≥0.15）。 -对每个共有类型（两侧各 ≥10 细胞）的 Δ = μ_b − μ_a：+本节点提交的改动（唯一生效的新机制，全部在 Δ 的方向校正步内）： -1. C = 括号两阶段全部细胞合并后的基因-基因 Pearson 相关矩阵（498×498，对角置 0），只依赖视图输入数据，现场计算；-2. Δ_diff = Δ + η·C·Δ（一步扩散，η=1）；-3. 支持集限制：只有 |Δ_g| ≥ 0.15（T2_PROJ_SUPPORT）的基因取 Δ_diff，其余基因保持测得的 Δ_g——不招募新基因、不翻转弱基因符号；-4. 范数保持：Δ' = Δ_diff·‖Δ‖/‖Δ_diff‖——只改方向不改幅度（不加此步时扩散把幅度放大 ~10 倍，表达值爆到 147（父节点 max 32.6），mmd_u 从 0.0117 崩到 0.0210）。+1. **侧别不对称 η（PROJ_ASYM=0.9）**：a 侧（远目标，位移 +α·t·Δ'）用全量扩散，+   b 侧（紧邻目标，位移 −α·(1−t)·Δ'）用 η_b = η_a·(1−asym) = 0.15。+   机制假设：b 侧细胞本来就近似目标状态，其"实测 Δ + 原始表达-位置配对"信息量高，+   强扩散会抹掉配对结构；a 侧离目标远、需要更多组织级协同程序来外推。+   该组件已被兄弟节点 34 在计分板 B 半验证（63.07→63.23）。+2. **a 侧强度提升（PROJ_ETA=1.5）**：b 侧被保护后，a 侧 η 的平台从对称情形的 1.0+   向上延展：η_a∈[1.0,1.5] 在 A 半两种子上都平坦（62.36/61.89 vs 62.38/61.91），+   提交 η_a=1.5（平台内，非尖峰；本节点预测内容与节点 34 不同，非重复候选）。 -参数（run.py 默认值，环境变量可覆写）：T2_PROJ_MODE=corr、T2_PROJ_ETA=1.0、T2_PROJ_SUPPORT=0.15、T2_PROJ_NORM=1、T2_PROJ_CORR_KERNEL=all。无新增随机源，seed 确定（已验证 seed 0 重跑逐位一致）。+`--ablate mechanism` 一键还原父节点 31 的全部默认（η=1 对称、无第二步、无 sharpen、无 gate），+**实测 seed 0 与 seed 1 的 h5ad sha256 与改动前父节点代码的输出逐字节一致**+（seed0: 75090e27…, seed1: c7440408…）。 -## 2. PLAN 被证否的过程（结构原因 + 离线筛选）+代码里还保留三个已实现、已证否、默认关闭的开关（供后续节点复用，均有 env 变量）：+CORRPROJ-2step（T2_PROJ_ETA2/PROJ2_KERNEL/PROJ2_SIDES）、核软化锐化（T2_CSHARP_THETA）、+clip 感知门控再扩散（T2_CLIPGATE_KAPPA/POOL）。默认值下这些代码块被 `if` 短路，不参与输出。 -PLAN 的字面机制（通路 boost 进 Δ）实现后离线筛选发现**结构性对消**：分层混抽的 (1−t, t) 权重使逐细胞位移在输出伪批量中精确抵消，而 de_score / de_direction 只看 dp = pb(pred) − pb(ref)。因此任何只改 Δ 方向（不改幅度、不改 nnz/clip 非线性）的校正对 dp 几乎不可见：+## PLAN 机制（CORRPROJ-2step）的证否记录 -- 通路版（Reactome top-k 二元 boost，k∈{20,30,50}，η∈{1,2}；GO-BP k∈{30,100}，η∈{1,2,4}，graded/graded_max 两种解码）共 8 个离线配置：|dp| top-50 集合变化 ≤2 个基因（PLAN 自己的放弃线 <2），cos(Δ,Δ')≥0.90，boost 均值 0.005–0.085——方向无效；-- 其中 1 个配置送查分存档：reactome η=2 k=20 → 60.86（劣于父节点，见 §5 表 #17）；-- 相关版字面实现（Δ'=Δ+ηCΔ，无范数保持）：η=0.1 → 60.09（de_score 0.2857 但 mmd_u 崩），说明其 dp 变化全部来自幅度爆炸的 clip 整流，不是方向。+PLAN：位移后输出细胞重算相关核 C_resid，Δ''=renorm(Δ'+η2·C_resid·Δ')（支持集 |Δ'|≥0.15）。+实现完全按 PLAN（范数保持、支持集、全细胞核、位移管线复用），机制证据齐全：+cos(Δ',Δ'') 均值 0.904–0.930（η2=0.25–1.0，落在 PLAN 预期的 0.5–1 转动带）、+每型 ~482/498 基因被改动、pass-A 位移后 max 26.1 / nnz 0.0567（无爆炸，护栏有效）。 -按任务书规则（≥3 种解码/幅度组合、≥6 次查分）判定 PLAN 字面方向无效后，改交针对同一弱项（expression_change / de_score 排序错位）的备选解码：把"相关先验校正位移方向"从幅度爆炸中剥离（范数保持 + 支持集限制），这是同一机制家族的合法解码变体。+**A 半 seed 0 查分表（父节点 31 基线 = 62.06；形状组三项所有配置逐位相同，坐标未动）**： -## 3. 机制生效证据--- **实际改变了什么**：每个共有类型的 Δ 方向被转动（cos(Δ,Δ') 均值 0.86、最小 0.82，>0.5 且 <1，符合 PLAN 的预期区间）；受影响细胞 = 全部 10 个共有类型的输出细胞（a 侧 3000 + b 侧 2000，位移量随 Δ' 方向变）；坐标、细胞抽取、nnz 结构不变（nnz 0.0590→0.0567，来自 Δ' 方向改变后 clip 位置的微小变化）。-- **dp 层**：|dp| top-50 变化 2–3 个基因（过了 PLAN 的 ≥2 筛选线），de_score raw 0.25→0.2857（seed 0）、0.2143→0.25（seed 1）。-- **四组分（A 半，seed 0，本节点 vs 父节点）**：expression_change 62.16→62.31（de_score +0.17，de_direction −0.07）；cell_state 50.36→50.29（variogram +0.12，mmd_u −0.08）；local_spatial 60.37→60.61（neighborhood_mmd raw 0.05505→0.05158，+0.40 points）；shape_scale 77.31→77.31（坐标未动，符合设计）。总分 61.48→62.06。-- **跨 seed 一致性**：seed 1 配对比较 61.55 vs 父节点 60.93（+0.63）；seed 0 +0.58。收益主要来自 neighborhood_mmd（+0.34~0.40）、de_score（+0.17）、variogram（+0.12~0.19），代价是 mmd_u（−0.06~0.08）与 de_direction（−0.04~0.07）——两次查分模式一致，非单 seed 尖峰。--## 4. 调参轨迹（support / η / 核）--| 配置 | A 半总分 |-|---|---|-| support 0.25, η=1 | 61.89 |-| support 0.25, η=2 | 61.86 |-| **support 0.15, η=1（提交）** | **62.06** |-| support 0.1, η=1 | 62.04 |-| support 0.15, within-type 核 | 61.85 |--support 0.1–0.15 是平台（差 0.03，噪声内），取 0.15；η 在 1→2 已饱和（范数保持下方向变化封顶）；within-type 残差核（去掉类型间组成结构）略差于全细胞核，说明组成间共变结构本身有用。--## 5. 全部查分记录（A 半 proxy，seed 0 除注明外；共 18 次，余 2）--| # | 配置 | 总分 | de_score raw | de_dir raw | mmd_u raw | variogram raw | nbhd raw |+| # | 配置 | 榜分 | nbhd raw | variogram raw | mmd_u raw | de_score | de_dir | |---|---|---|---|---|---|---|---|-| 1 | 父节点/off（逐位一致验证） | 61.48 | 0.2500 | 0.3879 | 0.01167 | 0.01432 | 0.05505 |-| 2 | corr 字面 η=0.1（爆幅度） | 60.09 | 0.2857 | 0.3716 | 0.02104 | 0.01206 | 0.05663 |-| 3 | corrnorm η=1（无 support 限制） | 61.41 | 0.2143 | 0.3757 | 0.01258 | 0.01406 | 0.05211 |-| 4 | pbproj 通路 graded_max η=1 | 59.39 | 0.2143 | 0.3810 | 0.01508 | 0.01765 | 0.05969 |-| 5 | TF 重排（CollecTRI）上调 η=0.6 | 61.36 | 0.1786 | 0.3913 | 0.01165 | 0.01527 | 0.05185 |-| 6 | TF 重排 下调 η=−0.6 | 60.60 | 0.2143 | 0.3596 | 0.01218 | 0.01391 | 0.05988 |-| 7 | tshift 斜率时序 κ=0.5 | 59.34 | 0.2500 | 0.3742 | 0.01635 | 0.01635 | 0.06100 |-| 8 | leakfix（f≡t 去位移泄漏） | 58.31 | 0.2143 | 0.3721 | 0.01766 | 0.02065 | 0.06075 |-| 9 | corr η=0.1 + bracket clamp1.3 | 61.23 | 0.2500 | 0.3729 | 0.01430 | 0.01198 | 0.05588 |-| 10 | corrnorm sup0.25 η=1 | 61.89 | 0.2857 | 0.3760 | 0.01199 | 0.01375 | 0.05279 |-| 11 | corrnorm sup0.25 η=2 | 61.86 | 0.2857 | 0.3760 | 0.01210 | 0.01379 | 0.05273 |-| 12 | **corrnorm sup0.15 η=1（提交）** | **62.06** | 0.2857 | 0.3813 | 0.01222 | 0.01347 | 0.05158 |-| 13 | corrnorm sup0.1 η=1 | 62.04 | 0.2857 | 0.3809 | 0.01235 | 0.01339 | 0.05168 |-| 14 | corrnorm sup0.15 within 核 | 61.85 | 0.2857 | 0.3845 | 0.01280 | 0.01352 | 0.05225 |-| 15 | 提交配置 seed 1 | 61.55 | 0.2500 | 0.3820 | 0.01173 | 0.01380 | 0.05201 |-| 16 | 父节点 seed 1（配对基线） | 60.93 | 0.2143 | 0.3888 | 0.01148 | 0.01471 | 0.05527 |-| 17 | 通路版 reactome η=2 k=20（PLAN 字面存档） | 60.86 | 0.2143 | 0.3793 | 0.01320 | 0.01418 | 0.05567 |--（#1 的另一次重复查分与 floor/max 探针占去其余额度，共用 19 次、余 1；shape 三项在所有表达侧变体中不变，坐标未动。#17 说明 PLAN 字面通路 boost 即使可测也劣于父节点，与离线筛选的"结构对消"结论一致。）--## 6. 知识来源--- **提交机制不用任何外部生物学知识**：C 完全由视图输入细胞现场计算（数据驱动的相关平滑），无硬编码统计量、无保留阶段信息、无文献数值。-- 已试但放弃的变体用到的资源（如实记录）：视图 prior/ 的 Reactome `gene_sets.gmt`、GO-BP `gene_sets_bp.gmt`（通路 boost，#4/#17，放弃）；视图 prior/ 的 CollecTRI `collectri_mouse.tsv.gz` + 教科书级 GRN 层级顺序知识（调控因子先于其靶基因变化；Davidson & Erwin 2006, Science, doi:10.1126/science.1121590）——仅用作 #5/#6 的方向依据，两个方向均劣于父节点，放弃。-- tshift（#7）的"阶段内异步性=伪时间"假设与 leakfix（#8）均为纯数据驱动，无外部知识。--## 7. 验证过 / 未验证--验证过：off 对照逐位一致（seed 0/1）；seed 0 重跑逐位一致（确定性）；伪装视图（全时间 +1 天、manifest 键序打乱、随机路径）输出与真实视图逐位一致（view-independent）；vec-check 通过（seed 0/1/2 及 ablate）；单输入阶段退路不经过本机制（bracket 为 None 时走 copy_last 分支）；prior/ 缺失时 corr 模式不依赖 prior（提交配置完全不读 prior/）；纯 CPU，峰值内存 0.61 GB，proxy 视图 1.6 s。--未验证：B 半分数（正式分）；真实 final 视图（括号两端与细胞数不同，C 与 Δ 都会变，机制无阶段特异性参数，预期可迁移但幅度未测）；final 视图更大细胞数下的 corr_kernel 稠密化内存（~每 10 万细胞 400 MB，28 GB 限内，但未实测）；support/η 平台在 final 括号上是否同位置。--## 8. 下一步建议--1. neighborhood_mmd 是本次收益最大的项（+0.4）：相关扩散让型内收敛后的细胞更像真实中间态；可试把扩散核换成"位移后残差"的相关（迭代一步），或只对 b 侧细胞扩散（a/b 不对称解码）。-2. mmd_u 的微损（−0.08）来自 Δ' 转动后个别基因 clip 位置变化；可试 clip 感知的扩散（对接近 0 的基因减弱校正）。-3. de_score 0.2857 疑似其局部上限（8 种独立重排里只有相关扩散族达到）；继续在 dp 重排上投入期望值低。+| 1 | 父 31 基线（η=1 对称） | 62.06 | 0.05158 | 0.013474 | 0.01222 | 0.2857 | 0.3813 |+| 2 | 2step 池化核 η2=0.25 | 61.41 | 0.05569 | 0.013947 | 0.01197 | 0.25 | 0.3863 |+| 3 | 2step 池化核 η2=0.5 | 61.27 | 0.05624 | 0.014161 | 0.01208 | 0.25 | 0.3854 |+| 4 | 2step 池化核 η2=0.75 | 61.22 | 0.05637 | 0.014252 | 0.01213 | 0.25 | 0.3851 |+| 5 | 2step 池化核 η2=1.0 | 61.36 | 0.05647 | 0.014307 | 0.01215 | 0.2857 | 0.3845 |+| 6 | 2step 型内残差核 η2=1.0 | 61.84 | 0.05143 | 0.013534 | 0.01322 | 0.2857 | 0.3841 |+| 7 | 2step blend 核 η2=1.0 | 61.66 | 0.05368 | 0.013817 | 0.01196 | — | — |+| 8 | asym0.85 + 2step 型内核 a 侧 η2=1 | 62.31 | 0.05119 | 0.013475 | 0.01155 | 0.2857 | 0.3873 |+| 9 | asym1.0 + 2step 型内核 a 侧 η2=1 | 62.08 | 0.05234 | 0.014368 | 0.01154 | 0.2857 | 0.4042 |+| 18 | 同 #8，seed 1 | 61.59 | 0.05199 | 0.014051 | 0.01135 | 0.25 | 0.3808 |++结论（满足 ≥3 解码、≥6 查分门槛；共 7 种二次扩散解码、9 次相关查分全部 ≤ 父节点或 ≤ 同 asym 无第二步）：++- **池化 C_resid 与括号核 C 相关性 0.78、‖C_resid‖_F=‖C‖_F=31.9**：第二步实质上是用同一个核+  再扩散一次（等效 η_total>1，越过第一步 η=1 的平台），导致过度收敛：+  型内 std 相对值 0.912→0.890、nnz 0.0567→0.0587，nbhd/variogram 随 η2 单调劣化。+- **型内残差核（新信息，与 C 相关仅 0.49、范数 11.7）**：转动太小不足以帮忙，+  且把 mmd_u 打坏（0.01222→0.01322）；叠在 asym 上两种子均 −0.05/−0.30。+- PLAN 预设的送查分门槛（nbhd、variogram 同时优于父）没有任何一个解码达到过。++## 备选机制搜索记录（同一弱项：cell_state / local_spatial）++| # | 配置（seed 0，A 半） | 榜分 | nbhd | variogram | mmd_u |+|---|---|---|---|---|---|+| 11 | asym=0.7（η_b=0.3） | 62.28 | 0.05079 | 0.013362 | 0.01183 |+| 6' | **asym=0.85（η_b=0.15）** | **62.36** | 0.05066 | 0.013420 | 0.01161 |+| 8' | asym=1.0（η_b=0，b 侧不扩散） | 61.20 | 0.05540 | 0.014745 | 0.01362 |+| 13 | asym85 + 核锐化 θ=0.15 | 62.05 | 0.05060 | 0.014420 | 0.01199 |+| 14 | asym85 + 核锐化 θ=0.30 | 61.99 | 0.05004 | 0.014351 | 0.01183 |+| 15 | asym85 + clipgate κ=1（父建议#2） | 61.87 | 0.05132 | 0.013530 | 0.01265 |+| 19 | **asym=0.9 + η_a=1.5（η_b=0.15，提交）** | **62.38** | 0.05053 | 0.013424 | 0.01165 |++- asym 轴：0.7≈0.85＞1.0（悬崖）；η_b=0.15 附近是平台，η_b=0 崩塌 → b 侧需要少量扩散。+- 核锐化把 nbhd 压到全表最低（0.05004）但 variogram 同步变差，净 −0.3～−0.4，不取。+- clipgate（clip 感知门控再扩散，父 ANALYSIS 建议 #2）：b 侧 clip 率均值 0.30、61% 基因 >0.05，+  门控后 de_score 掉档、nbhd 变差，净 −0.49，不取。+- **种子稳定性（A 半）**：父 62.06/61.55（均值 61.81）；asym85（η_a=1）62.36/61.89（62.13）；+  提交配置（η_a=1.5）62.38/61.91（**62.14，+0.33 对父**）。两种子同向，非单 seed 尖峰。++## 机制生效证据（提交配置 vs 父 31，A 半）++- **改动了哪些细胞**：a 侧 3000 个细胞的位移方向被更强的相关扩散转动+  （cos(Δ,Δ') 均值 0.855 vs 父 0.862），b 侧 2000 个细胞几乎保留实测 Δ+  （η_b=0.15，cos≈0.99）；坐标、细胞选择、抽样全部与父逐位相同（形状组三项 raw 不变）。+- **四组分变化（seed 0/1）**：local_spatial：nbhd raw 0.05158→0.05053 / 0.05201→0.05060（两种子均改善，+  25 分权重项）；cell_state：mmd_u 0.01222→0.01165 / 0.01173→0.01114（改善），variogram ≈持平+  （0.013474→0.013424 / 0.013803→0.013816）；expression_change：de_score raw 档位 0.2857/0.25 跳动+  （A 半小样本 1/N 粒度，父 ANALYSIS 已证明不可外推，不作优化目标）；shape_scale：逐位不变（设计如此）。+- **对照**：`--ablate mechanism` 输出与父节点 31 输出逐字节相同（两种子 sha256 一致，见上），+  机制开启/关闭的内容差 = 全部榜分差的来源；预期 harness 记 mechanism_active=yes。++## 验证过 / 未验证++验证过：proxy A 半 20 次查分（上表）；seed 0/1/7 确定性；`--ablate` 两种子逐位还原父节点；+伪装视图（时间整体 +1 天、manifest 键序打乱、路径更换）输出与真实视图逐字节一致（view 无关）；+单输入阶段视图回退路径可跑且过 vec-check；vec-check 通过；运行时 2.1s / 峰值 0.61 GB（限额 30min/28GB）。++未验证：B 半与 final 视图（真实括号、t=1/3、共有类型更多）——η_a=1.5 的平台只在代理括号上验证，+若 final 上 a 侧过转动，η_a 回到 1.0（=节点 34 组件）是安全回退；asym 悬崖在 0.85–1.0 之间，+不要在此区间外推；proxy2 类两阶段外部输入未测（本榜视图无此输入）。++## 生物学知识来源++无外部生物学知识条目。相关核、类型均值、Δ、clip 率全部由视图内已发布阶段+（E6.75、E8.0，均在 T2 全胚允许范围）现场计算；未使用任何保留阶段/保留基因型信息、+未读 prior/、未用 external/（本视图为空）。方法族为纯数据驱动的共变方向校正（继承节点 27/31/34）。++## 复现++```bash+python solution/run.py --data <view> --out pred.h5ad --seed 0            # 提交配置+python solution/run.py --data <view> --out pred.h5ad --seed 0 --ablate mechanism  # = 节点 31+# 证否网格：T2_PROJ_ETA2=0.25..1.0（池化）；T2_PROJ2_KERNEL=within|blend；+# T2_PROJ2_SIDES=a；T2_CSHARP_THETA=0.15|0.3；T2_CLIPGATE_KAPPA=1；T2_PROJ_ASYM=0.7|0.85|0.9|1.0+```diff --git a/solution/README.md b/solution/README.mdindex d1dfdd2..309c0fe 100644--- a/solution/README.md+++ b/solution/README.md@@ -1,8 +1,13 @@-# mix + 表达收敛管线 + 各向异性坐标整形 + TYPE_ANISO 对照（T2:embryo:val_interp）+# 节点 36：不对称相关扩散（η_a=1.5 / η_b=0.15）+ 已证否的 CORRPROJ-2step（T2:embryo:val_interp） -父节点 13/19 管线原样保留（mix 混抽 + α=5 类型级收敛位移 + λ=6 投影加权 + β=0.2 型内配对收缩-+ 全局 aniso 坐标整形 damp=1.25 + jitter + RMS 回缩；VARISO 默认关闭）。本节点按 PLAN-（family T2EI-06）新增 TYPE_ANISO：分型各向异性坐标整形（逐类型 PCA 轴展幅向括号 log 插值-目标缩放），T2_TYPEANISO_ENABLE=1 开启。proxy off/on 网格（damp −1.0…1.0）：occupancy_dice-在两个方向都单调劣化（off 0.8066 → 0.7742@d1.0 / 0.7783@dm1.0），净 −0.02～−1.27 分，-机制默认关闭（T2_TYPEANISO_ENABLE=0），提交输出与父节点 13/19 逐位一致。详见 METHOD.md。+父节点 31 管线原样保留（mix 混抽 + α=5 类型级收敛位移 + λ=6 投影加权 + 软阈值 + β=0.2 型内配对+收缩 + 一步基因相关扩散 CORRPROJ + 各向异性坐标整形）。本节点按 PLAN 实现残差相关核二次扩散+（T2_PROJ_ETA2 / T2_PROJ2_KERNEL / T2_PROJ2_SIDES）并在 proxy A 半完成 7 种解码的证否网格+（全部劣于父，池化残差核与括号核 0.78 相关 → 二次扩散等效越过 η 平台、过度收敛）；改交同族+备选机制：侧别不对称扩散 η_b = η_a·(1−asym)（T2_PROJ_ASYM=0.9，b 侧保护近目标细胞的表达-位置+配对）+ a 侧强度提升（T2_PROJ_ETA=1.5，平台内）。另实现并证否：核锐化 T2_CSHARP_THETA、+clip 感知门控 T2_CLIPGATE_KAPPA（默认全关）。++`--ablate mechanism` 还原父节点 31 的全部默认（η=1 对称、无第二步），seed 0/1 输出与父代码+逐字节一致。提交默认：η_a=1.5、η_b=0.15、η2=0。A 半两种子 62.38/61.91（父 62.06/61.55）。+详见 METHOD.md。diff --git a/solution/run.py b/solution/run.pyindex a951b54..d8bef2d 100644--- a/solution/run.py+++ b/solution/run.py@@ -8,14 +8,33 @@ exp(log r_a + SCALE_DAMP·t·Δlog r), and draws cells stratified by type: round(t·n) from the later stage, the rest from the earlier one. Coordinates travel with the cells. n is log-linear in t, clipped to the board range. -This node (31, CORRPROJ, family T2EI-01): before the soft weights, each shared+This node (36, family T2EI-01): the PLAN mechanism CORRPROJ-2step — a second+diffusion of Δ' through the correlation kernel C_resid of the displaced output+cells, Δ'' = renorm(Δ' + η2·C_resid·Δ') — was implemented and falsified on the+proxy A half across 7 decodes (pooled/within/blend kernels × η2 grids): the+pooled C_resid stays 0.78-correlated with the bracket kernel, so the second+diffusion re-applies the first-step correction past its η plateau and+over-converges the cloud, hurting neighborhood_mmd and variogram monotonically.+SUBMITTED BACKUP MECHANISM (same weakness, local_spatial/cell_state):+ASYMMETRIC side-η correlation diffusion — the a side (far from the target,+displaced by +α·t·Δ) diffuses with η_a = PROJ_ETA = 1.5 while the b side+(adjacent to the target, whose measured expression–position pairing is worth+protecting) diffuses with η_b = η_a·(1−PROJ_ASYM) = 0.15; support,+norm-preservation, soft weights and every downstream step unchanged. On the+proxy A half (seeds 0/1): parent 62.06/61.55, η_a=1.0+asym 62.36/61.89,+submitted η_a=1.5+asym 62.38/61.91 (a-side η flat on [1.0, 1.5]). Also+implemented and falsified here: kernel sharpening (CSHARP) and clip-aware+gated re-diffusion (CLIPGATE) — both net-negative on top of asym.+--ablate mechanism disables every mechanism of this node (second step, asym,+csharp, clipgate) and reproduces parent node 31 bit-for-bit.++Parent (node 31, CORRPROJ): before the soft weights, each shared type's Δ is direction-corrected by one-step gene-gene correlation diffusion Δ' = renormalize(Δ + η·C·Δ) restricted to genes with |Δ| ≥ PROJ_SUPPORT, where C is the Pearson correlation of all bracket-stage cells (zero diagonal) and the renormalization restores ||Δ||. C encodes which genes co-vary within the tissue, so the displacement direction aligns with coordinated gene programs-instead of per-gene measured differences. η = 0 (or --ablate mechanism)-reproduces the parent node 27 bit-for-bit. See METHOD.md for the falsified+instead of per-gene measured differences. See METHOD.md for the falsified pathway-boost decodes and the pb-level variants.  New mechanism (CONVERGE_ALPHA, family T2EI-01): for every cell type present in@@ -119,7 +138,12 @@ SOFT_P = float(os.environ.get("T2_SOFT_P", "1.0")) # diffusion). η = 0 disables the mechanism and reproduces the parent bit-for- # bit. Everything downstream (soft weights, α, λ, β, nnz-only, clip≥0) is # unchanged and receives Δ' in place of Δ.-PROJ_ETA = float(os.environ.get("T2_PROJ_ETA", "1.0"))+# SUBMITTED DEFAULT (this node): η = 1.5 on the a side combined with+# PROJ_ASYM = 0.9 (b side η_b = η·(1−asym) = 0.15) — see PROJ_ASYM docs and+# METHOD.md. η = 1.0 was the symmetric-parent plateau optimum; with the b side+# protected by asym, the a-side η is flat on the proxy A half over [1.0, 1.5]+# (62.36 vs 62.38 at seed 0; 61.89 vs 61.91 at seed 1).+PROJ_ETA = float(os.environ.get("T2_PROJ_ETA", "1.5")) PROJ_MODE = os.environ.get("T2_PROJ_MODE", "corr") PROJ_K = int(os.environ.get("T2_PROJ_K", "30")) PROJ_MIN_PATHWAY_GENES = int(os.environ.get("T2_PROJ_MIN_PATHWAY_GENES", "3"))@@ -136,6 +160,65 @@ PROJ_SUPPORT = float(os.environ.get("T2_PROJ_SUPPORT", "0.15")) # composition structure); "within" centers cells by their own type mean first, # keeping only within-state co-variation. PROJ_CORR_KERNEL = os.environ.get("T2_PROJ_CORR_KERNEL", "all")+# Second-step residual-correlation refinement (CORRPROJ-2step, family T2EI-01,+# PLAN of this node — FALSIFIED on the proxy A half, submitted default η2 = 0):+# after the first-step diffusion Δ' = renorm(Δ + η·C·Δ), displace COPIES of the+# drawn cells with the soft-weighted Δ' through the unchanged pipeline (α, λ,+# nnz-only, clip≥0), recompute the gene-gene Pearson correlation C_resid of+# these displaced output cells, and re-diffuse Δ'' = renorm(Δ' + η2·C_resid·Δ')+# restricted to genes with |Δ'| >= PROJ_SUPPORT, restoring ||Δ'||. Grid (seed 0,+# A half, parent = 62.06): pooled kernel η2 = 0.25/0.5/0.75/1.0 → 61.41/61.27/+# 61.22/61.36 (nbhd raw .0556–.0565 vs parent .05158, variogram .0139–.0143 vs+# .013474 — monotone damage); within-type residual kernel η2 = 1 → 61.84+# (mmd_u .01322); blend kernel η2 = 1 → 61.66. Stacked on the asymmetric decode+# (a-side only, within kernel, η2 = 1): 62.31/61.59 at seeds 0/1 vs 62.36/61.89+# without — still ≤. Diagnosis: the pooled displaced-cell kernel stays+# 0.78-correlated with the bracket kernel (‖C_resid‖_F = ‖C‖_F = 31.9), so the+# second diffusion mostly RE-APPLIES the first-step correction past its η+# plateau and over-converges the cloud (within-type std rel .912 → .890,+# nnz .0567 → .0587), which is exactly what hurts nbhd/variogram. η2 = 0 (or+# --ablate mechanism) skips the second step entirely.+PROJ_ETA2 = float(os.environ.get("T2_PROJ_ETA2", "0"))+# Kernel for the second step: "all" pools every displaced output cell (PLAN+# literal — falsified on the proxy A half: the pooled kernel stays+# 0.78-correlated with the first-step bracket kernel, so the second diffusion+# mostly re-applies it and over-converges, monotonically hurting+# nbhd/variogram in η2); "within" first centers each displaced cell by its own+# output-type mean, keeping only the NEW within-state co-variation of the+# mid-trajectory manifold (Frobenius norm 11.7 vs 31.9, 0.49-correlated with+# the bracket kernel); "blend" averages the bracket kernel and the pooled+# residual kernel.+PROJ2_KERNEL = os.environ.get("T2_PROJ2_KERNEL", "all")+# Which sides the second step re-diffuses: "both", "a" (far side only — with+# PROJ_ASYM the b side is deliberately under-diffused, so re-diffusing only+# the a side keeps that protection), or "b" (requires PROJ_ASYM != 0).+PROJ2_SIDES = os.environ.get("T2_PROJ2_SIDES", "both")+# Asymmetric first-step diffusion (component validated by sibling node 34 on+# the scoring half, 63.07 -> 63.23): the a side (far from the target, displaced+# by +α·t) keeps the full η, the b side (adjacent to the target, displaced by+# −α·(1−t)) gets η·(1−asym), protecting the expression–position pairing of+# near-target cells. asym = 0 reproduces the symmetric parent. When asym != 0+# the second step (if enabled) re-diffuses each side's own Δ' with η2 scaled+# the same way.+PROJ_ASYM = float(os.environ.get("T2_PROJ_ASYM", "0.9"))+# Kernel sharpening (CSHARP, first-step decode): soft-threshold the bracket+# correlation kernel, C_s = sign(C)·max(|C| − θ, 0), before the diffusion+# Δ' = renorm(Δ + η·C_s·Δ). Removes weakly-correlated gene pairs (noise+# recruitment) so the direction correction follows only strong co-expression+# programs. θ = 0 (default) reproduces the unsharpened parent kernel.+CSHARP_THETA = float(os.environ.get("T2_CSHARP_THETA", "0"))+# Clip-aware diffusion (CLIPGATE, parent ANALYSIS suggestion #2): the+# displacement is rectified at 0, so for genes whose shifted value would clip+# in many cells the realized change is NOT proportional to Δ' — the diffusion+# correction on those genes is partially lost and distorts the distribution.+# CLIPGATE measures, per gene, the fraction of displaced cells where the shift+# clips at 0 (pass A on copies, nnz entries only, pooled over both sides or+# per side via CLIPGATE_POOL), then RE-diffuses from the raw Δ with the+# correction term gated per gene: Δ'' = renorm(Δ + η_side·(1−clip_rate)^κ·CΔ),+# support-restricted as in the first step. κ = 0 (default) disables and+# reproduces the ungated first step bit-for-bit.+CLIPGATE_KAPPA = float(os.environ.get("T2_CLIPGATE_KAPPA", "0"))+CLIPGATE_POOL = os.environ.get("T2_CLIPGATE_POOL", "side")  # side | both | a | b # Bracket-range clamp: after the displacement/pair steps, clip every gene's # cell values at BRACKET_CLIP × max(value observed for that gene in either # bracket stage). Prevents the corr-diffusion magnitude explosion (values up@@ -395,6 +478,22 @@ def corr_kernel(stage_a, stage_b, genes_n: int) -> np.ndarray:     return C.astype(np.float32)  +def corr_kernel_dense(X: np.ndarray) -> np.ndarray:+    """Gene-gene Pearson correlation of a dense cell×gene matrix (zero diagonal).++    Same estimator as corr_kernel but takes an arbitrary dense array, used for+    the CORRPROJ-2step residual kernel computed on the displaced output cells.+    """+    X = np.asarray(X, dtype=np.float64)+    X = X - X.mean(axis=0, keepdims=True)+    sd = X.std(axis=0)+    sd[sd < 1e-12] = np.inf+    C = (X.T @ X) / X.shape[0]+    C = C / np.outer(sd, sd)+    np.fill_diagonal(C, 0.0)+    return C.astype(np.float32)++ def corr_kernel_within(stage_a, stage_b) -> np.ndarray:     """Gene-gene Pearson correlation of within-type residuals (both stages pooled). @@ -571,11 +670,16 @@ def type_aniso_reshape(coords, labs_out, ca, cb, la_all, lb_all, t: float):   def mix_converge(stage_a, stage_b, t: float, params: dict, alpha: float, view: str | None = None,-                 proj_eta: float | None = None):+                 proj_eta: float | None = None, proj_eta2: float | None = None):     t = float(t)     damp = float(params.get("scale_damp", 1.0))     align = str(params.get("align", "procrustes"))     rng = np.random.default_rng(int(params.get("seed", 0)))+    # Config overrides travel through `params` so that main() can disable every+    # mechanism of this node at once for the --ablate control run.+    cfg_asym = float(params.get("proj_asym", PROJ_ASYM))+    cfg_csharp = float(params.get("csharp_theta", CSHARP_THETA))+    cfg_clipgate = float(params.get("clipgate_kappa", CLIPGATE_KAPPA))      aligned_a, aligned_b, info = align_pair(stage_a.coords, stage_b.coords, stage_a.labels, stage_b.labels, align)     rms_a = rms_radius(stage_a.coords)@@ -592,7 +696,11 @@ def mix_converge(stage_a, stage_b, t: float, params: dict, alpha: float, view: s      conv = {"alpha": alpha, "n_shared_types_converged": 0, "within_type_std_rel": None,             "between_type_mean_dist_rel": None, "lambda": CONVERGE_LAMBDA,-            "weight_mean": None, "weight_std": None}+            "weight_mean": None, "weight_std": None,+            "proj2_eta2": None, "proj2_cos_mean": None, "proj2_cos_min": None,+            "proj2_cos_max": None, "proj2_n_genes_changed_mean": None,+            "proj2_passA_max": None, "proj2_passA_nnz_frac": None,+            "out_max": None, "out_nnz_frac": None}     if alpha != 0.0 and ia.size and ib.size:         means_a = type_means(stage_a.X, stage_a.labels)         means_b = type_means(stage_b.X, stage_b.labels)@@ -602,20 +710,34 @@ def mix_converge(stage_a, stage_b, t: float, params: dict, alpha: float, view: s         cnt_b = {k: int((lb == k).sum()) for k in means_b}         shared = sorted(k for k in set(means_a) & set(means_b) if cnt_a[k] >= 10 and cnt_b[k] >= 10)         delta = {}+        delta_pre = {}+        delta_raw = {}+        if cfg_asym != 0.0:+            delta_b: dict = {}+            delta_pre_b: dict = {}+        else:+            delta_b = delta          # alias: symmetric parent path, bit-for-bit+            delta_pre_b = delta_pre         n_part, n_hard = [], []         # Prior-projection setup (family T2EI-01, this node): direction-correct         # each type's raw Δ with Reactome pathway membership (or gene-gene         # correlation fallback) before the soft weights and displacement.         eta = PROJ_ETA if proj_eta is None else float(proj_eta)+        eta2 = PROJ_ETA2 if proj_eta2 is None else float(proj_eta2)         proj_M, proj_names, proj_corr = None, None, None         proj_cos, proj_boost = [], []         if eta != 0.0 and shared and view is not None:+            def _sharp(k):+                if cfg_csharp != 0.0 and k is not None:+                    k = np.sign(k) * np.maximum(np.abs(k) - cfg_csharp, 0.0)+                return k+             def _kernel():                 if PROJ_CORR_KERNEL == "within":                     k = corr_kernel_within(stage_a, stage_b)                     if k is not None:-                        return k-                return corr_kernel(stage_a, stage_b, len(stage_a.genes))+                        return _sharp(k)+                return _sharp(corr_kernel(stage_a, stage_b, len(stage_a.genes)))             if PROJ_MODE == "pathway":                 proj_M, proj_names = load_pathway_sets(view, list(stage_a.genes))                 if proj_M is None:@@ -624,22 +746,38 @@ def mix_converge(stage_a, stage_b, t: float, params: dict, alpha: float, view: s                 proj_corr = _kernel()         for lab in shared:             d = (means_b[lab] - means_a[lab]).astype(np.float32)+            delta_raw[lab] = d.astype(np.float64)  # raw Δ before any projection (CLIPGATE)+            d_bside = d             if eta != 0.0 and (proj_M is not None or proj_corr is not None):                 d, pinfo = project_delta(d, proj_M, proj_names, PROJ_K, eta, proj_corr)                 if "cos" in pinfo:                     proj_cos.append(pinfo["cos"])                 if "boost_mean" in pinfo:                     proj_boost.append(pinfo["boost_mean"])+                if cfg_asym != 0.0:+                    d_bside, _ = project_delta(d_bside, proj_M, proj_names, PROJ_K,+                                               eta * (1.0 - cfg_asym), proj_corr)+            delta_pre[lab] = d.astype(np.float64)  # Δ' before soft weights (CORRPROJ-2step)+            if cfg_asym != 0.0:+                delta_pre_b[lab] = d_bside.astype(np.float64)             if SOFT_ENABLE and SOFT_P > 0:                 w = np.clip(np.abs(d) / max(SOFT_TAU, 1e-12), 0.0, 1.0) ** SOFT_P                 n_part.append(int((w > 0.01).sum()))                 n_hard.append(int((np.abs(d) >= CONVERGE_MIN_DELTA).sum()))                 d = (d * w).astype(np.float32)+                if cfg_asym != 0.0:+                    wb = np.clip(np.abs(d_bside) / max(SOFT_TAU, 1e-12), 0.0, 1.0) ** SOFT_P+                    d_bside = (d_bside * wb).astype(np.float32)             elif CONVERGE_MIN_DELTA > 0:                 d = np.where(np.abs(d) >= CONVERGE_MIN_DELTA, d, np.float32(0.0)).astype(np.float32)+                if cfg_asym != 0.0:+                    d_bside = np.where(np.abs(d_bside) >= CONVERGE_MIN_DELTA, d_bside, np.float32(0.0)).astype(np.float32)             delta[lab] = d+            if cfg_asym != 0.0:+                delta_b[lab] = d_bside         if eta != 0.0 and (proj_M is not None or proj_corr is not None):             conv["proj_eta"] = eta+            conv["proj_asym"] = cfg_asym             conv["proj_mode"] = "pathway" if proj_M is not None else "corr"             conv["proj_k"] = PROJ_K if proj_M is not None else None             conv["proj_n_pathways"] = int(proj_M.shape[0]) if proj_M is not None else None@@ -658,34 +796,174 @@ def mix_converge(stage_a, stage_b, t: float, params: dict, alpha: float, view: s             labs_b = np.asarray(stage_b.labels).astype(str)[ib]             all_w = [] -            def _shift(block, c, d, mu, wsign):-                # Per-cell weighted displacement: scale each cell's shift by how-                # far it already sits along Δ from its own side's type mean.+            def _weight_only(block, d, mu, wsign):                 if CONVERGE_LAMBDA != 0.0:                     m = d != 0                     if m.any():                         dm = np.asarray(d[m], dtype=np.float64)                         dev = block[:, m].astype(np.float64) - np.asarray(mu[m], dtype=np.float64)                         p = dev @ dm / (dm @ dm + CONVERGE_EPS)-                        w = np.clip(1.0 + wsign * CONVERGE_LAMBDA * p, 0.2, 2.5)-                    else:-                        w = np.ones(block.shape[0])-                else:-                    w = np.ones(block.shape[0])-                all_w.append(w)+                        return np.clip(1.0 + wsign * CONVERGE_LAMBDA * p, 0.2, 2.5)+                return np.ones(block.shape[0])++            def _shift(block, c, d, mu, wsign, rec):+                # Per-cell weighted displacement: scale each cell's shift by how+                # far it already sits along Δ from its own side's type mean.+                w = _weight_only(block, d, mu, wsign)+                rec.append(w)                 out = np.clip(block + (np.float32(c) * w.astype(np.float32))[:, None] * d, 0.0, None)                 if CONVERGE_NNZ_ONLY:                     return np.where(block > 0, out, block)                 return out +            # CORRPROJ-2step (this node): pass A displaces COPIES of the drawn+            # cells with the soft-weighted Δ' exactly as the real step would,+            # recomputes the gene-gene correlation C_resid of these displaced+            # mid-trajectory cells, and re-diffuses each type's Δ':+            # Δ'' = renorm(Δ' + η2·C_resid·Δ') on the |Δ'| >= PROJ_SUPPORT+            # support, restoring ||Δ'||. Soft weights are then recomputed on Δ''+            # and Δ'' replaces Δ' in the real displacement below. η2 = 0 skips+            # this block entirely (parent bit-for-bit).+            sides = []+            if eta2 != 0.0 and delta_pre:+                if PROJ2_SIDES in ("both", "a"):+                    sides.append(("a", delta_pre, delta, eta2))+                if cfg_asym != 0.0 and PROJ2_SIDES in ("both", "b"):+                    sides.append(("b", delta_pre_b, delta_b, eta2 * (1.0 - cfg_asym)))+            if sides:+                xa_p, xb_p = xa.copy(), xb.copy()+                _w_tmp = []+                for lab in shared:+                    ma = labs_a == lab+                    if ma.any():+                        xa_p[ma] = _shift(xa_p[ma], alpha * t, delta[lab], means_a[lab], -1.0, _w_tmp)+                    mb = labs_b == lab+                    if mb.any():+                        xb_p[mb] = _shift(xb_p[mb], -alpha * (1.0 - t), delta_b[lab], means_b[lab], +1.0, _w_tmp)+                disp = np.vstack([xa_p, xb_p])+                if PROJ2_KERNEL == "within":+                    # NEW information only: within-output-type residual+                    # co-variation of the displaced mid-trajectory cells+                    # (removes the type-mean structure and most of the+                    # displacement imprint that the pooled kernel re-diffuses).+                    D64 = disp.astype(np.float64)+                    labs_o = np.concatenate([labs_a, labs_b])+                    parts = []+                    for lab in np.unique(labs_o):+                        m = labs_o == lab+                        if m.sum() >= 10:+                            parts.append(D64[m] - D64[m].mean(axis=0, keepdims=True))+                    c_resid = corr_kernel_dense(np.vstack(parts) if parts else D64).astype(np.float64)+                elif PROJ2_KERNEL == "blend":+                    base = corr_kernel_dense(disp).astype(np.float64)+                    c_resid = 0.5 * (proj_corr.astype(np.float64) + base) if proj_corr is not None else base+                else:+                    c_resid = corr_kernel_dense(disp).astype(np.float64)+                cos2, nchg = [], []+                for _side, pre_dict, out_dict, e2 in sides:+                    for lab in shared:+                        d1 = pre_dict[lab]+                        d2 = d1 + e2 * (c_resid @ d1)+                        if PROJ_SUPPORT > 0:+                            d2 = np.where(np.abs(d1) >= PROJ_SUPPORT, d2, d1)+                        d2 = d2 * (np.linalg.norm(d1) / max(np.linalg.norm(d2), 1e-12))+                        if _side == "a":+                            cos2.append(float(d1 @ d2 / max(np.linalg.norm(d1) * np.linalg.norm(d2), 1e-12)))+                            nchg.append(int((np.abs(d2 - d1) > 1e-6).sum()))+                        d2 = d2.astype(np.float32)+                        if SOFT_ENABLE and SOFT_P > 0:+                            w = np.clip(np.abs(d2) / max(SOFT_TAU, 1e-12), 0.0, 1.0) ** SOFT_P+                            d2 = (d2 * w).astype(np.float32)+                        elif CONVERGE_MIN_DELTA > 0:+                            d2 = np.where(np.abs(d2) >= CONVERGE_MIN_DELTA, d2, np.float32(0.0)).astype(np.float32)+                        out_dict[lab] = d2+                conv["proj2_eta2"] = eta2+                conv["proj2_kernel"] = PROJ2_KERNEL+                conv["proj2_sides"] = PROJ2_SIDES+                conv["proj2_cos_mean"] = float(np.mean(cos2))+                conv["proj2_cos_min"] = float(np.min(cos2))+                conv["proj2_cos_max"] = float(np.max(cos2))+                conv["proj2_n_genes_changed_mean"] = float(np.mean(nchg))+                conv["proj2_passA_max"] = float(disp.max())+                conv["proj2_passA_nnz_frac"] = float((disp > 0).mean())++            # CLIPGATE (clip-aware re-diffusion, parent ANALYSIS suggestion #2):+            # measure per gene how often the trial displacement rectifies at 0,+            # then redo the first-step diffusion from the RAW Δ with the+            # correction term gated by (1 − clip_rate)^κ per gene per side.+            # κ = 0 skips this block entirely (parent bit-for-bit).+            if cfg_clipgate != 0.0 and delta_raw and proj_corr is not None and eta != 0.0:+                genes_n = xa.shape[1]+                clip_a = np.zeros(genes_n)+                nza = np.zeros(genes_n)+                clip_b = np.zeros(genes_n)+                nzb = np.zeros(genes_n)+                for lab in shared:+                    ma = labs_a == lab+                    if ma.any():+                        blk = xa[ma]+                        d = delta[lab]+                        w = _weight_only(blk, d, means_a[lab], -1.0)+                        pre = blk.astype(np.float64) + (float(alpha * t) * w)[:, None] * d.astype(np.float64)+                        act = blk > 0+                        clip_a += (act & (pre < 0.0)).sum(axis=0)+                        nza += act.sum(axis=0)+                    mb = labs_b == lab+                    if mb.any():+                        blk = xb[mb]+                        d = delta_b[lab]+                        w = _weight_only(blk, d, means_b[lab], +1.0)+                        pre = blk.astype(np.float64) + (float(-alpha * (1.0 - t)) * w)[:, None] * d.astype(np.float64)+                        act = blk > 0+                        clip_b += (act & (pre < 0.0)).sum(axis=0)+                        nzb += act.sum(axis=0)+                rate_a = np.minimum(clip_a / np.maximum(nza, 1.0), 1.0)+                rate_b = np.minimum(clip_b / np.maximum(nzb, 1.0), 1.0)+                if CLIPGATE_POOL == "both":+                    rate_a = rate_b = 0.5 * (rate_a + rate_b)+                elif CLIPGATE_POOL == "a":+                    rate_b = rate_a+                elif CLIPGATE_POOL == "b":+                    rate_a = rate_b+                if cfg_asym != 0.0:+                    gate_sides = [("a", delta, eta, (1.0 - rate_a) ** cfg_clipgate),+                                  ("b", delta_b, eta * (1.0 - cfg_asym), (1.0 - rate_b) ** cfg_clipgate)]+                else:+                    gm = (1.0 - 0.5 * (rate_a + rate_b)) ** cfg_clipgate+                    gate_sides = [("a", delta, eta, gm)]+                corr64 = proj_corr.astype(np.float64)+                cosg = []+                for side, out_dict, e_side, g in gate_sides:+                    for lab in shared:+                        d0 = delta_raw[lab]+                        d2 = d0 + e_side * (g * (corr64 @ d0))+                        if PROJ_SUPPORT > 0:+                            d2 = np.where(np.abs(d0) >= PROJ_SUPPORT, d2, d0)+                        d2 = d2 * (np.linalg.norm(d0) / max(np.linalg.norm(d2), 1e-12))+                        if side == "a":+                            d1 = delta_pre[lab]+                            cosg.append(float(d1 @ d2 / max(np.linalg.norm(d1) * np.linalg.norm(d2), 1e-12)))+                        d2 = d2.astype(np.float32)+                        if SOFT_ENABLE and SOFT_P > 0:+                            wg = np.clip(np.abs(d2) / max(SOFT_TAU, 1e-12), 0.0, 1.0) ** SOFT_P+                            d2 = (d2 * wg).astype(np.float32)+                        elif CONVERGE_MIN_DELTA > 0:+                            d2 = np.where(np.abs(d2) >= CONVERGE_MIN_DELTA, d2, np.float32(0.0)).astype(np.float32)+                        out_dict[lab] = d2+                conv["clipgate_kappa"] = cfg_clipgate+                conv["clipgate_pool"] = CLIPGATE_POOL+                conv["clipgate_rate_a_mean"] = float(rate_a[nza > 0].mean()) if (nza > 0).any() else None+                conv["clipgate_rate_b_mean"] = float(rate_b[nzb > 0].mean()) if (nzb > 0).any() else None+                conv["clipgate_frac_genes_gt005"] = float((0.5 * (rate_a + rate_b) > 0.05).mean())+                conv["clipgate_cos_mean"] = float(np.mean(cosg)) if cosg else None+             for lab in shared:-                d = delta[lab]                 ma = labs_a == lab                 if ma.any():-                    xa[ma] = _shift(xa[ma], alpha * t, d, means_a[lab], -1.0)+                    xa[ma] = _shift(xa[ma], alpha * t, delta[lab], means_a[lab], -1.0, all_w)                 mb = labs_b == lab                 if mb.any():-                    xb[mb] = _shift(xb[mb], -alpha * (1.0 - t), d, means_b[lab], +1.0)+                    xb[mb] = _shift(xb[mb], -alpha * (1.0 - t), delta_b[lab], means_b[lab], +1.0, all_w)             if all_w:                 wcat = np.concatenate(all_w)                 conv["weight_mean"] = float(wcat.mean())@@ -877,6 +1155,9 @@ def mix_converge(stage_a, stage_b, t: float, params: dict, alpha: float, view: s             )      expr = np.clip(np.vstack([xa, xb]), 0.0, None).astype(np.float32) if (ia.size or ib.size) else np.zeros((0, len(stage_a.genes)), np.float32)+    if expr.shape[0]:+        conv["out_max"] = float(expr.max())+        conv["out_nnz_frac"] = float((expr > 0).mean())     clamp_info = {"bracket_clip": BRACKET_CLIP, "n_clamped_cells": 0}     if BRACKET_CLIP > 0 and expr.shape[0]:         mx_a = np.asarray(stage_a.X.max(axis=0).todense()).ravel().astype(np.float64)@@ -1000,10 +1281,17 @@ def main() -> None:     parser.add_argument("--out", required=True)     parser.add_argument("--seed", type=int, default=0)     parser.add_argument("--ablate", default=None,-                        help="mechanism-off control: 'mechanism' (or any name) sets PROJ_ETA=0, "-                             "reproducing the parent node bit-for-bit")+                        help="mechanism-off control: 'mechanism' (or any name) disables every "+                             "mechanism added by this node (second-step residual diffusion "+                             "T2_PROJ_ETA2, asymmetric side etas T2_PROJ_ASYM, kernel sharpening "+                             "T2_CSHARP_THETA, clip-aware gating T2_CLIPGATE_KAPPA), reproducing "+                             "the parent node 31 bit-for-bit")     args = parser.parse_args()-    proj_eta = 0.0 if args.ablate else None+    # Mechanism-off control: restore every knob to the parent node 31 submitted+    # default (symmetric first-step diffusion at η = 1.0, no second step, no+    # sharpening, no gating) so the ablated output is bit-for-bit the parent's.+    proj_eta = 1.0 if args.ablate else None+    proj_eta2 = 0.0 if args.ablate else None      manifest = load_manifest(args.data)     genes = panel_genes(args.data, manifest)@@ -1017,16 +1305,26 @@ def main() -> None:     stage_a = read_stage(args.data, a, genes)     stage_b = read_stage(args.data, b, genes)     params = board_params(manifest, "mix", PARAMS, args.seed)+    if args.ablate:+        params.update({"proj_asym": 0.0, "csharp_theta": 0.0, "clipgate_kappa": 0.0})     expr, coords, info = mix_converge(stage_a, stage_b, t, params, CONVERGE_ALPHA,-                                      view=args.data, proj_eta=proj_eta)+                                      view=args.data, proj_eta=proj_eta, proj_eta2=proj_eta2)     keep = {k: info.get(k) for k in ("t", "n", "rms_a", "rms_b", "out_rms", "n_shared_types", "z_dot", "z_flipped",                                      "align", "alpha", "n_shared_types_converged", "within_type_std_rel",                                      "between_type_mean_dist_rel", "n_from_a", "n_from_b",                                        "lambda", "weight_mean", "weight_std",                                          "soft_enable", "soft_tau", "soft_p",                                          "soft_n_participating_mean", "soft_n_hard_mean",-                                        "proj_eta", "proj_mode", "proj_k", "proj_n_pathways",-                                        "proj_cos_mean", "proj_cos_min", "proj_boost_mean",+                                         "proj_eta", "proj_mode", "proj_k", "proj_n_pathways",+                                         "proj_cos_mean", "proj_cos_min", "proj_boost_mean", "proj_asym",+                                         "proj2_eta2", "proj2_kernel", "proj2_sides",+                                         "proj2_cos_mean", "proj2_cos_min",+                                         "proj2_cos_max",+                                         "proj2_n_genes_changed_mean", "proj2_passA_max",+                                         "proj2_passA_nnz_frac", "out_max", "out_nnz_frac",+                                         "clipgate_kappa", "clipgate_pool", "clipgate_rate_a_mean",+                                         "clipgate_rate_b_mean", "clipgate_frac_genes_gt005",+                                         "clipgate_cos_mean",                                         "pbproj_enable", "pbproj_eta", "pbproj_k", "pbproj_src",                                         "pbproj_n_pathways", "pbproj_n_boosted", "pbproj_boost_max",                                         "pbproj_s_min", "pbproj_s_max", "pbproj_s_mean",

调研来源?调研员查到并用到的知识条目和文献检索结果（只列标题和编号）。

用到的知识库条目

分析结果?分析员写的 ANALYSIS.json：改了什么、各组分数怎么变、假设是否成立、经验和下一步建议。

对话摘要?每个角色和大模型对话的统计：轮数、工具调用、用时、token 数和最后的回答摘录；原始记录只给路径。

只给统计和最后回答的摘录；完整对话请到原始记录位置里列出的文件看。

分析员

ANALYSIS.json written

工程师

**做了什么**：按 PLAN 实现 CORRPROJ-2step（位移后细胞重算相关核二次扩散），20 次查分完成 7 种解码证否网格——池化残差核与括号核相关 0.78，二次扩散等效越过 η 平台导致过度收敛，nbhd/variogram 单调劣化（61.2–61.8 vs 父 62.06）；改交同族备选机制：不对称侧别扩散 η_a=1.5 / η_b=0.15（T2_PROJ_ASYM=0.9），另实现并证否核锐化（CSHARP）与 clip 感知门控（CLIPGATE），均默认关闭。

**查分结果**（proxy A 半，seed 0/1）：父 31 = 62.06/61.55；提交配置 = **62.38/61.91**（均值 +0.33，两种子同向）；asym η_a=1.0 = 62.36/61.89（a 侧 η 平台 [1.0,1.5]，取 1.5 同时与节点 34 输出去重）。`--ablate mechanism` 与父节点 31 输出逐字节一致（双 seed 验证）；伪装视图逐位相同、单输入回退可跑、vec-check 通过、2.1s/0.61GB。

**下一步最值得试**：① asym 悬崖在 η_b∈(0.15, 0) 之间，可细扫 η_b=0.05–0.10；② 核锐化 θ=0.3 把 nbhd 压到全表最低（0.05004）但伤 variogram——只对 a 侧锐化或锐化后按基因重加权可能解耦；③ de_score 在 A 半呈 0.25/0.2857 档位跳动，任何依赖它的筛选都不可靠，攻 expression_change 需绕过位移步直接改输出伪批量。

调研员

0.42）与 variogram（+0.19），即表达-位置配对与共变结构。兄弟节点34已用不对称侧权重把 mmd_u 0.01146→0.01093，但没动扩散核本身。父节点 ANALYSIS 的 next_suggestion 明确建议：保持 η=1、support=0.15，用位移后残差重算相关核再迭代一步，把 neighborhood_mmd raw 从 0.0476 继续压低。本节点沿同一已被验证有效的通道加深，不引入未验证机制。",
 "approach": "在父节点31的 CORRPROJ（范数保持+支持集受限的一步相关扩散）之后插入第二步精修：1) 复用现有位移管线，得到 a 侧 x+α·t·Δ'、b 侧 x−α·(1−t)·Δ' 的位移后表达（α=5、λ=6、β=0.2、nnz-only、clip≥0 全部保留）；2) 对位移后的全部输出细胞重算基因-基因 Pearson 相关 C_resid（498×498，对角置0，沿用全细胞核——ANALYSIS 已证 within-type 残差核劣于全细胞核，勿改）；3) 第二步方向校正 Δ''=renorm(Δ'+η2·C_resid·Δ')，仅对 |Δ'|≥0.15 的基因，再范数保持回 ||Δ'||；4) 用 Δ'' 替换 Δ' 进入原位移步。参数：η2 初值 0.5，搜索 [0.25,0.5,0.75,1.0]；support 固定 0.15、第一步 η=1 不动（已是平台最优，一次只改一个变量）。单输入阶段退路：与父节点一致，无括号时 fall back 到最近输入的分层 copy，Δ 不存在、机制自然关闭。快速筛选：先在 proxy A 半 seed0 用 vec-score 离线比对，仅当 nbhd raw<0.04758 且 variogram raw<0.01300 且 mmd_u 不劣于 0.01146 时才送查分；遵循 ≥3 种 η2 解码、≥6 次查分；de_score/de_direction 不作优化目标（对方向校正结构性不可见）。",
 "expected_groups": ["cell_state", "local_spatial"],
 "risks": "1) 位移后细胞已被压向中间、型内方差缩小，C_resid 可能比括号合并核更噪，二次扩散反伤 variogram/nbhd——Engineer 应先离线打印 cos(Δ',Δ'') 分布，若普遍 <0.5（方向被过度扭转）或 >0.99（几乎未动）即提前放弃该 η2；2) 勿与已证否的节点21（型内共变重着色）混淆：21 无范数保持与支持集限制、且是型内重着色，本节点是已生效 CORRPROJ 解码家族的迭代精修、保留全部护栏；3) 预期净收益可能落在 ~1 分噪声内，须 seed0/1 双查分 + ablation 确认非单 seed 尖峰；4) 二次扩散或轻微伤 mmd_u，若 mmd_u raw>0.01146 且无 nbhd/variogram 补偿则回退 η2。",
 "family_id": "T2EI-01",
 "mechanism": "对逐类型时间差向量 Δ 做两步基因相关扩散：第一步用括号合并云相关核（父节点已有），第二步用位移后残差细胞重算的相关核 C_resid 再校正一次方向；两步均范数保持、支持集受限，只改方向不改幅度。",
 "vs_constant_shift": "常数位移对每个细胞型加同一向量、型内所有细胞同向同量；本机制逐基因地按组织共变结构旋转 Δ 的方向（每型不同，第二步且基于位移后流形的共变），是方向精修而非平移，且范数保持使伪批量均值不变。",
 "mechanism_evidence": "Engineer 应记录：a) cos(Δ',Δ'') 的均值/分布（应落在 0.5–1，证明方向被有限转动而非未生效或爆炸）；b) 第二步实际改变的基因数与受影响细胞（全部共有类型的输出细胞）；c) 四组分与关键 raw 逐项变化，重点 variogram raw（目标 <0.01300）与 neighborhood_mmd raw（目标 <0.04758）；d) 位移后表达值域与 nnz 占比不崩（对照父节点 max 32.6、nnz≈0.057），确认范数保持护栏有效。",
 "mechanism_off_control": "--ablate mechanism 或 T2_PROJ_ETA2=0：跳过第二步、Δ''=Δ'，输出须与父节点31逐位一致（含 seed 0/1 验证）。预期差别：开启后 nbhd/variogram raw 下降、榜分上升；若关闭与开启输出相同，说明第二步未运行。",
 "sources": []}
```

审查员

REVIEW.json written