总览 · ← 返回运行 20261002-202908-search-t1-scr-B

节点 n20

manifold_ode v2: OT 耦合逐细胞重心位移作速度回归目标，推理位移由耦合方向锚定（α=2.0），Sinkhorn/kNN 流形项降为辅助

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

来自 programs.git fc42f7150a:solution/METHOD.md

调研员的计划

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

对比：父节点版本 7b4368e689。改动的文件：solution/METHOD.md +22 −42、solution/run.py +123 −52

diff --git a/solution/METHOD.md b/solution/METHOD.mdindex 3fa21ae..68e1628 100644--- a/solution/METHOD.md+++ b/solution/METHOD.md@@ -1,53 +1,33 @@-# manifold_ode: PCA 潜空间神经 ODE + Sinkhorn 分布匹配 + kNN 流形惩罚+# manifold_ode v2: OT 耦合逐细胞重心位移作速度回归目标，推理位移由耦合方向锚定（α=2.0），Sinkhorn/kNN 流形项降为辅助 -PCA(30) 潜空间中训练时间依赖 MLP 速度场，用 Sinkhorn 散度把第一输入阶段推到第二输入阶段，加动能正则与 kNN(20) 流形惩罚；推理从最后输入阶段继续积分到目标时间（阻尼 α），PCA 逆变换 + 逐细胞残差解码，仅作用于非零位。+## 方法（family: manifold_ode，PLAN v2） -## 方法+1. 骨架同父节点 18：HVG(2500，两输入共同实测)→PCA(30)→按 stage-1 标准差归一；单输入逐比特退化 copy_last。+2. 新增：log-domain Sinkhorn（ε=1e-3，平方欧氏代价，2000 次迭代）算 stage0→stage1 耦合；逐细胞重心位移 d_i=bary_i−z0_i 作为速度目标。耦合诊断：行归一 top-1 质量 0.70（近硬耦合），行边际残差较大（~2.8e0，未完全收敛），平均传输代价 22.0（独立耦合 ~60）。d1 方向离散（mean-cos 0.06），非常数位移。+3. 训练（1000 步 Adam lr=3e-3，ODE 5 步 Euler）：L = 1.0·‖v(z_t,t)−d_i‖²（z_t 为 OT 配对点线性插值，t~U[0,1]）+ 0.1·Sinkhorn(推前, stage1, blur=0.05) + 0.01·‖v‖² + 0.1·kNN(20) 流形惩罚。+4. 推理：最后阶段细胞的祖先重心方向 d_j=z1_j−anc_j，kNN(30) 平滑后乘 α=2.0（X3 上目标距最后输入恰为 2 个输入间隔，α=2 即线性外推；α 只由时间差语义确定，无绝对时间分支）；神经 ODE 外推仅以 β=0.1 混入作流形修正，避免自由外推。+5. 解码：PCA 逆变换 + 逐细胞残差，只写非零位，clip≥0，非 HVG 取原值。+6. 确定性：全部随机性来自 --seed（权重初始化、minibatch、细胞抽样）；Sinkhorn/耦合/kNN 均确定性。视图无关：只用时间差 (t_target−t_last)/(t_last−t_first)。 -1. 读两个输入阶段（`view_io.read_stage`, missing="zero"）；单输入时逐比特退化为 copy_last（按 seed 抽样到 [min,max] 细胞数）。-2. HVG=2500（两输入都实测到的基因，按合并方差选）；PCA(30) 在合并细胞上拟合，潜变量按 stage-1 标准差归一。-3. 速度场 v(z,u)：MLP [31→128→128→30]，Tanh；u 为归一时间（第一输入=0，最后输入=1；推理时 u 钳到 ≤1）。-4. 损失 = SamplesLoss("sinkhorn", p=2, blur=0.05)(推前分布, 真实 stage-1) + λ_v·∫‖v‖² + λ_m·mean kNN(k=20) 距离（积分中间点到两阶段合并云）。Euler 10 步，1500 步 Adam lr=3e-3，每步子采样 ≤2048 细胞/阶段；训练有 15 分钟硬上限。-5. 推理：从最后输入的细胞潜变量积分 u=1→u_target（u_target 只由时间差算出，X3 上 =3.0），净位移乘阻尼 α，解码 = PCA 逆变换 + 该细胞自身残差（stage-1 原值 − 重建），只写非零位，clip≥0；非 HVG 基因取 stage-1 原值。-6. 确定性：所有随机性来自 `--seed`（权重初始化、minibatch、细胞抽样），无全局随机状态。视图无关：无绝对时间分支、无路径/字段依赖。--## 默认超参数（提交配置）--α=0.1, λ_m=0.1, λ_v=0.01, blur=0.05, HVG=2500, PCA=30, steps=1500, lr=3e-3。全部可用环境变量 VEC_* 覆盖（对照实验用，默认即提交配置）。--## 查分结果（X3 A 半，seed 0）+## 查分结果（X3 A 半，seed 0，本地半查分只用于同方法内排序）  | 配置 | 总分 | cell_state | covariation | de_recovery | direction | |---|---|---|---|---|---|-| α=0.7, λ_m=0.1（PLAN 默认） | 45.75 | 38.43 | 53.30 | 44.54 | 49.72 |-| α=0.5 | 46.27 | 41.35 | 52.10 | 44.17 | 49.61 |-| α=0.3 | 47.07 | 44.55 | 50.67 | 44.92 | 49.38 |-| α=0.2 | 47.09 | 46.20 | 49.91 | 43.80 | 49.21 |-| **α=0.1（提交默认）** | **47.33** | 47.87 | 49.15 | 43.44 | 49.12 |-| α=0.3, blur=0.1, 4000 步 | 46.50 | 43.93 | 50.61 | 43.44 | 49.36 |-| α=0.3, λ_v=0.3 | 46.89 | 46.61 | 48.77 | 43.44 | 49.16 |-| α=0.5, λ_v=0.3 | 46.93 | 44.95 | 49.09 | 45.30 | 49.20 |-| α=0.2, λ_v=0.3 | 47.22 | 47.52 | 48.64 | 43.80 | 49.12 |-| **对照 λ_m=0, α=0.3** | 46.66 | 45.39 | 48.73 | 44.17 | 49.02 |--参考：seed copy_last 在 X3 = 47.92；当前最佳节点 8/11 (local_ot) = 62.24。+| **α=2.0 latent（提交默认）** | **49.59** | 56.82 | 41.50 | 47.75 | 49.21 |+| α=3.0 latent | 49.16 | 56.48 | 38.17 | 49.07 | 49.26 |+| gene 解码放大 λ_g=3.0, α_latent=1.0 | 48.91 | 55.68 | 37.51 | 49.53 | 49.28 |+| 机制关闭对照 VEC_REG_WEIGHT=0（λ_s 自动=1.0，纯 Sinkhorn ODE，同预算） | 50.17 | 57.27 | 43.04 | 48.18 | 49.35 |+| 父节点 18（α=0.1 自由 ODE 外推） | 47.33/47.56 正式 | 47.90 | 48.94 | 44.45 | 49.17 | -## 机制生效证据+## 机制生效证据与对照结论（如实报告） -- 速度场方向离散度：u=1 处平均余弦 ≈ 0.14–0.18（1.0 才是常数位移）→ 强状态依赖，非退化为常数位移。-- 流形惩罚在训练中从 21.2 降到 ~15.0 后持平；推理中途点 kNN 距离 18.4–20.8，说明惩罚确实把训练轨迹拉向数据云。-- **机制关闭对照（λ_m=0，其余全同）**：输出 100% 细胞逐值不同（平均 L1 差 89.7），分数 46.66 vs 开启 47.07 → 流形惩罚真实改变了预测，方向上略有帮助（差距在噪声内）。-- 潜空间净位移 L2 均值 3.9（α=0.7）/1.0（λ_v=0.3），非退化。--## 结论（如实报告）--在 X3 上，ODE 外推位移**单调有害**：α 越大分越低，α→0 趋近 copy_last（47.92）。α=0.1 是本方法族最好点（47.33），仍略低于 copy_last，低于当前最佳 local_ot（62.24）。covariation 随 α 增大而升高（53.3 @ α=0.7，最佳单项），但 cell_state 崩塌更快——外推速度场的逐细胞方向在 X3 上与真实 E9.0→E9.5 变化不符（direction ≈ 49.2–49.7，几乎无提升）。更长训练（4000 步、blur=0.1）与更强动能正则（λ_v=0.3）都不能把位移变成正贡献。+- 回归目标确实改变了训练：reg 损失 18.1→5.0；训练后 v(z1,1) 与耦合方向余弦 mean 0.36（父节点自由外推方向余弦仅 0.14–0.18），未达 PLAN 期望的 >0.7（kNN 平滑目标本身分散 + Sinkhorn/流形项牵制）。+- 推理位移由耦合锚定：anchor L2 mean 3.18（逐细胞 std 0.50，非均匀），ODE 项仅 β=0.1 混入。+- **关闭对照（reg=0）总分 50.17 反而略高于开启 49.59，差 0.58 在 T1 噪声（~2 分）内**：因位移主体来自耦合锚（与速度场训练方式几乎无关），速度回归监督在本配置下无可测净收益。按规则提交保持机制开启（λ_reg=1.0），但结论是"锚定有效、回归监督未证明有效"。+- 相对父节点（47.33/47.56）：耦合锚定 + α=2 时间差标定的位移带来 +2.3（本地半），主要来自 cell_state（47.9→56.8）和 de_recovery（44.5→47.8），代价是 covariation（48.9→41.5）——与节点 8/10/11（local_ot 族）的方向一致但幅度小得多，local_ot 的 top-k 祖先截断 + gene 解码放大组合仍显著优于本实现（本实现 gene 放大单独用无益，48.91）。  ## 验证过 / 没验证 -- 验证过：X3 视图 seed 0 完整跑通（~1.5 分钟，GPU），vec-check 通过，输出 652 细胞、nnz 比例 ~6%；9 个超参组合的 A 半查分；λ_m=0 关闭对照。-- 没验证：proxy/proxy2/final 视图（本节点只挂 X3；单输入退路代码存在但未在该视图实跑）；B 半分数；种子 1/2 的方差；λ_m 更大值（0.2+）。--## 生物学知识来源--未使用任何保留阶段/基因型的测量信息；未读 `uns.celltype_palette`；程序只用视图内输入表达与时间差。外部数据（external/）与 prior/ 均未使用。+- 验证过：X3 seed 0 完整跑通（~67s，GPU，内存 <3GB），vec-check ok；4 个配置的 A 半查分；reg=0 关闭对照；耦合质量诊断。+- 没验证：proxy/proxy2/final 视图实跑（单输入退路代码在）；B 半；种子 1/2；ε 网格（1e-3 固定，PLAN 风险 1 的 ε=1e-4 未试）；α 在 1.5–2.5 加密；耦合行边际未收敛对重心质量的影响未修（可加迭代数或换 POT stabilized solver）。+- 生物学知识来源：仅"两个输入间隔的耦合位移可按时间差线性外推"这一通用假设；未使用任何保留阶段/基因型信息。diff --git a/solution/run.py b/solution/run.pyindex 5175b54..8ba4980 100644--- a/solution/run.py+++ b/solution/run.py@@ -1,14 +1,16 @@-"""manifold_ode: PCA-space neural ODE with Sinkhorn distribution matching + kNN manifold penalty.--Two input stages -> train v(z,u) to push stage0 onto stage1 in PCA latent space,-with kinetic regularisation and a kNN manifold penalty keeping trajectories near the-training cloud. Inference: continue integrating from the last stage towards the-target time (clamped velocity time), damp the displacement by alpha, decode with-PCA inverse + per-cell residual on nonzero positions. Single input -> copy_last.+"""manifold_ode v2: OT-coupling velocity-target supervision + manifold-constrained neural ODE.++Two input stages -> (1) compute a Sinkhorn coupling between stage0 and stage1 in the+PCA latent space and extract per-cell barycentric displacements d_i = bary_i - z0_i;+(2) train the time-dependent velocity field v(z,u) by regressing onto d_i along OT+interpolation paths (main loss), with a small Sinkhorn distribution-matching term,+kinetic regularisation and a kNN manifold penalty; (3) inference anchors the+displacement to the coupling direction of the last-stage cells (ancestor barycentre),+kNN-smoothed, and mixes in a small-weight ODE extrapolation. Decode with PCA inverse++ per-cell residual on nonzero positions. Single input -> copy_last. """  import argparse-import json import os  import numpy as np@@ -18,26 +20,30 @@ from sklearn.decomposition import PCA  import src.task1_temporal.view_io as view_io -# hyper-parameters (env-overridable for the mechanism-off control)+# hyper-parameters (env-overridable for controls) HVG = int(os.environ.get("VEC_HVG", 2500)) PCA_DIM = int(os.environ.get("VEC_PCA_DIM", 30))-STEPS = int(os.environ.get("VEC_STEPS", 1500))+STEPS = int(os.environ.get("VEC_STEPS", 1000)) LR = float(os.environ.get("VEC_LR", 3e-3))-ALPHA = float(os.environ.get("VEC_ALPHA", 0.1))+ALPHA = float(os.environ.get("VEC_ALPHA", 2.0))+BETA = float(os.environ.get("VEC_BETA", 0.1))+REG_WEIGHT = float(os.environ.get("VEC_REG_WEIGHT", 1.0))+LAMBDA_S = float(os.environ.get("VEC_LAMBDA_S", 0.1 if REG_WEIGHT > 0 else 1.0)) LAMBDA_V = float(os.environ.get("VEC_LAMBDA_V", 0.01)) LAMBDA_M = float(os.environ.get("VEC_LAMBDA_M", 0.1)) BLUR = float(os.environ.get("VEC_BLUR", 0.05))+EPS_OT = float(os.environ.get("VEC_EPS_OT", 1e-3))+SMOOTH_K = int(os.environ.get("VEC_SMOOTH_K", 30)) KNN_K = int(os.environ.get("VEC_KNN_K", 20)) SUBSAMPLE = int(os.environ.get("VEC_SUBSAMPLE", 2048))-ODE_STEPS = int(os.environ.get("VEC_ODE_STEPS", 10))+ODE_STEPS = int(os.environ.get("VEC_ODE_STEPS", 5)) HID = int(os.environ.get("VEC_HID", 128))+DECODE_MODE = os.environ.get("VEC_DECODE", "latent")+LAMBDA_G = float(os.environ.get("VEC_LAMBDA_G", 3.0))   def integrate(vel, z, u0, u1, n_steps):-    """Fixed-step Euler; velocity time argument clamped to [u0_train_max]=1.0.--    Returns final z and list of intermediate points (excluding start).-    """+    """Fixed-step Euler; velocity time argument clamped to <=1.0."""     du = (u1 - u0) / n_steps     pts = []     zc = z@@ -51,6 +57,31 @@ def integrate(vel, z, u0, u1, n_steps):     return zc, pts  +def sinkhorn_plan(Z0, Z1, eps, seed):+    """Log-domain Sinkhorn coupling between two point clouds (torch, deterministic).++    Returns plan Pi (n0 x n1) with uniform marginals, squared-euclidean cost.+    """+    n0, n1 = Z0.shape[0], Z1.shape[0]+    M = torch.cdist(Z0.double(), Z1.double()) ** 2+    K = -M / eps+    log_mu = torch.full((n0,), -np.log(n0), device=Z0.device, dtype=torch.float64)+    log_nu = torch.full((n1,), -np.log(n1), device=Z0.device, dtype=torch.float64)+    f = torch.zeros(n0, device=Z0.device, dtype=torch.float64)+    g = torch.zeros(n1, device=Z0.device, dtype=torch.float64)+    for _ in range(2000):+        f_new = log_mu - torch.logsumexp(K + g.unsqueeze(0), dim=1)+        g_new = log_nu - torch.logsumexp(K + f_new.unsqueeze(1), dim=0)+        err = max(float((f_new - f).abs().max()), float((g_new - g).abs().max()))+        f, g = f_new, g_new+        if err < 1e-8:+            break+    logPi = K + f.unsqueeze(1) + g.unsqueeze(0)+    Pi = torch.exp(logPi)+    Pi = Pi / Pi.sum()  # normalise exactly+    return Pi, M++ def main():     ap = argparse.ArgumentParser()     ap.add_argument("--data", required=True)@@ -75,22 +106,19 @@ def main():         keep = np.arange(X_last.shape[0])      if len(inputs) < 2:-        # single-input fallback: copy_last (subset of cells, deterministic)         out = sp.csr_matrix(X_last[keep])         view_io.write_prediction(out, genes, args.out, seed=args.seed)-        print("[manifold_ode] single input -> copy_last")+        print("[manifold_ode_v2] single input -> copy_last")         return      a_first = view_io.read_stage(view, inputs[0], genes, missing="zero")     X_first = np.asarray(a_first.X.todense(), dtype=np.float32) -    # covered genes = measured in BOTH inputs     cov_first = view_io.covered_mask(view, inputs[0], genes)     cov_last = view_io.covered_mask(view, entry_last, genes)     covered = np.asarray(cov_first) & np.asarray(cov_last)     cov_idx = np.flatnonzero(covered) -    # HVG among covered genes, variance over concatenated cells     both = np.concatenate([X_first[:, cov_idx], X_last[:, cov_idx]], axis=0)     var = both.var(axis=0)     hvg_local = np.argsort(-var)[: min(HVG, len(cov_idx))]@@ -104,24 +132,50 @@ def main():     pca.fit(np.concatenate([A0, A1], axis=0))     Z0 = pca.transform(A0).astype(np.float32)     Z1 = pca.transform(A1).astype(np.float32)-    # scale latent to unit-ish variance for stable network input     sd = Z1.std(axis=0) + 1e-6     Z0s = (Z0 / sd).astype(np.float32)     Z1s = (Z1 / sd).astype(np.float32) -    # normalised time: u=0 at first input, u=1 at last input     t_first = float(inputs[0]["time"])     t_last = float(inputs[-1]["time"])     t_target = float(manifest["target"]["time"])     dt_in = max(t_last - t_first, 1e-6)     u_target = 1.0 + (t_target - t_last) / dt_in-    print(f"[manifold_ode] dt_in={dt_in} u_target={u_target} alpha={ALPHA} lam_m={LAMBDA_M} lam_v={LAMBDA_V}")+    print(f"[manifold_ode_v2] dt_in={dt_in} u_target={u_target} alpha={ALPHA} beta={BETA} "+          f"reg_w={REG_WEIGHT} lam_s={LAMBDA_S} lam_m={LAMBDA_M} eps_ot={EPS_OT} steps={STEPS}")      device = torch.device("cuda" if torch.cuda.is_available() else "cpu")     torch.manual_seed(args.seed)     z0 = torch.tensor(Z0s, device=device)     z1 = torch.tensor(Z1s, device=device)     dim = z0.shape[1]+    n0, n1 = z0.shape[0], z1.shape[0]++    # ---- OT coupling and per-cell barycentric displacements --------------------+    Pi, Mcost = sinkhorn_plan(z0, z1, EPS_OT, args.seed)+    row = Pi.sum(dim=1).clamp_min(1e-12)+    col = Pi.sum(dim=0).clamp_min(1e-12)+    bary0 = (Pi @ z1.double()) / row.unsqueeze(1)          # forward barycentre (stage0 cells)+    anc1 = (Pi.t() @ z0.double()) / col.unsqueeze(1)        # ancestor barycentre (stage1 cells)+    d0 = (bary0 - z0.double()).float()                       # regression targets, per unit interval+    d1 = (z1.double() - anc1).float()                        # forward direction at last stage+    # coupling quality diagnostics (PLAN risk 1)+    Pn = Pi / Pi.sum()+    ent = float(-(Pn * (Pn.clamp_min(1e-300).log())).sum())+    topk = float(Pn.topk(min(10, n1), dim=1).values.sum(dim=1).mean())+    hard_cost = float((Pn * Mcost).sum())+    d0n = d0.norm(dim=1)+    print(f"[diag] coupling entropy={ent:.3f} (max {np.log(min(n0, n1)):.3f}) top10 mass={topk:.3f} "+          f"transport cost={hard_cost:.3f}")+    print(f"[diag] d0 norm mean={float(d0n.mean()):.4f} std={float(d0n.std()):.4f}; "+          f"d1 dir mean-cos={float((d1 / (d1.norm(dim=1, keepdim=True) + 1e-9) @ (d1 / (d1.norm(dim=1, keepdim=True) + 1e-9)).mean(0)).mean()):.4f}")++    # kNN smoothing of the last-stage displacement field (deterministic)+    with torch.no_grad():+        D2 = torch.cdist(z1, z1) ** 2+        kk = min(SMOOTH_K, n1)+        _, nbr = torch.topk(D2, kk, largest=False, dim=1)+        d1s = d1[nbr].mean(dim=1)      class Vel(torch.nn.Module):         def __init__(self):@@ -148,13 +202,11 @@ def main():     from geomloss import SamplesLoss     loss_ot = SamplesLoss("sinkhorn", p=2, blur=BLUR, backend="tensorized") -    n0, n1 = z0.shape[0], z1.shape[0]     cloud = torch.cat([z0, z1], dim=0)+    cloud_sub = cloud  # clouds are small on X3; cap anyway     if cloud.shape[0] > 4096:         idx = torch.randperm(cloud.shape[0], generator=torch.Generator().manual_seed(args.seed))[:4096].to(device)         cloud_sub = cloud[idx]-    else:-        cloud_sub = cloud      def knn_dist(pts, ref, k):         d2 = torch.cdist(pts, ref) ** 2@@ -162,58 +214,77 @@ def main():         vals, _ = torch.topk(d2, k, largest=False, dim=1)         return vals.mean(dim=1).mean() -    hist = []+    bary0_f = bary0.float()     import time as _time     t0_wall = _time.time()     for step in range(STEPS):-        if _time.time() - t0_wall > 900:  # hard cap: 15 min of training-            print(f"[manifold_ode] training time cap hit at step {step}")+        if _time.time() - t0_wall > 720:+            print(f"[manifold_ode_v2] training time cap hit at step {step}")             break         g0 = torch.Generator(device="cpu").manual_seed(args.seed * 100003 + step)         g1 = torch.Generator(device="cpu").manual_seed(args.seed * 1000003 + step)         i0 = torch.randint(0, n0, (min(SUBSAMPLE, n0),), generator=g0).to(device)         i1 = torch.randint(0, n1, (min(SUBSAMPLE, n1),), generator=g1).to(device)         s0, s1 = z0[i0], z1[i1]++        # main loss: velocity regression onto coupling barycentre displacement+        tt = torch.rand(s0.shape[0], 1, generator=g0).to(device)+        zt = (1.0 - tt) * s0 + tt * bary0_f[i0]+        vpred = vel(zt, tt)+        l_reg = ((vpred - d0[i0]) ** 2).sum(dim=1).mean()+        kin = (vpred ** 2).sum(dim=1).mean()++        # auxiliary: Sinkhorn distribution matching over integrated flow         zf, pts = integrate(vel, s0, 0.0, 1.0, ODE_STEPS)         l_match = loss_ot(zf, s1)-        kin = torch.stack([(vel(p, torch.full((p.shape[0], 1), min(u, 1.0), device=device)) ** 2).sum(1).mean()-                           for p, u in zip(pts, np.linspace(0, 1, ODE_STEPS))]).mean()         mids = pts[1:-1] if len(pts) > 2 else pts         l_man = torch.stack([knn_dist(p, cloud_sub, KNN_K) for p in mids]).mean()-        loss = l_match + LAMBDA_V * kin + LAMBDA_M * l_man++        loss = REG_WEIGHT * l_reg + LAMBDA_S * l_match + LAMBDA_V * kin + LAMBDA_M * l_man         opt.zero_grad()         loss.backward()         torch.nn.utils.clip_grad_norm_(vel.parameters(), 5.0)         opt.step()-        if step % 100 == 0 or step == STEPS - 1:-            hist.append((step, float(l_match), float(kin), float(l_man), float(loss)))-            print(f"step {step:5d} match={float(l_match):.5f} kin={float(kin):.5f} manifold={float(l_man):.5f} total={float(loss):.5f}", flush=True)+        if step % 200 == 0 or step == STEPS - 1:+            print(f"step {step:5d} reg={float(l_reg):.5f} match={float(l_match):.5f} "+                  f"kin={float(kin):.5f} manifold={float(l_man):.5f} total={float(loss):.5f}", flush=True)      vel.eval()     with torch.no_grad():-        # mechanism diagnostics-        zsel = z1[torch.arange(0, n1, max(1, n1 // 512)).to(device)]-        v_at = vel(zsel, torch.ones(zsel.shape[0], 1, device=device))-        vn = v_at / (v_at.norm(dim=1, keepdim=True) + 1e-9)-        cos_mean = float((vn @ vn.mean(0) / (vn.mean(0).norm() + 1e-9)).mean())-        print(f"[diag] velocity direction mean-cosine at u=1: {cos_mean:.4f} (1.0 == constant shift)")-        zf, pts = integrate(vel, z1[torch.tensor(keep, device=device)], 1.0, u_target, ODE_STEPS)-        z_pred = z1[torch.tensor(keep, device=device)] + ALPHA * (zf - z1[torch.tensor(keep, device=device)])-        l2 = (z_pred - z1[torch.tensor(keep, device=device)]).norm(dim=1)-        print(f"[diag] latent displacement L2: mean={float(l2.mean()):.4f} std={float(l2.std()):.4f} min={float(l2.min()):.4f}")-        midpts = torch.cat(pts[: len(pts) // 2], 0)-        print(f"[diag] manifold penalty at midway: {float(knn_dist(midpts, cloud_sub, KNN_K)):.5f} (final-train value above)")--        # decode: PCA inverse on full-latent scale+        keep_t = torch.tensor(keep, device=device)+        zl = z1[keep_t]+        # mechanism evidence: cosine between learned v(z1, u=1) and coupling direction+        v_at = vel(z1, torch.ones(n1, 1, device=device))+        cos = torch.nn.functional.cosine_similarity(v_at, d1s, dim=1)+        print(f"[diag] cos(v(z1,1), coupling dir): mean={float(cos.mean()):.4f} "+              f"median={float(cos.median()):.4f} (PLAN target >0.7)")++        zf, pts = integrate(vel, zl, 1.0, u_target, ODE_STEPS)+        ode_disp = zf - zl+        anchor = ALPHA * d1s[keep_t]+        z_pred = zl + anchor + BETA * ode_disp+        l2a = anchor.norm(dim=1)+        l2t = (z_pred - zl).norm(dim=1)+        print(f"[diag] anchor L2 mean={float(l2a.mean()):.4f} std={float(l2a.std()):.4f}; "+              f"total L2 mean={float(l2t.mean()):.4f}; ode L2 mean={float(ode_disp.norm(dim=1).mean()):.4f}")+        midpts = torch.cat(pts[: max(1, len(pts) // 2)], 0)+        print(f"[diag] manifold penalty midway: {float(knn_dist(midpts, cloud_sub, KNN_K)):.5f}")+         Zp = (z_pred.cpu().numpy() * sd).astype(np.float64)         Xr = pca.inverse_transform(Zp)         Z1k = pca.transform(A1[keep])         X1k_rec = pca.inverse_transform(Z1k)         resid = A1[keep] - X1k_rec -        nH = len(hvg_idx)         out = X_last[keep].copy()-        Xpred_hvg = np.clip(Xr + resid, 0, None)+        if DECODE_MODE == "gene":+            # amplify the HVG gene-space delta (decode amplification, node-8 style)+            Z1k = pca.transform(A1[keep])+            X1k_rec = pca.inverse_transform(Z1k)+            delta = Xr - X1k_rec+            Xpred_hvg = np.clip(A1[keep] + LAMBDA_G * delta, 0, None)+        else:+            Xpred_hvg = np.clip(Xr + resid, 0, None)         src = A1[keep]         nz = src > 0         sub = out[:, hvg_idx]@@ -222,7 +293,7 @@ def main():      out = np.nan_to_num(out, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32)     view_io.write_prediction(sp.csr_matrix(out), genes, args.out, seed=args.seed)-    print(f"[manifold_ode] wrote {out.shape} nnz_frac={float((out > 0).mean()):.4f}")+    print(f"[manifold_ode_v2] wrote {out.shape} nnz_frac={float((out > 0).mean()):.4f}")   if __name__ == "__main__":

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

