总览 · ← 返回运行 20261003-093415-search-t1-r2-D-s1

节点 n22 在终选来历上

growth_dynamics v2 — METHOD

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

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

调研员的计划

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

对比：父节点版本 7f050577dd。改动的文件：solution/METHOD.md +55 −67、solution/run.py +271 −144

diff --git a/solution/METHOD.md b/solution/METHOD.mdindex 32b3a5a..5d63ab8 100644--- a/solution/METHOD.md+++ b/solution/METHOD.md@@ -1,70 +1,58 @@-growth_dynamics 最小版：两输入阶段做非平衡 Sinkhorn OT，取逐细胞生长权重 g_i（源边际失衡）驱动重采样 + 重心速度 α 外推（残差解码回真实细胞，稀疏门控）；单输入退路为 copy_last。--## 方法族与机制--family_id = growth_dynamics（PLAN 指定的最小实现）。机制：非平衡最优传输（POT-`ot.sinkhorn_unbalanced`，reg=0.05）在 25 维 PCA 空间（2500 HVG，两阶段合并拟合，-randomized SVD，random_state=seed）耦合相邻两输入阶段；每个源细胞的耦合行和 /-(1/n) 给出局部生长权重 g_i（clip [0.4,2.5]），重心差给出速度 v_i（范数 clip 到-2×中位数）。(v,g) 经 5-NN 传到末阶段全部细胞；外推 z_pred = z_last + α·v，-α = 0.8·clip(Δt_out/Δt_train, 1, 1.5)（只用时间差，视图无关）；输出 N_out 个细胞-按 p ∝ g 有放回重采样（机制关闭时均匀采样）；解码为残差式：真实末阶段细胞的稀疏-表达 + PCA 逆投影位移，位移只加在该细胞已表达的基因上（稀疏门控，默认开），-clip ≥0；非 HVG 覆盖基因原样保留。单输入阶段（proxy10）生长不可辨识，退路为-copy_last 均匀子采样。--reg_m 自适应：依次尝试 2.0 → 1.0 → 0.5，取第一个使 std(g_src) ≥ 0.05 的（PLAN-风险 1 的处置）；X3 上实际选中 reg_m=1.0。--## 机制生效证据（X3_qiu_heart_early，seed 0，A 半）--- g_i 分布（NN 平滑后）：mean 0.845，std 0.047，min 0.705，max 0.928；-  15.4% 细胞 g∉[0.8,1.2]。std > 0.05 在源细胞层面成立（reg_m=1.0 时 g_src-  std=0.057），NN 平滑后略降 → 机制活性偏弱。-- 机制改变的内容：只改变被抽样细胞的组成（g 高的亚状态被过采样），不改变表达-  解码路径。生长开 vs 关（同一位移，均匀重采样）：-  - growth-on：47.16（cell_state 49.19，covariation 48.36，mmd_u 0.03475）-  - growth-off：47.41（cell_state 48.89，covariation 48.57）-  差值在 ±2 噪声内 → 生长重采样在 X3 上**惰性到轻微有害**，未产生可测收益。-- 位移外推（α）扫描：α=1.2 无门控 46.16（variogram 42.1，稠密位移破坏共变）；-  α=1.2 门控 47.16；α=0.6 门控 47.24；α=0（纯生长重采样）47.38；均 ≤ copy_last-  参考 47.92（节点 1）。OT 重心速度方向在 X3 上未带来 mmd/DE 收益。--## 查分记录（A 半）--| 配置 | X3 |-|---|---|-| resid 无门控 α=1.2 growth-on / off | 46.16 / 46.18 |-| resid 无门控 α=0.6 | 46.66 |-| 纯生长重采样 α=0 / sharpen^4 | 47.38 / 44.41 |-| 门控 α=1.2 / α=0.6 | 47.16 / 47.24 |-| 门控 α=1.2 growth-off（对照，提交配置） | 47.41 |--proxy10（copy_last 退路，提交配置）：52.97（种子 copy_last 节点 1 为 52.75，-噪声内一致）。--## 验证过 / 未验证--- 验证过：X3 与 proxy 两视图 vec-check 通过；seed 0 下跨 cwd 重跑输出逐位相同-  （确定性）；只用时间差与视图数据（视图无关）；纯 CPU（EXECUTION.json gpu=false），-  X3 全程 <40s、proxy <5s。-- 未验证：α、λ、reg 的系统扫描（时间预算内只做了上述点）；blend 解码（实现了-  GROWTH_DECODE=blend 但未查分）；生长机制在输入间隔更长/细胞更多的视图（如-  proxy2、final）上是否更强——X3 两阶段同为 Qiu 心脏细胞、间隔仅 0.25 天，-  生长信号弱。--## 结论与下一步--按 PLAN 要求提交时机制保持打开（growth-on、门控残差解码）。诚实结论：在 X3 上-该机制族的最小版未跑赢 copy_last（≈47.2 vs 47.9，噪声内），瓶颈是 0.25 天间隔-下非平衡 OT 的生长权重对比度太低（std≈0.05），以及重心速度对 mmd 无收益。-下一步最值得试：(1) 把生长权重按细胞类型聚合（去噪）再与组成趋势重加权（节点-7/13/16 已证明有效）组合；(2) 更低 reg_m / KL 权重扫描提高 g 对比度；(3) 在-proxy2（0.5 天间隔、跨数据集）上检验生长信号是否更可辨识。+# growth_dynamics v2 — METHOD++组成趋势×簇级OT生长权重重采样+门控型级位移外推；单输入退路=心脏解剖组成先验+型内复杂度选择。++## 方法（family_id = growth_dynamics）++统一管线：对末阶段每个细胞算权重 `w_i = w_type(i) × G_cluster(i)^γ × exp(λ·z_i)`，+按型做 largest-remainder 配额、型内按 w_i 有放回/不放回抽样（λ=0.15，γ=1.0），输出真实末阶段细胞。++**两输入路径（X3）**：+1. 组成趋势：`w_t = c1_t · clip((n1_t+3)/(n0_t+3), 0.2, 5)^T`，`T = clip(Δt_out/Δt_in, 0, 1.5)`（只用时间差；X3 上 T=1.5）。+2. 生长权重（机制）：HVG2500+PCA25 上非平衡 Sinkhorn OT（reg=0.05，**reg_m=0.3 固定**，跳过父节点自适应），源边际失衡 → 逐源细胞 g_i（clip [0.4,2.5]）→ 5-NN 传到末阶段全部细胞 → KMeans(20, random_state=seed) 聚类 → 逐簇中位数 G_c（PLAN 的 Leiden 换成 KMeans：更快且严格确定，见"偏差"）。`final = trend × G_c^γ`。+3. 型内成熟度倾斜：细胞在型级伪批量差方向（mean_last − mean_first，覆盖基因）上的投影，型内 z 分数，×exp(0.15·z)。+4. 位移：型级伪批量差 × β·T（β=1.0），**稀疏门控**（只加在该细胞已表达基因上，父节点教训），clip ≥0；非覆盖基因不动。++**单输入路径（proxy10）**：生长不可辨识（无 OT）。组成 = 心脏解剖先验重加权（HEART_TYPES ×1.6，Surface Ectoderm/EXEM/Paraxial Mesoderm ×0.25，Neural Tube 剔除；同 src/task1_temporal/reweight.py 的 run2 验证规则）；型内选择 = 细胞复杂度（log 总 counts）z 分数倾斜 λ=0.15。无位移。不再用父节点的 copy_last 退路。++## 机制生效证据（X3，seed 0，A 半）++- 簇级 G_c：std=0.052（≥0.05 阈值），range [0.475, 0.642]；KMeans 20 簇的中位数聚合比父节点 NN 平滑（std 0.047）对比度略升。reg_m 从父节点的 1.0 降到 0.3 提高了源级 g 对比度。+- growth-on vs growth-off（GROWTH_OFF=1，同一程序同一 seed，其余全同）：+  - on：**58.90**（de_score 14.89 / de_dir 13.48 / mmd_u 0.0214→20.27 / variogram 0.001474→10.26）+  - off：**57.69**（14.56 / 13.63 / 0.02227→19.79 / 0.001619→9.72）+  - 差 +1.21，在 ±2 噪声内 → 机制**弱活性**：方向为正，主要落在 mmd_u（+0.48）和 variogram（+0.55），但不可辨识为确定收益。如实报告。+- γ=2.0（加强生长）：56.82，比 γ=1.0 差 → 对比度加强反而放大噪声，保持 γ=1.0。+- 位移门控是关键：β·T=1.5 稠密位移 variogram 崩到 3.47（总 49.75），门控后 10.26（总 58.90）——与父节点"稀疏门控保护共变结构"的教训一致。++## 查分记录（A 半，seed 0）++| 配置 | X3 | proxy10 |+|---|---|---|+| 父节点 19 | 47.03 | 52.75 |+| v1 稠密位移 γ=1 | 49.75 | — |+| **提交：门控位移 γ=1 growth-on** | **58.90** | — |+| 门控 growth-off（对照） | 57.69 | — |+| 门控 γ=2 | 56.82 | — |+| 单输入：prolif 倾斜 λ=0.15 | — | 58.15 |+| **提交：complexity 倾斜 λ=0.15** | — | **58.79** |+| complexity λ=0.5 | — | 54.43 |+| HEART_WEIGHT 2.2 / EDGE 0.2 | — | 58.55 |++节点分估计 = (58.79 + 2×58.90)/3 ≈ 58.9（父 48.94）。++## 偏差与未验证++- PLAN 的 Leiden 聚类换成 KMeans(k=20)：确定性更强、无 igraph 依赖、X3 2174 细胞下快；聚类目的（G_c 去噪聚合）等价。+- 未验证：reg_m<0.3、簇数扫描、λ 在两输入路径上的扫描、β<1.0、单输入 prolif vs complexity 在 B 半的表现（A 半差 0.64，噪声内，选了 mmd 更好的 complexity）。+- 单输入路径（58.8）仍低于节点 3/7 的 63.7/64.3：其"型内成熟度选择"具体实现不可见，本次用心脏先验+复杂度倾斜逼近，未完全恢复。++## 确定性 / 视图无关++`np.random.default_rng(seed)`、KMeans(random_state=seed)、randomized_svd(random_state=seed)；无全局随机态。只用时间差（Δt_out/Δt_in）与视图内数据；不读 external/、不读绝对阶段名分支。两视图 vec-check 通过；X3 全程 <20s，proxy <5s，纯 CPU（EXECUTION.json gpu=false）。  ## 知识来源 -未使用任何保留阶段/保留基因型的测量信息；未用外部数据（X3 视图挂载的-external/ 未读取——输入本身即 Qiu E8.75/E9.0，输出目标 E9.5 在禁窗外但无对应-外部数据可用）。方法为通用算法知识（非平衡 OT：Séjourné et al. sinkhorn-divergences 框架；生长权重 = 边际失衡，Waddington-OT 生长项的标准做法）。+- 心脏解剖先验（心脏侧类型上调、表面/边缘类型下调、Neural Tube 剔除）：E9.5 心脏解剖取样的通用谱系知识，与 src reweight.py（run2 已验证）一致，不含保留阶段测量。+- 增殖基因列表：GO:0007049（细胞周期）通用注释（最终配置未使用，保留在代码里作 TILT_MODE=prolif 分支）。+- 非平衡 OT 生长权重 = 边际失衡：Waddington-OT 生长项的标准做法（Séjourné et al. Sinkhorn divergences 框架）。diff --git a/solution/run.py b/solution/run.pyindex 58e5c44..823659c 100644--- a/solution/run.py+++ b/solution/run.py@@ -1,19 +1,24 @@-"""growth_dynamics draft: unbalanced OT growth weights + barycentric velocity extrapolation.--Two-input path: HVG -> PCA(25) -> unbalanced Sinkhorn OT between the two input-stages -> per-source-cell growth g_i (row marginal imbalance) and barycentric-velocity v_i -> transfer (v, g) to last-stage cells via 5-NN -> extrapolate-z_pred = z_last + alpha * v (alpha = damp * clip(dt_out/dt_train, 1, 1.5)) ->-resample N_out cells with probability proportional to g -> decode to gene space.--Single-input path: growth is not identifiable from one stage; fall back to-copy_last (uniform subsample of the last input stage).--Mechanism control: GROWTH_OFF=1 sets all g_i = 1 (uniform resampling), keeping-the velocity displacement identical. Kept ON for submission.--Only time differences (not absolute times) and view data are used; deterministic-under --seed.+"""growth_dynamics v2: composition trend x cluster-level growth weights + type displacement.++Two-input path (X3-style):+  1. Type-frequency trend between the two inputs: w_t = c1_t * clip((n1+s)/(n0+s), 0.2, 5)^T,+     T = clip(dt_out/dt_in, 0, 1.5), s = 3 (uses only time differences).+  2. Unbalanced Sinkhorn OT (reg=0.05, reg_m=0.3) between the two inputs in PCA(25)/HVG(2500)+     space -> per-source-cell growth g_i (row marginal imbalance) -> 5-NN transfer to last-stage+     cells -> KMeans(20) clusters on last stage -> per-cluster median G_c.+     final per-cell weight = w_type(i) * G_cluster(i)^gamma, gamma = 1.0.+     GROWTH_OFF=1 sets G_c = 1 (pure composition trend) - mechanism control.+  3. Within-type maturity tilt: project cells on the type-level pseudobulk delta+     (mean last - mean first), z-score within type, weight *= exp(lambda*z), lambda = 0.15.+  4. Type-level displacement: x_out = clip(x + beta * T * delta_t, 0), beta = 1.0,+     optionally gated to genes already expressed in the cell (GATE env).++Single-input path (proxy10-style): heart-anatomy composition prior reweighting+(heart types x1.6, surface/edge types x0.25, Neural Tube dropped) + within-type+proliferation-program tilt (lambda = 0.15); no OT (growth unidentifiable), no+displacement (no second stage to difference).++Deterministic under --seed; only view data and time differences are used. """ from __future__ import annotations @@ -28,29 +33,44 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))  from src.task1_temporal import view_io  # noqa: E402 - # --- hyperparameters (PLAN.json) --- N_HVG = 2500 N_PCA = 25 MAX_TRAIN = 3000 OT_REG = 0.05-OT_REG_M = 2.0-OT_REG_M_FALLBACK = 1.0-OT_REG_M_FALLBACK2 = 0.5+OT_REG_M = 0.3 G_CLIP = (0.4, 2.5)-G_STD_MIN = 0.05-ALPHA_DAMP = float(os.environ.get("GROWTH_DAMP", "0.8"))-T_CLIP = (1.0, 1.5)-V_NORM_CLIP = 2.0  # clip displacement norm to 2x median+K_CLUSTERS = 20 K_TRANSFER = 5-LAMBDA_RESID = 0.4-DECODE = os.environ.get("GROWTH_DECODE", "resid")  # "resid" | "blend"+GAMMA = float(os.environ.get("GROWTH_GAMMA", "1.0")) GROWTH_OFF = os.environ.get("GROWTH_OFF", "0") == "1"-GROWTH_SHARP = float(os.environ.get("GROWTH_SHARP", "1.0"))+SMOOTH = 3.0+T_CLIP = (0.0, 1.5)+RATIO_CLIP = (0.2, 5.0)+LAMBDA_TILT = float(os.environ.get("TILT_LAMBDA", "0.15"))+BETA_DISP = float(os.environ.get("DISP_BETA", "1.0"))+GATE_DISP = os.environ.get("DISP_GATE", "1") == "1"+HEART_WEIGHT = float(os.environ.get("HEART_WEIGHT", "1.6"))+EDGE_WEIGHT = float(os.environ.get("EDGE_WEIGHT", "0.25"))++HEART_TYPES = {+    "OFT/RV-CM", "IFT-CM", "AVC-CM", "SV-CM", "LV-CM", "RV-CM", "V-CM",+    "Endothelium", "Endocardium", "BEC",+    "aSHF", "pSHF", "aPHM", "pPHM",+    "JCF", "Pericardium", "Proepicardium",+}+EDGE_TYPES = {"Surface Ectoderm", "EXEM", "Paraxial Mesoderm"}+DROP_TYPES = {"Neural Tube"}++# cell-cycle / proliferation program (general GO:0007049 knowledge, not stage-specific)+PROLIF_GENES = [+    "Mki67", "Top2a", "Cdk1", "Ccnb1", "Ccna2", "Birc5", "Ube2c", "Pcna",+    "Mcm2", "Mcm3", "Mcm4", "Mcm5", "Mcm6", "Mcm7", "Mcm10", "Rrm2", "Tyms",+    "E2f1", "Ccnf", "Gins1", "Pola1", "Prim1", "Cdk4", "Ccnd1", "Ccne1",+]   def hvg_indices(X: sparse.csr_matrix, mask: np.ndarray, n_hvg: int) -> np.ndarray:-    """Top variable genes among covered genes (seurat-style on log data)."""     sub = X[:, mask]     mean = np.asarray(sub.mean(axis=0)).ravel()     sq = np.asarray(sub.multiply(sub).mean(axis=0)).ravel()@@ -64,14 +84,41 @@ def hvg_indices(X: sparse.csr_matrix, mask: np.ndarray, n_hvg: int) -> np.ndarra     return np.sort(idx[keep])  -def fit_pca(A: np.ndarray, k: int, seed: int):-    from sklearn.utils.extmath import randomized_svd--    mean = A.mean(axis=0)-    C = A - mean-    _, _, Vt = randomized_svd(C, k, random_state=seed, n_oversamples=30)-    comp = Vt.astype(np.float32)-    return mean.astype(np.float32), comp+def largest_remainder(weights: np.ndarray, n: int) -> np.ndarray:+    weights = np.clip(np.asarray(weights, dtype=np.float64), 0, None)+    if n <= 0 or weights.sum() <= 0:+        return np.zeros(len(weights), dtype=int)+    raw = weights / weights.sum() * n+    out = np.floor(raw).astype(int)+    short = int(n - out.sum())+    order = np.argsort(-(raw - out))+    for i in order[:short]:+        out[i] += 1+    return out+++def z_within(scores: np.ndarray, groups: np.ndarray) -> np.ndarray:+    """z-score `scores` within each group label (stable, deterministic)."""+    z = np.zeros_like(scores, dtype=np.float64)+    for g in np.unique(groups):+        m = groups == g+        s = scores[m]+        if m.sum() < 3:+            continue+        sd = s.std()+        if sd > 1e-9:+            z[m] = (s - s.mean()) / sd+    return np.clip(z, -4.0, 4.0)+++def type_alloc(labels: np.ndarray, type_w: dict, n_out: int, rng) -> dict:+    """Per-type integer allocation proportional to abundance * type_w, then+    within-type sampling handled by caller. Returns {type: (pool_idx, n_take)}."""+    types = [str(t) for t in np.unique(labels) if str(t) not in DROP_TYPES]+    counts = np.array([(labels == t).sum() for t in types], dtype=np.float64)+    w = np.array([type_w.get(t, 1.0) for t in types], dtype=np.float64)+    alloc = largest_remainder(counts * w, n_out)+    return {t: (np.flatnonzero(labels == t), int(n)) for t, n in zip(types, alloc) if n > 0}   def main() -> None:@@ -86,130 +133,210 @@ def main() -> None:      def _tm(tag):         print(f"[time] {tag} {time.time() - _t0:.1f}s", file=sys.stderr)+     view = args.data     rng = np.random.default_rng(args.seed)      manifest = view_io.load_manifest(view)     genes = view_io.panel_genes(view, manifest)+    gene_pos = {g: i for i, g in enumerate(genes)}     entries = view_io.inputs_by_time(manifest, include_external=True)     last = entries[-1]     adata_last = view_io.read_stage(view, last, genes, missing="fill")-    n_out = view_io.target_n_cells(manifest, adata_last.n_obs)--    if len(entries) < 2:-        # single-input fallback: copy_last (uniform subsample of real cells)-        idx = view_io.sample_rows(adata_last.n_obs, n_out, rng)-        view_io.write_prediction(adata_last.X[idx], genes, args.out, seed=args.seed)-        return--    first = entries[-2]-    adata_first = view_io.read_stage(view, first, genes, missing="fill")-+    labels_last = view_io.labels_of(adata_last)+    n_last = adata_last.n_obs+    n_out = view_io.target_n_cells(manifest, n_last)++    two = len(entries) >= 2+    adata_first = None+    if two:+        first = entries[-2]+        adata_first = view_io.read_stage(view, first, genes, missing="fill")+        labels_first = view_io.labels_of(adata_first)     _tm("read")-    cov = np.asarray(adata_last.var["covered"], dtype=bool) & np.asarray(-        adata_first.var["covered"], dtype=bool-    )-    hvg = hvg_indices(adata_last.X, cov, N_HVG)--    _tm("hvg")-    # subsample for training-    def sub(a, n):-        if a.n_obs <= n:-            return np.arange(a.n_obs)-        return np.sort(rng.choice(a.n_obs, size=n, replace=False))--    i0 = sub(adata_first, MAX_TRAIN)-    i1 = sub(adata_last, MAX_TRAIN)-    X0 = np.asarray(adata_first.X[i0][:, hvg].todense(), dtype=np.float32)-    X1 = np.asarray(adata_last.X[i1][:, hvg].todense(), dtype=np.float32)--    mean, comp = fit_pca(np.vstack([X0, X1]), N_PCA, args.seed)-    Z0 = (X0 - mean) @ comp.T-    Z1 = (X1 - mean) @ comp.T-    Z1_full = (np.asarray(adata_last.X[:, hvg].todense(), dtype=np.float32) - mean) @ comp.T--    _tm("pca")-    # --- unbalanced OT: growth + barycentric velocity on source cells ----    import ot as pot--    a = np.full(Z0.shape[0], 1.0 / Z0.shape[0])-    b = np.full(Z1.shape[0], 1.0 / Z1.shape[0])-    d = Z0[:, None, :] - Z1[None, :, :]-    M = (d * d).sum(-1).astype(np.float64)-    M /= max(np.median(M), 1e-8)--    P = rs = None-    for reg_m in (OT_REG_M, OT_REG_M_FALLBACK, OT_REG_M_FALLBACK2):-        P = pot.sinkhorn_unbalanced(a, b, M, reg=OT_REG, reg_m=reg_m)++    # ---------- type-level composition weights ----------+    if two:+        dt_in = max(float(last["time"]) - float(first["time"]), 1e-6)+        dt_out = max(float(manifest["target"]["time"]) - float(last["time"]), 0.0)+        T = float(np.clip(dt_out / dt_in, *T_CLIP))+        n0 = np.array([(labels_first == t).sum() for t in np.unique(labels_first)])+        cnt0 = {str(t): float(c) for t, c in zip(np.unique(labels_first), n0)}+        cnt1 = {str(t): float((labels_last == t).sum()) for t in np.unique(labels_last)}+        type_w = {}+        for t, c1 in cnt1.items():+            ratio = (c1 + SMOOTH) / (cnt0.get(t, 0.0) + SMOOTH)+            type_w[t] = c1 * float(np.clip(ratio, *RATIO_CLIP)) ** T+        type_w = {t: w / max(cnt1[t], 1.0) for t, w in type_w.items()}  # per-cell weight+        deltas = None+    else:+        T = 0.0+        hw = {"heart": HEART_WEIGHT, "edge": EDGE_WEIGHT}+        type_w = {}+        for t in np.unique(labels_last):+            t = str(t)+            if t in HEART_TYPES:+                type_w[t] = hw["heart"]+            elif t in EDGE_TYPES:+                type_w[t] = hw["edge"]+            else:+                type_w[t] = 1.0++    # ---------- growth weights (two-input only) ----------+    growth_cell = np.ones(n_last, dtype=np.float64)+    diag = {"T": T, "G_std": 0.0, "reg_m": OT_REG_M}+    if two and not GROWTH_OFF:+        cov = np.asarray(adata_last.var["covered"], dtype=bool) & np.asarray(+            adata_first.var["covered"], dtype=bool+        )+        hvg = hvg_indices(adata_last.X, cov, N_HVG)++        def sub(a, n):+            if a.n_obs <= n:+                return np.arange(a.n_obs)+            return np.sort(rng.choice(a.n_obs, size=n, replace=False))++        i0 = sub(adata_first, MAX_TRAIN)+        i1 = sub(adata_last, MAX_TRAIN)+        X0 = np.asarray(adata_first.X[i0][:, hvg].todense(), dtype=np.float32)+        X1 = np.asarray(adata_last.X[i1][:, hvg].todense(), dtype=np.float32)+        from sklearn.utils.extmath import randomized_svd++        A = np.vstack([X0, X1])+        mean = A.mean(axis=0)+        C = A - mean+        _, _, Vt = randomized_svd(C, N_PCA, random_state=args.seed, n_oversamples=30)+        comp = Vt.astype(np.float32)+        Z0 = ((X0 - mean) @ comp.T).astype(np.float32)+        Z1 = ((X1 - mean) @ comp.T).astype(np.float32)+        Z1_full = (+            (np.asarray(adata_last.X[:, hvg].todense(), dtype=np.float32) - mean) @ comp.T+        ).astype(np.float32)+        _tm("pca")++        import ot as pot++        a = np.full(Z0.shape[0], 1.0 / Z0.shape[0])+        b = np.full(Z1.shape[0], 1.0 / Z1.shape[0])+        d = Z0[:, None, :] - Z1[None, :, :]+        M = (d * d).sum(-1).astype(np.float64)+        M /= max(np.median(M), 1e-8)+        P = pot.sinkhorn_unbalanced(a, b, M, reg=OT_REG, reg_m=OT_REG_M)         rs = P.sum(axis=1)-        if np.std(rs * Z0.shape[0]) >= G_STD_MIN:-            break-    g_src = np.clip(rs * Z0.shape[0], *G_CLIP)--    rs_safe = np.maximum(rs, 1e-12)-    v_src = (P @ Z1) / rs_safe[:, None] - Z0-    vn = np.linalg.norm(v_src, axis=1)-    med = np.median(vn[vn > 0]) if np.any(vn > 0) else 1.0-    scale = np.minimum(1.0, (V_NORM_CLIP * med) / np.maximum(vn, 1e-12))-    v_src = v_src * scale[:, None]--    _tm("ot")-    # --- transfer (v, g) to every last-stage cell via k-NN in PCA space ----    from sklearn.neighbors import NearestNeighbors--    nn = NearestNeighbors(n_neighbors=K_TRANSFER).fit(Z0)-    _, ind = nn.kneighbors(Z1_full)-    v_full = v_src[ind].mean(axis=1)-    g_full = np.clip(g_src[ind].mean(axis=1), *G_CLIP)--    # --- extrapolation scale from time differences only ----    dt_train = max(float(last["time"]) - float(first["time"]), 1e-6)-    dt_out = max(float(manifest["target"]["time"]) - float(last["time"]), 0.0)-    T = float(np.clip(dt_out / dt_train, *T_CLIP))-    alpha = ALPHA_DAMP * T--    z_pred = Z1_full + alpha * v_full--    # --- growth-weighted resampling ----    if GROWTH_OFF:-        sel = view_io.sample_rows(Z1_full.shape[0], n_out, rng)+        g_src = np.clip(rs * Z0.shape[0], *G_CLIP)++        from sklearn.neighbors import NearestNeighbors++        nn = NearestNeighbors(n_neighbors=K_TRANSFER).fit(Z0)+        _, ind = nn.kneighbors(Z1_full)+        g_full = np.clip(g_src[ind].mean(axis=1), *G_CLIP)++        from sklearn.cluster import KMeans++        km = KMeans(n_clusters=min(K_CLUSTERS, n_last), random_state=args.seed, n_init=10).fit(Z1_full)+        cl = km.labels_+        G_c = np.ones(km.n_clusters)+        for c in range(km.n_clusters):+            m = cl == c+            if m.sum():+                G_c[c] = np.median(g_full[m])+        growth_cell = G_c[cl] ** GAMMA+        diag["G_std"] = float(G_c.std())+        diag["G_min"] = float(G_c.min())+        diag["G_max"] = float(G_c.max())+        _tm("ot")++    # ---------- within-type tilt ----------+    tilt = np.zeros(n_last, dtype=np.float64)+    if two:+        # project on type-level pseudobulk delta direction (maturity along observed change)+        cov = np.asarray(adata_last.var["covered"], dtype=bool) & np.asarray(+            adata_first.var["covered"], dtype=bool+        )+        for t in np.unique(labels_last):+            m = labels_last == t+            mf = labels_first == t+            if m.sum() < 3 or mf.sum() < 3:+                continue+            dl = np.asarray(adata_last.X[m].mean(axis=0)).ravel() - np.asarray(+                adata_first.X[mf].mean(axis=0)+            ).ravel()+            dl = dl * cov+            nrm = np.linalg.norm(dl)+            if nrm < 1e-9:+                continue+            Xs = adata_last.X[m]+            proj = np.asarray(Xs @ (dl / nrm)).ravel()+            tilt[m] = z_within(proj, labels_last[m])     else:-        p = g_full**GROWTH_SHARP+        mode = os.environ.get("TILT_MODE", "complexity")+        if mode == "complexity":+            score = np.log1p(np.asarray(adata_last.X.sum(axis=1)).ravel())+            tilt = z_within(score, labels_last)+        else:+            idx = np.array([gene_pos[g] for g in PROLIF_GENES if g in gene_pos], dtype=np.int64)+            covl = np.asarray(adata_last.var["covered"], dtype=bool)[idx]+            idx = idx[covl]+            if idx.size:+                sub = adata_last.X[:, idx]+                score = np.asarray(sub.mean(axis=1)).ravel()+                tilt = z_within(score, labels_last)+    w_tilt = np.exp(LAMBDA_TILT * tilt)++    # ---------- per-cell weights and allocation ----------+    cell_type_w = np.array([type_w.get(str(t), 1.0) for t in labels_last], dtype=np.float64)+    cell_w = cell_type_w * growth_cell * w_tilt+    types_kept = [t for t in np.unique(labels_last) if str(t) not in DROP_TYPES]+    wt = np.array([max(cell_w[labels_last == t].mean(), 1e-9) for t in types_kept])+    cnt = np.array([(labels_last == t).sum() for t in types_kept], dtype=np.float64)+    alloc = largest_remainder(cnt * wt, n_out)++    sel = []+    for t, n in zip(types_kept, alloc):+        if n <= 0:+            continue+        pool = np.flatnonzero(labels_last == t)+        p = cell_w[pool]         p = p / p.sum()-        sel = rng.choice(Z1_full.shape[0], size=n_out, replace=True, p=p)-        sel = np.sort(sel)--    # --- decode to gene space ----    full = np.zeros((n_out, len(genes)), dtype=np.float32)-    rows = adata_last.X[sel].toarray().astype(np.float64)-    non_hvg = np.setdiff1d(np.flatnonzero(cov), hvg)-    if non_hvg.size:-        full[:, non_hvg] = rows[:, non_hvg]-    if DECODE == "blend":-        decoded = z_pred[sel] @ comp + mean-        nn2 = NearestNeighbors(n_neighbors=K_TRANSFER).fit(Z1_full)-        _, ind2 = nn2.kneighbors(z_pred[sel])-        Xr = np.asarray(adata_last.X[:, hvg].todense(), dtype=np.float64)-        nn_mean = Xr[ind2].mean(axis=1)-        Xh = (1.0 - LAMBDA_RESID) * decoded + LAMBDA_RESID * nn_mean-    else:  # "resid": keep real sparse cell, add gene-space displacement-        disp = (alpha * v_full[sel]) @ comp  # n_out x len(hvg)-        if os.environ.get("GROWTH_GATE", "1") == "1":-            disp = disp * (rows[:, hvg] > 0)-        Xh = rows[:, hvg] + disp-    full[:, hvg] = np.maximum(Xh, 0.0).astype(np.float32)-    X_out = sparse.csr_matrix(full)-+        take = rng.choice(pool, size=int(n), replace=pool.size < n, p=p)+        sel.append(take)+    sel = np.sort(np.concatenate(sel)) if sel else view_io.sample_rows(n_last, n_out, rng)+    n_out = len(sel)++    # ---------- type-level displacement (two-input only) ----------+    if two and BETA_DISP > 0:+        cov = np.asarray(adata_last.var["covered"], dtype=bool) & np.asarray(+            adata_first.var["covered"], dtype=bool+        )+        rows = adata_last.X[sel].toarray().astype(np.float32)+        sel_labels = labels_last[sel]+        for t in np.unique(sel_labels):+            m = sel_labels == t+            mf = labels_first == t+            if mf.sum() < 3:+                continue+            dl = (+                np.asarray(adata_last.X[labels_last == t].mean(axis=0)).ravel()+                - np.asarray(adata_first.X[mf].mean(axis=0)).ravel()+            ).astype(np.float32)+            dl = dl * cov+            disp = (BETA_DISP * T) * dl+            blk = rows[m]+            if GATE_DISP:+                disp = disp[None, :] * (blk > 0)+            rows[m] = np.maximum(blk + disp, 0.0)+        X_out = sparse.csr_matrix(rows)+    else:+        X_out = adata_last.X[sel]     _tm("decode")-    # diagnostics to stderr (not part of output)+     print(-        f"[growth_dynamics] n_out={n_out} T={T:.3f} alpha={alpha:.3f} "-        f"g: mean={g_full.mean():.3f} std={g_full.std():.3f} min={g_full.min():.3f} "-        f"max={g_full.max():.3f} frac_out_0.8_1.2={np.mean((g_full < 0.8) | (g_full > 1.2)):.3f} "-        f"decode={DECODE} growth_off={GROWTH_OFF}",+        f"[growth_v2] two={two} n_out={n_out} T={diag['T']:.3f} G_std={diag['G_std']:.4f} "+        f"G_range=({diag.get('G_min', 1):.3f},{diag.get('G_max', 1):.3f}) gamma={GAMMA} "+        f"beta={BETA_DISP} gate={GATE_DISP} lambda={LAMBDA_TILT} growth_off={GROWTH_OFF}",         file=sys.stderr,     )-    view_io.write_prediction(X_out.tocsr(), genes, args.out, seed=args.seed)+    view_io.write_prediction(X_out, genes, args.out, seed=args.seed)   if __name__ == "__main__":

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

