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

节点 n35

改了什么

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

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

调研员的计划

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

对比：这个提交的上一版（种子程序：相对空仓库）。改动的文件：solution/EXECUTION.json +1 −0、solution/METHOD.md +17 −0、solution/README.md +4 −0、solution/g37_common.py +101 −0、solution/run.py +190 −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..10b6ba8--- /dev/null+++ b/solution/METHOD.md@@ -0,0 +1,17 @@+## 改了什么+将 ot_moscot（Waddington-OT 耦合 + 位移外推）替换为 regulatory_program 方向的最小实现：+1. 从 `prior/tf_regulons/collectri_mouse.tsv.gz` 加载 CollecTRI 调控网络；+2. 用 numpy 实现 ULM（univariate linear model）计算每个细胞的 TF 活性：A = X @ W^T / ||W_row||，其中 W 是 TF×gene 权重矩阵；+3. 按细胞类型计算活性转移：delta_a[ct] = mean_activity_last[ct] - mean_activity_prev[ct]；+4. 外推到目标时间：dA = delta_a × (dt_out/dt_in)；+5. 在合并输入上拟合岭回归解码 X_covered ≈ A @ B，将活性变化映射回表达变化；+6. 只对调控子覆盖且实际测到的基因施加变化，乘收缩系数 0.5，只修改非零条目（保持稀疏结构），夹到 ≥0。+单输入阶段退化为 copy（无转移可估计）。+对照机制：环境变量 REGULON_CONTROL=shuffle 打乱靶基因分配（保留度分布），提交时保持打开。+与常数位移的区别：转移随细胞的活性状态（细胞类型）变化，不同细胞类型有不同的活性增量。+第 1 轮修复：norms 广播维度错误（`[:, None]` → `[None, :]`），原代码将 (n_tfs,1) 除以 (n_cells, n_tfs) 导致 ValueError。+## 用到的知识与出处+- k042：decoupler ULM 计算 TF 活性的方法与 CollecTRI 先验格式（Badia-i-Mompel et al., Bioinform Adv 2022, 10.1093/bioadv/vbac016）+- CollecTRI 来源：prior/README.md 说明+- 方向库 regulatory_program 最小实现规范（岭回归解码、只动调控子覆盖基因、强收缩）+- 外推部分为本项目设计，无外部文献支持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..aa3e23d--- /dev/null+++ b/solution/run.py@@ -0,0 +1,190 @@+#!/usr/bin/env python3+"""regulatory_program: TF activity transition + regulon-constrained decode (draft).++Two input stages:+  1. Load CollecTRI regulon from prior/tf_regulons/collectri_mouse.tsv.gz+  2. Compute per-cell TF activities via ULM (univariate linear model, numpy)+  3. Per-celltype activity transition: delta_a[ct] = mean_a_last[ct] - mean_a_prev[ct]+  4. Extrapolate: target activity = last activity + delta_a * (dt_out / dt_in)+  5. Decode: fit ridge X_covered ~ A @ B on combined input; dX = dA @ B * shrinkage+  6. Apply only to regulon-covered genes that are also measured; clip >= 0++One input stage: copy last stage (no transition estimable).++Control: env REGULON_CONTROL=shuffle shuffles target assignments preserving TF degree.+"""++from __future__ import annotations++import argparse+import os+import sys+from pathlib import Path++import numpy as np+from scipy import sparse++sys.path.insert(0, str(Path(__file__).resolve().parent))+from g37_common import stage_pair  # noqa: E402++from src.task1_temporal.view_io import (  # noqa: E402+    covered_mask,+    inputs_by_time,+    load_manifest,+    panel_genes,+    target_n_cells,+    write_prediction,+)++RIDGE_ALPHA = 1.0+SHRINKAGE = 0.5+MIN_CELLS_PER_CT = 5+++def load_regulon(view_dir: str, rng: np.random.Generator):+    prior_dir = Path(view_dir) / "prior" / "tf_regulons"+    path = prior_dir / "collectri_mouse.tsv.gz"+    if not path.exists():+        alt = prior_dir / "collectri_mouse.tsv"+        if alt.exists():+            path = alt+        else:+            return None+    import gzip+    import csv+    tfs, targets, weights = [], [], []+    opener = gzip.open if str(path).endswith(".gz") else open+    with opener(path, "rt") as f:+        reader = csv.DictReader(f, delimiter="\t")+        for row in reader:+            tfs.append(row.get("source", row.get("tf", "")))+            targets.append(row.get("target", ""))+            weights.append(float(row.get("weight", row.get("mor", 1))))+    if os.environ.get("REGULON_CONTROL") == "shuffle":+        targets = list(rng.permutation(targets))+    return tfs, targets, weights+++def build_activity_matrix(X: sparse.csr_matrix, gene_names: list[str],+                          regulon, mask: np.ndarray):+    tfs, targets, weights = regulon+    gene_to_idx = {g: i for i, g in enumerate(gene_names)}+    tf_set = sorted(set(tfs))+    tf_to_idx = {t: i for i, t in enumerate(tf_set)}+    n_tfs = len(tf_set)+    n_genes = len(gene_names)+    rows_w, cols_w, vals_w = [], [], []+    for tf, tgt, w in zip(tfs, targets, weights):+        gi = gene_to_idx.get(tgt)+        ti = tf_to_idx.get(tf)+        if gi is not None and ti is not None and mask[gi]:+            rows_w.append(ti)+            cols_w.append(gi)+            vals_w.append(w)+    if len(rows_w) == 0:+        return None, None, None, None+    W = sparse.csr_matrix((vals_w, (rows_w, cols_w)), shape=(n_tfs, n_genes),+                          dtype=np.float32)+    norms = np.sqrt(np.asarray(W.multiply(W).sum(axis=1)).ravel())+    norms[norms == 0] = 1.0+    A = (X @ W.T).toarray() / norms[None, :]+    covered_genes = np.unique(np.array(cols_w))+    return A.astype(np.float32), tf_set, covered_genes, W+++def ridge_decode(A: np.ndarray, X_sub: np.ndarray, alpha: float):+    n_tfs = A.shape[1]+    AtA = A.T @ A + alpha * np.eye(n_tfs, dtype=np.float32)+    AtX = A.T @ X_sub+    B = np.linalg.solve(AtA, AtX)+    return B+++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()++    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:+        idx = rng.choice(last.n_obs, size=n, replace=n > last.n_obs)+        idx = np.sort(idx)+        write_prediction(last.X[idx], genes, args.out, seed=args.seed)+        return++    regulon = load_regulon(args.data, rng)+    if regulon is None:+        idx = rng.choice(last.n_obs, size=n, replace=n > last.n_obs)+        idx = np.sort(idx)+        write_prediction(last.X[idx], genes, args.out, seed=args.seed)+        return++    A_prev, tf_set, cov_genes, W = build_activity_matrix(+        prev.X, genes, regulon, mask)+    A_last, _, _, _ = build_activity_matrix(+        last.X, genes, regulon, mask)++    if A_prev is None or A_last is None:+        idx = rng.choice(last.n_obs, size=n, replace=n > last.n_obs)+        idx = np.sort(idx)+        write_prediction(last.X[idx], genes, args.out, seed=args.seed)+        return++    ct_prev = np.asarray(prev.obs["celltype"])+    ct_last = np.asarray(last.obs["celltype"])+    ct_names = sorted(set(ct_prev) | set(ct_last))++    delta_a = np.zeros_like(A_last)+    ct_to_delta = {}+    for ct in ct_names:+        ip = np.where(ct_prev == ct)[0]+        il = np.where(ct_last == ct)[0]+        if len(ip) >= MIN_CELLS_PER_CT and len(il) >= MIN_CELLS_PER_CT:+            ct_to_delta[ct] = A_last[il].mean(axis=0) - A_prev[ip].mean(axis=0)+        elif len(il) >= MIN_CELLS_PER_CT:+            ct_to_delta[ct] = np.zeros(A_last.shape[1], dtype=np.float32)++    global_delta = A_last.mean(axis=0) - A_prev.mean(axis=0)+    for i in range(len(ct_last)):+        ct = ct_last[i]+        if ct in ct_to_delta:+            delta_a[i] = ct_to_delta[ct]+        else:+            delta_a[i] = global_delta++    idx = rng.choice(last.n_obs, size=n, replace=n > last.n_obs)+    idx = np.sort(idx)++    factor = dt_out / dt_in+    dA = delta_a[idx] * factor++    A_all = np.vstack([A_prev, A_last])+    X_all = sparse.vstack([prev.X, last.X]).tocsr()+    X_sub_all = X_all[:, cov_genes].toarray().astype(np.float32)+    B = ridge_decode(A_all, X_sub_all, RIDGE_ALPHA)+    dX = dA @ B++    X_out = last.X[idx].toarray().astype(np.float32)+    gene_mask_regulon = np.zeros(len(genes), dtype=bool)+    gene_mask_regulon[cov_genes] = True+    gene_mask_regulon &= mask++    step = np.zeros_like(X_out)+    step[:, gene_mask_regulon] = dX * SHRINKAGE+    step *= X_out > 0+    X_out += step+    np.maximum(X_out, 0.0, out=X_out)++    write_prediction(X_out, genes, args.out, seed=args.seed)+++if __name__ == "__main__":+    main()

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