用到的知识库条目

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

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

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

分析员

ANALYSIS.json written

工程师

Final state verified: `solution/run.py` defaults = submitted config (latent decode, α=2.0, β=0.1, λ_reg=1.0), `preds/a2.0.h5ad` passes `vec-check`.

**Summary**
- Implemented PLAN v2 on parent 18: Sinkhorn coupling (ε=1e-3) per-cell barycentric displacements as velocity-regression targets (λ_reg=1.0, Sinkhorn demoted to 0.1), inference anchored to kNN-smoothed coupling direction with α=2.0 (= time-gap ratio on X3), ODE mixed at β=0.1, 1000 steps/5 Euler steps.
- Scores (X3 A-half, seed 0): α=2.0 → **49.59** (parent 47.33/47.56); α=3.0 → 49.16; gene-decode λ=3 → 48.91; control REG_WEIGHT=0 → 50.17 (within noise of on — anchored displacement does the work, regression supervision not proven beneficial; reported honestly, mechanism kept ON).
- Next best direction: adopt local_ot's top-k ancestor truncation inside this family and fix coupling marginal convergence; covariation is the weak group (41.5) — displacement amplification trades it for cell_state.

调研员

name": "manifold_ode v2: OT耦合速度目标监督 + 流形约束神经ODE",
 "motivation": "父节点18的核心结构问题：Sinkhorn散度只匹配边际分布，不提供逐细胞方向监督，导致速度场方向与真实后续变化不符（direction≈49.2，无提升；α越大分越低，α=0.7时45.75）。而节点8/11证明OT耦合的逐细胞位移方向极有效（cell_state=90.95）。de_recovery是最弱组（44.45，-6.93），covariation也损失3.58。修复方向：用OT耦合的重心位移作为速度场的逐细胞训练目标，替换纯分布匹配。",
 "approach": "1) 保留父节点骨架：HVG(2500)→PCA(30)→归一化。2) 新增：用geomloss/POT在PCA空间计算stage0→stage1的Sinkhorn耦合（ε=1e-3），提取逐细胞重心位移d_i=bary_i-z0_i，归一化到单位时间间隔得速度目标v_target_i=d_i。3) 训练损失改为：L=L_reg(‖v(z,u)-v_target‖²,在u∈[0,1]均匀采样，用OT配对点插值z_t=(1-t)z0+t·bary)+λ_s·Sinkhorn(z1_pred,z1)+λ_m·kNN流形惩罚+λ_v·‖v‖²。关键：回归损失权重λ_reg=1.0为主，Sinkhorn降为辅助（λ_s=0.1）。4) 推理：从最后输入阶段积分，但位移方向锚定到耦合重心方向：step=α·(coupling_bary−z_last)的kNN平滑版，ODE积分仅做流形修正（小权重β=0.1混合），避免自由外推。α网格：{0.0,0.05,0.1,0.15,0.2,0.3}，λ=3.0参考节点8。5) 解码：PCA逆变换+逐细胞残差，仅写非零位，clip≥0，非HVG取原值。6) 单输入退路：copy_last。7) vec-score快速筛选：先跑α=0.1和0.2两个点（各~2分钟），确认cell_state>50后再扩展网格。训练预算：1500步Adam，每步≤2048细胞，15分钟硬上限。8) kNN流形惩罚保留（k=20,λ_m=0.1），但作为辅助正则而非主损失。",
 "expected_groups": ["cell_state", "de_recovery", "direction"],
 "risks": "1) OT耦合在2500 HVG、~2000细胞的PCA空间上可能退化（entropic smoothing过度），Engineer应检查耦合矩阵的熵和top-k集中度；若退化则降ε到1e-4。2) 速度回归+Sinkhorn双损失可能冲突，若cell_state<50则去掉Sinkhorn项只保留回归。3) 30分钟内训练+推理时间紧张，父节点已耗97.7s；减少ODE步数到5步、训练步数降到1000可省时间。4) α=0时输出=copy_last（50.65），若所有α>0都不超过α=0，说明即使有正确方向监督，ODE外推仍无益，如实报告阴性。5) 尽早发现：第一个α=0.1查分若cell_state<55，立即检查耦合质量（重心位移与真实变化的余弦），不要继续网格。",
 "family_id": "manifold_ode",
 "mechanism": "神经ODE速度场以OT耦合逐细胞重心位移为回归目标训练（而非仅分布匹配），推理时沿耦合方向做流形约束积分，位移由耦合锚定而非自由外推。",
 "vs_constant_shift": "每细胞位移方向和幅度不同：由OT耦合的逐细胞重心差决定，在PCA空间逐细胞计算；常数位移对所有细胞施加同一向量。速度场是状态的函数（MLP(z,u)），不同位置的细胞获得不同速度；且流形kNN惩罚使轨迹弯曲贴合数据云，而非直线。",
 "mechanism_evidence": "1) 报告速度场与耦合目标方向的余弦相似度（训练后应>0.7，父节点仅0.14-0.18说明方向错）；2) 逐细胞位移幅度分布（应非零且非均匀）；3) 四组分各自变化；4) 与α=0（=copy_last）的逐细胞L1差；5) 耦合重心位移的方向离散度（应远大于常数位移）。",
 "mechanism_off_control": "设VEC_REG_WEIGHT=0（去掉速度回归目标），退化为父节点的纯Sinkhorn分布匹配ODE（同一程序、同一训练预算）。预期：回归权重=0时输出回到父节点水平（~47），开启后cell_state应显著提升（>55）。若两者输出相同，说明回归目标未生效。另设VEC_ALPHA=0作为完全关闭对照（输出=copy_last）。"}
```