| # 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_{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}$$ |
| |
| - $\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（新增）**： |
| |
| ```python |
| 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（新增）**： |
| |
| ```python |
| 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()` 最后阶段，原始代码： |
| |
| ```python |
| # 原始 scDFM (model.py line ~240) |
| x = self.decoder(x) # ExprDecoder, returns dict |
| return x['pred'] # (B, G) |
| ``` |
| |
| RegFM 修改为： |
| |
| ```python |
| # 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$$ |
| |
| 与 scDFM baseline 完全一致。 |
| |
| ### 4.2 调控结构监督 $\mathcal{L}_{reg}$ |
| |
| delta_attention 是高度稀疏的（~3% 非零 at G_sub=1000, delta_topk=30），需要特殊处理： |
| |
| ```python |
| 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，可选） |
| |
| ```python |
| # 从 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}$$ |
| |
| **超参数建议**： |
| - $\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 参数： |
| |
| ```python |
| @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 |
| ``` |
|
|