没有记录调研来源。

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

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

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

分析员

ANALYSIS.json written

native

审查员

REVIEW.json written

stream

Looking at the scores: cell_state 52.19 is good, but covariation (48.34), de_recovery (48.18), and direction (49.33) are weak. The per-celltype mean transition is too coarse (essentially constant per type), and the decode is over-regularized. I'll make three changes:

1. **kNN-based local activity transition** instead of per-celltype means (truly state-dependent)
2. **Lower ridge alpha + higher shrinkage** for stronger decode signal
3. **Growth-weighted resampling** from g37_common (proven to help cell_state/direction)

<<<<<<< SEARCH
RIDGE_ALPHA = 1.0
SHRINKAGE = 0.5
MIN_CELLS_PER_CT = 5
=======
RIDGE_ALPHA = 0.1
SHRINKAGE = 0.7
K_LOCAL = 20
>>>>>>> REPLACE

<<<<<<< SEARCH
from src.task1_temporal.view_io import (  # noqa: E402
    covered_mask,
    inputs_by_time,
    load_manifest,
    panel_genes,
    target_n_cells,
    write_prediction,
)
=======
from src.task1_temporal.view_io import (  # noqa: E402
    covered_mask,
    inputs_by_time,
    load_manifest,
    panel_genes,
    target_n_cells,
    write_prediction,
)

from g37_common import growth_rates  # noqa: E402
>>>>>>> REPLACE

<<<<<<< SEARCH
    ct_prev = np.asarray(prev.obs["celltype"])