总览 · ← 返回运行 20261003-094241-search-t2-heart-interp-g24-D-s2

节点 n25 在终选来历上

T2HI-05：logit组成配额混抽括号真实细胞 + 同型kNN收缩(k=20,α=1.25) + 细胞数–RMS幂律预测目标RMS并各向同性缩放坐标。

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

来自 programs.git 18dd1f216c:solution/METHOD.md

调研员的计划

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

对比：这个提交的上一版（种子程序：相对空仓库）。改动的文件：solution/EXECUTION.json +1 −0、solution/METHOD.md +49 −0、solution/run.py +208 −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..87f21a1--- /dev/null+++ b/solution/METHOD.md@@ -0,0 +1,49 @@+T2HI-05：logit组成配额混抽括号真实细胞 + 同型kNN收缩(k=20,α=1.25) + 细胞数–RMS幂律预测目标RMS并各向同性缩放坐标。++## 方法（family_id: T2HI-05，机制默认打开）++1. 基座：`interp_bracket` 取目标两侧输入 (a,b,t)；输出细胞数 n = 两端细胞数 log 线性插值后夹到 [min_cells, max_cells]。+   组成按 logit 空间插值：对并集类型做 Laplace(0.5 细胞) 平滑得两侧频率 f_a,f_b，+   log p ∝ (1−t)·log f_a + t·log f_b，归一化得配额 p；每类型配额按 ((1−t)f_a, t f_b) 权重分到两侧，+   在 (侧,类型) 分层内无放回抽真实细胞，表达与坐标原样。+2. 同型 kNN 收缩：每个抽样细胞向同类型（抽样云内）k=20 近邻质心移动 α=1.25 倍位移（质心不含自身），只动坐标。+3. **尺度机制（核心）**：对视图内全部已发布输入阶段拟合 log RMS = log a + γ·log n（最小二乘；≥2 个不同 n 才拟合），+   预测 target_RMS = a·n_target^γ（n_target = 实际输出细胞数），收缩后把坐标各向同性缩放到 target_RMS。+   γ 超出 [0.3,1.0] 或无法拟合时回退 log 线性。+4. 单输入退路：无括号时直接抽该阶段细胞，target_RMS = 该阶段 RMS。+5. 所有统计（n、RMS、γ、a、组成）都从视图输入现场计算，无硬编码；输出只依赖数据与 --seed，与视图路径/绝对时间无关。++## 机制生效证据（proxy：E8.25_late+E9.5→E8.75，t=0.4，seed 0）++- 拟合 γ=0.6284（∈[0.4,0.7] 预期区间），a=0.3569；n_target=17616 → target_RMS=166.19，实际输出 RMS=166.19（比值 1.000）。+- 对照（T2HI_SCALE_MODE=loglinear，同一脚本）：target_RMS=346.33，两者数值明显不同（缩放分支确实执行）。+- scale_log_ratio raw：机制 −0.267 vs 对照 +0.467（|raw| 向 0 收敛 43%；未完全到 0，因为幂律用的是输出细胞数+  17616，而真值阶段有更多细胞，属机制假设内的系统偏差）。+- shape_scale 组分：机制 55.54 vs 对照 50.98（+4.6，远超噪声）；d2_shape/occupancy_dice 基本不动（尺度不变的形状项），+  提升全部来自 scale_log_ratio skill 0.51→0.648。+- 榜分：机制 65.71 vs 对照 64.57（A 半，各 1 次查询）。++## 查分记录（proxy，A 半）++| 配置 | 榜分 | cell_state | expression | local_spatial | shape_scale |+|---|---:|---:|---:|---:|---:|+| power k20 α1.25（提交） | 65.71 | 70.97 | 69.72 | 66.62 | 55.54 |+| power k10 α1.25 | 65.56 | 70.97 | 69.72 | 66.30 | 55.26 |+| loglinear 对照 k20 | 64.57 | 70.97 | 69.72 | 66.62 | 50.98 |+| α=0（无收缩） | 65.44 | 70.97 | 69.72 | 65.03 | 56.06 |+| α=1.0 / 1.5 | 65.68 / 65.67 | 70.97 | 69.72 | 66.73 / 66.43 | 55.3 / 55.5 |+| pooled 侧分配 | 65.33 | 70.81 | 70.51 | 65.64 | 54.37 |++## 验证过 / 没验证++- 验证：seed 0 双跑逐位相同（确定）；vec-check 通过；机制 on/off 对照；k、α、侧分配的小网格（上表）。+- 未验证：多 seed（终选护栏按 seed 0/1/2 均值 vs copy_last，本方法在 proxy 上 65.7 ≫ 50+1，风险低）；+  final 视图（3 输入时幂律用全部输入阶段拟合，括号取最近两侧）。+- 弱点：本实现的基座比树最佳（节点 17，66.60）低约 0.9 分——local_spatial 66.6 vs 70.3、cell_state 71.0 vs 72.4，+  说明我的 logit 混抽/收缩与节点 10/13 的实现有未识别的差异；但 shape_scale 55.54 是全树最高（此前最佳 51.86），+  幂律尺度机制是本节点的净新增，可与更强基座组合。++## 知识来源++- 只用通用机制知识：RMS 半径随样本细胞数增长的幂律关系由视图内已发布阶段现场回归得到（数据驱动，非文献常数）；+  未使用任何保留阶段（E8.5、禁窗 (8.25,8.75)、9.5<E≤13.5）或保留基因型的测量信息，未用外部数据。diff --git a/solution/run.py b/solution/run.pynew file mode 100644index 0000000..03f0f86--- /dev/null+++ b/solution/run.py@@ -0,0 +1,208 @@+"""T2HI-05 draft: logit-composition quota mix + homotypic kNN shrink + power-law RMS scaling.++Pipeline (all statistics computed from the view at runtime):+1. Interpolation bracket (a, b, t) from manifest times.+2. Output cell count n = log-linear interpolation of bracket cell counts, clipped to [min, max].+3. Per-celltype composition fractions of both bracket sides are interpolated in logit space+   (Laplace-smoothed log fractions, linear in t, renormalised). Each type's quota is split+   between the two sides with weight ((1-t) f_a, t f_b); real cells are drawn without+   replacement per (side, type) stratum. Expression and coordinates are carried unchanged.+4. Homotypic kNN shrink: every sampled cell moves alpha x displacement toward the centroid+   of its k nearest same-type neighbours (among sampled cells). Expression untouched.+5. Scale mechanism (T2HI-05): fit RMS = a * n^gamma (log-log least squares) across the+   view's published input stages, predict target_RMS = a * n_target^gamma, and rescale the+   shrunk cloud isotropically to it. Control (env T2HI_SCALE_MODE=loglinear/off):+   target_RMS = log-linear interpolation of the bracket-end RMS values.+6. Single-input fallback: no bracket -> use the anchor stage alone, target_RMS = its RMS.+"""++from __future__ import annotations++import argparse+import os+import sys++import numpy as np+import scipy.sparse as sp+from scipy.spatial import cKDTree++from src.task2_spatial import view_io++SHRINK_K = int(os.environ.get("T2HI_K", "20"))+SHRINK_ALPHA = float(os.environ.get("T2HI_ALPHA", "1.25"))+GAMMA_LO, GAMMA_HI = 0.3, 1.0+++def _fractions(labels: np.ndarray, types: list[str]) -> np.ndarray:+    counts = np.array([np.count_nonzero(labels == t) for t in types], dtype=np.float64)+    return counts+++def _quotas(p: np.ndarray, w_a: np.ndarray, w_b: np.ndarray, m_a: np.ndarray, m_b: np.ndarray,+            n: int) -> tuple[np.ndarray, np.ndarray]:+    """Per-type quota split between sides; clip to pool sizes and redistribute the deficit."""+    q = p * n+    s = np.where(w_a + w_b > 0, w_a / np.maximum(w_a + w_b, 1e-300), m_a / np.maximum(m_a + m_b, 1))+    ca = np.minimum(np.floor(q * s).astype(int), m_a)+    cb = np.minimum(q.astype(int) - ca, m_b)+    ca = np.minimum(ca, m_a)+    deficit = n - int(ca.sum() + cb.sum())+    if deficit > 0:+        room = np.stack([m_a - ca, m_b - cb])+        order = np.argsort(-(p + 1e-12))+        guard = 0+        while deficit > 0 and room.sum() > 0 and guard < 10 * n:+            progressed = False+            for i in order:+                if deficit <= 0:+                    break+                for side in (0, 1):+                    if room[side, i] > 0:+                        room[side, i] -= 1+                        deficit -= 1+                        if side == 0:+                            ca[i] += 1+                        else:+                            cb[i] += 1+                        progressed = True+                        break+            if not progressed:+                break+            guard += 1+    return ca, cb+++def _draw(rng: np.random.Generator, pool: np.ndarray, c: int) -> np.ndarray:+    if c <= 0:+        return np.array([], dtype=int)+    if c >= pool.size:+        return pool+    return pool[rng.permutation(pool.size)[:c]]+++def mix_by_logit_composition(sa, sb, t: float, n: int, rng: np.random.Generator):+    types = sorted(set(sa.labels.astype(str)) | set(sb.labels.astype(str)))+    la = sa.labels.astype(str)+    lb = sb.labels.astype(str)+    cnt_a = _fractions(la, types)+    cnt_b = _fractions(lb, types)+    k = len(types)+    fa = (cnt_a + 0.5) / (sa.n + 0.5 * k)+    fb = (cnt_b + 0.5) / (sb.n + 0.5 * k)+    logit = (1.0 - t) * np.log(fa) + t * np.log(fb)+    p = np.exp(logit - logit.max())+    p /= p.sum()+    if os.environ.get("T2HI_SPLIT", "tw") == "pooled":+        ca, cb = _quotas(p, fa * cnt_a, fb * cnt_b, cnt_a.astype(int), cnt_b.astype(int), n)+        s = cnt_a / np.maximum(cnt_a + cnt_b, 1)+        ca = np.minimum(np.round(p * n * s).astype(int), cnt_a.astype(int))+        cb = np.minimum((p * n).astype(int) - ca, cnt_b.astype(int))+    else:+        ca, cb = _quotas(p, (1 - t) * fa, t * fb, cnt_a.astype(int), cnt_b.astype(int), n)+    idx_rows, idx_cols, parts_expr, parts_coord, parts_lab = [], [], [], [], []+    for side, (stage, labels, counts) in enumerate([(sa, la, ca), (sb, lb, cb)]):+        for j, ty in enumerate(types):+            c = int(counts[j])+            if c <= 0:+                continue+            pool = np.flatnonzero(labels == ty)+            sel = _draw(rng, pool, c)+            parts_expr.append(stage.X[sel])+            parts_coord.append(stage.coords[sel])+            parts_lab.append(np.full(sel.size, ty, dtype=object))+    expr = sp.vstack(parts_expr, format="csr")+    coords = np.concatenate(parts_coord).astype(np.float64)[:, :3]+    out_lab = np.concatenate(parts_lab).astype(str)+    return expr, coords, out_lab+++def homotypic_shrink(coords: np.ndarray, labels: np.ndarray, k: int, alpha: float) -> np.ndarray:+    out = coords.copy()+    for ty in sorted(set(labels)):+        m = np.flatnonzero(labels == ty)+        if m.size < 3:+            continue+        pts = coords[m]+        tree = cKDTree(pts)+        kk = min(k, m.size - 1)+        _, idx = tree.query(pts, k=kk + 1)+        idx = idx[:, 1:]  # drop self+        cent = pts[idx].mean(axis=1)+        out[m] = pts + alpha * (cent - pts)+    return out+++def rms(coords: np.ndarray) -> float:+    c = coords - coords.mean(axis=0)+    return float(np.sqrt((c ** 2).sum(axis=1).mean()))+++def fit_power_law(stages) -> tuple[float, float] | None:+    """Least-squares fit of log RMS = log a + gamma log n across >=2 stages with distinct n."""+    pts = [(float(s.n), rms(np.asarray(s.coords, dtype=np.float64)[:, :3])) for s in stages]+    pts = [(n, r) for n, r in pts if n > 0 and r > 0]+    ns = sorted({n for n, _ in pts})+    if len(pts) < 2 or len(ns) < 2:+        return None+    x = np.log(np.array([n for n, _ in pts]))+    y = np.log(np.array([r for _, r in pts]))+    gamma, log_a = np.polyfit(x, y, 1)+    return float(log_a), float(gamma)+++def main() -> None:+    ap = argparse.ArgumentParser()+    ap.add_argument("--data", required=True)+    ap.add_argument("--out", required=True)+    ap.add_argument("--seed", type=int, required=True)+    args = ap.parse_args()+    rng = np.random.default_rng(args.seed)++    manifest = view_io.load_manifest(args.data)+    genes = view_io.panel_genes(args.data, manifest)+    entries = view_io.inputs_by_time(manifest)+    stages = {e["path"]: view_io.read_stage(args.data, e, genes) for e in entries}+    lo, hi = int(manifest["min_cells"]), int(manifest["max_cells"])++    a_entry, b_entry, t = view_io.interp_bracket(manifest)+    sa = stages[a_entry["path"]]++    if b_entry is None or t is None:+        n = int(np.clip(sa.n, lo, hi))+        sel = _draw(rng, np.arange(sa.n), n)+        expr, coords, labels = sa.X[sel], np.asarray(sa.coords, dtype=np.float64)[sel][:, :3], sa.labels.astype(str)[sel]+        target_rms = rms(np.asarray(sa.coords, dtype=np.float64)[:, :3])+        mode = "single"+    else:+        sb = stages[b_entry["path"]]+        n = int(np.clip(np.exp(np.log(sa.n) + t * (np.log(sb.n) - np.log(sa.n))), lo, hi))+        expr, coords, labels = mix_by_logit_composition(sa, sb, t, n, rng)+        mode = os.environ.get("T2HI_SCALE_MODE", "power").strip().lower()+        fit = fit_power_law([stages[e["path"]] for e in entries])+        target_rms = None+        if mode not in {"off", "loglinear", "log_linear"} and fit is not None:+            log_a, gamma = fit+            if GAMMA_LO <= gamma <= GAMMA_HI:+                target_rms = float(np.exp(log_a + gamma * np.log(n)))+                print(f"[T2HI-05] power law: gamma={gamma:.4f} a={np.exp(log_a):.4f} "+                      f"target_RMS={target_rms:.2f} n_target={n}", file=sys.stderr)+        if target_rms is None:+            ra = rms(np.asarray(sa.coords, dtype=np.float64)[:, :3])+            rb = rms(np.asarray(sb.coords, dtype=np.float64)[:, :3])+            target_rms = float(np.exp(np.log(ra) + t * (np.log(rb) - np.log(ra))))+            print(f"[T2HI-05] loglinear control: target_RMS={target_rms:.2f} n_target={n}", file=sys.stderr)++    coords = homotypic_shrink(coords, labels, SHRINK_K, SHRINK_ALPHA)+    cur = rms(coords)+    if cur > 0 and np.isfinite(target_rms) and target_rms > 0:+        coords = coords * (target_rms / cur)+        print(f"[T2HI-05] rescale: post-shrink RMS={cur:.2f} -> {target_rms:.2f} "+              f"(ratio {target_rms / cur:.4f}), final RMS={rms(coords):.2f}", file=sys.stderr)++    from src.task1_temporal.view_io import write_prediction+    write_prediction(expr, genes, args.out, coords=np.asarray(coords, dtype=np.float64))+    print(f"[T2HI-05] wrote {expr.shape[0]} cells x {expr.shape[1]} genes, mode={mode}", file=sys.stderr)+++if __name__ == "__main__":+    main()

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

