GRN/RegFM_design.md

Regulatory Flow Matching (RegFM): 设计文档

1. 问题背景

1.1 当前方法的局限

scDFM 是一个基于流匹配（Flow Matching）的单细胞扰动预测模型。它学习一个速度场 $v_\theta(x, t)$，将控制细胞的表达分布沿 ODE 轨迹传输到扰动后的表达分布。

核心局限：scDFM 将基因表达视为 无结构的向量 ——速度场对每个基因的预测是独立的，不显式建模基因间的调控交互。但生物学告诉我们，扰动响应是通过基因调控网络（GRN）传播的：knockout gene A → 直接靶基因 B 变化 → 下游基因 C 变化。

1.2 已有尝试的失败分析

GRN 项目（grn_ccfm / grn_svd / grn_att_only）借鉴 LatentForcing 的双时间步级联方法，试图同时生成 delta_attention（GRN 变化）和基因表达。但所有变体都遇到了：

• latent loss 收敛困难：稳定在 ~1.0-2.0，无法有效训练
• 级联解耦：训练时 40% step 只训 latent / 60% 只训 expression，推理时两阶段串行 ODE
• 表达生成未受益：GRN 信息未能有效引导 expression flow

根本原因：级联方法要求模型「生成」GRN 变化，但这本身是一个极其困难的任务（稀疏 G×G 矩阵，0.6% 非零）。我们的目标不是生成 GRN，而是用 GRN 信息来提升表达预测。

1.3 核心洞察

delta_attention 是一种 训练时特权信息（Learning Using Privileged Information）：训练时有（可从 source + target 细胞计算），推理时无（只有 source 细胞）。

与其训练一个 latent flow 来生成它，不如直接将其融入速度场的 结构 中。

---

2. 方法：Regulatory Flow Matching (RegFM)

2.1 核心思想

将速度场分解为两个语义明确的成分：

$$v_{\theta }(x,t)={\alpha }_{\theta }\odot v_{reg}(x,t)+(1-{\alpha }_{\theta })\odot v_{int}(x,t)v\_\backslash theta(x,\; t)\; =\; \backslash alpha\_\backslash theta\; \backslash odot\; v\_\{reg\}(x,\; t)\; +\; (1\; -\; \backslash alpha\_\backslash theta)\; \backslash odot\; v\_\{int\}(x,\; t)$$

• $v_{reg}$（调控速度）：由基因间交互关系驱动。通过一个可学习的调控交互矩阵 $R_\theta$ 聚合其他基因的信息来计算 gene j 的速度
• $v_{int}$（内在速度）：基因自身的自主动力学，不依赖其他基因的状态
• $\alpha_\theta$（门控）：逐基因、逐时间步的可学习混合比例

训练时，$R_\theta$ 与 delta_attention 对齐（软监督）。推理时，$R_\theta$ 由模型自主预测，不需要任何 GRN 输入。

2.2 数学形式

标准流匹配回顾：

给定 affine 概率路径 $x_t = (1-t) \cdot \epsilon + t \cdot x_{target}$，目标速度为 $v_{target} = x_{target} - \epsilon$。

标准训练目标：$\mathcal{L}_{vel} = \mathbb{E}t | v_\theta(x_t, t) - v{target} |^2$

RegFM 的速度场分解：

给定 backbone 隐状态 $h \in \mathbb{R}^{B \times G \times d}$：

1. 调控交互矩阵： $$R_\theta = \tanh!\left(\text{zero_diag}!\left(\frac{Q_r \cdot K_r^\top}{\sqrt{d_r}}\right)\right) \in [-1, 1]^{B \times G \times G}$$ 其中 $Q_r = W_q \cdot h$，$K_r = W_k \cdot h$，zero_diag 置零对角线防止自环泄漏，tanh 匹配 delta_attn 值域

2. 调控速度： $$v_{reg} = \text{Linear}(R_\theta \cdot V_r) \in \mathbb{R}^{B \times G}$$ 其中 $V_r = W_v \cdot h \in \mathbb{R}^{B \times G \times d_r}$

3. 内在速度： $$v_{int} = \text{ExprDecoder}(h) \in \mathbb{R}^{B \times G}$$

4. 门控混合（三路条件化：基因状态 × 扰动类型 × 流时间步）： $$\alpha = \sigma(\text{MLP}([h;; \text{pert_emb};; t_\text{emb}])) \in (0, 1)^{B \times G}$$ $$v = \alpha \odot v_{reg} + (1 - \alpha) \odot v_{int}$$

