# CCFM (Cascaded Conditioned Flow Matching) 架构文档 ## 一、项目概述 CCFM 是一个**级联流匹配**框架，融合三个模型的优势来做单细胞扰动预测： - **scDFM**：基础流匹配架构（backbone、数据加载、训练范式） - **LatentForcing**：级联双流思想（latent 流 + 表达流分阶段生成） - **scGPT**：冻结的预训练模型，提供 per-gene 上下文化特征 ### 核心创新 借鉴 LatentForcing 的双流架构，将其从图像域迁移到单细胞域： | LatentForcing (图像) | CCFM (单细胞) | |---|---| | 像素值 | 基因表达值 | | DINO-v2 特征（辅助生成目标） | scGPT 上下文特征（辅助生成目标） | | 类别标签（条件信号） | control 表达 + perturbation_id（条件信号） | **关键区分**：scGPT 特征是从 target（扰动细胞）提取的**辅助生成目标**，不是条件信号。推理时模型从噪声生成 scGPT 特征（Stage 1），再用生成的特征引导表达值生成（Stage 2）。真正的条件信号是 control 表达和 perturbation_id，它们在推理时始终可获取。 ### 文件结构 ``` CCFM/ ├── _bootstrap_scdfm.py # Bootstrap scDFM 模块，命名空间隔离 ├── config/ │ └── config_cascaded.py # CascadedFlowConfig dataclass (tyro CLI) ├── src/ │ ├── __init__.py │ ├── utils.py # Re-exports scDFM utils │ ├── _scdfm_imports.py # scDFM 模块集中导入 │ ├── denoiser.py # CascadedDenoiser (训练/推理逻辑) │ ├── model/ │ │ ├── model.py # CascadedFlowModel 双流模型 │ │ └── layers.py # LatentEmbedder, LatentDecoder │ └── data/ │ ├── data.py # scDFM 数据加载集成 │ └── scgpt_extractor.py # FrozenScGPTExtractor ├── scripts/ │ ├── run_cascaded.py # 训练/评估入口 │ └── download_scgpt.py # 下载 scGPT 预训练模型 ├── run.sh # pjsub 模板 └── run_topk30_neg.sh # 完整参数化 job 脚本 ``` ### 默认超参数 | 参数 | 值 | 说明 | |---|---|---| | `B` | 48 | batch size | | `G_full` | 5000 | HVG 总数 | | `G` | 1000 | 训练时随机基因子集 | | `d_model` | 128 | 隐藏维度 | | `scgpt_dim` | 512 | scGPT 输出特征维度 | | `bottleneck_dim` | 128 | LatentEmbedder 瓶颈维度 | | `nhead` | 8 | 注意力头数 | | `nlayers` | 4 | Transformer 层数 | | `dh_depth` | 2 | LatentDecoder block 数 | | `choose_latent_p` | 0.4 | 训练 latent 流的概率 | | `latent_weight` | 1.0 | latent loss 权重 | | `gamma` | 0.5 | MMD loss 权重 | | `lr` | 5e-5 | 学习率 | | `steps` | 200000 | 训练总步数 | | `latent_steps` | 20 | 推理 ODE 步数（latent） | | `expr_steps` | 20 | 推理 ODE 步数（表达） | | `warmup_batches` | 200 | scGPT running stats 预热 | --- ## 二、训练流程 Tensor 数据流 ### 2.1 数据准备 ``` 输入: source: (B, G_full=5000) 控制组表达 target: (B, G_full=5000) 扰动后表达 perturbation_id: (B, 2) 扰动 token ID gene_ids: (G_full=5000,) 全部基因的 vocab ID 随机采样 1000 个基因: input_gene_ids = randperm(5000)[:1000] → (1000,) source_sub = source[:, input_gene_ids] → (48, 1000) target_sub = target[:, input_gene_ids] → (48, 1000) gene_input = gene_ids[input_gene_ids].expand → (48, 1000) ``` ### 2.2 冻结 scGPT 提取辅助生成目标（类似 LatentForcing 的 DINO 特征提取） ``` scgpt_extractor.extract(target_sub, gene_indices=input_gene_ids): target_sub: (48, 1000) 输入表达 hvg_ids: (1000,) HVG → scGPT vocab ID 映射 valid_mask: (1000,) bool, 过滤在 scGPT vocab 中的基因 expr_valid: (48, G_valid) 有效基因的表达值 若 G_valid+1 > max_seq_len(1200): 随机采样 1199 个基因 seq_len = 1200 否则: seq_len = G_valid + 1 拼接 CLS token: src = [cls_id | gene_ids] → (48, seq_len) long values = [0 | expr_valid] → (48, seq_len) float scGPT frozen forward: encoder_out = scgpt._encode(src, values, mask) → (48, seq_len, 512) 去掉 CLS, scatter 回固定位置: gene_features = encoder_out[:, 1:, :] → (48, seq_len-1, 512) output = zeros(48, 1000, 512) output.scatter_(1, idx, gene_features) → (48, 1000, 512) 归一化 (running mean/var, warmup 200 batches 后冻结): output = (output - running_mean) / sqrt(running_var) * target_std z_target: (48, 1000, 512) ``` ### 2.3 级联时间采样 ``` t_latent = rand(48) → (48,) t_expr = rand(48) → (48,) choose_latent_mask = rand(48) < 0.4 → (48,) bool 对每个样本二选一: 若 mask=True (40%概率): t_latent 保留, t_expr=0, w_expr=0, w_latent=1 → 训练 latent 流 若 mask=False (60%概率): t_expr 保留, t_latent=1, w_expr=1, w_latent=0 → 训练表达流 输出: t_expr: (48,) 表达流时间步 t_latent: (48,) 潜变量流时间步 w_expr: (48,) 表达 loss 权重 (0 或 1) w_latent: (48,) 潜变量 loss 权重 (0 或 1) ``` ### 2.4 Flow Path 采样（线性插值 + 速度） ``` 表达流: noise_expr = randn_like(source_sub) → (48, 1000) path_expr = AffineProbPath.sample(t_expr, noise_expr, target_sub) path_expr.x_t = (1-t)*noise + t*target → (48, 1000) 插值后的噪声表达 path_expr.dx_t = target - noise → (48, 1000) 目标速度 (ground truth) 潜变量流: noise_latent = randn_like(z_target) → (48, 1000, 512) 展平: z_target_flat = z_target.reshape(48, 512000) → (48, 512000) noise_latent_flat = noise_latent.reshape(48, 512000) → (48, 512000) path_latent_flat = AffineProbPath.sample(t_latent, noise_latent_flat, z_target_flat) 还原: path_latent.x_t = reshape → (48, 1000, 512) 插值后的噪声 latent path_latent.dx_t = reshape → (48, 1000, 512) 目标速度 ``` ### 2.5 模型前向传播 (`CascadedFlowModel.forward`) ``` 输入: gene_input: (48, 1000) 基因 token ID source_sub: (48, 1000) 源表达 path_expr.x_t: (48, 1000) 噪声表达 path_latent.x_t: (48, 1000, 512) 噪声 latent t_expr: (48,) t_latent: (48,) perturbation_id: (48, 2) ``` #### Step 5a: 表达流 Embedding ``` gene_emb = GeneEncoder(gene_input) → (48, 1000, 128) val_emb_1 = ContinuousValueEncoder(x_t) → (48, 1000, 128) encoder_1 = 噪声 target (同 scDFM) val_emb_2 = ContinuousValueEncoder(source_sub) → (48, 1000, 128) encoder_2 = control (同 scDFM) expr_tokens = fusion_layer(cat[val_emb_1, val_emb_2]) + gene_emb = Linear(256→128) → GELU → Linear(128→128) → LN + gene_emb → (48, 1000, 128) ``` > **设计说明**（与 scDFM 对齐）： > - `value_encoder_1` 编码噪声 target（`x_t`），`value_encoder_2` 编码 control（`source`），与 scDFM 角色一致 > - `gene_emb` 只在融合后加一次（去冗余），而非分别加到两个 encoder 的输出上 > - `val_emb_2`（control 嵌入）传入 backbone 的 DiffPerceiverBlock 作为交叉注意力 KV（稳定参考基线） #### Step 5b: 潜变量流 Embedding ``` latent_tokens = LatentEmbedder(path_latent.x_t) = Linear(512→128) → GELU → Linear(128→128) → (48, 1000, 128) ``` #### Step 5c: 双流融合 ``` x = expr_tokens + latent_tokens → (48, 1000, 128) ``` #### Step 5d: 条件向量 ``` t_expr_emb = TimestepEmbedder(t_expr) → (48, 128) t_latent_emb = TimestepEmbedder(t_latent) → (48, 128) pert_emb = GeneEncoder(perturbation_id).mean(dim=1) → (48, 128) # perturbation_id: (48,2) → encoder → (48,2,128) → mean → (48,128) c = t_expr_emb + t_latent_emb + pert_emb → (48, 128) ``` #### Step 5e: 共享 Backbone (4 层 DiffPerceiverBlock) ``` for i in range(4): # GeneadaLN: 用 gene_emb 调制 x x = gene_adaLN[i](gene_emb, x) → (48, 1000, 128) # Adapter: 拼接 pert_emb 后降维 pert_exp = pert_emb[:, None, :].expand(-1, 1000, -1) → (48, 1000, 128) x = cat[x, pert_exp] → (48, 1000, 256) x = adapter_layer[i](x) = Linear(256→128) → LeakyReLU → Linear(128→128) → LeakyReLU → (48, 1000, 128) # DiffPerceiverBlock: attention + MLP, 用 c 做 AdaLN 条件 x = DiffPerceiverBlock(x, val_emb_2, c) → (48, 1000, 128) ``` #### Step 5f: 表达 Decoder Head ``` x_with_pert = cat[x, pert_exp] → (48, 1000, 256) pred_v_expr = ExprDecoder(x_with_pert)["pred"] → (48, 1000) ``` #### Step 5g: Latent Decoder Head ``` h = dh_proj(x) # Linear(128→128) → (48, 1000, 128) for j in range(2): # dh_depth=2 # AdaLN: c → SiLU → Linear(128→768) → chunk 6 shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = adaLN_modulation(c) 各 (48, 128) # Self-Attention with AdaLN h_norm = LayerNorm(h) * (1+scale_msa[:,None,:]) + shift_msa[:,None,:] → (48, 1000, 128) h_attn = MultiheadAttention(h_norm, h_norm, h_norm) → (48, 1000, 128) h = h + gate_msa[:,None,:] * h_attn → (48, 1000, 128) # MLP with AdaLN h_norm = LayerNorm(h) * (1+scale_mlp[:,None,:]) + shift_mlp[:,None,:] → (48, 1000, 128) h_mlp = Linear(128→512) → GELU → Linear(512→128) → (48, 1000, 128) h = h + gate_mlp[:,None,:] * h_mlp → (48, 1000, 128) pred_v_latent = final(h) = LN → Linear(128→128) → GELU → Linear(128→512) → (48, 1000, 512) ``` ### 2.6 Loss 计算 ``` loss_expr = MSE(pred_v_expr - path_expr.dx_t) * w_expr[:, None] = ((48,1000) - (48,1000))^2 * (48,1) → mean → scalar 只对 w_expr=1 的样本有贡献 (约60%) loss_latent = MSE(pred_v_latent - path_latent.dx_t) * w_latent[:, None, None] = ((48,1000,512) - (48,1000,512))^2 * (48,1,1) → mean → scalar 只对 w_latent=1 的样本有贡献 (约40%) loss = loss_expr + latent_weight * loss_latent 可选 MMD loss (对 w_expr>0 的样本): x1_hat = x_t + pred_v_expr * (1-t_expr) # 单步重建 → (N_expr, 1000) mmd_loss = mmd2_unbiased_multi_sigma(x1_hat, target_sub) → scalar loss += gamma * mmd_loss ``` ### 2.7 训练循环 ``` for iteration in range(200000): batch → source(48, 5000), target(48, 5000), pert_id(48, 2) loss = denoiser.train_step(source, target, pert_id, gene_ids, infer_top_gene=1000) optimizer.zero_grad() accelerator.backward(loss) optimizer.step() scheduler.step() # CosineAnnealing if iteration % 5000 == 0: save checkpoint + run evaluation ``` --- ## 三、推理流程 Tensor 数据流 推理时**不调用 scGPT 编码器**，模型从噪声自行生成 latent（辅助语义表征）。用**全部 5000 个基因**，不做子集采样。 条件信号（control 表达 + perturbation_id）在每个 ODE 步中持续提供。 ``` 输入: source: (B, 5000) 控制组表达 perturbation_id: (B, 2) 扰动 ID gene_ids: (B, 5000) 基因 vocab ID ``` ### 3.1 Stage 1: 生成 Latent（t_latent: 0→1, t_expr 固定=0） ``` z_noise = randn(B, 5000, 512) 初始噪声 ODE 求解 (RK4, 20步, t ∈ [0,1]): 每一步调用 latent_vf(t, z_t): t_latent = t.expand(B) → (B,) 当前时间步 t_expr = zeros(B) → (B,) 固定为 0 model.forward( gene_ids, (B, 5000) source, (B, 5000) 源表达 source, (B, 5000) ← 注意: x_t 用 source (因为 t_expr=0) z_t, (B, 5000, 512) 当前 latent 状态 t_expr=0, (B,) t_latent=t, (B,) perturbation_id, (B, 2) ) → _, v_latent (B, 5000, 512) latent 速度场 return v_latent z_traj = odeint(latent_vf, z_noise, linspace(0,1,20)) → (20, B, 5000, 512) z_generated = z_traj[-1] → (B, 5000, 512) ★ 生成的 latent ``` ### 3.2 Stage 2: 用生成的 Latent 引导表达生成（t_expr: 0→1, t_latent 固定=1） ``` expr_noise = randn_like(source) → (B, 5000) 高斯噪声 (或 Poisson) ODE 求解 (RK4, 20步, t ∈ [0,1]): 每一步调用 expr_vf(t, x_t): t_expr = t.expand(B) → (B,) 当前时间步 t_latent = ones(B) → (B,) 固定为 1 (latent 已完成) model.forward( gene_ids, (B, 5000) source, (B, 5000) x_t, (B, 5000) ← 当前噪声表达 z_generated, (B, 5000, 512) ★ Stage 1 的结果 (固定) t_expr=t, (B,) t_latent=1, (B,) perturbation_id, (B, 2) ) → v_expr, _ (B, 5000) 表达速度场 return v_expr x_traj = odeint(expr_vf, expr_noise, linspace(0,1,20)) → (20, B, 5000) x_generated = clamp(x_traj[-1], min=0) → (B, 5000) ★ 最终预测表达 ``` ### 3.3 评估流程 ``` 对每个扰动条件: source = 随机采样 128 个控制细胞 → (128, 5000) 按 batch_size 调用 generate: pred = denoiser.generate(source, pert_id, gene_ids) → (128, 5000) 汇总: pred_adata = AnnData(X=所有预测表达, obs=扰动标签) real_adata = AnnData(X=所有真实表达, obs=扰动标签) MetricsEvaluator(pred_adata, real_adata) → results.csv, agg_results.csv ``` --- ## 四、训练 vs 推理 对比总结 | 维度 | 训练 | 推理 | |---|---|---| | 基因数 | 随机采样 G=1000 | 全量 G=5000 | | scGPT 特征（辅助生成目标） | 冻结提取 target 特征 `z_target` 作为 latent 流的生成目标 | **不使用**，模型从噪声自行生成 latent（Stage 1） | | 时间步 | 级联采样：40% 训练 latent, 60% 训练表达 | 两阶段串行：先 latent(0→1), 再表达(0→1) | | 流采样 | 单步：`x_t = (1-t)*noise + t*target` | ODE 积分：RK4, 20 步 | | Loss | MSE(velocity) + MMD | 无 | | 输出 | scalar loss | `(B, G_full)` 表达矩阵 | | 条件信号 | control + pert_id（真条件）；scGPT 特征是生成目标 | control + pert_id（每步输入）；latent 由 Stage1 生成 | | 时间步 | `t_expr` 和 `t_latent` 随机，互斥激活 | Stage1: `t_expr=0, t_latent∈[0,1]`; Stage2: `t_latent=1, t_expr∈[0,1]` | --- ## 五、模型架构总览图 ``` ┌──────────────────────────────────────────────┐ │ CascadedFlowModel │ │ │ gene_id (B,G) ───────→│ GeneEncoder ──→ gene_emb (B,G,d) │ │ │ │ x_t (B,G) ──────────→│ ValEnc1 ──→ val_emb_1 (B,G,d) 噪声target │ source (B,G) ────────→│ ValEnc2 ──→ val_emb_2 (B,G,d) control │ │ │ │ │ fusion_layer(cat[val_emb_1, val_emb_2]) │ │ + gene_emb (融合后加一次) │ │ ↓ │ │ expr_tokens (B,G,d) │ │ │ │ z_t (B,G,512) ──────→│ LatentEmbedder(512→128→d) │ │ ↓ │ │ latent_tokens (B,G,d) │ │ │ │ │ x = expr_tokens + latent_tokens (B,G,d) │ │ │ t_expr (B,) ────────→│ TimestepEmb ──┐ │ t_latent (B,) ──────→│ TimestepEmb ──┼→ c = sum (B,d) │ pert_id (B,2) ──────→│ PertEmb ──────┘ │ │ │ │ ┌─ 4x DiffPerceiverBlock ──────────────┐ │ │ │ gene_adaLN(gene_emb, x) │ │ │ │ cat[x, pert_emb] → adapter → x │ │ │ │ DiffPerceiverBlock(x, val_emb_2, c) │ │ │ └──────────────────────────────────────┘ │ │ │ │ │ ├──→ ExprDecoder(cat[x, pert]) ──→ pred_v_expr (B,G) │ │ │ │ └──→ LatentDecoder(x, c) │ │ dh_proj → 2x AdaLN Block │ │ → final proj ──→ pred_v_latent (B,G,512) └──────────────────────────────────────────────┘ ```