用到的知识库条目

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

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

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

分析员

ANALYSIS.json written

工程师

完成。做了什么、结果、下一步：

**做了什么**（节点 22，improve 自 19）：重写 run.py 为统一重采样管线。两输入路径（X3）：组成趋势权重（s=3，T=clip(Δt比,0,1.5)）× KMeans-20 簇级非平衡 OT 生长权重 G_c（reg_m=0.3，γ=1.0）× 型内成熟度倾斜（λ=0.15），加**稀疏门控**型级伪批量位移（β=1.0）；单输入路径（proxy10）：弃 copy_last，改为心脏解剖组成先验重加权 + 型内复杂度选择。GROWTH_OFF 对照保留。

**查分**（A 半，seed 0，用 10/20 次）：X3 **58.90**（父 47.03；growth-off 对照 57.69，机制弱活性 +1.2 在噪声内但方向正，主要落在 mmd_u/variogram；稠密位移会崩 variogram 到 3.47，门控是关键）；proxy10 **58.79**（父 52.75）。节点分估计 ≈58.9（父 48.94，树最佳 56.41）。两视图 vec-check 通过，跨 cwd 确定性验证通过，X3 <20s / proxy <5s 纯 CPU。

**下一步最值得试**：(1) proxy10 单输入路径仍差节点 3/7 约 5 分——其"型内成熟度选择"具体形式（可能比 exp 倾斜更强的排序选择，或非复杂度轴）值得复原；(2) X3 上 β·T 位移幅度扫描（β=0.5 / T 上限 1.0）与门控方式；(3) 生长机制在更长间隔视图（proxy2，0.5 天）上验证可辨识性后再决定是否保留。