训练目标：

$$\mathcal{L}={\mathcal{L}}_{vel}+\lambda \cdot {\mathcal{L}}_{reg}+\gamma \cdot {\mathcal{L}}_{mmd}\backslash mathcal\{L\}\; =\; \backslash mathcal\{L\}\_\{vel\}\; +\; \backslash lambda\; \backslash cdot\; \backslash mathcal\{L\}\_\{reg\}\; +\; \backslash gamma\; \backslash cdot\; \backslash mathcal\{L\}\_\{mmd\}$$

• $\mathcal{L}{vel} = | v - v{target} |^2$（标准流匹配）
• $\mathcal{L}_{reg}$（调控结构监督，详见 §2.4）
• $\mathcal{L}_{mmd}$（可选 MMD loss，沿用 scDFM）

---

3. 架构设计

3.1 整体结构

Input: source(B,G), x_t(B,G), t(B,), pert_id(B,2), gene_ids(G,)
  │
  ▼
┌─────────────────────────────────────────────┐
│         scDFM Backbone (不改)                │
│                                              │
│  gene_emb = GeneEncoder(gene_ids)            │
│  val_emb_xt = ContinuousValueEncoder(x_t)    │
│  val_emb_src = ContinuousValueEncoder(src)    │
│  + gene_emb                                  │
│  fused = FusionLayer(cat(val_emb_xt,          │
│                          val_emb_src))        │
│  + gene_emb                                  │
│                                              │
│  t_emb = TimestepEmbedder(t)                 │
│  pert_emb = get_perturbation_emb(pert_id)    │
│                                              │
│  h = DiffPerceiverBlocks(fused, t_emb,       │
│         pert_emb, gene_emb)                  │
│  → h: (B, G, d_model=128)                   │
└──────────────┬──────────────────────────────┘
               │
       ┌───────┼───────────┐
       ▼       │           ▼
┌──────────┐   │   ┌──────────────────────────┐
│ v_int    │   │   │ RegulatoryHead (新增)     │
│          │   │   │                           │
│ ExprDec  │   │   │ Q = W_q(h)  (B,G,d_r)    │
│ (原有)    │   │   │ K = W_k(h)  (B,G,d_r)    │
│          │   │   │ V = W_v(h)  (B,G,d_r)    │
│ → (B,G)  │   │   │                           │
└────┬─────┘   │   │ R = Q·K^T/√d_r (B,G,G)   │──→ L_reg
     │         │   │                           │
     │         │   │ agg = R · V   (B,G,d_r)   │
     │         │   │ v_reg = Linear(agg) (B,G)  │
     │         │   └────────────┬──────────────┘
     │         │                │
     │    ┌────┴──────────────┐   │
     │    │  Gate (新增)        │   │
     │    │ 输入: h+pert+t_emb │   │
     │    │ MLP(384→128→1)    │   │
     │    │ α=σ(MLP[h;p;t])   │   │
     │    │ (B,G)              │   │
     │    └────┬───────────────┘   │
     │         │               │
     ▼         ▼               ▼
   ┌─────────────────────────────┐
   │ v = α ⊙ v_reg              │
   │   + (1-α) ⊙ v_int          │
   │              → (B, G)       │
   └─────────────────────────────┘

3.2 各模块详细规格

Backbone（完全复用 scDFM，不改）：

参数	值	来源
d_model	128	与 baseline 一致
nlayers	4	differential_perceiver 默认
nhead	8	scDFM 默认
d_hid	512	scDFM 默认
fusion_method	differential_perceiver	scDFM 默认

RegulatoryHead（新增）：

