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

节点 n49 在终选来历上

改了什么

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

来自 programs.git 3d0c226e44:solution/METHOD.md

调研员的计划

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

对比：这个提交的上一版（种子程序：相对空仓库）。改动的文件：solution/EXECUTION.json +1 −0、solution/METHOD.md +8 −0、solution/README.md +4 −0、solution/g37_common.py +101 −0、solution/run.py +181 −0

diff --git a/solution/EXECUTION.json b/solution/EXECUTION.jsonnew file mode 100644index 0000000..9d5125c--- /dev/null+++ b/solution/EXECUTION.json@@ -0,0 +1 @@+{"gpu": false}diff --git a/solution/METHOD.md b/solution/METHOD.mdnew file mode 100644index 0000000..88bee6e--- /dev/null+++ b/solution/METHOD.md@@ -0,0 +1,8 @@+## 改了什么+从 ot_moscot（Waddington-OT 耦合 + 重心位移外推）完全替换为 stochastic_bridge 方向的最小实现：在联合 PCA 空间中训练 Schrödinger 桥条件流匹配（[SF]²M, Tong et al. 2024）的速度场 v(z,t)，路径为 x_t=(1-t)x0+t·x1+σ√(t(1-t))ε，条件速度 u_t=(x1-x0)+σ(1-2t)/(2√(t(1-t)))ε。训练 600 步小型 MLP（128 hidden, SiLU），随机配对。推理时取 t=1 处的漂移，乘以阻尼系数 α=0.7·dt_out/dt_in 推进，加 σ_out·√α 的受控噪声维持扩散。解码：PCA 位移→HVG 基因空间（乘 components 和 sd），只加在非零条目上（addnz），夹到 ≥0。单输入阶段退化为生长加权重抽样复制。机制对照通过环境变量 SB_MECHANISM 实现：full（默认，漂移+噪声）、det（σ=0 确定性 CFM）、noise_only（无漂移只加噪声）。+## 用到的知识与出处+- Tong A. et al. Simulation-free Schrödinger bridges for score and flow matching. arXiv:2307.03672 (2024)：[SF]²M 条件流匹配公式、熵正则桥路径。+- 知识条目 k034（torchcfm / OT-CFM / SF2M）：PCA 空间训练、解码加回残差、proxy 单阶段退化策略。+- 方向库 stochastic_bridge 条目：最小实现要求（固定小 σ、t=1 局部漂移推一小步、解码后加回残差）、失败方式（桥外延续是额外假设）、对照设计（σ=0 与纯噪声）。+- 父节点 ot_moscot 的 addnz 解码策略（G37 在 X3 上验证）和生长加权重抽样（WOT birth-death 模型, Schiebinger 2019）。+- 通用知识：无禁窗阶段数据；增殖/凋亡基因列表来自 moscot（阶段无关的基因功能注释）。diff --git a/solution/README.md b/solution/README.mdnew file mode 100644index 0000000..dc1cbaf--- /dev/null+++ b/solution/README.md@@ -0,0 +1,4 @@+# ot_moscot++Waddington-OT / moscot：两个最新输入阶段在联合 PCA 上做非平衡熵 OT 耦合（WOT 增殖/凋亡先验生长），最新阶段按 g^Δt 重抽样，每个细胞沿“kNN 平滑位置 − 耦合祖先均值”再走一个等比例步长，只加在非零基因上，夹到 ≥0。+来自 G37 候选 modeling/candidates/T1/ot_moscot；addnz 解码是在 X3 上选的（详见 METHOD.md）。纯 CPU，final 约 70 s、6.7 GB。diff --git a/solution/g37_common.py b/solution/g37_common.pynew file mode 100644index 0000000..8c991b3--- /dev/null+++ b/solution/g37_common.py@@ -0,0 +1,101 @@+"""Helpers of the ot_moscot seed (copy of modeling/candidates/T1/ot_moscot/g37_common.py, G37; stage_pair reads every+input stage of the view).++- ``stage_pair``: the two latest input stages (official, or external in proxy2 / test views) and the gene mask on+  which both are really measured (external stages lack part of the panel; filled columns must not drive dynamics);+- ``embed``: HVG -> z-score (clip 10) -> PCA, fitted on the input stages only (scanpy-style preprocessing);+- ``knn_mean``: per-cell kNN average in the embedding (smooths single-cell noise before taking displacements);+- ``growth_rates``: Waddington-OT / moscot prior growth from proliferation and apoptosis gene scores.+"""++from __future__ import annotations++import numpy as np+from scipy import sparse++from src.task1_temporal.view_io import covered_mask, inputs_by_time, read_stage+++def stage_pair(view, manifest: dict, genes: list[str]):+    """(prev, last, mask, dt_in) for the two latest inputs; prev None with a single input stage."""+    stages = inputs_by_time(manifest, include_external=True)  # every input stage, whatever its source+    last_e = stages[-1]+    last = read_stage(view, last_e, genes)+    mask = covered_mask(view, last_e, genes)+    if len(stages) < 2:+        return None, last, mask, None, last_e+    prev_e = stages[-2]+    prev = read_stage(view, prev_e, genes)+    mask &= covered_mask(view, prev_e, genes)+    return prev, last, mask, float(last_e["time"] - prev_e["time"]), last_e+++def _gene_moments(X: sparse.csr_matrix):+    n = X.shape[0]+    mean = np.asarray(X.mean(axis=0)).ravel()+    sq = np.asarray(X.multiply(X).sum(axis=0)).ravel() / n+    return mean, np.maximum(sq - mean ** 2, 0.0)+++def embed(mats: list, mask: np.ndarray, n_hvg: int, n_pcs: int, seed: int):+    """PCA coordinates of each matrix in ``mats`` (same order), fitted on all of them together.++    Returns (list of Z, info) with info = {hvg, mean, std, components} so displacements can be decoded."""+    from sklearn.decomposition import PCA++    allX = sparse.vstack(mats).tocsr()+    mean, var = _gene_moments(allX)+    var = np.where(mask, var, -1.0)+    hvg = np.sort(np.argsort(var)[::-1][:n_hvg])+    sub = allX[:, hvg].toarray().astype(np.float32)+    mu, sd = mean[hvg].astype(np.float32), np.sqrt(var[hvg]).astype(np.float32)+    sd[sd == 0] = 1.0+    sub -= mu+    sub /= sd+    np.clip(sub, -10, 10, out=sub)+    pca = PCA(n_components=n_pcs, svd_solver="randomized", random_state=seed)+    Z = pca.fit_transform(sub).astype(np.float32)+    out, start = [], 0+    for M in mats:+        out.append(Z[start:start + M.shape[0]])+        start += M.shape[0]+    return out, {"hvg": hvg, "mu": mu, "sd": sd, "components": pca.components_.astype(np.float32)}+++def knn_mean(Z: np.ndarray, X: sparse.csr_matrix, rows: np.ndarray, k: int) -> np.ndarray:+    """Dense (len(rows), n_genes): mean expression of the k nearest cells (in Z, the cell itself included)."""+    from sklearn.neighbors import NearestNeighbors++    nn = NearestNeighbors(n_neighbors=k).fit(Z)+    idx = nn.kneighbors(Z[rows], return_distance=False)+    W = sparse.csr_matrix((np.full(idx.size, 1.0 / k, dtype=np.float32), idx.ravel(),+                           np.arange(0, idx.size + 1, k)), shape=(len(rows), Z.shape[0]))+    return np.asarray((W @ X).todense(), dtype=np.float32)+++# Waddington-OT prior growth (Schiebinger et al. 2019, Cell; as implemented in moscot.base.problems.birth_death):+# birth = generalised logistic of the proliferation score, death = of the apoptosis score, g = exp(birth - death) / day.+def _gen_logistic(p, sup, inf, center, width):+    return inf + (sup - inf) / (1 + np.exp(-(p - center) / width))+++def growth_rates(adata_list: list, genes: list[str], mask: np.ndarray, seed: int) -> list[np.ndarray]:+    """Per-day growth rate of every cell of each AnnData (scores computed on all of them jointly)."""+    import anndata as ad+    import scanpy as sc+    from moscot.utils.data import apoptosis_markers, proliferation_markers++    ok = set(np.asarray(genes)[mask])+    joint = ad.concat(adata_list, join="inner")+    prolif = [g for g in proliferation_markers("mouse") if g in ok]+    apopt = [g for g in apoptosis_markers("mouse") if g in ok]+    sc.tl.score_genes(joint, prolif, score_name="proliferation", random_state=seed)+    sc.tl.score_genes(joint, apopt, score_name="apoptosis", random_state=seed)+    birth = _gen_logistic(joint.obs["proliferation"].to_numpy(float), 1.7, 0.3, 0.25, 0.5)+    death = _gen_logistic(joint.obs["apoptosis"].to_numpy(float), 1.7, 0.3, 0.1, 0.2)+    g = np.exp(birth - death)+    out, start = [], 0+    for a in adata_list:+        out.append(g[start:start + a.n_obs])+        start += a.n_obs+    return outdiff --git a/solution/run.py b/solution/run.pynew file mode 100644index 0000000..4f70ea5--- /dev/null+++ b/solution/run.py@@ -0,0 +1,181 @@+#!/usr/bin/env python3+"""stochastic_bridge: Schrödinger bridge conditional flow matching ([SF]²M) in PCA space.++Draft node for the stochastic_bridge direction. Trains a small time-dependent velocity field+v(z, t) by regressing the conditional vector field of a Schrödinger bridge between the two+latest input stages in PCA space (Tong et al. 2024, arXiv:2307.03672). The bridge path is+x_t = (1-t)*x0 + t*x1 + sigma*sqrt(t*(1-t))*eps with conditional velocity+u_t = (x1 - x0) + sigma*(1-2t)/(2*sqrt(t*(1-t)))*eps.++At inference, the learned drift at t=1 is evaluated on the output cells and used to push them+forward by a damped fraction of the target interval. A controlled noise term (proportional to+sigma and sqrt(dt)) is added to maintain spread. The displacement is decoded back to gene space+via the PCA components and applied only to non-zero entries (addnz strategy).++Mechanism contrast (SB_MECHANISM env var, default "full"):+  "full"       - drift + noise (the stochastic bridge mechanism)+  "det"        - sigma=0, deterministic CFM (no bridge noise in training or inference)+  "noise_only" - no drift, only isotropic noise added to a copy of the last stage++One input stage: falls back to growth-weighted copy (same as parent).+"""++from __future__ import annotations++import argparse+import os+import sys+from pathlib import Path++import numpy as np++sys.path.insert(0, str(Path(__file__).resolve().parent))+from g37_common import embed, growth_rates, stage_pair  # noqa: E402++from src.task1_temporal.view_io import load_manifest, panel_genes, target_n_cells, write_prediction  # noqa: E402++N_HVG = 2000+N_PCS = 30+SIGMA = 0.5+N_TRAIN_STEPS = 600+LR = 1e-3+HIDDEN = 128+ALPHA = 0.7+NOISE_OUT = 0.3+N_THREADS = 8+GROWTH = True+T_EPS = 0.02+++def weighted_rows(w: np.ndarray, n: int, rng: np.random.Generator) -> np.ndarray:+    p = w / w.sum()+    return np.sort(rng.choice(len(w), size=n, replace=n > len(w), p=p))+++def build_velocity_net(d: int, hidden: int):+    import torch+    import torch.nn as nn++    class VNet(nn.Module):+        def __init__(self):+            super().__init__()+            self.net = nn.Sequential(+                nn.Linear(d + 1, hidden),+                nn.SiLU(),+                nn.Linear(hidden, hidden),+                nn.SiLU(),+                nn.Linear(hidden, d),+            )++        def forward(self, z, t):+            t_exp = t.expand(z.shape[0], 1) if t.dim() == 1 else t+            return self.net(torch.cat([z, t_exp], dim=-1))++    return VNet()+++def train_bridge(Z0: np.ndarray, Z1: np.ndarray, sigma: float, n_steps: int,+                 lr: float, hidden: int, seed: int):+    import torch++    torch.manual_seed(seed)+    torch.set_num_threads(N_THREADS)+    d = Z0.shape[1]+    net = build_velocity_net(d, hidden)+    opt = torch.optim.Adam(net.parameters(), lr=lr)+    x0 = torch.from_numpy(Z0.astype(np.float32))+    x1 = torch.from_numpy(Z1.astype(np.float32))+    n0, n1 = x0.shape[0], x1.shape[0]+    bs = min(256, n0, n1)++    for step in range(n_steps):+        i0 = torch.randint(0, n0, (bs,))+        i1 = torch.randint(0, n1, (bs,))+        a = x0[i0]+        b = x1[i1]+        t = torch.empty(bs, 1).uniform_(T_EPS, 1.0 - T_EPS)+        eps = torch.randn(bs, d)+        st = torch.sqrt(t * (1.0 - t))+        xt = (1.0 - t) * a + t * b + sigma * st * eps+        ut = (b - a) + sigma * (1.0 - 2.0 * t) / (2.0 * st) * eps+        vt = net(xt, t)+        loss = ((vt - ut) ** 2).mean()+        opt.zero_grad()+        loss.backward()+        opt.step()++    return net+++def main() -> None:+    parser = argparse.ArgumentParser()+    parser.add_argument("--data", required=True)+    parser.add_argument("--out", required=True)+    parser.add_argument("--seed", type=int, default=0)+    args = parser.parse_args()++    mechanism = os.environ.get("SB_MECHANISM", "full")+    manifest = load_manifest(args.data)+    genes = panel_genes(args.data, manifest)+    prev, last, mask, dt_in, last_e = stage_pair(args.data, manifest, genes)+    dt_out = float(manifest["target"]["time"] - last_e["time"])+    rng = np.random.default_rng(args.seed)+    n = target_n_cells(manifest, last.n_obs)++    if prev is None:+        (g_last,) = growth_rates([last], genes, mask, args.seed)+        rows = weighted_rows(g_last ** dt_out if GROWTH else np.ones(last.n_obs), n, rng)+        write_prediction(last.X[rows], genes, args.out, seed=args.seed)+        return++    (Zp, Zl), info = embed([prev.X, last.X], mask, N_HVG, N_PCS, args.seed)+    g_prev, g_last = growth_rates([prev, last], genes, mask, args.seed)+    rows = weighted_rows(g_last ** dt_out if GROWTH else np.ones(last.n_obs), n, rng)++    X = last.X[rows].toarray().astype(np.float32)++    if mechanism == "noise_only":+        hvg = info["hvg"]+        sd = info["sd"]+        noise = rng.standard_normal((n, N_PCS)).astype(np.float32) * NOISE_OUT+        dX_hvg = (noise @ info["components"]) * sd+        step = np.zeros_like(X)+        step[:, hvg] = dX_hvg+        step *= X > 0+        X += step+        np.maximum(X, 0.0, out=X)+        write_prediction(X, genes, args.out, seed=args.seed)+        return++    sigma_train = SIGMA if mechanism == "full" else 0.0+    net = train_bridge(Zp, Zl, sigma_train, N_TRAIN_STEPS, LR, HIDDEN, args.seed)++    import torch+    torch.set_num_threads(N_THREADS)+    net.eval()++    z_last = torch.from_numpy(Zl[rows].astype(np.float32))+    t_one = torch.ones(z_last.shape[0], 1)+    with torch.no_grad():+        drift = net(z_last, t_one).numpy()++    alpha = ALPHA * dt_out / dt_in+    dz = drift * alpha++    if mechanism == "full":+        dz += rng.standard_normal(dz.shape).astype(np.float32) * NOISE_OUT * np.sqrt(alpha)++    hvg = info["hvg"]+    sd = info["sd"]+    dX_hvg = (dz @ info["components"]) * sd+    step = np.zeros_like(X)+    step[:, hvg] = dX_hvg+    step[:, ~mask] = 0.0+    step *= X > 0+    X += step+    np.maximum(X, 0.0, out=X)+    write_prediction(X, genes, args.out, seed=args.seed)+++if __name__ == "__main__":+    main()

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

没有记录调研来源。

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

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

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

分析员

ANALYSIS.json written

native

审查员

REVIEW.json written

stream

I'll analyze the task and produce an improved version of the program. Let me first read the full current program.

<tool_call>
<function=read_file>
<parameter=path>
/home/spark-longxinyang/.local/state/vec-report/calls/2-202908-search-t1-scr-C-n49-920eaf/work/PROMPT.md
</parameter>
<parameter=offset>
630
</parameter>
</function>
</tool_call>