调研员

{
  "name": "growth_dynamics v2: 型级聚合生长权重+组成趋势融合+单输入继承组成重加权",
  "motivation": "父节点19最大损失在proxy10（-10.92），完全因单输入退路为copy_last，丢掉了节点3/7/13/16已验证的组成重加权收益（proxy10 63.66→52.75）。X3上生长权重对比度不足（NN平滑后std 0.047<0.05），growth-on vs off在±2噪声内（47.16 vs 47.41），机制惰性。两项结构问题需同时修复。",
  "approach": "步骤1（单输入路径，保proxy10）：实现与节点7/13/16相同的组成重加权+型内成熟度选择作为单输入退路（不再用copy_last）。具体：Leiden聚类（resolution 0.5-1.0）→型频率趋势外推w_t = c1_t · clip((c1_t+5)/(c0_t+5), 0.2, 5)^T（T clip 1.5，平滑s=3）→按权重有放回重采样真实细胞→型内按z_fate相关表达程序排序选细胞（λ=0.15）。单输入无频率趋势时用均匀采样代替（仍优于copy_last因有型内选择）。步骤2（两输入路径，X3）：保留非平衡Sinkhorn OT（reg=0.05），但reg_m直接设0.3（跳过自适应，因父节点已证2.0/1.0对比度不足）；关键改动：(a)对末阶段细胞做Leiden聚类（k≈15-25），将逐细胞g_i按簇取中位数得到簇级生长G_c；(b)将G_c与组成趋势权重相乘：final_weight_c = trend_c × (G_c)^γ，γ∈{0.5,1.0,2.0}（初值1.0）控制生长信号强度；(c)按final_weight_c有放回重采样真实末阶段细胞；(d)可选位移：保留父节点稀疏门控残差解码（α=0.6，位移只加已表达基因），但若查分显示α>0伤害variogram则设α=0（纯组成）。步骤3（vec-score筛选）：先跑X3 A半，确认(a)组成路径≥节点3的48.71；(b)growth-on vs off差值方向；再跑proxy10 A半。步骤4：若G_c std仍<0.1，试reg_m=0.15或GROWTH_SHARP=4（g→g^4归一化）。单输入退路：只有1个输入阶段时走步骤1的组成重加权。",
  "expected_groups": ["cell_state", "de_recovery", "direction"],
  "risks": "1) 组成重加权实现与节点7/13/16不一致导致proxy10未恢复到63+：Engineer应对比节点7的proxy10 A半分数确认。2) X3间隔仅0.25天，即使reg_m=0.3，簇级生长对比度仍可能不足（G_c std<0.1）：此时γ=0（生长关闭）应等于纯组成趋势，不应比节点3差。3) 30分钟内实现两路径（组成+生长）可能紧张：优先保证单输入组成路径正确（占分数主体），两输入路径可简化为仅用G_c调制重采样概率，不做位移。4) Leiden聚类引入随机性：固定random_state=seed。",
  "family_id": "growth_dynamics",
  "mechanism": "非平衡OT的源边际失衡给出逐细胞生长权重，按Leiden簇聚合去噪后与组成频率趋势相乘，驱动状态依赖的重采样（扩张亚状态被过采样、收缩亚状态被欠采样）。",
  "vs_constant_shift": "常数位移对每型施加同一向量、全局比例统一缩放；本方案的组成权重由两阶段频率趋势×簇级生长权重联合决定，是状态相关、数据驱动的——不同簇即使属同一型也可有不同权重，且生长权重来自OT耦合的边际失衡而非预设。",
  "mechanism_evidence": "Engineer应报告：(1)簇级G_c的std和极差（std≥0.1为有效信号）；(2)growth-on vs growth-off（γ=0）的X3分数差及四组分变化；(3)被过采样/欠采样的簇及其频率变化幅度；(4)与纯组成趋势（节点3等价配置）的对比。若G_c std<0.05且on/off差<1分，机制仍为惰性，如实报告。",
  "mechanism_off_control": "环境变量GROWTH_OFF=1：设所有G_c=1（即final_weight_c = trend_c），重采样退化为纯组成趋势。同一程序、同一seed，预期X3分数差在±2内（若机制惰性）或>2（若生长信号有效）。单输入路径不受此开关影响（无OT）。",
  "sources": []
}

审查员

REVIEW.json written