class RegulatoryHead(nn.Module):
    def __init__(self, d_model: int, d_r: int = 32):
        super().__init__()
        self.d_r = d_r
        self.W_q = nn.Linear(d_model, d_r, bias=False)
        self.W_k = nn.Linear(d_model, d_r, bias=False)
        self.W_v = nn.Linear(d_model, d_r, bias=False)
        self.out_proj = nn.Linear(d_r, 1)
        self.scale = d_r ** -0.5

    def forward(self, h):
        """
        Args:
            h: (B, G, d_model) backbone hidden states
        Returns:
            v_reg: (B, G) regulatory velocity
            R:     (B, G, G) predicted interaction matrix
        """
        Q = self.W_q(h)                        # (B, G, d_r)
        K = self.W_k(h)                        # (B, G, d_r)
        V = self.W_v(h)                        # (B, G, d_r)

        R = torch.bmm(Q, K.transpose(1, 2))    # (B, G, G)
        R = R * self.scale

        # 移除对角线：防止自环泄漏，确保 v_reg 只编码基因间交互
        R = R - torch.diag_embed(R.diagonal(dim1=1, dim2=2))

        # Tanh 约束到 [-1, 1]：匹配 delta_attn 的值域，稳定训练
        R = torch.tanh(R)

        agg = torch.bmm(R, V)                  # (B, G, d_r)
        v_reg = self.out_proj(agg).squeeze(-1)  # (B, G)

        return v_reg, R

关键设计：

• 移除对角线：若 R[j,j] 很大，v_reg_j ≈ R[j,j]·V_r[j]，退化为另一个 v_int。GRN 描述的是基因间的调控，自环属于内在动力学（v_int 负责）
• Tanh 约束：(1) delta_attn ∈ [-1,1]，R_θ 匹配此值域使 L_reg 的 MSE 尺度合理；(2) 防止训练初期 R_θ 数值爆炸导致 v_reg 不稳定；(3) R_θ ∈ [-1,1] 有直接的生物学可解释性（调控强度）。v_reg = Linear(tanh(R)·V) 中 out_proj 可自行学习缩放

参数量：3 * d_model * d_r + d_r = 3 * 128 * 32 + 32 = 12,320（极轻量）

Gate（新增）：

class VelocityGate(nn.Module):
    def __init__(self, d_model: int):
        super().__init__()
        # 三路输入: h (基因状态) + pert_emb (扰动标识) + t_emb (时间步)
        self.mlp = nn.Sequential(
            nn.Linear(d_model * 3, d_model),
            nn.SiLU(),
            nn.Linear(d_model, 1),
        )
        # 末层初始化: bias=-3 → sigmoid(-3)≈0.05, 训练初期 v ≈ v_int
        nn.init.zeros_(self.mlp[-1].weight)
        nn.init.constant_(self.mlp[-1].bias, -3.0)

    def forward(self, h, pert_emb, t_emb):
        """
        Args:
            h:        (B, G, d_model) backbone hidden states
            pert_emb: (B, d_model)    perturbation embedding
            t_emb:    (B, d_model)    timestep embedding
        Returns:
            alpha: (B, G) in (0, 1), 初始≈0.05
        """
        pert_exp = pert_emb.unsqueeze(1).expand_as(h)   # (B, G, d_model)
        t_exp = t_emb.unsqueeze(1).expand_as(h)         # (B, G, d_model)
        x = torch.cat([h, pert_exp, t_exp], dim=-1)     # (B, G, 3*d_model)
        return torch.sigmoid(self.mlp(x).squeeze(-1))
        return torch.sigmoid(self.proj(h).squeeze(-1))

参数量：d_model + 1 = 129

ExprDecoder（复用，不改）：

原有的 3 层 MLP：d_model → d_model → d_model → 1，LeakyReLU 激活。

输入 (B, G, d_model)（不使用 perturbation concat，即 use_batch_labels=False），输出 (B, G)。

3.3 与 scDFM model 的集成方式

在 scDFM 的 model.forward() 最后阶段，原始代码：

# 原始 scDFM (model.py line ~240)
x = self.decoder(x)                 # ExprDecoder, returns dict
return x['pred']                    # (B, G)

RegFM 修改为：

# RegFM
v_int = self.decoder(x)['pred']     # (B, G) — 原有 ExprDecoder
v_reg, R = self.reg_head(x)         # (B, G), (B, G, G) — 新增
alpha = self.gate(x, pert_emb, t_emb)  # (B, G) — 新增, 三路条件化
v = alpha * v_reg + (1 - alpha) * v_int
return v, R                         # 训练时返回 R 用于 L_reg

推理时只需要 v，R 可选择性保存用于事后分析。

---

4. 损失函数

4.1 速度损失 $\mathcal{L}_{vel}$（标准流匹配）

$${\mathcal{L}}_{vel}=\frac{1}{B\cdot G}\sum _{b,g}(v_{pred}^{(b,g)}-v_{target}^{(b,g)}{)}^2\backslash mathcal\{L\}\_\{vel\}\; =\; \backslash frac\{1\}\{B\; \backslash cdot\; G\}\; \backslash sum\_\{b,g\}\; (v\_\{pred\}^\{(b,g)\}\; -\; v\_\{target\}^\{(b,g)\})^2$$