用到的知识库条目

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

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

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

分析员

ANALYSIS.json written

工程师

完成。

- **做了什么**：从零实现 T2HI-05（draft）：logit 组成配额混抽括号真实细胞（表达/坐标原样）+ 同型 kNN 收缩（k=20, α=1.25）+ **细胞数–RMS 幂律尺度机制**（视图内已发布阶段现场拟合 log RMS = log a + γ log n，预测 target_RMS 并各向同性缩放坐标）；对照开关 `T2HI_SCALE_MODE=loglinear`；单输入退路齐备；seed 0 双跑逐位相同，vec-check 通过。
- **查分结果**（proxy A 半，用 9/20 次）：机制 **65.71**（shape_scale 55.54，全树最高；scale_log_ratio raw −0.267）vs log 线性对照 64.57（shape_scale 50.98，raw +0.467）；γ=0.628、target_RMS=166.2，机制证据齐全。总分离树最佳 66.60 还差 0.9（基座 local_spatial 66.6 vs 70.3，收缩实现与节点 13/17 有未识别差异）。
- **下一步最值得试**：把幂律尺度机制嫁接到节点 17 的基座（其 local_spatial/cell_state 更强），预期 66.6 + 4~5 分 shape_scale 增益 ≈ 70+；另外 scale raw 的系统偏差（−0.267）提示可用"目标阶段细胞数估计"替代输出细胞数来进一步逼近 0。