与 scDFM baseline 完全一致。

4.2 调控结构监督 $\mathcal{L}_{reg}$

delta_attention 是高度稀疏的（~3% 非零 at G_sub=1000, delta_topk=30），需要特殊处理：

def compute_reg_loss(R_pred, delta_attn, missing_mask=None, sparse_weight=0.01):
    """
    Magnitude-weighted L_reg with diagonal exclusion and sparsity regularization.

    Args:
        R_pred:       (B, G, G) predicted interaction matrix (diagonal already zeroed)
        delta_attn:   (B, G, G) ground truth delta attention (sparse, topk=50 per row)
        missing_mask: (G,) bool, True = gene exists in scGPT vocab
        sparse_weight: float, weight for zero-entry sparsity regularization
    Returns:
        loss: scalar
    """
    B, G, _ = R_pred.shape

    # 1. 排除对角线（自环不属于 GRN）
    diag_mask = torch.eye(G, dtype=torch.bool, device=R_pred.device)
    R_pred = R_pred.masked_fill(diag_mask.unsqueeze(0), 0.0)
    delta_attn = delta_attn.masked_fill(diag_mask.unsqueeze(0), 0.0)

    # 2. 处理 missing genes: 清零对应行列
    if missing_mask is not None:
        inv = ~missing_mask
        R_pred = R_pred.clone()
        R_pred[:, inv, :] = 0;  R_pred[:, :, inv] = 0
        delta_attn = delta_attn.clone()
        delta_attn[:, inv, :] = 0;  delta_attn[:, :, inv] = 0

    # 3. 非零 entry: magnitude-weighted MSE
    #    大 |δ_attn| 的调控边获得更大权重，防止弱交互梯度淹没强交互
    mask_nz = (delta_attn != 0)
    if mask_nz.any():
        residual = (R_pred[mask_nz] - delta_attn[mask_nz]) ** 2
        mag_weights = delta_attn[mask_nz].abs()
        mag_weights = mag_weights / mag_weights.sum()   # 归一化为概率分布
        loss_nz = (mag_weights * residual).sum()
    else:
        loss_nz = 0.0

    # 4. 零 entry: Hard Negative Mining 稀疏正则
    #    只惩罚"模型猜得大但实际为 0"的假阳性边，
    #    忽略已经正确接近零的 entry（避免梯度被大量近零值稀释）
    mask_zero = ~mask_nz
    if missing_mask is not None:
        valid = missing_mask.unsqueeze(0).unsqueeze(2) & missing_mask.unsqueeze(0).unsqueeze(1)
        mask_zero = mask_zero & valid

    if mask_zero.any():
        zero_preds = R_pred[mask_zero]                          # 所有零 entry 的预测值
        n_hard = min(3 * mask_nz.sum().item(), len(zero_preds)) # 采样 3× 正样本数
        n_hard = max(int(n_hard), 1)
        _, hard_idx = zero_preds.abs().topk(n_hard)             # 取 |R_pred| 最大的
        loss_sparse = zero_preds[hard_idx].pow(2).mean()
    else:
        loss_sparse = 0.0

    return loss_nz + sparse_weight * loss_sparse

设计要点：

• Magnitude weighting：|δ_attn|=0.8 的强调控边权重远大于 |δ_attn|=0.01 的弱交互，防止弱信号梯度淹没强信号
• 对角线排除：与 RegulatoryHead 的 zero-diagonal 一致，R_pred 和 delta_attn 的对角线均置零
• Hard Negative Mining：零 entry 中只惩罚 top-K 假阳性（K = 3× 非零 entry 数），梯度集中在真正有问题的边上，不被大量近零值稀释
• delta_topk 默认 100：覆盖方差拐点附近的有意义交互边，magnitude weighting 自动抑制尾部噪声

4.3 MMD 损失 $\mathcal{L}_{mmd}$（沿用 scDFM，可选）

# 从 v_pred 估算 x_1_hat
x1_hat = x_t + v_pred * (1 - t).unsqueeze(-1)
sigmas = median_sigmas(target, scales=(0.5, 1.0, 2.0, 4.0))
loss_mmd = mmd2_unbiased_multi_sigma(x1_hat, target, sigmas)

4.4 总损失

$$\mathcal{L}={\mathcal{L}}_{vel}+{\lambda }_{reg}\cdot {\mathcal{L}}_{reg}+\gamma \cdot {\mathcal{L}}_{mmd}\backslash mathcal\{L\}\; =\; \backslash mathcal\{L\}\_\{vel\}\; +\; \backslash lambda\_\{reg\}\; \backslash cdot\; \backslash mathcal\{L\}\_\{reg\}\; +\; \backslash gamma\; \backslash cdot\; \backslash mathcal\{L\}\_\{mmd\}$$

超参数建议：

• $\lambda_{reg} = 0.1$（目标值，可调）
• $\gamma = 0.5$（沿用 scDFM baseline）
• delta_topk = 100（第 ~92 位附近方差较大，消融对比 {50, 100, 150}）

两层 Warmup 策略（架构层 + loss 层联合保护）：

层级	机制	效果
架构层	Gate bias 初始化为 -3（α≈0.05）	v ≈ v_int，v_reg 噪声不干扰 L_vel
Loss 层	λ_reg 两阶段调度	backbone 梯度前 N 步完全来自 L_vel

λ_reg 调度 (从零训练):
  Phase 1: step [0, 3000)      → λ_reg = 0        (backbone 专注学 flow)
  Phase 2: step [3000, 5000)   → λ_reg 线性 0→0.1  (逐步引入调控监督)
  Phase 3: step [5000, ∞)      → λ_reg = 0.1      (正常训练)

λ_reg 调度 (warm start from baseline):
  Phase 1: step [0, 1000)      → λ_reg = 0
  Phase 2: step [1000, 2000)   → λ_reg 线性 0→0.1
  Phase 3: step [2000, ∞)      → λ_reg = 0.1

两层保护的必要性：Gate bias 只保护 L_vel 不被 v_reg 噪声影响，但 L_reg 的梯度仍通过 R_θ=Q(h)·K(h)^T 流入 backbone。Phase 1 的 λ_reg=0 确保 backbone 早期梯度完全来自 L_vel。

---

5. 训练流程

5.1 算法伪代码

Algorithm: RegFM Training
────────────────────────────────────────────────────────
Input:
  - scDFM backbone (可从 baseline checkpoint warm start)
  - SparseRawDeltaCache (已有, 来自 GRN 项目)
  - GRNDatasetWrapper (已有, 提供 delta_attention)

Initialize:
  - 加载 scDFM backbone weights (可选 warm start)
  - 随机初始化 RegulatoryHead + VelocityGate
  - Adam optimizer, lr=5e-5
  - LinearLR warmup (2000 steps) → CosineAnnealingLR
  - EMA model copy (decay=0.9999)

For iter = 1 to 200,000:
  1. Sample batch from GRNDatasetWrapper:
     {source, target, delta_attn, gene_ids_sub, input_gene_ids, condition_id}
     source, target: (B, G_sub)
     delta_attn: (B, G_sub, G_sub)

  2. Flow matching path:
     t ~ LogitNormal(0, 1)  or  Uniform[0, 1]
     ε ~ N(0, I)
     x_t = (1-t)·ε + t·target
     v_target = target - ε       (CondOT affine path)

  3. Forward:
     h = Backbone(gene_ids_sub, x_t, t, source, condition_id)
     v_int = ExprDecoder(h)
     v_reg, R_pred = RegulatoryHead(h)
     α = Gate(h)
     v_pred = α · v_reg + (1-α) · v_int

  4. Loss:
     L_vel = MSE(v_pred, v_target)
     L_reg = compute_reg_loss(R_pred, delta_attn, missing_mask)
     L_mmd = mmd_loss(x_t, v_pred, t, target)  # 可选

     # λ_reg 两阶段调度
     if iter < lambda_reg_zero_steps:
         λ_eff = 0.0
     elif iter < lambda_reg_zero_steps + lambda_reg_ramp_steps:
         λ_eff = lambda_reg * (iter - lambda_reg_zero_steps) / lambda_reg_ramp_steps
     else:
         λ_eff = lambda_reg

     L = L_vel + λ_eff · L_reg + γ · L_mmd

  5. Backward + optimizer.step() + scheduler.step()
  6. EMA update

  Every 5000 iters:
     Evaluate on validation set (cell-eval metrics)
     Save checkpoint

5.2 数据加载