调研员

新增）：\n   a. 从视图内已发布阶段（E8.25_late、E8.75、E9.5）读取细胞数 n 和坐标，计算各阶段全云 RMS。\n   b. 拟合幂律 RMS = a·n^γ（log-log 线性回归，3 点拟合；预期 γ≈0.57, a≈1.25）。\n   c. 由组成配额估计目标细胞数 n_target（= 混抽后总细胞数），预测 target_RMS = a·n_target^γ。\n   d. 对收缩后坐标做各向同性缩放：coords *= target_RMS / current_RMS。\n   e. 备选（c 方案，若时间允许）：按主轴分别计算 extent（std 沿 PCA 前 3 轴），逐轴插值后缩放，保留各向异性信息。\n4. 关闭对照：跳过步骤 3，改用括号两端 RMS 的 log 线性插值作为 target_RMS（即种子做法）。\n5. 单输入阶段退路：若视图只提供一个输入阶段，直接用该阶段 RMS 作为 target_RMS，不做插值。\n6. vec-score 筛选：在 proxy 上跑 mechanism on/off 各一次，比较 shape_scale 组分。预期 proxy 上两者差距 <1 分（两端 RMS 接近，幂律与 log 线性给出相近目标）；底线是不低于 mix 种子（59.5）。若 shape_scale 组分下降超过 1 分，检查缩放方向是否反了。\n7. 额外验证：打印 target_RMS 和 actual_RMS 的比值，确认 scale_log_ratio raw 接近 0（即 log ratio ≈ 0）。",
  "expected_groups": ["shape_scale"],
  "risks": "1. proxy 上机制无法与对照区分（两端 RMS 接近），Engineer 可能误判机制无效——应看 target_RMS 数值是否合理（proxy 预期 ~340），而非仅看总分差。2. 幂律拟合只有 3 个点，过拟合风险；若 γ 超出 [0.3, 1.0] 范围则回退 log 线性。3. 收缩后 RMS 已偏离原始值，缩放步骤需在收缩后执行；顺序错误会导致双重缩放。4. 30 分钟时限紧：基座 + 收缩 + 缩放三步，Engineer 应先跑通基座（5 min），再加收缩（10 min），最后加缩放（10 min），留 5 min 查分。5. 不得读取或硬编码 E8.5 的尺寸统计量（E8.5 在禁窗 (8.25, 8.75) 内）；只用 E8.25_late、E8.75、E9.5 的公开统计。",
  "family_id": "T2HI-05",
  "mechanism": "用已发布阶段的细胞数–RMS 幂律关系（RMS = a·n^γ）预测目标 RMS，对混抽+收缩后的坐标做各向同性缩放，使输出点云的绝对尺度匹配生物学预期，而非依赖简单 log 线性插值。",
  "vs_constant_shift": "常数位移是对所有细胞坐标加同一向量（平移），不改变形状和尺度；本机制是乘性缩放（改变点云展布），且缩放系数由细胞数–RMS 的幂律回归决定，随目标细胞数变化，不是固定常数。全局组成重加权改变细胞类型比例而不触碰坐标；本机制只动坐标、不动表达和组成。",
  "mechanism_evidence": "Engineer 应记录：(1) 拟合的 γ 和 a 值（预期 γ∈[0.4,0.7]）；(2) 预测 target_RMS vs 实际输出 RMS（比值应 ≈1）；(3) scale_log_ratio raw 值（应接近 0，即 |log ratio| < 0.1）；(4) 对照（log 线性）与机制的 target_RMS 差异（proxy 上 <5%，final 上可达 20%+）；(5) shape_scale 组三项各自的 raw 和 skill 变化。若 scale_log_ratio raw 未向 0 收敛，说明机制未正确运行。",
  "mechanism_off_control": "环境变量 T2HI_SCALE_MODE=off（或 =loglinear）时，跳过幂律拟合，target_RMS 改用括号两端 RMS 的 log 线性插值（即种子/当前做法）。同一脚本跑两次（on/off），比较：(1) target_RMS 数值；(2) scale_log_ratio raw；(3) shape_scale 组分。预期 proxy 上差别 <0.5 分（噪声内），但 target_RMS 数值不同（幂律 ~340 vs log 线性 ~344）；若输出完全逐位相同，说明缩放分支未被执行。"
}
```