完全复用已有的 GRNDatasetWrapper + SparseRawDeltaCache：

• SparseRawDeltaCache：从 HDF5 读取稀疏 delta_attention → 稠密 (B, G_sub, G_sub)
• GRNDatasetWrapper：在 DataLoader worker 中完成 gene subsetting + cache lookup
• 返回格式不变：{src_cell_data, tgt_cell_data, z_target, gene_ids_sub, input_gene_ids, condition_id}

唯一改动：将 z_target 改名为 delta_attn 以提高语义清晰度（可选，非必须）。

5.3 关于 warm start

推荐两阶段训练策略：

1. 阶段 1（可选）：先用标准 scDFM 训练 backbone 到一个合理的 checkpoint（或直接使用已有的 baseline checkpoint）
2. 阶段 2：加载 backbone weights，新增 RegulatoryHead + Gate，用 RegFM 的完整 loss 继续训练

这避免了 RegulatoryHead 随机初始化的噪声干扰 backbone 的早期训练。

也可以选择 端到端从零训练，此时建议对 $\lambda_{reg}$ 做 warmup（前 N 步设为 0 或很小值）。

---

6. 推理流程

6.1 算法伪代码

Algorithm: RegFM Inference
────────────────────────────────────────────────────────
与标准 scDFM 完全相同，无任何额外输入。

Input: source (B, G), perturbation_id (B, 2)

1. Random gene subset: input_gene_ids = randperm(G_full)[:infer_top_gene]
   source_sub = source[:, input_gene_ids]

2. Initialize: ε ~ N(0, I)  shape (B, G_sub)

3. ODE integration:
   traj = torchdiffeq.odeint(
       func = lambda t, x: model(gene_ids_sub, x, t, source_sub, pert_id)[0],
       #                                           只取 v, 忽略 R  ^^^^
       y0 = ε,
       t = linspace(0, 1, steps=20),
       method = "rk4",
       atol = 1e-4, rtol = 1e-4,
   )

4. x_pred = clamp(traj[-1], min=0)

Optional: 保存 R 用于可解释性分析
  在 ODE 的最后一个时间步（t=1）额外运行一次 forward，获取 R_final

6.2 推理不需要 delta_attention

这是 RegFM 相对于级联方案的核心优势：

• 级联方案：推理需要两阶段 ODE（先 latent 20 steps + 后 expression 20 steps = 40 steps）
• RegFM：推理只需要单阶段 ODE（20 steps），与 scDFM baseline 完全一致
• 速度提升约 2x，且无 latent flow 收敛的前置依赖

---

7. 配置设计

7.1 RegFMConfig

基于现有 CascadedFlowConfig，移除级联相关参数，新增 RegFM 参数：

@dataclass
class RegFMConfig:
    # === Base (与 scDFM baseline 对齐) ===
    model_type: str = "regfm"
    batch_size: int = 48            # 与 baseline 一致 (级联用 96 是因为不需要 G×G latent)
    ntoken: int = 512
    d_model: int = 128
    nhead: int = 8
    nlayers: int = 4                # differential_perceiver 默认
    d_hid: int = 512
    lr: float = 5e-5
    steps: int = 200000
    eta_min: float = 1e-6

    data_name: str = "norman"
    perturbation_function: str = "crisper"
    noise_type: str = "Gaussian"
    fusion_method: str = "differential_perceiver"
    infer_top_gene: int = 1000
    n_top_genes: int = 5000
    fold: int = 1
    split_method: str = "additive"
    use_negative_edge: bool = True
    topk: int = 30

    mode: str = "predict_y"
    gamma: float = 0.5              # MMD loss weight
    use_mmd_loss: bool = True
    print_every: int = 5000

    # === RegFM 特有参数 (新增) ===
    d_r: int = 32                   # regulatory head 投影维度
    lambda_reg: float = 0.1         # L_reg 目标权重
    lambda_reg_zero_steps: int = 3000   # Phase 1: λ_reg 严格为 0 的步数
    lambda_reg_ramp_steps: int = 2000   # Phase 2: 线性增长到 lambda_reg 的步数
    gate_init_bias: float = -3.0    # Gate bias 初始值, sigmoid(-3)≈0.05
    sparse_reg_weight: float = 0.01 # 零 entry 稀疏正则权重

    # === Sparse attention cache (复用) ===
    sparse_cache_path: str = "/home/hp250092/ku50001222/qian/aivc/lfj/GRN/grn_ccfm/cache/norman_attn_L11_sparse.h5"
    delta_topk: int = 100           # per-row top-K (第~92位附近方差较大, 消融对比 {50,100,150})

    # === EMA ===
    ema_decay: float = 0.9999

    # === LR warmup ===
    warmup_steps: int = 2000

    # === Time sampling ===
    t_sample_mode: str = "logit_normal"
    t_mean: float = 0.0
    t_std: float = 1.0

    # === Inference ===
    ode_steps: int = 20
    ode_method: str = "rk4"
    eval_batch_size: int = 128

    # === Warm start (可选) ===
    pretrained_backbone: str = ""   # scDFM baseline checkpoint 路径

    # === Paths ===
    result_path: str = "/home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/regfm"
    exp_name: str = ""

7.2 移除的参数（相比级联方案）

以下参数不再需要：

• choose_latent_p（无 latent flow）
• latent_weight（无 latent loss）
• noise_beta（无级联噪声）
• t_latent_mean/std（无 latent 时间步）
• latent_steps（无 latent ODE）
• bilinear_head_dim（无 BilinearLatentDecoder）

---

8. 显存分析

8.1 R_θ 的显存开销

关键张量 R = Q · K^T，shape (B, G_sub, G_sub)：

B=48, G_sub=1000:  R = 48 × 1000 × 1000 × 4 bytes = 192 MB
B=96, G_sub=1000:  R = 96 × 1000 × 1000 × 4 bytes = 384 MB

对比：当前级联方案 grn_att_only 已经在处理 (B=96, G_sub=1000, G_sub=1000) 的 z_target 张量，同样是 384 MB。所以这不是新增的显存瓶颈。

如果显存紧张，可选优化：

• 降低 batch_size 到 48（与 baseline 一致）
• 用 mixed precision (fp16)：R 显存减半至 96 MB (B=48)
• chunk 计算：分块计算 R · V，不需要完整存储 R

8.2 新增参数量

模块	参数量
RegulatoryHead (W_q, W_k, W_v, out_proj)	3 × 128 × 32 + 32 × 1 = 12,320
VelocityGate (MLP: 384→128→1)	384 × 128 + 128 + 128 × 1 + 1 = 49,409
总新增	~62K

scDFM backbone 约 2-3M 参数（4 层 differential_perceiver），新增 ~2% 参数。可忽略不计。

---

9. 实验设计

9.1 主实验：与 baseline 和级联方案对比

Method	描述	GRN 使用方式
scDFM (baseline)	原始流匹配	无
Cascaded (grn_att_only)	级联双 ODE	生成目标
Cascaded (grn_svd)	级联 + SVD 压缩	生成目标
RegFM (ours)	结构化速度分解	训练时监督

评估指标：cell-eval 全套指标（MSE, Pearson, DE Spearman, Direction Match, PR-AUC 等）

9.2 消融实验

实验	配置	验证
A1: v_int only	RegFM 移除 v_reg（相当于 scDFM + L_reg 辅助 loss）	L_reg 通过 backbone gradient 的间接效果
A2: v_reg only	移除 v_int，α 恒=1	纯调控驱动的速度场效果
A3: 无门控	α 恒=0.5（固定等权混合）	门控学习的价值
A4: 无 L_reg	RegFM 架构但 λ_reg=0（R_θ 完全自由学习）	结构分解本身的归纳偏置 vs 监督信号
A5: λ_reg 扫描	λ_reg ∈ {0.01, 0.05, 0.1, 0.5, 1.0}	最优监督强度

9.3 交互信号消融（论文 story 的关键实验）

R_supervision 信号	来源	预期
Random	随机生成	负对照，应 ≈ A4 (无 L_reg)
Δ_attn (scGPT L11)	预训练模型	主实验
Co-expression Δ	训练数据统计：Pearson corr(target) - Pearson corr(source)	纯数据驱动信号
Known GRN (TRRUST)	生物数据库	先验知识，静态（不含扰动特异性）

如果 Δ_attn > Random → 说明 scGPT attention 变化捕获了有意义的交互结构 如果 Known GRN ≈ Δ_attn → 说明两者互通 如果 Δ_attn + Known GRN > 单独任一 → 说明互补

9.4 可解释性分析

1. R_θ 可视化：选择特定扰动，可视化 R_θ 的 top entries 作为 heatmap，与已知 GRN 对比
2. Gate α 分析：
   • 被 knockout 的基因的 α 分布（预期偏低——内在驱动）
   • 下游靶基因的 α 分布（预期偏高——调控驱动）
   • α 随 t 的变化（是否反映调控级联的时序？）
3. R_θ 随 t 的演化：提取不同 t 时间步的 R_θ，分析调控结构是否随时间变化

---

10. 文件结构

GRN/regfm/                                # 新建子目录
├── _bootstrap_scdfm.py                    # 复用：scDFM 模块导入
├── config/
│   └── config_regfm.py                    # 新建：RegFMConfig
├── scripts/
│   └── run_regfm.py                       # 新建：主训练/推理脚本
├── src/
│   ├── __init__.py
│   ├── _scdfm_imports.py                  # 复用：scDFM 导入桥
│   ├── utils.py                           # 复用
│   ├── model/
│   │   ├── __init__.py
│   │   ├── model.py                       # 修改：RegFMModel (继承/包装 scDFM model)
│   │   └── layers.py                      # 新建：RegulatoryHead, VelocityGate
│   ├── denoiser.py                        # 新建：RegFMDenoiser (简化版, 无级联)
│   └── data/
│       ├── __init__.py
│       ├── data.py                        # 复用：GRNDatasetWrapper
│       └── sparse_raw_cache.py            # 复用：SparseRawDeltaCache
└── run_regfm.sh                           # 新建：SLURM 提交脚本

10.1 复用清单

文件	来源	复用方式
_bootstrap_scdfm.py	grn_att_only	直接复制
_scdfm_imports.py	grn_att_only	直接复制
utils.py	grn_att_only	直接复制
data/data.py	grn_att_only	直接复制（GRNDatasetWrapper）
data/sparse_raw_cache.py	grn_att_only	直接复制（SparseRawDeltaCache）
scDFM backbone classes	ori_scDFM	通过 _scdfm_imports 导入
ExprDecoder	ori_scDFM	通过 _scdfm_imports 导入
AffineProbPath	ori_scDFM	通过 _scdfm_imports 导入
cell-eval MetricsEvaluator	cell-eval package	pip install

10.2 新建文件清单

文件	内容	行数估计
config/config_regfm.py	RegFMConfig dataclass	~80 行
src/model/layers.py	RegulatoryHead + VelocityGate	~60 行
src/model/model.py	RegFMModel（包装 scDFM model + 新增 head）	~80 行
src/denoiser.py	RegFMDenoiser（train_step + generate）	~150 行
scripts/run_regfm.py	主脚本（训练循环 + 评估）	~300 行
run_regfm.sh	SLURM 提交	~20 行
总计		~690 行新代码

---

11. 风险和缓解

风险	缓解措施
R_θ 显存过大 (G=5000)	训练用 G_sub=1000，推理同理。如需全基因：低秩分解
L_reg 干扰 L_vel 的训练	λ_reg warmup；消融实验 A4 验证
delta_attention 噪声大，误导 R_θ	软约束（MSE，非硬对齐）；消融实验验证信号质量
Gate α 塌缩到 0 或 1	监控 α 分布；必要时加 entropy regularization
scDFM baseline 本身就够好	这正是论文需要验证的假设；若不够好，RegFM 的改进空间更大

---

12. 论文结构建议

Title: Regulatory Flow Matching: Structuring Velocity Fields
       with Gene Interaction Priors for Perturbation Prediction

1. Introduction
   - 扰动预测的重要性
   - Flow matching 的局限（无结构速度场）
   - 核心贡献：结构化速度分解 + 交互矩阵监督

2. Background
   - Flow matching / Conditional OT
   - scDFM 回顾
   - Gene regulatory networks

3. Method: Regulatory Flow Matching
   3.1 Velocity field decomposition
   3.2 Regulatory interaction head
   3.3 Gated velocity mixing
   3.4 Interaction supervision objective
   3.5 Training and inference

4. Experiments
   4.1 Setup (Norman dataset, baselines, metrics)
   4.2 Main results (vs scDFM, vs cascaded methods)
   4.3 Ablation study (decomposition components)
   4.4 Interaction signal analysis (Δ_attn vs known GRN vs random)
   4.5 Interpretability (R_θ visualization, gate analysis)

5. Related Work
   - Flow matching for biology
   - GRN-informed generative models
   - Privileged information learning

6. Conclusion