Upload folder using huggingface_hub

.gitattributes

@@ -77,3 +77,62 @@ transfer/code/ori_scDFM/logs/ccfm_baseline_5404238.out filter=lfs diff=lfs merge
 transfer/code/scDFM/data/norman/go.csv filter=lfs diff=lfs merge=lfs -text
 transfer/code/scDFM/data/norman/perturb_processed.h5ad filter=lfs diff=lfs merge=lfs -text
 transfer/code/scDFM/data/norman.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/baseline/baseline_5418102.out filter=lfs diff=lfs merge=lfs -text
+GRN/baseline/baseline_d128_5527533.out filter=lfs diff=lfs merge=lfs -text
+GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/eval_only/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/eval_only/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/iteration_200000/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/iteration_200000/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/loss_curve.csv filter=lfs diff=lfs merge=lfs -text
+GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30-gene_noise_scale/iteration_215000/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30-gene_noise_scale/iteration_215000/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30-gene_noise_scale/loss_curve.csv filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/A1_baseline/eval_only/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/A1_baseline/eval_only/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/A1_baseline/iteration_195000/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/A1_baseline/iteration_195000/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/A1_baseline/loss_curve.csv filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/A5_full_asb_sde/loss_curve.csv filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/A6_dsm_aniso/eval_only/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/A6_dsm_aniso/eval_only/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/A6_dsm_aniso/iteration_195000/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/A6_dsm_aniso/iteration_195000/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/A6_dsm_aniso/loss_curve.csv filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/SA1_source_anchored_ode/iteration_195000/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/SA1_source_anchored_ode/iteration_195000/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/SA1_source_anchored_ode/loss_curve.csv filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/SA6_source_anchored_sde/iteration_195000/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/SA6_source_anchored_sde/iteration_195000/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/SB/SA6_source_anchored_sde/loss_curve.csv filter=lfs diff=lfs merge=lfs -text
+GRN/result/att_only/fall_att_only/iteration_0/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/att_only/fall_att_only/iteration_0/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/att_svd/svd_baseline/eval_only/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/att_svd/svd_baseline/eval_only/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/dense4/dense4-norman-f1-topk30-negTrue-d128-ld4-lr5e-05-lw1.0-lp0.4-ema0.9999-ln-wu2000-rk4/eval_only/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/dense4/dense4-norman-f1-topk30-negTrue-d128-ld4-lr5e-05-lw1.0-lp0.4-ema0.9999-ln-wu2000-rk4/eval_only/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/dim1_ablation/grn-norman-f1-topk30-negTrue-d512-lr5e-05-lw1.0-lp0.4-ema0.9999-ln-wu2000-rk4-online-attn_L11/eval_only/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/dim1_ablation/grn-norman-f1-topk30-negTrue-d512-lr5e-05-lw1.0-lp0.4-ema0.9999-ln-wu2000-rk4-online-attn_L11/eval_only/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/dim1_ablation/grn-norman-f1-topk30-negTrue-d512-lr5e-05-lw1.0-lp0.4-ema0.9999-ln-wu2000-rk4-online-attn_L11/iteration_195000/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/dim1_ablation/grn-norman-f1-topk30-negTrue-d512-lr5e-05-lw1.0-lp0.4-ema0.9999-ln-wu2000-rk4-online-attn_L11/iteration_195000/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/dim1_ablation/grn-norman-f1-topk30-negTrue-d512-lr5e-05-lw1.0-lp0.4-ema0.9999-ln-wu2000-rk4-online-attn_L11/loss_curve.csv filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/dense4_35k/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/dense4_35k/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/dim1_ablation_145k/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/dim1_ablation_145k/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/dim1_ablation_155k/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/dim1_ablation_155k/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/scalar_15k/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/scalar_15k/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/scalar_bs48_30k/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/scalar_bs48_30k/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/scalar_bs48_75k/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/scalar_bs48_75k/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/scalar_dtk100_30k/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/evl/scalar_dtk100_30k/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/grn-norman-f1-topk30-negTrue-d512-lr5e-05-lw1.0-lp0.4-ema0.9999-ln-wu2000-rk4-online-attn_L11/loss_curve.csv filter=lfs diff=lfs merge=lfs -text
+GRN/result/scalar/scalar-norman-f1-topk30-negTrue-d128-ld1-lr5e-05-lw1.0-lp0.4-agg_signed_l2-dtk100-ema0.9999-ln-wu2000-rk4/eval_only/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/scalar/scalar-norman-f1-topk30-negTrue-d128-ld1-lr5e-05-lw1.0-lp0.4-agg_signed_l2-dtk100-ema0.9999-ln-wu2000-rk4/eval_only/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/scalar/scalar_bs48/eval_only/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/scalar/scalar_bs48/eval_only/real.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/topk30_emb/grn-norman-f1-topk30-negTrue-d512-lr5e-05-lw1.0-lp0.4-ema0.9999-ln-wu2000-rk4-cached_sparse-sparse_tk30_L11/iteration_0/pred.h5ad filter=lfs diff=lfs merge=lfs -text
+GRN/result/topk30_emb/grn-norman-f1-topk30-negTrue-d512-lr5e-05-lw1.0-lp0.4-ema0.9999-ln-wu2000-rk4-cached_sparse-sparse_tk30_L11/iteration_0/real.h5ad filter=lfs diff=lfs merge=lfs -text

GRN/GRN_latent_design.md

@@ -0,0 +1,247 @@
+# GRN-CCFM：基于 Attention-Delta 的扰动预测模型
+
+## Context
+
+CCFM 当前两个核心问题：(1) 维度不对等——512 维 latent 压缩到 128 维 backbone；(2) scGPT encoder output 编码绝对状态，非扰动变化。此外还有一个实际 bug：scDFM/scGPT 词表未对齐，缺失基因在 latent 路径上处理不正确。
+
+三个问题合并为一个方案，代码从 CCFM 复制到 `GRN/grn_ccfm/` 独立开发。
+
+## 用户决策
+
+- 保留 LatentForcing 两阶段 cascaded 范式
+- 维度对齐：**d_model=512 + 加法融合**（同 LatentForcing，不用 concat）
+- 特征替换：**Attention-Delta**（`Δ_attn @ gene_emb`）
+- scGPT 保留为 backbone
+- 修复缺失基因处理
+
+---
+
+## 项目结构
+
+```
+GRN/grn_ccfm/                          # 新建子文件夹
+├── _bootstrap_scdfm.py                 # 复制自 CCFM
+├── config/
+│   └── config_cascaded.py              # 【修改】d_model=512 + 新参数
+├── src/
+│   ├── _scdfm_imports.py               # 复制
+│   ├── utils.py                        # 复制
+│   ├── model/
+│   │   ├── model.py                    # 【小改】无结构变化，d_model=512 自动适配
+│   │   └── layers.py                   # 【小改】LatentEmbedder 简化
+│   ├── data/
+│   │   ├── data.py                     # 复制
+│   │   ├── scgpt_extractor.py          # 【核心】新增 attention-delta + missing mask
+│   │   └── scgpt_cache.py              # 复制
+│   └── denoiser.py                     # 【修改】feature_mode 路由 + 缺失基因处理
+├── scripts/
+│   └── run_cascaded.py                 # 【修改】传新参数
+└── run_grn.sh                          # 【新增】GPU 提交脚本
+```
+
+复制命令：
+```bash
+CCFM=/home/hp250092/ku50001222/qian/aivc/lfj/transfer/code/CCFM
+GRN=/home/hp250092/ku50001222/qian/aivc/lfj/GRN/grn_ccfm
+mkdir -p $GRN/{config,src/model,src/data,scripts}
+cp $CCFM/_bootstrap_scdfm.py $GRN/
+cp $CCFM/config/config_cascaded.py $GRN/config/
+cp $CCFM/src/{_scdfm_imports.py,utils.py,__init__.py} $GRN/src/
+cp $CCFM/src/model/{model.py,layers.py,__init__.py} $GRN/src/model/
+cp $CCFM/src/data/{data.py,scgpt_extractor.py,scgpt_cache.py,__init__.py} $GRN/src/data/
+cp $CCFM/src/denoiser.py $GRN/src/
+cp $CCFM/scripts/run_cascaded.py $GRN/scripts/
+```
+
+---
+
+## Part 1：d_model=512 + 加法融合
+
+d_model 从 128 增到 512 后，latent 512→512 **无压缩**，expression 1→512 **充足容量**。加法融合与 LatentForcing 完全一致（pixel_emb + dino_emb in 1024-dim space）。model.py 的 forward() **不改结构**。
+
+### 改动 1：`config/config_cascaded.py`
+
+```python
+d_model: int = 512           # 128 → 512
+d_hid: int = 2048            # d_model * 4
+bottleneck_dim: int = 512    # 匹配 d_model
+
+# 新增
+feature_mode: str = "encoder"
+attn_layer: int = 11
+attn_use_rank_norm: bool = True
+attn_multi_layer: str = ""
+```
+
+### 改动 2：`src/model/layers.py`
+
+LatentEmbedder：scgpt_dim == d_model 时简化为 LayerNorm + Linear。
+
+### 改动 3：`src/model/model.py`
+
+**无结构改动**。forward() 保持 `x = expr_tokens + latent_tokens`。所有层随 d_model=512 自动适配：
+- GeneadaLN：参数化 by hidden_size ✓
+- ContinuousValueEncoder：1→d_model MLP ✓
+- ExprDecoder(use_batch_labels=True)：接受 2*d_model 输入 ✓
+- DiffPerceiverBlock：参数化 by d_model ✓
+
+---
+
+## Part 2：Attention-Delta 特征
+
+### 计算流程
+
+```
+输入: control_expr (B, G), target_expr (B, G), gene_ids (G_sel,)
+
+Step 1: gene_emb = scGPT.encoder(gene_ids)          → (G_sel, 512)  [查表，静态]
+Step 2: hidden_ctrl = scGPT_layers_0_to_10(ctrl)     → (B, S, 512)
+        hidden_tgt  = scGPT_layers_0_to_10(tgt)      → (B, S, 512)
+Step 3: attn_ctrl = Q_ctrl @ K_ctrl^T  (rank norm, avg heads) → (B, S, S)
+        attn_tgt  = Q_tgt  @ K_tgt^T   (rank norm, avg heads) → (B, S, S)
+Step 4: Δ_attn = attn_tgt - attn_ctrl, 去 CLS        → (B, G_sel, G_sel)
+Step 5: features = Δ_attn @ gene_emb                  → (B, G_sel, 512)
+Step 6: scatter 到 G 位 + 归一化                       → (B, G, 512)
+```
+
+### 改动 4：`src/data/scgpt_extractor.py`
+
+保留 `extract()` 不变。新增：
+
+- `_prepare_gene_selection(gene_indices, device)` → 共享的基因子集逻辑
+- `_forward_to_layer(src, values, mask, target_layer)` → scGPT 前 L 层
+- `_compute_attention(hidden, layer_idx, use_rank_norm)` → Q/K via `in_proj_weight` + rank norm
+- `extract_attention_delta(control_expr, target_expr, ...)` → 核心方法，输出 (B, G, 512)
+- **`get_missing_gene_mask(gene_indices)`** → 返回布尔 mask，True = 缺失基因
+
+Q/K 提取细节：CCFM 设 `use_fast_transformer=False`，`self_attn` 是标准 `nn.MultiheadAttention`，Q/K/V 权重在 `in_proj_weight` 中按 `[W_q; W_k; W_v]` 排列。`_load_pretrained_safe()` 已处理 Wqkv→in_proj_weight ���射。
+
+### 改动 5：`src/denoiser.py`
+
+feature_mode 路由 + 缺失基因处理（见 Part 3）。
+
+### 改动 6：`scripts/run_cascaded.py`
+
+传入新参数。attention_delta 模式下 cache 不可用。
+
+---
+
+## Part 3：缺失基因修复
+
+### 问题
+
+scDFM 有 5000 HVG，部分不在 scGPT vocab 中。当前：scGPT 特征为零，但 latent 噪声/归一化/loss/推理 未适配。
+
+### 修复：`missing_mask` 贯穿 latent 全路径
+
+在 `scgpt_extractor` 中获取 mask：
+
+```python
+def get_missing_gene_mask(self, gene_indices=None):
+    """返回 (G,) bool tensor, True = 该基因不在 scGPT vocab"""
+    hvg_ids = self.hvg_to_scgpt_id[gene_indices] if gene_indices is not None else self.hvg_to_scgpt_id
+    return hvg_ids < 0
+```
+
+#### 训练路径：`denoiser.train_step()` 中 4 处使用 mask
+
+```python
+missing = self.scgpt_extractor.get_missing_gene_mask(input_gene_ids)  # (G_sub,)
+
+# ① z_target 已经是零（extractor scatter 保证），无需改
+
+# ② Latent 噪声置零
+noise_latent = torch.randn_like(z_target)
+noise_latent[:, missing, :] = 0.0        # 缺失基因无噪声
+
+# ③ 归一化跳过缺失基因
+# 已有逻辑: nonzero_mask = output.abs().sum(-1) > 0 → 天然跳过零值 ✓
+
+# ④ Latent loss mask 缺失基因
+loss_latent_per_gene = ((pred_v_latent - path_latent.dx_t) ** 2).mean(dim=-1)  # (B, G)
+loss_latent_per_gene[:, missing] = 0.0
+n_valid = (~missing).sum().clamp(min=1)
+loss_latent_per_sample = loss_latent_per_gene.sum(dim=-1) / n_valid
+```
+
+#### 推理路径：`denoiser.generate()` 中 3 处使用 mask
+
+`generate()` 不调用 extractor，但需要 missing_mask。通过 `get_missing_gene_mask()` 获取全量基因的 mask（推理时用全部 5000 基因，不做随机子集）：
+
+```python
+@torch.no_grad()
+def generate(self, source, perturbation_id, gene_ids, ...):
+    B, G = source.shape
+
+    # 获取全量 missing mask（推理用全部基因，gene_indices=None）
+    missing = self.scgpt_extractor.get_missing_gene_mask()  # (G_full,)
+
+    # ⑤ 初始 latent 噪声置零
+    z_t = torch.randn(B, G, scgpt_dim, device=device)
+    z_t[:, missing, :] = 0.0
+
+    # ⑥ ODE 积分过程中，每步后强制置零（防止数值漂移）
+    # RK4 模式：在 latent_vf 返回前
+    def latent_vf(t, z):
+        v_expr, v_latent = self.model(...)
+        v_latent[:, missing, :] = 0.0    # 缺失基因速度为零
+        return v_latent
+
+    # ⑦ Euler 模式：每步更新后
+    z_t[:, missing, :] = 0.0  # 每步 Euler 更新后置零
+```
+
+**Expression flow 完全不受影响**——expression 不依赖 scGPT vocab。
+
+---
+
+## 实施顺序
+
+1. 从 CCFM 复制文件到 `GRN/grn_ccfm/`
+2. `config/config_cascaded.py` — d_model=512 + 新字段
+3. `src/model/layers.py` — LatentEmbedder 适配
+4. `src/data/scgpt_extractor.py` — attention-delta + get_missing_gene_mask
+5. `src/denoiser.py` — feature_mode 路由 + missing mask 训练 4 处 + 推理 3 处
+6. `scripts/run_cascaded.py` — 传参
+7. `run_grn.sh` — GPU 提交脚本
+
+## 验证
+
+```bash
+# scDFM baseline（已有 GRN/baseline/）
+
+# GRN-CCFM: encoder 特征（隔离维度+vocab修复效果）
+pjsub run_grn.sh  # --feature-mode encoder
+
+# GRN-CCFM: attention-delta（完整方案）
+pjsub run_grn.sh  # --feature-mode attention_delta
+```
+
+- Shape 验证：attention-delta 输出 (B, G, 512)
+- Sanity: control==target 时 Δ_attn≈0
+- Missing mask: 缺失基因 latent noise/loss/velocity 均为零
+- cell-eval 对比三个实验
+
+---
+
+## 后续优化方向（不在本次实施范围）
+
+### 1. 聚合基底：gene_emb → z_ctrl
+当前 `Δ_attn @ gene_emb`（静态身份向量）。可改为 `Δ_attn @ z_ctrl`（上下文相关，编码身份+表达状态）。z_ctrl 在 attention 提取时已算出，几乎免费。更丰富但可能更不稳定。
+
+### 2. MLP 增强版融合
+```python
+z_change = MLP(concat(Δ_attn @ z_ctrl, Δ_attn @ z_tgt, z_tgt - z_ctrl))
+```
+引入可学习参数，可端到端训练。增加复杂度但可能提升表现。
+
+### 3. 多层 attention 计算优化
+用 `attn_multi_layer="9,10,11"` 时，共享 0→8 层计算，只对 9/10/11 层分别续接。
+
+### 4. LR / 训练超参适配
+d_model 从 128→512，参数量 ~15 倍。可能需要：更多 warmup（2000→4000）、略低 LR（5e-5→3e-5）。初次实验先用原值观察 loss 曲线。
+
+### 5. 横向对比备忘
+- **vs LatentForcing**：未使用 Bottleneck 两阶段投影（LF 用 Conv2d 做空间降采样，我们不需要）
+- **vs scGPT Tutorial**：单细胞 attention 比群体平均更嘈杂，但 flow matching + 矩阵乘聚合有降噪效果
+- **vs scDFM**：所有 block（DiffPerceiverBlock, GeneadaLN, ExprDecoder）均参数化 by d_model，已验证 512 维兼容

GRN/PCA1/_bootstrap_scdfm.py

@@ -0,0 +1,101 @@
+"""
+Bootstrap scDFM imports by creating missing __init__.py files and loading
+its modules under a 'scdfm_src' prefix in sys.modules.
+
+This module MUST be imported before any CCFM src imports.
+"""
+
+import sys
+import os
+import types
+
+_SCDFM_ROOT = os.path.normpath(
+    os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "transfer", "code", "scDFM")
+)
+
+# Directories in scDFM that need __init__.py to be proper packages
+_DIRS_NEEDING_INIT = [
+    "src",
+    "src/models",
+    "src/models/origin",
+    "src/data_process",
+    "src/tokenizer",
+    "src/script",
+    "src/models/perturbation",
+]
+
+
+def _ensure_init_files():
+    """Create missing __init__.py files in scDFM so it can be imported as packages."""
+    created = []
+    for d in _DIRS_NEEDING_INIT:
+        init_path = os.path.join(_SCDFM_ROOT, d, "__init__.py")
+        if not os.path.exists(init_path):
+            with open(init_path, "w") as f:
+                f.write("# Auto-created by CCFM bootstrap\n")
+            created.append(init_path)
+    return created
+
+
+def bootstrap():
+    """Load scDFM's src package as 'scdfm_src' in sys.modules."""
+    if "scdfm_src" in sys.modules:
+        return  # Already bootstrapped
+
+    # Create missing __init__.py files
+    _ensure_init_files()
+
+    # Save CCFM's src modules
+    saved = {}
+    for key in list(sys.modules.keys()):
+        if key == "src" or key.startswith("src."):
+            saved[key] = sys.modules.pop(key)
+
+    # Add scDFM root to path
+    sys.path.insert(0, _SCDFM_ROOT)
+
+    try:
+        # Import scDFM modules (their relative imports work now)
+        import src as scdfm_src_pkg
+        import src.models
+        import src.models.origin
+        import src.models.origin.blocks
+        import src.models.origin.layers
+        import src.models.origin.model
+        import src.flow_matching
+        import src.flow_matching.path
+        import src.flow_matching.path.path
+        import src.flow_matching.path.path_sample
+        import src.flow_matching.path.affine
+        import src.flow_matching.path.scheduler
+        import src.flow_matching.path.scheduler.scheduler
+        # Skip src.flow_matching.ot (requires 'ot' package, not needed for CCFM)
+        import src.utils
+        import src.utils.utils
+        import src.tokenizer
+        import src.tokenizer.gene_tokenizer
+        # Skip src.data_process (has heavy deps like bs4, rdkit)
+        # We handle data loading separately in CCFM
+
+        # Re-register all under scdfm_src.* prefix
+        for key in list(sys.modules.keys()):
+            if key == "src" or key.startswith("src."):
+                new_key = "scdfm_" + key
+                sys.modules[new_key] = sys.modules[key]
+
+    finally:
+        # Remove scDFM's src.* entries
+        for key in list(sys.modules.keys()):
+            if (key == "src" or key.startswith("src.")) and not key.startswith("scdfm_"):
+                del sys.modules[key]
+
+        # Restore CCFM's src modules
+        for key, mod in saved.items():
+            sys.modules[key] = mod
+
+        # Remove scDFM from front of path
+        if _SCDFM_ROOT in sys.path:
+            sys.path.remove(_SCDFM_ROOT)
+
+
+bootstrap()

GRN/PCA1/pca_extractor.py

@@ -0,0 +1,63 @@
+"""
+PCAScGPTExtractor — Projects FrozenScGPTExtractor output onto
+the first n_dims principal components of scGPT gene embeddings.
+
+Instead of slicing the first n_dims (arbitrary), PCA captures the
+dominant variation direction in gene embedding space:
+    gene_proj = PCA(gene_emb, n_dims)   # (G, 1)
+    features  = delta_attn @ gene_proj  # (B, G, 1)
+"""
+
+import torch
+import torch.nn as nn
+
+
+class PCAScGPTExtractor(nn.Module):
+
+    def __init__(self, base_extractor, n_dims: int = 1):
+        super().__init__()
+        self.base = base_extractor
+        self.n_dims = n_dims
+        self.scgpt_d_model = n_dims
+        self.n_hvg = base_extractor.n_hvg
+        self._pca_V = None  # (512, n_dims), computed lazily
+
+    @torch.no_grad()
+    def _ensure_pca(self, device):
+        if self._pca_V is not None:
+            return
+        valid_ids = self.base.hvg_to_scgpt_id[self.base.hvg_to_scgpt_id >= 0]
+        gene_emb = self.base.scgpt_model.encoder(
+            valid_ids.unsqueeze(0).to(device)
+        ).squeeze(0)  # (G_valid, 512)
+
+        centered = gene_emb - gene_emb.mean(dim=0)
+        U, S, V = torch.pca_lowrank(centered, q=max(self.n_dims, 6))
+        self._pca_V = V[:, :self.n_dims].to(device)  # (512, n_dims)
+
+        explained = (S[:self.n_dims] ** 2).sum() / (centered ** 2).sum()
+        print(f"[PCA] gene_emb: {self.base.scgpt_d_model}D -> {self.n_dims}D, "
+              f"explained variance: {explained:.4f}")
+
+    def extract(self, expression_values, gene_indices=None):
+        z = self.base.extract(expression_values, gene_indices)  # (B, G, 512)
+        self._ensure_pca(z.device)
+        return torch.matmul(z, self._pca_V)  # (B, G, n_dims)
+
+    def extract_attention_delta(self, control_expr, target_expr,
+                                gene_indices=None, attn_layer=11,
+                                use_rank_norm=True, multi_layer=""):
+        z = self.base.extract_attention_delta(
+            control_expr, target_expr, gene_indices,
+            attn_layer, use_rank_norm, multi_layer,
+        )  # (B, G, 512)
+        self._ensure_pca(z.device)
+        return torch.matmul(z, self._pca_V)  # (B, G, n_dims)
+
+    def get_missing_gene_mask(self, gene_indices=None):
+        return self.base.get_missing_gene_mask(gene_indices)
+
+    def train(self, mode=True):
+        super().train(mode)
+        self.base.train(mode)
+        return self

GRN/PCA1/run_job.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+#PJM -L rscgrp=b-batch
+#PJM -L gpu=1
+#PJM -L elapse=4:00:00
+#PJM -N grn_pca1
+#PJM -j
+#PJM -o /home/hp250092/ku50001222/qian/aivc/lfj/GRN/PCA1/logs/pca1_%j.out
+
+module load cuda/12.2.2
+module load cudnn/8.9.7
+module load gcc-toolset/12
+
+source /home/hp250092/ku50001222/qian/aivc/lfj/stack_env/bin/activate
+
+cd /home/hp250092/ku50001222/qian/aivc/lfj/GRN/PCA1
+
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256
+
+echo "=========================================="
+echo "Job ID:    $PJM_JOBID"
+echo "Job Name:  $PJM_JOBNAME"
+echo "Start:     $(date)"
+echo "Node:      $(hostname)"
+echo "GPU:       $(nvidia-smi --query-gpu=name,memory.total --format=csv,noheader 2>/dev/null || echo 'N/A')"
+echo "Ablation:  PCA1 — project attention_delta @ gene_emb onto PC1"
+echo "=========================================="
+
+accelerate launch --num_processes=1 run_pca1.py \
+    --data-name norman \
+    --d-model 512 \
+    --d-hid 2048 \
+    --nhead 8 \
+    --nlayers 4 \
+    --batch-size 48 \
+    --lr 5e-5 \
+    --steps 50000 \
+    --fusion-method differential_perceiver \
+    --perturbation-function crisper \
+    --noise-type Gaussian \
+    --infer-top-gene 1000 \
+    --n-top-genes 5000 \
+    --use-mmd-loss \
+    --gamma 0.5 \
+    --split-method additive \
+    --fold 1 \
+    --scgpt-dim 1 \
+    --bottleneck-dim 512 \
+    --latent-weight 1.0 \
+    --choose-latent-p 0.4 \
+    --dh-depth 2 \
+    --print-every 5000 \
+    --topk 30 \
+    --use-negative-edge \
+    --ema-decay 0.9999 \
+    --t-sample-mode logit_normal \
+    --t-expr-mean 0.0 \
+    --t-expr-std 1.0 \
+    --t-latent-mean 0.0 \
+    --t-latent-std 1.0 \
+    --warmup-steps 2000 \
+    --ode-method rk4 \
+    --feature-mode attention_delta \
+    --attn-layer 11 \
+    --attn-use-rank-norm \
+    --result-path /home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/PCA1
+
+echo "=========================================="
+echo "Finished:  $(date)"
+echo "=========================================="

GRN/PCA1/run_pca1.py

@@ -0,0 +1,461 @@
+"""
+Training and evaluation entry point for CCFM (Cascaded Conditioned Flow Matching).
+PCA1 ablation: projects scGPT features onto first principal component of gene embeddings.
+"""
+
+import sys
+import os
+
+# Set up paths — grn_ccfm/ is the CCFM project root (one level up from PCA1/)
+_ABLATION_DIR = os.path.dirname(os.path.abspath(__file__))
+_PROJECT_ROOT = os.path.join(_ABLATION_DIR, "..", "grn_ccfm")
+_PROJECT_ROOT = os.path.normpath(_PROJECT_ROOT)
+sys.path.insert(0, _PROJECT_ROOT)
+sys.path.insert(0, _ABLATION_DIR)  # for pca_extractor
+
+# Bootstrap scDFM imports (must happen before any CCFM src imports)
+import _bootstrap_scdfm  # noqa: F401
+
+import copy
+import torch
+import torch.nn as nn
+import tyro
+import tqdm
+import numpy as np
+import pandas as pd
+import anndata as ad
+import scanpy as sc
+from torch.utils.data import DataLoader
+from tqdm import trange
+from accelerate import Accelerator, DistributedDataParallelKwargs
+from torch.optim.lr_scheduler import LinearLR, CosineAnnealingLR, SequentialLR
+
+from config.config_cascaded import CascadedFlowConfig as Config
+from src.data.data import get_data_classes
+from src.model.model import CascadedFlowModel
+from src.data.scgpt_extractor import FrozenScGPTExtractor
+from src.data.scgpt_cache import ScGPTFeatureCache
+from src.denoiser import CascadedDenoiser
+from src.utils import (
+    save_checkpoint,
+    load_checkpoint,
+    pick_eval_score,
+    process_vocab,
+    set_requires_grad_for_p_only,
+    GeneVocab,
+)
+from pca_extractor import PCAScGPTExtractor
+
+from cell_eval import MetricsEvaluator
+
+# Resolve scDFM directory paths
+_REPO_ROOT = os.path.normpath(os.path.join(_PROJECT_ROOT, "..", "..", "transfer", "code"))  # transfer/code/
+
+
+@torch.inference_mode()
+def test(data_sampler, denoiser, accelerator, config, vocab, data_manager,
+         batch_size=128, path_dir="./"):
+    """Evaluate: generate predictions and compute cell-eval metrics."""
+    device = accelerator.device
+    gene_ids_test = vocab.encode(list(data_sampler.adata.var_names))
+    gene_ids_test = torch.tensor(gene_ids_test, dtype=torch.long, device=device)
+
+    perturbation_name_list = data_sampler._perturbation_covariates
+    control_data = data_sampler.get_control_data()
+    inverse_dict = {v: str(k) for k, v in data_manager.perturbation_dict.items()}
+
+    all_pred_expressions = [control_data["src_cell_data"]]
+    obs_perturbation_name_pred = ["control"] * control_data["src_cell_data"].shape[0]
+    all_target_expressions = [control_data["src_cell_data"]]
+    obs_perturbation_name_real = ["control"] * control_data["src_cell_data"].shape[0]
+
+    print("perturbation_name_list:", len(perturbation_name_list))
+    for perturbation_name in perturbation_name_list:
+        perturbation_data = data_sampler.get_perturbation_data(perturbation_name)
+        target = perturbation_data["tgt_cell_data"]
+        perturbation_id = perturbation_data["condition_id"]
+        source = control_data["src_cell_data"].to(device)
+        perturbation_id = perturbation_id.to(device)
+
+        if config.perturbation_function == "crisper":
+            perturbation_name_crisper = [
+                inverse_dict[int(p_id)] for p_id in perturbation_id[0].cpu().numpy()
+            ]
+            perturbation_id = torch.tensor(
+                vocab.encode(perturbation_name_crisper), dtype=torch.long, device=device
+            )
+            perturbation_id = perturbation_id.repeat(source.shape[0], 1)
+
+        idx = torch.randperm(source.shape[0])
+        source = source[idx]
+        N = 128
+        source = source[:N]
+
+        pred_expressions = []
+        for i in trange(0, N, batch_size, desc=perturbation_name):
+            batch_source = source[i : i + batch_size]
+            batch_pert_id = perturbation_id[0].repeat(batch_source.shape[0], 1).to(device)
+
+            # Get the underlying model for generation
+            model = denoiser.module if hasattr(denoiser, "module") else denoiser
+
+            pred = model.generate(
+                batch_source,
+                batch_pert_id,
+                gene_ids_test,
+                latent_steps=config.latent_steps,
+                expr_steps=config.expr_steps,
+                method=config.ode_method,
+            )
+            pred_expressions.append(pred)
+
+        pred_expressions = torch.cat(pred_expressions, dim=0).cpu().numpy()
+        all_pred_expressions.append(pred_expressions)
+        all_target_expressions.append(target)
+        obs_perturbation_name_pred.extend([perturbation_name] * pred_expressions.shape[0])
+        obs_perturbation_name_real.extend([perturbation_name] * target.shape[0])
+
+    all_pred_expressions = np.concatenate(all_pred_expressions, axis=0)
+    all_target_expressions = np.concatenate(all_target_expressions, axis=0)
+    obs_pred = pd.DataFrame({"perturbation": obs_perturbation_name_pred})
+    obs_real = pd.DataFrame({"perturbation": obs_perturbation_name_real})
+    pred_adata = ad.AnnData(X=all_pred_expressions, obs=obs_pred)
+    real_adata = ad.AnnData(X=all_target_expressions, obs=obs_real)
+
+    eval_score = None
+    if accelerator.is_main_process:
+        evaluator = MetricsEvaluator(
+            adata_pred=pred_adata,
+            adata_real=real_adata,
+            control_pert="control",
+            pert_col="perturbation",
+            num_threads=32,
+        )
+        results, agg_results = evaluator.compute()
+        results.write_csv(os.path.join(path_dir, "results.csv"))
+        agg_results.write_csv(os.path.join(path_dir, "agg_results.csv"))
+        pred_adata.write_h5ad(os.path.join(path_dir, "pred.h5ad"))
+        real_adata.write_h5ad(os.path.join(path_dir, "real.h5ad"))
+        eval_score = pick_eval_score(agg_results, "mse")
+        print(f"Current evaluation score: {eval_score:.4f}")
+
+    return eval_score
+
+
+if __name__ == "__main__":
+    config = tyro.cli(Config)
+
+    ddp_kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
+    accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])
+    if accelerator.is_main_process:
+        print(config)
+        save_path = config.make_path()
+        os.makedirs(save_path, exist_ok=True)
+    device = accelerator.device
+
+    # === Data loading (reuse scDFM) ===
+    Data, PerturbationDataset, TrainSampler, TestDataset = get_data_classes()
+
+    scdfm_data_path = os.path.join(_REPO_ROOT, "scDFM", "data")
+    data_manager = Data(scdfm_data_path)
+    data_manager.load_data(config.data_name)
+
+    # Convert var_names from Ensembl IDs to gene symbols if needed.
+    # scDFM vocab and perturbation encoding both expect gene symbols as var_names.
+    if "gene_name" in data_manager.adata.var.columns and data_manager.adata.var_names[0].startswith("ENSG"):
+        data_manager.adata.var_names = data_manager.adata.var["gene_name"].values
+        data_manager.adata.var_names_make_unique()
+        if accelerator.is_main_process:
+            print(f"Converted var_names to gene symbols, sample: {list(data_manager.adata.var_names[:5])}")
+
+    data_manager.process_data(
+        n_top_genes=config.n_top_genes,
+        split_method=config.split_method,
+        fold=config.fold,
+        use_negative_edge=config.use_negative_edge,
+        k=config.topk,
+    )
+    train_sampler, valid_sampler, _ = data_manager.load_flow_data(batch_size=config.batch_size)
+
+    train_dataset = PerturbationDataset(train_sampler, config.batch_size)
+    dataloader = DataLoader(
+        train_dataset, batch_size=1, shuffle=False,
+        num_workers=8, pin_memory=True, persistent_workers=True,
+    )
+
+    # === Build mask path ===
+    if config.use_negative_edge:
+        mask_path = os.path.join(
+            data_manager.data_path, data_manager.data_name,
+            f"mask_fold_{config.fold}topk_{config.topk}{config.split_method}_negative_edge.pt",
+        )
+    else:
+        mask_path = os.path.join(
+            data_manager.data_path, data_manager.data_name,
+            f"mask_fold_{config.fold}topk_{config.topk}{config.split_method}.pt",
+        )
+
+    # === Vocab ===
+    orig_cwd = os.getcwd()
+    os.chdir(os.path.join(_REPO_ROOT, "scDFM"))
+    vocab = process_vocab(data_manager, config)
+    os.chdir(orig_cwd)
+
+    # Vocab is built from var_names (may be Ensembl IDs or gene symbols)
+    gene_ids = vocab.encode(list(data_manager.adata.var_names))
+    gene_ids = torch.tensor(gene_ids, dtype=torch.long, device=device)
+
+    # === Build CascadedFlowModel ===
+    vf = CascadedFlowModel(
+        ntoken=len(vocab),
+        d_model=config.d_model,
+        nhead=config.nhead,
+        d_hid=config.d_hid,
+        nlayers=config.nlayers,
+        fusion_method=config.fusion_method,
+        perturbation_function=config.perturbation_function,
+        mask_path=mask_path,
+        scgpt_dim=config.scgpt_dim,
+        bottleneck_dim=config.bottleneck_dim,
+        dh_depth=config.dh_depth,
+    )
+
+    # === Build FrozenScGPTExtractor ===
+    # var_names have been converted to gene symbols above, matching scGPT vocab.
+    hvg_gene_names = list(data_manager.adata.var_names)
+    scgpt_model_dir = os.path.join(
+        os.path.dirname(_REPO_ROOT),  # transfer/
+        config.scgpt_model_dir.replace("transfer/", ""),
+    )
+    scgpt_extractor = FrozenScGPTExtractor(
+        model_dir=scgpt_model_dir,
+        hvg_gene_names=hvg_gene_names,
+        device=device,
+        max_seq_len=config.scgpt_max_seq_len,
+        target_std=config.target_std,
+        warmup_batches=config.warmup_batches,
+    )
+    scgpt_extractor = scgpt_extractor.to(device)
+
+    # === PCA1: project scGPT features onto first principal component ===
+    if config.scgpt_dim < scgpt_extractor.scgpt_d_model:
+        print(f"[PCA1] Projecting scGPT features: {scgpt_extractor.scgpt_d_model}D -> {config.scgpt_dim}D (PCA)")
+        scgpt_extractor = PCAScGPTExtractor(scgpt_extractor, n_dims=config.scgpt_dim)
+
+    # === Build CascadedDenoiser ===
+    denoiser = CascadedDenoiser(
+        model=vf,
+        scgpt_extractor=scgpt_extractor,
+        choose_latent_p=config.choose_latent_p,
+        latent_weight=config.latent_weight,
+        noise_type=config.noise_type,
+        use_mmd_loss=config.use_mmd_loss,
+        gamma=config.gamma,
+        poisson_alpha=config.poisson_alpha,
+        poisson_target_sum=config.poisson_target_sum,
+        t_sample_mode=config.t_sample_mode,
+        t_expr_mean=config.t_expr_mean,
+        t_expr_std=config.t_expr_std,
+        t_latent_mean=config.t_latent_mean,
+        t_latent_std=config.t_latent_std,
+        noise_beta=config.noise_beta,
+        feature_mode=config.feature_mode,
+        attn_layer=config.attn_layer,
+        attn_use_rank_norm=config.attn_use_rank_norm,
+        attn_multi_layer=config.attn_multi_layer,
+    )
+
+    # === Load scGPT cache if configured ===
+    scgpt_cache = None
+    if config.scgpt_cache_path and config.feature_mode == "attention_delta":
+        if accelerator.is_main_process:
+            print("WARNING: scGPT cache is not compatible with attention_delta mode. Ignoring cache.")
+        config.scgpt_cache_path = ""
+    if config.scgpt_cache_path:
+        scgpt_cache = ScGPTFeatureCache(
+            config.scgpt_cache_path,
+            target_std=config.target_std,
+        )
+        if accelerator.is_main_process:
+            print(f"Using pre-extracted scGPT cache: {config.scgpt_cache_path}")
+            print(f"  Cache shape: {scgpt_cache.features.shape}, cells: {len(scgpt_cache.name_to_idx)}")
+
+    # === EMA model (on same device as training model) ===
+    ema_model = copy.deepcopy(vf).to(device)
+    ema_model.eval()
+    ema_model.requires_grad_(False)
+
+    # === Optimizer & Scheduler (with warmup) ===
+    save_path = config.make_path()
+    optimizer = torch.optim.Adam(vf.parameters(), lr=config.lr)
+    warmup_scheduler = LinearLR(
+        optimizer, start_factor=1e-3, end_factor=1.0, total_iters=config.warmup_steps,
+    )
+    cosine_scheduler = CosineAnnealingLR(
+        optimizer, T_max=max(config.steps - config.warmup_steps, 1), eta_min=config.eta_min,
+    )
+    scheduler = SequentialLR(
+        optimizer, [warmup_scheduler, cosine_scheduler], milestones=[config.warmup_steps],
+    )
+
+    start_iteration = 0
+    if config.checkpoint_path != "":
+        start_iteration, _ = load_checkpoint(config.checkpoint_path, vf, optimizer, scheduler)
+        # Sync EMA with loaded weights
+        ema_model.load_state_dict(vf.state_dict())
+
+    # === Prepare with accelerator ===
+    denoiser = accelerator.prepare(denoiser)
+    optimizer, scheduler, dataloader = accelerator.prepare(optimizer, scheduler, dataloader)
+
+    inverse_dict = {v: str(k) for k, v in data_manager.perturbation_dict.items()}
+
+    # === Test-only mode ===
+    if config.test_only:
+        eval_path = os.path.join(save_path, "eval_only")
+        os.makedirs(eval_path, exist_ok=True)
+        if accelerator.is_main_process:
+            print(f"Test-only mode. Saving results to {eval_path}")
+        eval_score = test(
+            valid_sampler, denoiser, accelerator, config, vocab, data_manager,
+            batch_size=config.batch_size, path_dir=eval_path,
+        )
+        if accelerator.is_main_process and eval_score is not None:
+            print(f"Final evaluation score: {eval_score:.4f}")
+        sys.exit(0)
+
+    # === Loss logging (CSV + TensorBoard) ===
+    import csv
+    from torch.utils.tensorboard import SummaryWriter
+    if accelerator.is_main_process:
+        os.makedirs(save_path, exist_ok=True)
+        csv_path = os.path.join(save_path, 'loss_curve.csv')
+        if start_iteration > 0 and os.path.exists(csv_path):
+            csv_file = open(csv_path, 'a', newline='')
+            csv_writer = csv.writer(csv_file)
+        else:
+            csv_file = open(csv_path, 'w', newline='')
+            csv_writer = csv.writer(csv_file)
+            csv_writer.writerow(['iteration', 'loss', 'loss_expr', 'loss_latent', 'loss_mmd', 'lr'])
+        tb_writer = SummaryWriter(log_dir=os.path.join(save_path, 'tb_logs'))
+
+    # === Training loop ===
+    pbar = tqdm.tqdm(total=config.steps, initial=start_iteration)
+    iteration = start_iteration
+
+    while iteration < config.steps:
+        for batch_data in dataloader:
+            source = batch_data["src_cell_data"].squeeze(0)
+            target = batch_data["tgt_cell_data"].squeeze(0)
+            perturbation_id = batch_data["condition_id"].squeeze(0).to(device)
+
+            if config.perturbation_function == "crisper":
+                perturbation_name = [
+                    inverse_dict[int(p_id)] for p_id in perturbation_id[0].cpu().numpy()
+                ]
+                perturbation_id = torch.tensor(
+                    vocab.encode(perturbation_name), dtype=torch.long, device=device
+                )
+                perturbation_id = perturbation_id.repeat(source.shape[0], 1)
+
+            # Get the underlying denoiser for train_step
+            base_denoiser = denoiser.module if hasattr(denoiser, "module") else denoiser
+            base_denoiser.model.train()
+
+            if scgpt_cache is not None:
+                # Cache mode: sample gene subset here, look up pre-extracted features
+                # DataLoader collate wraps strings in tuples; unwrap them
+                tgt_cell_names = [n[0] if isinstance(n, (tuple, list)) else n for n in batch_data["tgt_cell_id"]]
+                input_gene_ids = torch.randperm(source.shape[-1], device=device)[:config.infer_top_gene]
+                cached_z_target = scgpt_cache.lookup(tgt_cell_names, input_gene_ids, device=device)
+                loss_dict = base_denoiser.train_step(
+                    source, target, perturbation_id, gene_ids,
+                    infer_top_gene=config.infer_top_gene,
+                    cached_z_target=cached_z_target,
+                    cached_gene_ids=input_gene_ids,
+                )
+            else:
+                loss_dict = base_denoiser.train_step(
+                    source, target, perturbation_id, gene_ids,
+                    infer_top_gene=config.infer_top_gene,
+                )
+
+            loss = loss_dict["loss"]
+            optimizer.zero_grad(set_to_none=True)
+            accelerator.backward(loss)
+            optimizer.step()
+            scheduler.step()
+
+            # === EMA update ===
+            with torch.no_grad():
+                decay = config.ema_decay
+                for ema_p, model_p in zip(ema_model.parameters(), vf.parameters()):
+                    ema_p.lerp_(model_p.data, 1 - decay)
+
+            if iteration % config.print_every == 0:
+                save_path_ = os.path.join(save_path, f"iteration_{iteration}")
+                os.makedirs(save_path_, exist_ok=True)
+                if accelerator.is_main_process:
+                    print(f"Saving iteration {iteration} checkpoint...")
+                    # Save EMA model (used for inference) and training state
+                    save_checkpoint(
+                        model=ema_model,
+                        optimizer=optimizer,
+                        scheduler=scheduler,
+                        iteration=iteration,
+                        eval_score=None,
+                        save_path=save_path_,
+                        is_best=False,
+                    )
+                # Evaluate with EMA weights
+                # Only evaluate at the start and the last checkpoint
+                if iteration == 0 or iteration + config.print_every >= config.steps:
+                    # Swap EMA weights into denoiser for evaluation
+                    orig_state = copy.deepcopy(vf.state_dict())
+                    vf.load_state_dict(ema_model.state_dict())
+
+                    eval_score = test(
+                        valid_sampler, denoiser, accelerator, config, vocab, data_manager,
+                        batch_size=config.batch_size, path_dir=save_path_,
+                    )
+
+                    # Restore training weights
+                    vf.load_state_dict(orig_state)
+
+                    if accelerator.is_main_process and eval_score is not None:
+                        tb_writer.add_scalar('eval/score', eval_score, iteration)
+
+            # --- Per-iteration loss logging ---
+            if accelerator.is_main_process:
+                current_lr = scheduler.get_last_lr()[0]
+                csv_writer.writerow([
+                    iteration, loss.item(),
+                    loss_dict["loss_expr"].item(),
+                    loss_dict["loss_latent"].item(),
+                    loss_dict["loss_mmd"].item(),
+                    current_lr,
+                ])
+                if iteration % 100 == 0:
+                    csv_file.flush()
+                tb_writer.add_scalar('loss/train', loss.item(), iteration)
+                tb_writer.add_scalar('loss/expr', loss_dict["loss_expr"].item(), iteration)
+                tb_writer.add_scalar('loss/latent', loss_dict["loss_latent"].item(), iteration)
+                tb_writer.add_scalar('loss/mmd', loss_dict["loss_mmd"].item(), iteration)
+                tb_writer.add_scalar('lr', current_lr, iteration)
+
+            accelerator.wait_for_everyone()
+
+            pbar.update(1)
+            pbar.set_description(
+                f"loss: {loss.item():.4f} (expr: {loss_dict['loss_expr'].item():.4f}, "
+                f"latent: {loss_dict['loss_latent'].item():.4f}, "
+                f"mmd: {loss_dict['loss_mmd'].item():.4f}), iter: {iteration}"
+            )
+            iteration += 1
+            if iteration >= config.steps:
+                break
+
+    # === Close logging ===
+    if accelerator.is_main_process:
+        csv_file.close()
+        tb_writer.close()

GRN/RegFM_design.md

@@ -0,0 +1,768 @@
+# 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
+```

GRN/SB/_bootstrap_scdfm.py

@@ -0,0 +1,101 @@
+"""
+Bootstrap scDFM imports by creating missing __init__.py files and loading
+its modules under a 'scdfm_src' prefix in sys.modules.
+
+This module MUST be imported before any CCFM src imports.
+"""
+
+import sys
+import os
+import types
+
+_SCDFM_ROOT = os.path.normpath(
+    os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "transfer", "code", "scDFM")
+)
+
+# Directories in scDFM that need __init__.py to be proper packages
+_DIRS_NEEDING_INIT = [
+    "src",
+    "src/models",
+    "src/models/origin",
+    "src/data_process",
+    "src/tokenizer",
+    "src/script",
+    "src/models/perturbation",
+]
+
+
+def _ensure_init_files():
+    """Create missing __init__.py files in scDFM so it can be imported as packages."""
+    created = []
+    for d in _DIRS_NEEDING_INIT:
+        init_path = os.path.join(_SCDFM_ROOT, d, "__init__.py")
+        if not os.path.exists(init_path):
+            with open(init_path, "w") as f:
+                f.write("# Auto-created by CCFM bootstrap\n")
+            created.append(init_path)
+    return created
+
+
+def bootstrap():
+    """Load scDFM's src package as 'scdfm_src' in sys.modules."""
+    if "scdfm_src" in sys.modules:
+        return  # Already bootstrapped
+
+    # Create missing __init__.py files
+    _ensure_init_files()
+
+    # Save CCFM's src modules
+    saved = {}
+    for key in list(sys.modules.keys()):
+        if key == "src" or key.startswith("src."):
+            saved[key] = sys.modules.pop(key)
+
+    # Add scDFM root to path
+    sys.path.insert(0, _SCDFM_ROOT)
+
+    try:
+        # Import scDFM modules (their relative imports work now)
+        import src as scdfm_src_pkg
+        import src.models
+        import src.models.origin
+        import src.models.origin.blocks
+        import src.models.origin.layers
+        import src.models.origin.model
+        import src.flow_matching
+        import src.flow_matching.path
+        import src.flow_matching.path.path
+        import src.flow_matching.path.path_sample
+        import src.flow_matching.path.affine
+        import src.flow_matching.path.scheduler
+        import src.flow_matching.path.scheduler.scheduler
+        # Skip src.flow_matching.ot (requires 'ot' package, not needed for CCFM)
+        import src.utils
+        import src.utils.utils
+        import src.tokenizer
+        import src.tokenizer.gene_tokenizer
+        # Skip src.data_process (has heavy deps like bs4, rdkit)
+        # We handle data loading separately in CCFM
+
+        # Re-register all under scdfm_src.* prefix
+        for key in list(sys.modules.keys()):
+            if key == "src" or key.startswith("src."):
+                new_key = "scdfm_" + key
+                sys.modules[new_key] = sys.modules[key]
+
+    finally:
+        # Remove scDFM's src.* entries
+        for key in list(sys.modules.keys()):
+            if (key == "src" or key.startswith("src.")) and not key.startswith("scdfm_"):
+                del sys.modules[key]
+
+        # Restore CCFM's src modules
+        for key, mod in saved.items():
+            sys.modules[key] = mod
+
+        # Remove scDFM from front of path
+        if _SCDFM_ROOT in sys.path:
+            sys.path.remove(_SCDFM_ROOT)
+
+
+bootstrap()

GRN/SB/config/config_sb.py

@@ -0,0 +1,103 @@
+from dataclasses import dataclass
+import os
+
+
+@dataclass
+class SBConfig:
+    # === Base (same as scDFM FlowConfig) ===
+    model_type: str = "sb"
+    batch_size: int = 48
+    ntoken: int = 512
+    d_model: int = 128
+    nhead: int = 8
+    nlayers: int = 4
+    d_hid: int = 512
+    lr: float = 5e-5
+    steps: int = 200000
+    eta_min: float = 1e-6
+    devices: str = "1"
+    test_only: bool = False
+
+    data_name: str = "norman"
+    perturbation_function: str = "crisper"
+    noise_type: str = "Gaussian"
+    poisson_alpha: float = 0.8
+    poisson_target_sum: int = -1
+
+    print_every: int = 5000
+    mode: str = "predict_y"
+    result_path: str = "/home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/sb"
+    fusion_method: str = "differential_perceiver"
+    infer_top_gene: int = 1000
+    n_top_genes: int = 5000
+    checkpoint_path: str = ""
+    gamma: float = 0.5
+    split_method: str = "additive"
+    use_mmd_loss: bool = True
+    fold: int = 1
+    use_negative_edge: bool = True
+    topk: int = 30
+
+    # === Anisotropic diffusion ===
+    sigma_min: float = 0.01
+    sigma_max: float = 2.0
+    sigma_init: float = 0.5
+    sigma_hidden_dim: int = 256
+    sigma_num_layers: int = 2
+
+    # === Score training ===
+    score_weight: float = 0.1
+    score_head_depth: int = 2
+    score_t_clip: float = 0.02
+    use_score: bool = True  # False for A1-A3 ablations (no score head)
+
+    # === σ_g regularization ===
+    sigma_base: float = 0.5
+    sigma_sparse_weight: float = 0.01
+    sigma_volume_weight: float = 0.01
+
+    # === OT coupling ===
+    ot_method: str = "sinkhorn"  # "sinkhorn" or "exact"
+    ot_reg: float = 0.05
+    ot_use_sigma: bool = True  # use anisotropic Mahalanobis cost
+
+    # === SDE inference ===
+    sde_steps: int = 50
+    use_sde_inference: bool = True  # False = PF-ODE (dx/dt = v_θ)
+
+    # === Source-Anchored Bridge ===
+    source_anchored: bool = False  # True = x_0 = source; False = x_0 = noise
+
+    # === EMA ===
+    ema_decay: float = 0.9999
+
+    # === Logit-normal time-step sampling ===
+    t_sample_mode: str = "logit_normal"
+    t_mean: float = 0.0
+    t_std: float = 1.0
+
+    # === LR warmup ===
+    warmup_steps: int = 2000
+
+    # === Inference ===
+    ode_method: str = "rk4"
+    ode_steps: int = 20
+    eval_batch_size: int = 32
+
+    exp_name: str = ""
+
+    def __post_init__(self):
+        if self.data_name == "norman":
+            self.n_top_genes = 5000
+
+    def make_path(self):
+        if self.exp_name:
+            return os.path.join(self.result_path, self.exp_name)
+        exp_name = (
+            f"sb-{self.data_name}-f{self.fold}"
+            f"-d{self.d_model}-lr{self.lr}"
+            f"-sw{self.score_weight}-si{self.sigma_init}"
+            f"-ot{self.ot_method}-reg{self.ot_reg}"
+            f"-sde{self.sde_steps if self.use_sde_inference else 'off'}"
+        )
+        return os.path.join(self.result_path, exp_name)

GRN/SB/run_a1_baseline.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+#PJM -L rscgrp=b-batch
+#PJM -L gpu=1
+#PJM -L elapse=48:00:00
+#PJM -N sb_a1_baseline
+#PJM -j
+#PJM -o logs/a1_%j.out
+
+module load cuda/12.2.2
+module load cudnn/8.9.7
+module load gcc-toolset/12
+
+source /home/hp250092/ku50001222/qian/aivc/lfj/ori_scDFM_env/bin/activate
+
+cd /home/hp250092/ku50001222/qian/aivc/lfj/GRN/SB
+
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256
+
+# === A1: Baseline reproduction (no score, no sigma, exact OT, ODE) ===
+accelerate launch --num_processes=1 scripts/run_sb.py \
+    --data-name norman \
+    --d-model 128 --nhead 8 --nlayers 4 --d-hid 512 \
+    --batch-size 48 --lr 5e-5 --steps 200000 \
+    --fusion-method differential_perceiver \
+    --perturbation-function crisper \
+    --noise-type Gaussian \
+    --infer-top-gene 1000 --n-top-genes 5000 \
+    --use-mmd-loss --gamma 0.5 \
+    --split-method additive --fold 1 --topk 30 --use-negative-edge \
+    --no-use-score \
+    --ot-method exact --no-ot-use-sigma \
+    --no-use-sde-inference --ode-steps 20 --ode-method rk4 \
+    --ema-decay 0.9999 --warmup-steps 2000 \
+    --t-sample-mode logit_normal --t-mean 0.0 --t-std 1.0 \
+    --print-every 5000 --eval-batch-size 32 \
+    --exp-name A1_baseline \
+    --result-path /home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/SB

GRN/SB/run_eval_rk4.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+#PJM -L rscgrp=b-batch
+#PJM -L gpu=1
+#PJM -L elapse=6:00:00
+#PJM -N sb_eval_rk4
+#PJM -j
+#PJM -o /home/hp250092/ku50001222/qian/aivc/lfj/GRN/SB/logs/eval_rk4_%j.out
+
+module load cuda/12.2.2
+module load cudnn/8.9.7
+module load gcc-toolset/12
+
+source /home/hp250092/ku50001222/qian/aivc/lfj/ori_scDFM_env/bin/activate
+
+cd /home/hp250092/ku50001222/qian/aivc/lfj/GRN/SB
+
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256
+
+# === Re-evaluate A1_baseline with torchdiffeq RK4 ODE (was Euler before) ===
+echo "=== Evaluating A1_baseline with RK4 ODE ==="
+accelerate launch --num_processes=1 scripts/run_sb.py \
+    --data-name norman \
+    --d-model 128 --nhead 8 --nlayers 4 --d-hid 512 \
+    --batch-size 48 --lr 5e-5 --steps 200000 \
+    --fusion-method differential_perceiver \
+    --perturbation-function crisper \
+    --noise-type Gaussian \
+    --infer-top-gene 1000 --n-top-genes 5000 \
+    --use-mmd-loss --gamma 0.5 \
+    --split-method additive --fold 1 --topk 30 --use-negative-edge \
+    --no-use-score \
+    --ot-method exact --no-ot-use-sigma \
+    --no-use-sde-inference --ode-steps 20 --ode-method rk4 \
+    --ema-decay 0.9999 --warmup-steps 2000 \
+    --t-sample-mode logit_normal --t-mean 0.0 --t-std 1.0 \
+    --print-every 5000 --eval-batch-size 32 \
+    --exp-name A1_baseline \
+    --result-path /home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/SB \
+    --checkpoint-path /home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/SB/A1_baseline/iteration_195000/checkpoint.pt \
+    --test-only
+
+# === Re-evaluate A6_dsm_aniso with ODE instead of SDE ===
+echo "=== Evaluating A6_dsm_aniso with RK4 ODE (was SDE-50 before) ==="
+accelerate launch --num_processes=1 scripts/run_sb.py \
+    --data-name norman \
+    --d-model 128 --nhead 8 --nlayers 4 --d-hid 512 \
+    --batch-size 48 --lr 5e-5 --steps 200000 \
+    --fusion-method differential_perceiver \
+    --perturbation-function crisper \
+    --noise-type Gaussian \
+    --infer-top-gene 1000 --n-top-genes 5000 \
+    --use-mmd-loss --gamma 0.5 \
+    --split-method additive --fold 1 --topk 30 --use-negative-edge \
+    --use-score --score-weight 0.5 --score-head-depth 2 --score-t-clip 0.02 \
+    --sigma-min 0.01 --sigma-max 2.0 --sigma-init 0.5 \
+    --sigma-base 0.5 --sigma-sparse-weight 0.01 --sigma-volume-weight 0.01 \
+    --ot-method sinkhorn --ot-reg 0.05 --ot-use-sigma \
+    --no-use-sde-inference --ode-steps 20 \
+    --ema-decay 0.9999 --warmup-steps 2000 \
+    --t-sample-mode logit_normal --t-mean 0.0 --t-std 1.0 \
+    --print-every 5000 --eval-batch-size 32 \
+    --exp-name A6_dsm_aniso \
+    --result-path /home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/SB \
+    --checkpoint-path /home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/SB/A6_dsm_aniso/iteration_195000/checkpoint.pt \
+    --test-only

GRN/SB/run_sb.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+#PJM -L rscgrp=b-batch
+#PJM -L gpu=1
+#PJM -L elapse=48:00:00
+#PJM -N sb_a5_full
+#PJM -j
+#PJM -o logs/sb_%j.out
+
+module load cuda/12.2.2
+module load cudnn/8.9.7
+module load gcc-toolset/12
+
+source /home/hp250092/ku50001222/qian/aivc/lfj/ori_scDFM_env/bin/activate
+
+cd /home/hp250092/ku50001222/qian/aivc/lfj/GRN/SB
+
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256
+
+# === A5: Full ASB with SDE inference ===
+accelerate launch --num_processes=1 scripts/run_sb.py \
+    --data-name norman \
+    --d-model 128 --nhead 8 --nlayers 4 --d-hid 512 \
+    --batch-size 48 --lr 5e-5 --steps 200000 \
+    --fusion-method differential_perceiver \
+    --perturbation-function crisper \
+    --noise-type Gaussian \
+    --infer-top-gene 1000 --n-top-genes 5000 \
+    --use-mmd-loss --gamma 0.5 \
+    --split-method additive --fold 1 --topk 30 --use-negative-edge \
+    --sigma-min 0.01 --sigma-max 2.0 --sigma-init 0.5 \
+    --sigma-base 0.5 --sigma-sparse-weight 0.01 --sigma-volume-weight 0.01 \
+    --score-weight 0.1 --score-head-depth 2 --score-t-clip 0.02 --use-score \
+    --ot-method sinkhorn --ot-reg 0.05 --ot-use-sigma \
+    --use-sde-inference --sde-steps 50 \
+    --ema-decay 0.9999 --warmup-steps 2000 \
+    --t-sample-mode logit_normal --t-mean 0.0 --t-std 1.0 \
+    --print-every 5000 --eval-batch-size 32 \
+    --exp-name A5_full_asb_sde \
+    --result-path /home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/SB

GRN/SB/run_sb_a6.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+#PJM -L rscgrp=b-batch
+#PJM -L gpu=1
+#PJM -L elapse=48:00:00
+#PJM -N sb_a6_dsm
+#PJM -j
+#PJM -o logs/sb_%j.out
+
+module load cuda/12.2.2
+module load cudnn/8.9.7
+module load gcc-toolset/12
+
+source /home/hp250092/ku50001222/qian/aivc/lfj/ori_scDFM_env/bin/activate
+
+cd /home/hp250092/ku50001222/qian/aivc/lfj/GRN/SB
+
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256
+
+# === A6: Fixed DSM score loss + anisotropic sigma unlocked ===
+#   vs A5: (1) var_t-weighted score loss (≡ ε-prediction, loss_s ~1 not ~16)
+#          (2) L1 sparse penalty removed from total loss (σ_g free to vary per gene)
+#          (3) score_weight 0.1 → 0.5 (compensate loss_s magnitude drop 16x → 1x)
+accelerate launch --num_processes=1 scripts/run_sb.py \
+    --data-name norman \
+    --d-model 128 --nhead 8 --nlayers 4 --d-hid 512 \
+    --batch-size 48 --lr 5e-5 --steps 200000 \
+    --fusion-method differential_perceiver \
+    --perturbation-function crisper \
+    --noise-type Gaussian \
+    --infer-top-gene 1000 --n-top-genes 5000 \
+    --use-mmd-loss --gamma 0.5 \
+    --split-method additive --fold 1 --topk 30 --use-negative-edge \
+    --sigma-min 0.01 --sigma-max 2.0 --sigma-init 0.5 \
+    --sigma-base 0.5 --sigma-sparse-weight 0.01 --sigma-volume-weight 0.01 \
+    --score-weight 0.5 --score-head-depth 2 --score-t-clip 0.02 --use-score \
+    --ot-method sinkhorn --ot-reg 0.05 --ot-use-sigma \
+    --use-sde-inference --sde-steps 50 \
+    --ema-decay 0.9999 --warmup-steps 2000 \
+    --t-sample-mode logit_normal --t-mean 0.0 --t-std 1.0 \
+    --print-every 5000 --eval-batch-size 32 \
+    --exp-name A6_dsm_aniso \
+    --result-path /home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/SB

GRN/SB/run_sb_sa6.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+#PJM -L rscgrp=b-batch
+#PJM -L gpu=1
+#PJM -L elapse=48:00:00
+#PJM -N sb_sa6_sde
+#PJM -j
+#PJM -o /home/hp250092/ku50001222/qian/aivc/lfj/GRN/SB/logs/sb_sa6_%j.out
+
+module load cuda/12.2.2
+module load cudnn/8.9.7
+module load gcc-toolset/12
+
+source /home/hp250092/ku50001222/qian/aivc/lfj/ori_scDFM_env/bin/activate
+
+cd /home/hp250092/ku50001222/qian/aivc/lfj/GRN/SB
+
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256
+
+# === SA6: Source-Anchored + Score Head + SDE inference ===
+#   对比 SA1 (无 score, ODE): score head 在 source-anchored 下是否有用?
+#   对比 A6 (noise-anchored, score, SDE): source-anchoring 对 SDE 推理的影响?
+accelerate launch --num_processes=1 scripts/run_sb.py \
+    --data-name norman \
+    --d-model 128 --nhead 8 --nlayers 4 --d-hid 512 \
+    --batch-size 48 --lr 5e-5 --steps 200000 \
+    --fusion-method differential_perceiver \
+    --perturbation-function crisper \
+    --noise-type Gaussian \
+    --infer-top-gene 1000 --n-top-genes 5000 \
+    --use-mmd-loss --gamma 0.5 \
+    --split-method additive --fold 1 --topk 30 --use-negative-edge \
+    --sigma-min 0.001 --sigma-max 0.5 --sigma-init 0.01 \
+    --sigma-base 0.01 --sigma-sparse-weight 0.01 --sigma-volume-weight 0.01 \
+    --use-score --score-weight 0.5 --score-head-depth 2 --score-t-clip 0.02 \
+    --ot-method sinkhorn --ot-reg 0.05 --ot-use-sigma \
+    --use-sde-inference --sde-steps 50 \
+    --ema-decay 0.9999 --warmup-steps 2000 \
+    --t-sample-mode uniform \
+    --print-every 5000 --eval-batch-size 32 \
+    --source-anchored \
+    --exp-name SA6_source_anchored_sde \
+    --result-path /home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/SB

GRN/SB/run_sb_source_anchored.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+#PJM -L rscgrp=b-batch
+#PJM -L gpu=1
+#PJM -L elapse=48:00:00
+#PJM -N sb_sa1_ode
+#PJM -j
+#PJM -o /home/hp250092/ku50001222/qian/aivc/lfj/GRN/SB/logs/sb_sa1_%j.out
+
+module load cuda/12.2.2
+module load cudnn/8.9.7
+module load gcc-toolset/12
+
+source /home/hp250092/ku50001222/qian/aivc/lfj/ori_scDFM_env/bin/activate
+
+cd /home/hp250092/ku50001222/qian/aivc/lfj/GRN/SB
+
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256
+
+# === SA1: Source-Anchored Bridge, no score head, ODE inference ===
+#   x_0 = source (control cells), not random noise
+#   sigma ~100x smaller (0.01 vs 0.5) to match perturbation effect scale
+#   OT couples control <-> perturbed cells (biologically meaningful)
+#   uniform time sampling (short trajectory, all timesteps equally important)
+accelerate launch --num_processes=1 scripts/run_sb.py \
+    --data-name norman \
+    --d-model 128 --nhead 8 --nlayers 4 --d-hid 512 \
+    --batch-size 48 --lr 5e-5 --steps 200000 \
+    --fusion-method differential_perceiver \
+    --perturbation-function crisper \
+    --noise-type Gaussian \
+    --infer-top-gene 1000 --n-top-genes 5000 \
+    --use-mmd-loss --gamma 0.5 \
+    --split-method additive --fold 1 --topk 30 --use-negative-edge \
+    --sigma-min 0.001 --sigma-max 0.5 --sigma-init 0.01 \
+    --sigma-base 0.01 --sigma-sparse-weight 0.01 --sigma-volume-weight 0.01 \
+    --no-use-score \
+    --ot-method sinkhorn --ot-reg 0.05 --ot-use-sigma \
+    --no-use-sde-inference --ode-steps 20 \
+    --ema-decay 0.9999 --warmup-steps 2000 \
+    --t-sample-mode uniform \
+    --print-every 5000 --eval-batch-size 32 \
+    --source-anchored \
+    --exp-name SA1_source_anchored_ode \
+    --result-path /home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/SB

GRN/SB/scripts/run_sb.py

@@ -0,0 +1,366 @@
+"""
+Training and evaluation entry point for Anisotropic Schrödinger Bridge (SB).
+
+Simplified from grn_svd: no latent stream, no sparse cache, no SVD dict.
+Single-stage generation with SDE (or PF-ODE ablation).
+"""
+
+import sys
+import os
+
+_PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, _PROJECT_ROOT)
+
+import _bootstrap_scdfm  # noqa: F401
+
+import copy
+import csv
+import torch
+import tyro
+import tqdm
+import numpy as np
+import pandas as pd
+import anndata as ad
+from torch.utils.data import DataLoader
+from tqdm import trange
+from accelerate import Accelerator, DistributedDataParallelKwargs
+from torch.optim.lr_scheduler import LinearLR, CosineAnnealingLR, SequentialLR
+from torch.utils.tensorboard import SummaryWriter
+
+from config.config_sb import SBConfig as Config
+from src.data.data import get_data_classes
+from src.model.model import SBModel
+from src.denoiser import SBDenoiser
+from src.utils import (
+    save_checkpoint, load_checkpoint, pick_eval_score,
+    process_vocab, set_requires_grad_for_p_only, GeneVocab,
+)
+from cell_eval import MetricsEvaluator
+
+_REPO_ROOT = os.path.normpath(os.path.join(_PROJECT_ROOT, "..", "..", "transfer", "code"))
+
+
+@torch.inference_mode()
+def test(data_sampler, denoiser, accelerator, config, vocab, data_manager,
+         batch_size=32, path_dir="./"):
+    """Evaluate: generate predictions and compute cell-eval metrics."""
+    device = accelerator.device
+    gene_ids_test = vocab.encode(list(data_sampler.adata.var_names))
+    gene_ids_test = torch.tensor(gene_ids_test, dtype=torch.long, device=device)
+
+    perturbation_name_list = data_sampler._perturbation_covariates
+    control_data = data_sampler.get_control_data()
+    inverse_dict = {v: str(k) for k, v in data_manager.perturbation_dict.items()}
+
+    all_pred = [control_data["src_cell_data"]]
+    obs_pred = ["control"] * control_data["src_cell_data"].shape[0]
+    all_real = [control_data["src_cell_data"]]
+    obs_real = ["control"] * control_data["src_cell_data"].shape[0]
+
+    for pert_name in perturbation_name_list:
+        pert_data = data_sampler.get_perturbation_data(pert_name)
+        target = pert_data["tgt_cell_data"]
+        pert_id = pert_data["condition_id"].to(device)
+        source = control_data["src_cell_data"].to(device)
+
+        if config.perturbation_function == "crisper":
+            pert_name_crisper = [
+                inverse_dict[int(p)] for p in pert_id[0].cpu().numpy()
+            ]
+            pert_id = torch.tensor(
+                vocab.encode(pert_name_crisper), dtype=torch.long, device=device
+            ).repeat(source.shape[0], 1)
+
+        idx = torch.randperm(source.shape[0])
+        source = source[idx][:128]
+
+        preds = []
+        for i in trange(0, 128, batch_size, desc=pert_name):
+            bs = source[i:i+batch_size]
+            bp = pert_id[0].repeat(bs.shape[0], 1).to(device)
+            model = denoiser.module if hasattr(denoiser, "module") else denoiser
+            pred = model.generate(
+                bs, bp, gene_ids_test,
+                steps=config.sde_steps if config.use_sde_inference else config.ode_steps,
+                method="sde" if config.use_sde_inference else "ode",
+            )
+            preds.append(pred)
+
+        preds = torch.cat(preds, 0).cpu().numpy()
+        all_pred.append(preds)
+        all_real.append(target)
+        obs_pred.extend([pert_name] * preds.shape[0])
+        obs_real.extend([pert_name] * target.shape[0])
+
+    all_pred = np.concatenate(all_pred, 0)
+    all_real = np.concatenate(all_real, 0)
+    pred_adata = ad.AnnData(X=all_pred, obs=pd.DataFrame({"perturbation": obs_pred}))
+    real_adata = ad.AnnData(X=all_real, obs=pd.DataFrame({"perturbation": obs_real}))
+
+    eval_score = None
+    if accelerator.is_main_process:
+        evaluator = MetricsEvaluator(
+            adata_pred=pred_adata, adata_real=real_adata,
+            control_pert="control", pert_col="perturbation", num_threads=32,
+        )
+        results, agg_results = evaluator.compute()
+        results.write_csv(os.path.join(path_dir, "results.csv"))
+        agg_results.write_csv(os.path.join(path_dir, "agg_results.csv"))
+        pred_adata.write_h5ad(os.path.join(path_dir, "pred.h5ad"))
+        real_adata.write_h5ad(os.path.join(path_dir, "real.h5ad"))
+        df = agg_results.to_pandas()
+        for m in ("mse", "pearson_delta", "pr_auc"):
+            if m in df.columns and df[m].notna().any():
+                eval_score = float(df[m].iloc[0])
+                break
+        if eval_score is not None:
+            print(f"Eval score: {eval_score:.4f}")
+
+    return eval_score
+
+
+if __name__ == "__main__":
+    config = tyro.cli(Config)
+
+    ddp_kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
+    accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])
+    if accelerator.is_main_process:
+        print(config)
+        save_path = config.make_path()
+        os.makedirs(save_path, exist_ok=True)
+    device = accelerator.device
+
+    # === Data loading ===
+    Data, PerturbationDataset, TrainSampler, TestDataset = get_data_classes()
+    scdfm_data_path = os.path.join(_REPO_ROOT, "scDFM", "data")
+    data_manager = Data(scdfm_data_path)
+    data_manager.load_data(config.data_name)
+
+    if "gene_name" in data_manager.adata.var.columns and data_manager.adata.var_names[0].startswith("ENSG"):
+        data_manager.adata.var_names = data_manager.adata.var["gene_name"].values
+        data_manager.adata.var_names_make_unique()
+
+    data_manager.process_data(
+        n_top_genes=config.n_top_genes,
+        split_method=config.split_method,
+        fold=config.fold,
+        use_negative_edge=config.use_negative_edge,
+        k=config.topk,
+    )
+    train_sampler, valid_sampler, _ = data_manager.load_flow_data(batch_size=config.batch_size)
+
+    # === Mask path ===
+    if config.use_negative_edge:
+        mask_path = os.path.join(
+            data_manager.data_path, data_manager.data_name,
+            f"mask_fold_{config.fold}topk_{config.topk}{config.split_method}_negative_edge.pt",
+        )
+    else:
+        mask_path = os.path.join(
+            data_manager.data_path, data_manager.data_name,
+            f"mask_fold_{config.fold}topk_{config.topk}{config.split_method}.pt",
+        )
+
+    # === Vocab ===
+    orig_cwd = os.getcwd()
+    os.chdir(os.path.join(_REPO_ROOT, "scDFM"))
+    vocab = process_vocab(data_manager, config)
+    os.chdir(orig_cwd)
+
+    gene_ids = vocab.encode(list(data_manager.adata.var_names))
+    gene_ids = torch.tensor(gene_ids, dtype=torch.long, device=device)
+
+    # === Build SBModel ===
+    vf = SBModel(
+        ntoken=len(vocab),
+        d_model=config.d_model,
+        nhead=config.nhead,
+        d_hid=config.d_hid,
+        nlayers=config.nlayers,
+        fusion_method=config.fusion_method,
+        perturbation_function=config.perturbation_function,
+        mask_path=mask_path,
+        sigma_min=config.sigma_min,
+        sigma_max=config.sigma_max,
+        sigma_init=config.sigma_init,
+        sigma_hidden_dim=config.sigma_hidden_dim,
+        sigma_num_layers=config.sigma_num_layers,
+        score_head_depth=config.score_head_depth,
+        use_score=config.use_score,
+    )
+
+    # === Simple PerturbationDataset (no sparse cache needed) ===
+    base_dataset = PerturbationDataset(train_sampler, config.batch_size)
+    dataloader = DataLoader(
+        base_dataset, batch_size=1, shuffle=False,
+        num_workers=4, pin_memory=True, persistent_workers=True,
+    )
+
+    # === Build SBDenoiser ===
+    denoiser = SBDenoiser(
+        model=vf,
+        noise_type=config.noise_type,
+        use_mmd_loss=config.use_mmd_loss,
+        gamma=config.gamma,
+        poisson_alpha=config.poisson_alpha,
+        poisson_target_sum=config.poisson_target_sum,
+        score_weight=config.score_weight,
+        score_t_clip=config.score_t_clip,
+        use_score=config.use_score,
+        sigma_base=config.sigma_base,
+        sigma_sparse_weight=config.sigma_sparse_weight,
+        sigma_volume_weight=config.sigma_volume_weight,
+        ot_method=config.ot_method,
+        ot_reg=config.ot_reg,
+        ot_use_sigma=config.ot_use_sigma,
+        sigma_min=config.sigma_min,
+        t_sample_mode=config.t_sample_mode,
+        t_mean=config.t_mean,
+        t_std=config.t_std,
+        sde_steps=config.sde_steps,
+        use_sde_inference=config.use_sde_inference,
+        source_anchored=config.source_anchored,
+    )
+
+    # === EMA model ===
+    ema_model = copy.deepcopy(vf).to(device)
+    ema_model.eval()
+    ema_model.requires_grad_(False)
+
+    # === Optimizer & Scheduler ===
+    save_path = config.make_path()
+    optimizer = torch.optim.Adam(vf.parameters(), lr=config.lr)
+    warmup_scheduler = LinearLR(optimizer, start_factor=1e-3, end_factor=1.0, total_iters=config.warmup_steps)
+    cosine_scheduler = CosineAnnealingLR(optimizer, T_max=max(config.steps - config.warmup_steps, 1), eta_min=config.eta_min)
+    scheduler = SequentialLR(optimizer, [warmup_scheduler, cosine_scheduler], milestones=[config.warmup_steps])
+
+    start_iteration = 0
+    if config.checkpoint_path != "":
+        start_iteration, _ = load_checkpoint(config.checkpoint_path, vf, optimizer, scheduler)
+        ema_model.load_state_dict(vf.state_dict())
+
+    # === Prepare with accelerator ===
+    denoiser = accelerator.prepare(denoiser)
+    optimizer, scheduler, dataloader = accelerator.prepare(optimizer, scheduler, dataloader)
+
+    inverse_dict = {v: str(k) for k, v in data_manager.perturbation_dict.items()}
+
+    # === Test-only mode ===
+    if config.test_only:
+        eval_path = os.path.join(save_path, "eval_only")
+        os.makedirs(eval_path, exist_ok=True)
+        eval_score = test(
+            valid_sampler, denoiser, accelerator, config, vocab, data_manager,
+            batch_size=config.eval_batch_size, path_dir=eval_path,
+        )
+        sys.exit(0)
+
+    # === Loss logging ===
+    if accelerator.is_main_process:
+        os.makedirs(save_path, exist_ok=True)
+        csv_path = os.path.join(save_path, 'loss_curve.csv')
+        csv_file = open(csv_path, 'a' if start_iteration > 0 and os.path.exists(csv_path) else 'w', newline='')
+        csv_writer = csv.writer(csv_file)
+        if start_iteration == 0 or not os.path.exists(csv_path):
+            csv_writer.writerow([
+                'iteration', 'loss', 'loss_v', 'loss_s', 'loss_mmd',
+                'loss_sparse', 'loss_volume', 'sigma_mean', 'sigma_std', 'lr',
+            ])
+        tb_writer = SummaryWriter(log_dir=os.path.join(save_path, 'tb_logs'))
+
+    # === Training loop ===
+    pbar = tqdm.tqdm(total=config.steps, initial=start_iteration)
+    iteration = start_iteration
+
+    while iteration < config.steps:
+        for batch_data in dataloader:
+            source = batch_data["src_cell_data"].squeeze(0).to(device)
+            target = batch_data["tgt_cell_data"].squeeze(0).to(device)
+            perturbation_id = batch_data["condition_id"].squeeze(0).to(device)
+
+            # Random gene subset (same as scDFM)
+            G_full = source.shape[-1]
+            input_gene_ids_pos = torch.randperm(G_full, device=device)[:config.infer_top_gene]
+            source_sub = source[:, input_gene_ids_pos]
+            target_sub = target[:, input_gene_ids_pos]
+            gene_ids_sub = gene_ids[input_gene_ids_pos]
+
+            if config.perturbation_function == "crisper":
+                pert_name = [inverse_dict[int(p)] for p in perturbation_id[0].cpu().numpy()]
+                perturbation_id = torch.tensor(
+                    vocab.encode(pert_name), dtype=torch.long, device=device
+                ).repeat(source_sub.shape[0], 1)
+
+            base_denoiser = denoiser.module if hasattr(denoiser, "module") else denoiser
+            base_denoiser.model.train()
+
+            B = source_sub.shape[0]
+            gene_input = gene_ids_sub.unsqueeze(0).expand(B, -1)
+
+            loss_dict = base_denoiser.train_step(source_sub, target_sub, perturbation_id, gene_input)
+
+            loss = loss_dict["loss"]
+            optimizer.zero_grad(set_to_none=True)
+            accelerator.backward(loss)
+            optimizer.step()
+            scheduler.step()
+
+            # EMA update
+            with torch.no_grad():
+                for ema_p, model_p in zip(ema_model.parameters(), vf.parameters()):
+                    ema_p.lerp_(model_p.data, 1 - config.ema_decay)
+
+            # Checkpoint & eval
+            if iteration % config.print_every == 0:
+                save_path_ = os.path.join(save_path, f"iteration_{iteration}")
+                os.makedirs(save_path_, exist_ok=True)
+                if accelerator.is_main_process:
+                    save_checkpoint(
+                        model=ema_model, optimizer=optimizer, scheduler=scheduler,
+                        iteration=iteration, eval_score=None,
+                        save_path=save_path_, is_best=False,
+                    )
+                if iteration + config.print_every >= config.steps:
+                    orig_state = copy.deepcopy(vf.state_dict())
+                    vf.load_state_dict(ema_model.state_dict())
+                    eval_score = test(
+                        valid_sampler, denoiser, accelerator, config, vocab, data_manager,
+                        batch_size=config.eval_batch_size, path_dir=save_path_,
+                    )
+                    vf.load_state_dict(orig_state)
+                    if accelerator.is_main_process and eval_score is not None:
+                        tb_writer.add_scalar('eval/score', eval_score, iteration)
+
+            # Logging
+            if accelerator.is_main_process:
+                lr = scheduler.get_last_lr()[0]
+                csv_writer.writerow([
+                    iteration, loss.item(),
+                    loss_dict["loss_v"].item(), loss_dict["loss_s"].item(),
+                    loss_dict["loss_mmd"].item(),
+                    loss_dict["loss_sparse"].item(), loss_dict["loss_volume"].item(),
+                    loss_dict["sigma_mean"].item(), loss_dict["sigma_std"].item(), lr,
+                ])
+                if iteration % 100 == 0:
+                    csv_file.flush()
+                tb_writer.add_scalar('loss/total', loss.item(), iteration)
+                tb_writer.add_scalar('loss/velocity', loss_dict["loss_v"].item(), iteration)
+                tb_writer.add_scalar('loss/score', loss_dict["loss_s"].item(), iteration)
+                tb_writer.add_scalar('loss/mmd', loss_dict["loss_mmd"].item(), iteration)
+                tb_writer.add_scalar('sigma/mean', loss_dict["sigma_mean"].item(), iteration)
+                tb_writer.add_scalar('sigma/std', loss_dict["sigma_std"].item(), iteration)
+                tb_writer.add_scalar('lr', lr, iteration)
+
+            accelerator.wait_for_everyone()
+            pbar.update(1)
+            pbar.set_description(
+                f"L={loss.item():.4f} v={loss_dict['loss_v'].item():.3f} "
+                f"s={loss_dict['loss_s'].item():.3f} σ={loss_dict['sigma_mean'].item():.3f}"
+            )
+            iteration += 1
+            if iteration >= config.steps:
+                break
+
+    if accelerator.is_main_process:
+        csv_file.close()
+        tb_writer.close()

GRN/SB/src/_scdfm_imports.py

@@ -0,0 +1,50 @@
+"""
+Central import hub for scDFM modules.
+Requires _bootstrap_scdfm to have been imported first (at script entry point).
+"""
+
+import sys
+
+# Ensure bootstrap has run
+if "scdfm_src" not in sys.modules:
+    import os
+    sys.path.insert(0, os.path.normpath(os.path.join(os.path.dirname(__file__), "..")))
+    import _bootstrap_scdfm
+
+import scdfm_src.models.origin.layers as _layers
+import scdfm_src.models.origin.model as _model
+import scdfm_src.flow_matching.path as _fm_path
+import scdfm_src.flow_matching.path.scheduler.scheduler as _scheduler
+import scdfm_src.utils.utils as _utils
+import scdfm_src.tokenizer.gene_tokenizer as _tokenizer
+# === scDFM Layers ===
+GeneadaLN = _layers.GeneadaLN
+ContinuousValueEncoder = _layers.ContinuousValueEncoder
+GeneEncoder = _layers.GeneEncoder
+BatchLabelEncoder = _layers.BatchLabelEncoder
+TimestepEmbedder = _layers.TimestepEmbedder
+ExprDecoder = _layers.ExprDecoder
+
+# === scDFM Blocks ===
+DifferentialTransformerBlock = _model.DifferentialTransformerBlock
+PerceiverBlock = _model.PerceiverBlock
+DiffPerceiverBlock = _model.DiffPerceiverBlock
+
+# === scDFM Flow Matching ===
+AffineProbPath = _fm_path.AffineProbPath
+CondOTScheduler = _scheduler.CondOTScheduler
+
+# === scDFM Utils ===
+save_checkpoint = _utils.save_checkpoint
+load_checkpoint = _utils.load_checkpoint
+make_lognorm_poisson_noise = _utils.make_lognorm_poisson_noise
+pick_eval_score = _utils.pick_eval_score
+process_vocab = _utils.process_vocab
+set_requires_grad_for_p_only = _utils.set_requires_grad_for_p_only
+get_perturbation_emb = _utils.get_perturbation_emb
+
+# === scDFM Tokenizer ===
+GeneVocab = _tokenizer.GeneVocab
+
+# === scDFM Data ===
+# Data loading handled separately in CCFM (scDFM data module has heavy deps)

GRN/SB/src/data/data.py

@@ -0,0 +1,112 @@
+"""
+Data loading for grn_svd.
+Imports scDFM Data/PerturbationDataset by temporarily swapping sys.modules
+so that scDFM's 'src.*' packages are visible during import.
+"""
+
+import sys
+import os
+
+import torch
+from torch.utils.data import Dataset
+
+_SCDFM_ROOT = os.path.normpath(
+    os.path.join(os.path.dirname(__file__), "..", "..", "..", "..", "transfer", "code", "scDFM")
+)
+
+# Cache to avoid repeated imports
+_cached_classes = {}
+
+
+def get_data_classes():
+    """Lazily import scDFM data classes with proper module isolation."""
+    if _cached_classes:
+        return (
+            _cached_classes["Data"],
+            _cached_classes["PerturbationDataset"],
+            _cached_classes["TrainSampler"],
+            _cached_classes["TestDataset"],
+        )
+
+    # Save CCFM's src modules
+    saved = {}
+    for key in list(sys.modules.keys()):
+        if key == "src" or key.startswith("src."):
+            saved[key] = sys.modules.pop(key)
+
+    # Ensure __init__.py exists for scDFM data_process
+    for d in ["src", "src/data_process", "src/utils", "src/tokenizer"]:
+        init_path = os.path.join(_SCDFM_ROOT, d, "__init__.py")
+        if not os.path.exists(init_path):
+            os.makedirs(os.path.dirname(init_path), exist_ok=True)
+            with open(init_path, "w") as f:
+                f.write("# Auto-created by CCFM\n")
+
+    sys.path.insert(0, _SCDFM_ROOT)
+    try:
+        from src.data_process.data import Data, PerturbationDataset, TrainSampler, TestDataset
+        _cached_classes["Data"] = Data
+        _cached_classes["PerturbationDataset"] = PerturbationDataset
+        _cached_classes["TrainSampler"] = TrainSampler
+        _cached_classes["TestDataset"] = TestDataset
+    finally:
+        # Remove scDFM's src.* entries
+        for key in list(sys.modules.keys()):
+            if (key == "src" or key.startswith("src.")) and not key.startswith("scdfm_"):
+                del sys.modules[key]
+
+        # Restore CCFM's src modules
+        for key, mod in saved.items():
+            sys.modules[key] = mod
+
+        if _SCDFM_ROOT in sys.path:
+            sys.path.remove(_SCDFM_ROOT)
+
+    return Data, PerturbationDataset, TrainSampler, TestDataset
+
+
+class GRNDatasetWrapper(Dataset):
+    """
+    Wraps scDFM PerturbationDataset to produce sparse delta triplets.
+
+    Returns delta_values (B, G_sub, K) and delta_indices (B, G_sub, K)
+    instead of dense z_target (B, G_sub, G_sub).
+    SVD projection happens on GPU in denoiser.train_step().
+    """
+
+    def __init__(self, base_dataset, sparse_cache, gene_ids_cpu, infer_top_gene):
+        self.base = base_dataset          # scDFM PerturbationDataset
+        self.sparse_cache = sparse_cache  # SparseDeltaCache (multi-process safe)
+        self.gene_ids = gene_ids_cpu      # (G_full,) CPU tensor — vocab-encoded gene IDs
+        self.infer_top_gene = infer_top_gene
+
+    def __len__(self):
+        return len(self.base)
+
+    def __getitem__(self, idx):
+        batch = self.base[idx]
+
+        # 1. Random gene subset
+        G_full = batch["src_cell_data"].shape[-1]
+        input_gene_ids = torch.randperm(G_full)[:self.infer_top_gene]
+
+        # 2. Sparse cache lookup → sparse triplets (runs in worker process)
+        src_names = batch["src_cell_id"]
+        tgt_names = batch["tgt_cell_id"]
+        if src_names and isinstance(src_names[0], (tuple, list)):
+            src_names = [n[0] for n in src_names]
+            tgt_names = [n[0] for n in tgt_names]
+        delta_values, delta_indices = self.sparse_cache.lookup_delta(
+            src_names, tgt_names, input_gene_ids, device=torch.device("cpu")
+        )  # delta_values: (B, G_sub, K), delta_indices: (B, G_sub, K) int16
+
+        # 3. Subset expression data
+        return {
+            "src_cell_data": batch["src_cell_data"][:, input_gene_ids],   # (B, G_sub)
+            "tgt_cell_data": batch["tgt_cell_data"][:, input_gene_ids],   # (B, G_sub)
+            "condition_id": batch["condition_id"],                         # (B, 2)
+            "delta_values": delta_values,                                  # (B, G_sub, K)
+            "delta_indices": delta_indices,                                # (B, G_sub, K) int16
+            "gene_ids_sub": self.gene_ids[input_gene_ids],                 # (G_sub,)
+            "input_gene_ids": input_gene_ids,                              # (G_sub,)
+        }

GRN/SB/src/denoiser.py

@@ -0,0 +1,297 @@
+"""
+SBDenoiser — Anisotropic Schrödinger Bridge denoiser.
+
+Training: Joint velocity + score matching with anisotropic bridge paths.
+          v_θ target = x_T - x₀ (PF-ODE velocity, same as scDFM).
+          s_θ target = -(x_t - μ_t) / var_t (conditional score).
+          Minibatch anisotropic OT per step.
+
+Inference: Euler-Maruyama SDE using drift = v_θ + (σ²/2)·s_θ.
+           Or PF-ODE ablation: drift = v_θ.
+"""
+
+import math
+import torch
+import torch.nn as nn
+import torchdiffeq
+
+from ._scdfm_imports import make_lognorm_poisson_noise
+from .model.model import SBModel
+from .ot_anisotropic import AnisotropicOTSampler
+
+
+def pairwise_sq_dists(X, Y):
+    return torch.cdist(X, Y, p=2) ** 2
+
+
+@torch.no_grad()
+def median_sigmas(X, scales=(0.5, 1.0, 2.0, 4.0)):
+    D2 = pairwise_sq_dists(X, X)
+    tri = D2[~torch.eye(D2.size(0), dtype=bool, device=D2.device)]
+    m = torch.median(tri).clamp_min(1e-12)
+    s2 = torch.tensor(scales, device=X.device) * m
+    return [float(s.item()) for s in torch.sqrt(s2)]
+
+
+def mmd2_unbiased_multi_sigma(X, Y, sigmas):
+    m, n = X.size(0), Y.size(0)
+    Dxx = pairwise_sq_dists(X, X)
+    Dyy = pairwise_sq_dists(Y, Y)
+    Dxy = pairwise_sq_dists(X, Y)
+    vals = []
+    for sigma in sigmas:
+        beta = 1.0 / (2.0 * (sigma ** 2) + 1e-12)
+        Kxx = torch.exp(-beta * Dxx)
+        Kyy = torch.exp(-beta * Dyy)
+        Kxy = torch.exp(-beta * Dxy)
+        term_xx = (Kxx.sum() - Kxx.diag().sum()) / (m * (m - 1) + 1e-12)
+        term_yy = (Kyy.sum() - Kyy.diag().sum()) / (n * (n - 1) + 1e-12)
+        term_xy = Kxy.mean()
+        vals.append(term_xx + term_yy - 2.0 * term_xy)
+    return torch.stack(vals).mean()
+
+
+class SBDenoiser(nn.Module):
+    """
+    Anisotropic Schrödinger Bridge Denoiser.
+
+    σ_g simultaneously controls:
+    1. OT coupling cost (Mahalanobis weights)
+    2. Bridge noise level (conditional bridge variance)
+    3. SDE diffusion strength (Euler-Maruyama noise)
+    """
+
+    def __init__(
+        self,
+        model: SBModel,
+        noise_type: str = "Gaussian",
+        use_mmd_loss: bool = True,
+        gamma: float = 0.5,
+        poisson_alpha: float = 0.8,
+        poisson_target_sum: float = 1e4,
+        # Score training
+        score_weight: float = 0.1,
+        score_t_clip: float = 0.02,
+        use_score: bool = True,
+        # σ_g regularization
+        sigma_base: float = 0.5,
+        sigma_sparse_weight: float = 0.01,
+        sigma_volume_weight: float = 0.01,
+        # OT coupling
+        ot_method: str = "sinkhorn",
+        ot_reg: float = 0.05,
+        ot_use_sigma: bool = True,
+        sigma_min: float = 0.01,
+        # Time sampling
+        t_sample_mode: str = "logit_normal",
+        t_mean: float = 0.0,
+        t_std: float = 1.0,
+        # SDE inference
+        sde_steps: int = 50,
+        use_sde_inference: bool = True,
+        # Source-Anchored Bridge
+        source_anchored: bool = False,
+    ):
+        super().__init__()
+        self.model = model
+        self.noise_type = noise_type
+        self.use_mmd_loss = use_mmd_loss
+        self.gamma = gamma
+        self.poisson_alpha = poisson_alpha
+        self.poisson_target_sum = poisson_target_sum
+        self.score_weight = score_weight
+        self.score_t_clip = score_t_clip
+        self.use_score = use_score
+        self.sigma_base = sigma_base
+        self.sigma_sparse_weight = sigma_sparse_weight
+        self.sigma_volume_weight = sigma_volume_weight
+        self.ot_use_sigma = ot_use_sigma
+        self.t_sample_mode = t_sample_mode
+        self.t_mean = t_mean
+        self.t_std = t_std
+        self.sde_steps = sde_steps
+        self.use_sde_inference = use_sde_inference
+        self.source_anchored = source_anchored
+
+        self.ot_sampler = AnisotropicOTSampler(
+            method=ot_method, reg=ot_reg, sigma_min=sigma_min,
+        )
+
+    def _make_noise(self, source: torch.Tensor) -> torch.Tensor:
+        if self.noise_type == "Gaussian":
+            return torch.randn_like(source)
+        elif self.noise_type == "Poisson":
+            return make_lognorm_poisson_noise(
+                target_log=source,
+                alpha=self.poisson_alpha,
+                per_cell_L=self.poisson_target_sum,
+            )
+        else:
+            raise ValueError(f"Unknown noise_type: {self.noise_type}")
+
+    def _sample_t(self, n: int, device: torch.device) -> torch.Tensor:
+        if self.t_sample_mode == "logit_normal":
+            t = torch.sigmoid(torch.randn(n, device=device) * self.t_std + self.t_mean)
+        else:
+            t = torch.rand(n, device=device)
+        return t.clamp(self.score_t_clip, 1.0 - self.score_t_clip)
+
+    def train_step(
+        self,
+        source: torch.Tensor,            # (B, G) control expression
+        target: torch.Tensor,             # (B, G) perturbed expression
+        perturbation_id: torch.Tensor,    # (B, n_pert)
+        gene_input: torch.Tensor,         # (B, G) vocab-encoded gene IDs
+    ) -> dict:
+        """
+        Single training step with anisotropic bridge + minibatch OT.
+        """
+        B = source.shape[0]
+        device = source.device
+
+        # 1. Sample time
+        t = self._sample_t(B, device)                                    # (B,)
+        t_col = t.unsqueeze(-1)                                          # (B, 1)
+
+        # 2. Get σ_g from sigma_net (independent of backbone)
+        #    Need gene_emb and pert_emb — compute them via the model's encoder
+        with torch.no_grad():
+            gene_emb = self.model.encoder(gene_input)                    # (B, G, d)
+            pert_emb = self.model.get_perturbation_emb(
+                perturbation_id, cell_1=source)                          # (B, d)
+        # σ_g with gradient (for regularization loss)
+        sigma_g = self.model.sigma_net(pert_emb, t, gene_emb)           # (B, G)
+        sigma_g_det = sigma_g.detach()                                   # for bridge sampling
+
+        # 3. Create x_0 and do minibatch anisotropic OT
+        if self.source_anchored:
+            x_0 = source                                                  # bridge from control
+        else:
+            x_0 = self._make_noise(source)                                # bridge from noise
+        if self.ot_use_sigma:
+            sigma_for_ot = sigma_g_det.mean(0)                            # (G,) batch mean
+            x_0, target_matched = self.ot_sampler.sample_plan_fix_x0(
+                x_0, target, sigma_for_ot)
+        else:
+            x_0, target_matched = self.ot_sampler.sample_plan_fix_x0(
+                x_0, target, sigma_g=None)
+
+        # 4. Anisotropic conditional bridge sampling
+        mu_t = (1 - t_col) * x_0 + t_col * target_matched               # (B, G)
+        var_t = (sigma_g_det ** 2 * (t_col * (1 - t_col))).clamp(min=1e-8)
+        std_t = torch.sqrt(var_t)                                         # (B, G)
+        eps = torch.randn_like(x_0)
+        x_t = mu_t + std_t * eps                                          # (B, G)
+
+        # 5. Targets
+        v_target = target_matched - x_0                                    # source-anchored: Δ
+        s_target = -eps / (std_t + 1e-8)                                   # conditional score
+
+        # 6. Full model forward
+        pred_v, pred_s, sigma_g_pred = self.model(
+            gene_input, source, x_t, t, perturbation_id)
+
+        # 7. Velocity loss
+        loss_v = ((pred_v - v_target) ** 2).mean()
+
+        # 8. Score loss (var_t-weighted DSM — equivalent to ε-prediction)
+        #    var_t weighting cancels the 1/var_t in s_target, giving bounded loss ~O(1)
+        loss_s = torch.tensor(0.0, device=device)
+        if self.use_score and pred_s is not None:
+            loss_s = (var_t * (pred_s - s_target) ** 2).mean()
+
+        # 9. σ_g regularization
+        #    Volume penalty anchors geometric mean at σ_base (global scale).
+        #    L1 sparse penalty removed — it killed per-gene anisotropy by
+        #    pulling every σ_g to σ_base.  Sigmoid [σ_min, σ_max] prevents
+        #    collapse/explosion; volume penalty alone is sufficient.
+        loss_sparse = (sigma_g_pred - self.sigma_base).abs().mean()  # monitor only
+        loss_volume = (sigma_g_pred.log().mean() - math.log(self.sigma_base)) ** 2
+
+        # 10. MMD loss (optional)
+        loss_mmd = torch.tensor(0.0, device=device)
+        if self.use_mmd_loss:
+            x1_hat = x_t + pred_v * (1 - t_col)
+            sigmas_mmd = median_sigmas(target_matched, scales=(0.5, 1.0, 2.0, 4.0))
+            loss_mmd = mmd2_unbiased_multi_sigma(x1_hat, target_matched, sigmas_mmd)
+
+        # 11. Total loss
+        #    loss_sparse excluded — kept in return dict for monitoring
+        loss = (
+            loss_v
+            + self.score_weight * loss_s
+            + self.sigma_volume_weight * loss_volume
+            + self.gamma * loss_mmd
+        )
+
+        return {
+            "loss": loss,
+            "loss_v": loss_v.detach(),
+            "loss_s": loss_s.detach(),
+            "loss_mmd": loss_mmd.detach(),
+            "loss_sparse": loss_sparse.detach(),
+            "loss_volume": loss_volume.detach(),
+            "sigma_mean": sigma_g_pred.mean().detach(),
+            "sigma_std": sigma_g_pred.std().detach(),
+        }
+
+    @torch.no_grad()
+    def generate(
+        self,
+        source: torch.Tensor,            # (B, G)
+        perturbation_id: torch.Tensor,    # (B, n_pert)
+        gene_ids: torch.Tensor,           # (B, G) or (G,)
+        steps: int = None,
+        method: str = "sde",
+    ) -> torch.Tensor:
+        """
+        Generate perturbed expression via SDE or PF-ODE.
+
+        SDE:    dX = [v_θ + (σ²/2)·s_θ] dt + σ·dB  (Euler-Maruyama)
+        PF-ODE: dx/dt = v_θ                          (torchdiffeq RK4)
+        """
+        B, G = source.shape
+        device = source.device
+        steps = steps or self.sde_steps
+
+        if gene_ids.dim() == 1:
+            gene_ids = gene_ids.unsqueeze(0).expand(B, -1)
+
+        if self.source_anchored:
+            x_0 = source.clone()                                          # start from control
+        else:
+            x_0 = self._make_noise(source)                                # start from noise
+
+        use_sde = self.use_sde_inference and (method != "ode")
+
+        if use_sde:
+            # SDE: Euler-Maruyama (no high-order SDE solver available)
+            x_t = x_0
+            dt = 1.0 / steps
+            for i in range(steps):
+                t_val = i * dt
+                t = torch.full((B,), t_val, device=device)
+                pred_v, pred_s, sigma_g = self.model(
+                    gene_ids, source, x_t, t, perturbation_id)
+                if pred_s is not None:
+                    drift = pred_v + 0.5 * sigma_g ** 2 * pred_s
+                    diffusion_noise = sigma_g * math.sqrt(dt) * torch.randn_like(x_t)
+                    x_t = x_t + drift * dt + diffusion_noise
+                else:
+                    x_t = x_t + pred_v * dt
+        else:
+            # PF-ODE: torchdiffeq RK4 (matches scDFM inference)
+            def ode_func(t_scalar, x):
+                t_batch = torch.full((B,), t_scalar.item(), device=device)
+                pred_v, _, _ = self.model(
+                    gene_ids, source, x, t_batch, perturbation_id)
+                return pred_v
+
+            t_span = torch.linspace(0, 1, steps, device=device)
+            trajectory = torchdiffeq.odeint(
+                ode_func, x_0, t_span,
+                method="rk4", atol=1e-4, rtol=1e-4,
+            )
+            x_t = trajectory[-1]
+
+        return torch.clamp(x_t, min=0)

GRN/SB/src/model/layers.py

@@ -0,0 +1,111 @@
+"""
+ASB layers: AnisotropicSigmaNet and ScoreDecoder.
+"""
+
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .._scdfm_imports import TimestepEmbedder
+
+
+class AnisotropicSigmaNet(nn.Module):
+    """
+    Predicts per-gene anisotropic diffusion coefficient σ_g(perturbation, t).
+
+    Input:  pert_emb (B, d_model), t (B,), gene_emb (B, G, d_model)
+    Output: sigma_g (B, G) in [sigma_min, sigma_max]
+
+    Architecture: condition c = pert_emb + t_emb → c + gene_emb → MLP → sigmoid → [min, max]
+    Does NOT depend on x_t — can be called before bridge sampling.
+    """
+
+    def __init__(
+        self,
+        d_model: int = 128,
+        hidden_dim: int = 256,
+        num_layers: int = 2,
+        sigma_min: float = 0.01,
+        sigma_max: float = 2.0,
+        sigma_init: float = 0.5,
+    ):
+        super().__init__()
+        self.sigma_min = sigma_min
+        self.sigma_max = sigma_max
+
+        self.t_embedder = TimestepEmbedder(d_model)
+
+        layers = []
+        in_dim = d_model
+        for i in range(num_layers):
+            layers.append(nn.Linear(in_dim if i == 0 else hidden_dim, hidden_dim))
+            layers.append(nn.SiLU())
+        layers.append(nn.Linear(hidden_dim, 1))
+        self.mlp = nn.Sequential(*layers)
+
+        self._init_bias(sigma_init)
+
+    def _init_bias(self, sigma_init):
+        """Initialize final bias so sigmoid output maps to sigma_init."""
+        target = (sigma_init - self.sigma_min) / (self.sigma_max - self.sigma_min)
+        target = max(min(target, 0.999), 0.001)
+        bias_val = math.log(target / (1 - target))  # logit
+        nn.init.constant_(self.mlp[-1].bias, bias_val)
+        nn.init.zeros_(self.mlp[-1].weight)
+
+    def forward(self, pert_emb: torch.Tensor, t: torch.Tensor,
+                gene_emb: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            pert_emb: (B, d_model) perturbation embedding
+            t: (B,) timestep
+            gene_emb: (B, G, d_model) gene embeddings
+
+        Returns:
+            sigma_g: (B, G) in [sigma_min, sigma_max]
+        """
+        t_emb = self.t_embedder(t)                         # (B, d_model)
+        c = pert_emb + t_emb                                # (B, d_model)
+        c_exp = c.unsqueeze(1).expand_as(gene_emb)          # (B, G, d_model)
+        h = gene_emb + c_exp                                # (B, G, d_model)
+        raw = self.mlp(h).squeeze(-1)                       # (B, G)
+        sigma = self.sigma_min + (self.sigma_max - self.sigma_min) * torch.sigmoid(raw)
+        return sigma
+
+
+class ScoreDecoder(nn.Module):
+    """
+    Decodes backbone hidden states to score function prediction.
+
+    Input:  backbone output (B, G, d_model), pert_emb (B, d_model)
+    Output: score prediction (B, G)
+    """
+
+    def __init__(self, d_model: int = 128, depth: int = 2):
+        super().__init__()
+        self.proj = nn.Linear(d_model * 2, d_model)  # concat with pert_emb
+        blocks = []
+        for _ in range(depth):
+            blocks.extend([
+                nn.LayerNorm(d_model),
+                nn.Linear(d_model, d_model),
+                nn.SiLU(),
+            ])
+        blocks.append(nn.Linear(d_model, 1))
+        self.mlp = nn.Sequential(*blocks)
+
+    def forward(self, x: torch.Tensor, pert_emb: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            x: (B, G, d_model) backbone output
+            pert_emb: (B, d_model) perturbation embedding
+
+        Returns:
+            score: (B, G)
+        """
+        x_with_pert = torch.cat(
+            [x, pert_emb[:, None, :].expand(-1, x.size(1), -1)], dim=-1
+        )
+        h = self.proj(x_with_pert)
+        return self.mlp(h).squeeze(-1)

GRN/SB/src/model/model.py

@@ -0,0 +1,218 @@
+"""
+SBModel — Anisotropic Schrödinger Bridge model.
+
+Shared backbone with scDFM, dual output heads (velocity + score),
+plus AnisotropicSigmaNet for per-gene diffusion coefficients.
+"""
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+from typing import Optional, Tuple
+
+from .layers import AnisotropicSigmaNet, ScoreDecoder
+from .._scdfm_imports import (
+    GeneadaLN,
+    ContinuousValueEncoder,
+    GeneEncoder,
+    BatchLabelEncoder,
+    TimestepEmbedder,
+    ExprDecoder,
+    DifferentialTransformerBlock,
+    PerceiverBlock,
+    DiffPerceiverBlock,
+)
+
+
+class SBModel(nn.Module):
+    """
+    Anisotropic Schrödinger Bridge model.
+
+    forward(gene_id, cell_1, x_t, t, perturbation_id)
+      → (pred_velocity, pred_score, sigma_g)
+
+    - pred_velocity: (B, G) PF-ODE velocity (target = x_T - x₀)
+    - pred_score:    (B, G) score function (target = conditional score)
+    - sigma_g:       (B, G) per-gene diffusion coefficient in [σ_min, σ_max]
+    """
+
+    def __init__(
+        self,
+        ntoken: int = 6000,
+        d_model: int = 128,
+        nhead: int = 8,
+        d_hid: int = 512,
+        nlayers: int = 4,
+        dropout: float = 0.1,
+        fusion_method: str = "differential_perceiver",
+        perturbation_function: str = "crisper",
+        use_perturbation_interaction: bool = True,
+        mask_path: str = None,
+        # Sigma net params
+        sigma_min: float = 0.01,
+        sigma_max: float = 2.0,
+        sigma_init: float = 0.5,
+        sigma_hidden_dim: int = 256,
+        sigma_num_layers: int = 2,
+        # Score decoder params
+        score_head_depth: int = 2,
+        use_score: bool = True,
+    ):
+        super().__init__()
+        self.d_model = d_model
+        self.fusion_method = fusion_method
+        self.perturbation_function = perturbation_function
+        self.use_score = use_score
+
+        # === Timestep embedder (single, not cascaded) ===
+        self.t_embedder = TimestepEmbedder(d_model)
+
+        # === Perturbation embedder ===
+        self.perturbation_embedder = BatchLabelEncoder(ntoken, d_model)
+
+        # === Expression stream (reused from scDFM) ===
+        self.value_encoder_1 = ContinuousValueEncoder(d_model, dropout)
+        self.value_encoder_2 = ContinuousValueEncoder(d_model, dropout)
+        self.encoder = GeneEncoder(
+            ntoken, d_model,
+            use_perturbation_interaction=use_perturbation_interaction,
+            mask_path=mask_path,
+        )
+
+        self.fusion_layer = nn.Sequential(
+            nn.Linear(2 * d_model, d_model),
+            nn.GELU(),
+            nn.Linear(d_model, d_model),
+            nn.LayerNorm(d_model),
+        )
+
+        # === Shared backbone blocks ===
+        if fusion_method == "differential_transformer":
+            self.blocks = nn.ModuleList([
+                DifferentialTransformerBlock(d_model, nhead, i, mlp_ratio=4.0)
+                for i in range(nlayers)
+            ])
+        elif fusion_method == "differential_perceiver":
+            self.blocks = nn.ModuleList([
+                DiffPerceiverBlock(d_model, nhead, i, mlp_ratio=4.0)
+                for i in range(nlayers)
+            ])
+        elif fusion_method == "perceiver":
+            self.blocks = nn.ModuleList([
+                PerceiverBlock(d_model, d_model, heads=nhead, mlp_ratio=4.0, dropout=0.1)
+                for _ in range(nlayers)
+            ])
+        else:
+            raise ValueError(f"Invalid fusion method: {fusion_method}")
+
+        # === Per-layer gene AdaLN + adapter ===
+        self.gene_adaLN = nn.ModuleList([
+            GeneadaLN(d_model, dropout) for _ in range(nlayers)
+        ])
+        self.adapter_layer = nn.ModuleList([
+            nn.Sequential(
+                nn.Linear(2 * d_model, d_model),
+                nn.LeakyReLU(),
+                nn.Dropout(dropout),
+                nn.Linear(d_model, d_model),
+                nn.LeakyReLU(),
+            )
+            for _ in range(nlayers)
+        ])
+
+        # === Velocity decoder head (reused ExprDecoder from scDFM) ===
+        self.final_layer = ExprDecoder(d_model, explicit_zero_prob=False, use_batch_labels=True)
+
+        # === Score decoder head (NEW) ===
+        if use_score:
+            self.score_decoder = ScoreDecoder(d_model, depth=score_head_depth)
+
+        # === Anisotropic sigma network (NEW, independent of backbone) ===
+        self.sigma_net = AnisotropicSigmaNet(
+            d_model=d_model,
+            hidden_dim=sigma_hidden_dim,
+            num_layers=sigma_num_layers,
+            sigma_min=sigma_min,
+            sigma_max=sigma_max,
+            sigma_init=sigma_init,
+        )
+
+        self.initialize_weights()
+
+    def initialize_weights(self):
+        def _basic_init(module):
+            if isinstance(module, nn.Linear):
+                torch.nn.init.xavier_uniform_(module.weight)
+                if module.bias is not None:
+                    nn.init.constant_(module.bias, 0)
+        self.apply(_basic_init)
+        # Re-initialize sigma bias after global init
+        self.sigma_net._init_bias(self.sigma_net.sigma_min +
+            (self.sigma_net.sigma_max - self.sigma_net.sigma_min) * 0.5)
+
+    def get_perturbation_emb(
+        self,
+        perturbation_id: Optional[Tensor] = None,
+        perturbation_emb: Optional[Tensor] = None,
+        cell_1: Optional[Tensor] = None,
+    ) -> Tensor:
+        """Get perturbation embedding, replicating scDFM logic."""
+        assert perturbation_emb is None or perturbation_id is None
+        if perturbation_id is not None:
+            if self.perturbation_function == "crisper":
+                perturbation_emb = self.encoder(perturbation_id)
+            else:
+                perturbation_emb = self.perturbation_embedder(perturbation_id)
+            perturbation_emb = perturbation_emb.mean(1)
+        elif perturbation_emb is not None:
+            perturbation_emb = perturbation_emb.to(cell_1.device, dtype=cell_1.dtype)
+            if perturbation_emb.dim() == 1:
+                perturbation_emb = perturbation_emb.unsqueeze(0)
+            if perturbation_emb.size(0) == 1:
+                perturbation_emb = perturbation_emb.expand(cell_1.shape[0], -1).contiguous()
+            perturbation_emb = self.perturbation_embedder.enc_norm(perturbation_emb)
+        return perturbation_emb
+
+    def forward(
+        self,
+        gene_id: Tensor,             # (B, G) gene token IDs
+        cell_1: Tensor,               # (B, G) source expression
+        x_t: Tensor,                  # (B, G) noised target expression
+        t: Tensor,                    # (B,) timestep
+        perturbation_id: Optional[Tensor] = None,
+    ) -> Tuple[Tensor, Optional[Tensor], Tensor]:
+        if t.dim() == 0:
+            t = t.repeat(cell_1.size(0))
+
+        # 1. Expression embedding (aligned with scDFM)
+        gene_emb = self.encoder(gene_id)                         # (B, G, d)
+        val_emb_1 = self.value_encoder_1(x_t)
+        val_emb_2 = self.value_encoder_2(cell_1) + gene_emb
+        x = self.fusion_layer(torch.cat([val_emb_1, val_emb_2], dim=-1)) + gene_emb
+
+        # 2. Conditioning vector (single t, no cascaded)
+        t_emb = self.t_embedder(t)
+        pert_emb = self.get_perturbation_emb(perturbation_id, cell_1=cell_1)
+        c = t_emb + pert_emb
+
+        # 3. Shared backbone
+        for i, block in enumerate(self.blocks):
+            x = self.gene_adaLN[i](gene_emb, x)
+            pert_exp = pert_emb[:, None, :].expand(-1, x.size(1), -1)
+            x = torch.cat([x, pert_exp], dim=-1)
+            x = self.adapter_layer[i](x)
+            x = block(x, val_emb_2, c)
+
+        # 4a. Velocity head
+        x_with_pert = torch.cat([x, pert_emb[:, None, :].expand(-1, x.size(1), -1)], dim=-1)
+        pred_velocity = self.final_layer(x_with_pert)["pred"]   # (B, G)
+
+        # 4b. Score head
+        pred_score = None
+        if self.use_score:
+            pred_score = self.score_decoder(x, pert_emb)         # (B, G)
+
+        # 4c. Sigma (independent of backbone, only depends on pert_emb, t, gene_emb)
+        sigma_g = self.sigma_net(pert_emb, t, gene_emb)          # (B, G)
+
+        return pred_velocity, pred_score, sigma_g

GRN/SB/src/ot_anisotropic.py

@@ -0,0 +1,109 @@
+"""
+Anisotropic OT sampler with Mahalanobis cost weighted by learned σ_g.
+
+Cost: C(x₀, x_T | σ_g) = Σ_g (x₀_g - x_T_g)² / (σ_g² + ε)
+
+Uses pot.sinkhorn for entropic OT (vs baseline's pot.emd).
+"""
+
+import warnings
+import numpy as np
+import torch
+import ot as pot
+
+
+class AnisotropicOTSampler:
+    """
+    Minibatch OT sampler with anisotropic Mahalanobis cost.
+
+    Called every train_step with current σ_g (detached).
+    No caching or periodic re-coupling needed.
+    """
+
+    def __init__(
+        self,
+        method: str = "sinkhorn",
+        reg: float = 0.05,
+        sigma_min: float = 0.01,
+        eps: float = 1e-6,
+    ):
+        self.method = method
+        self.reg = reg
+        self.sigma_min = sigma_min
+        self.eps = eps
+
+    def _compute_cost(self, x0, x1, sigma_g=None):
+        """
+        Compute cost matrix.
+
+        Args:
+            x0: (N, G) source
+            x1: (M, G) target
+            sigma_g: (G,) per-gene sigma, or None for isotropic
+
+        Returns:
+            M: (N, M) cost matrix (numpy)
+        """
+        if sigma_g is not None:
+            # Mahalanobis cost: w_g = 1 / (σ_g² + ε)
+            w = (1.0 / (sigma_g ** 2 + self.eps))
+            w = w.clamp(max=1.0 / (self.sigma_min ** 2))              # prevent extreme weights
+            diff = x0.unsqueeze(1) - x1.unsqueeze(0)                  # (N, M, G)
+            cost = (diff ** 2 * w.unsqueeze(0).unsqueeze(0)).sum(-1)   # (N, M)
+        else:
+            # Isotropic Euclidean
+            cost = torch.cdist(x0, x1, p=2) ** 2                      # (N, M)
+
+        # Normalize to prevent Sinkhorn numerical issues
+        cost_max = cost.max()
+        if cost_max > 0:
+            cost = cost / cost_max
+
+        return cost.detach().cpu().numpy()
+
+    def get_plan(self, x0, x1, sigma_g=None):
+        """Compute OT plan."""
+        M = self._compute_cost(x0, x1, sigma_g)
+        a = pot.unif(x0.shape[0])
+        b = pot.unif(x1.shape[0])
+
+        if self.method == "sinkhorn":
+            plan = pot.sinkhorn(a, b, M, reg=self.reg, warn=False)
+        elif self.method == "exact":
+            plan = pot.emd(a, b, M)
+        else:
+            raise ValueError(f"Unknown OT method: {self.method}")
+
+        # Fallback on numerical errors
+        if not np.all(np.isfinite(plan)) or np.abs(plan.sum()) < 1e-8:
+            warnings.warn("Numerical error in OT plan, falling back to uniform.")
+            plan = np.ones_like(plan) / plan.size
+
+        return plan
+
+    def sample_plan_fix_x0(self, x0, x1, sigma_g=None):
+        """
+        Sample matched x1 from OT plan, keeping x0 order.
+
+        Args:
+            x0: (N, G) source (noise)
+            x1: (M, G) target (perturbed expression)
+            sigma_g: (G,) per-gene sigma or None
+
+        Returns:
+            x0: (N, G) unchanged
+            x1_matched: (N, G) reordered target
+        """
+        pi = self.get_plan(x0, x1, sigma_g)
+        matched_indices = []
+        for i in range(pi.shape[0]):
+            prob = pi[i]
+            prob_sum = prob.sum()
+            if prob_sum > 0:
+                prob = prob / prob_sum
+            else:
+                prob = np.ones(pi.shape[1]) / pi.shape[1]
+            j = np.random.choice(pi.shape[1], p=prob)
+            matched_indices.append(j)
+        matched_indices = torch.tensor(matched_indices, dtype=torch.long, device=x1.device)
+        return x0, x1[matched_indices]

GRN/SB/src/utils.py

@@ -0,0 +1,14 @@
+"""
+Re-export scDFM utility functions from the central import module.
+"""
+
+from ._scdfm_imports import (
+    save_checkpoint,
+    load_checkpoint,
+    make_lognorm_poisson_noise,
+    pick_eval_score,
+    process_vocab,
+    set_requires_grad_for_p_only,
+    get_perturbation_emb,
+    GeneVocab,
+)

GRN/baseline/baseline_5418102.out

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a54b5b210fdf6666037de0b25be137b0eb687cff9e44eeef3cd6bc06ece893de
+size 44993224

GRN/baseline/baseline_d128_5527533.out

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2aca6813ea4c289ea96e195c67bf8a3ad93bc2333b789ed2a5e7d6443288d688
+size 20793723

GRN/baseline/d128/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/iteration_100000/checkpoint.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d9f865cceaf5416e2c75eda60ba310268f8d532a5bccbc49d8118e1ac267ba1
+size 697879461

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30-gene_noise_scale/iteration_215000/agg_results.csv

@@ -0,0 +1,10 @@
+statistic,overlap_at_N,overlap_at_50,overlap_at_100,overlap_at_200,overlap_at_500,precision_at_N,precision_at_50,precision_at_100,precision_at_200,precision_at_500,de_spearman_sig,de_direction_match,de_spearman_lfc_sig,de_sig_genes_recall,de_nsig_counts_real,de_nsig_counts_pred,pr_auc,roc_auc,pearson_delta,mse,mae,mse_delta,mae_delta,discrimination_score_l1,discrimination_score_l2,discrimination_score_cosine,pearson_edistance,clustering_agreement
+count,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0
+null_count,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+mean,0.06870723975901172,0.05673145117294057,0.06178054611098185,0.06279620935091165,0.06870723975901172,0.1328009007879472,0.05641025641025644,0.060512820512820545,0.06294871794871797,0.09405128205128206,0.3302981554355994,0.7501098846062679,0.7070736354059303,0.9439070775427181,137.89743589743588,986.0,0.2992672357260559,0.5052572787713436,0.17479875495131963,0.17378047987436637,0.24015644307319933,0.1737804794922853,0.24015644383736146,0.7409598948060486,0.7712031558185406,0.7054569362261671,0.5894095251440064,0.5539158017707632
+std,0.07679721643631165,0.03580260630440812,0.047601325636955266,0.05660971461975514,0.07679721643631165,0.07267391308620531,0.0360910529434111,0.048501151258648546,0.057739409472281816,0.06921588983902344,0.0,0.07801718304990432,0.045601523705551456,0.025656279782161437,72.75871981447884,2.6950246556825492,0.0,2.2494727197818324e-16,0.15601927014310582,0.01723582388540501,0.012264578613397855,0.01723582356820253,0.012264577664446134,0.2464878295278745,0.2277797530123566,0.2699445454348245,0.0,1.1247363598909162e-16
+min,0.014084507042253521,0.0,0.01,0.014084507042253521,0.014084507042253521,0.03242147922998987,0.0,0.01,0.01,0.018,0.33029815543559937,0.6,0.5777058279370952,0.8837209302325582,32.0,980.0,0.29926723572605585,0.505257278771344,-0.04524721950292587,0.11434374749660492,0.2019038200378418,0.11434374749660492,0.2019038200378418,0.20512820512820518,0.23076923076923073,0.05128205128205132,0.5894095251440064,0.5539158017707626
+25%,0.03636363636363636,0.03125,0.030927835051546393,0.03636363636363636,0.03636363636363636,0.09898989898989899,0.02,0.03,0.03,0.062,0.33029815543559937,0.6948051948051948,0.6843389989281307,0.9344262295081968,103.0,985.0,0.29926723572605585,0.505257278771344,0.0786370113492012,0.16741803288459778,0.23513180017471313,0.16741803288459778,0.23513180017471313,0.6153846153846154,0.641025641025641,0.5384615384615384,0.5894095251440064,0.5539158017707626
+50%,0.052083333333333336,0.06,0.05263157894736842,0.052083333333333336,0.052083333333333336,0.1116751269035533,0.06,0.05,0.05,0.074,0.33029815543559937,0.75,0.7021493500976977,0.9484536082474226,117.0,986.0,0.29926723572605585,0.505257278771344,0.1494819074869156,0.17376112937927246,0.2394474297761917,0.17376112937927246,0.2394474297761917,0.7948717948717949,0.8461538461538461,0.7692307692307692,0.5894095251440064,0.5539158017707626
+75%,0.06578947368421052,0.08,0.07,0.06578947368421052,0.06578947368421052,0.15182186234817813,0.08,0.07,0.07,0.108,0.33029815543559937,0.8,0.7435060664157069,0.9578947368421052,158.0,988.0,0.29926723572605585,0.505257278771344,0.23058994114398956,0.1866130381822586,0.24731183052062988,0.1866130381822586,0.24731183052062988,1.0,0.9743589743589743,0.9487179487179487,0.5894095251440064,0.5539158017707626
+max,0.38903394255874674,0.16,0.23,0.305,0.38903394255874674,0.37955465587044535,0.16,0.23,0.305,0.372,0.33029815543559937,0.9347258485639687,0.798831345858713,1.0,384.0,992.0,0.29926723572605585,0.505257278771344,0.7125794887542725,0.21626025438308716,0.2681756019592285,0.21626025438308716,0.2681756019592285,1.0,1.0,1.0,0.5894095251440064,0.5539158017707626

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30-gene_noise_scale/iteration_215000/checkpoint.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47a078dc2cd96c574088e1d889d8f32df372b603fde6e76435d40b5c0189fcc1
+size 697879461

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30-gene_noise_scale/iteration_215000/pred.h5ad

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37151d34a01a3d67927d627db5196d72464cbe2d918fc7f1719d16103a6a905f
+size 49952825

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30-gene_noise_scale/iteration_215000/real.h5ad

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d906eb6262ae9d587a091c8f6722e562182c9cd62e18f7c2faecbd7c4935ec3c
+size 75069953

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30-gene_noise_scale/iteration_215000/results.csv

@@ -0,0 +1,40 @@
+perturbation,overlap_at_N,overlap_at_50,overlap_at_100,overlap_at_200,overlap_at_500,precision_at_N,precision_at_50,precision_at_100,precision_at_200,precision_at_500,de_spearman_sig,de_direction_match,de_spearman_lfc_sig,de_sig_genes_recall,de_nsig_counts_real,de_nsig_counts_pred,pr_auc,roc_auc,pearson_delta,mse,mae,mse_delta,mae_delta,discrimination_score_l1,discrimination_score_l2,discrimination_score_cosine,pearson_edistance,clustering_agreement
+AHR+FEV,0.10747663551401869,0.16,0.12,0.1,0.10747663551401869,0.2077001013171226,0.16,0.12,0.1,0.164,0.33029815543559937,0.7149532710280374,0.7405809655314368,0.9579439252336449,214.0,987.0,0.29926723572605585,0.505257278771344,0.1687520146369934,0.1943982094526291,0.2592649459838867,0.1943982094526291,0.2592649459838867,0.9230769230769231,0.9743589743589743,0.9487179487179487,0.5894095251440064,0.5539158017707626
+AHR+KLF1,0.05714285714285714,0.08,0.07,0.05714285714285714,0.05714285714285714,0.1347517730496454,0.08,0.07,0.055,0.086,0.33029815543559937,0.6357142857142857,0.6670808812268919,0.95,140.0,987.0,0.29926723572605585,0.505257278771344,0.005311842076480389,0.1893630176782608,0.2517276704311371,0.1893630176782608,0.2517276704311371,0.41025641025641024,0.41025641025641024,0.2564102564102564,0.5894095251440064,0.5539158017707626
+BCL2L11+BAK1,0.03125,0.03125,0.03125,0.03125,0.03125,0.03242147922998987,0.02,0.01,0.025,0.026,0.33029815543559937,0.78125,0.7206232813932172,1.0,32.0,987.0,0.29926723572605585,0.505257278771344,0.0065612467005848885,0.17376112937927246,0.23513180017471313,0.17376112937927246,0.23513180017471313,0.3589743589743589,0.3846153846153846,0.9487179487179487,0.5894095251440064,0.5539158017707626
+BPGM+ZBTB1,0.03636363636363636,0.06,0.03,0.03636363636363636,0.03636363636363636,0.10547667342799188,0.06,0.03,0.03,0.058,0.33029815543559937,0.7909090909090909,0.7813842955641034,0.9454545454545454,110.0,986.0,0.29926723572605585,0.505257278771344,0.19321857392787933,0.1814109832048416,0.2446288764476776,0.1814109832048416,0.2446288764476776,0.717948717948718,0.717948717948718,0.5897435897435898,0.5894095251440064,0.5539158017707626
+CBL+PTPN12,0.057692307692307696,0.04,0.06,0.057692307692307696,0.057692307692307696,0.09898989898989899,0.04,0.06,0.045,0.076,0.33029815543559937,0.8173076923076923,0.69942387709378,0.9423076923076923,104.0,990.0,0.29926723572605585,0.505257278771344,0.2184145301580429,0.16535134613513947,0.229812890291214,0.16535134613513947,0.229812890291214,0.6666666666666667,0.717948717948718,0.641025641025641,0.5894095251440064,0.5539158017707626
+CBL+PTPN9,0.05263157894736842,0.02,0.05263157894736842,0.05263157894736842,0.05263157894736842,0.09210526315789473,0.02,0.05,0.035,0.072,0.33029815543559937,0.8210526315789474,0.7017413701391416,0.9578947368421052,95.0,988.0,0.29926723572605585,0.505257278771344,0.27182719111442566,0.15468913316726685,0.22347722947597504,0.15468913316726685,0.22347724437713623,1.0,1.0,0.8205128205128205,0.5894095251440064,0.5539158017707626
+CBL+TGFBR2,0.0410958904109589,0.04,0.0410958904109589,0.0410958904109589,0.0410958904109589,0.06598984771573604,0.04,0.04,0.04,0.046,0.33029815543559937,0.7945205479452054,0.7141622955877815,0.8904109589041096,73.0,985.0,0.29926723572605585,0.505257278771344,0.1311197429895401,0.18153353035449982,0.24506469070911407,0.18153353035449982,0.24506469070911407,0.6153846153846154,0.5128205128205128,0.3076923076923077,0.5894095251440064,0.5539158017707626
+CBL+UBASH3A,0.02127659574468085,0.02127659574468085,0.02127659574468085,0.02127659574468085,0.02127659574468085,0.04369918699186992,0.02,0.01,0.01,0.018,0.33029815543559937,0.7446808510638298,0.5777058279370952,0.9148936170212766,47.0,984.0,0.29926723572605585,0.505257278771344,0.1250695437192917,0.1900354027748108,0.24834005534648895,0.1900354027748108,0.24834005534648895,0.6153846153846154,0.5384615384615384,0.41025641025641024,0.5894095251440064,0.5539158017707626
+CBL+UBASH3B,0.03424657534246575,0.04,0.03,0.03424657534246575,0.03424657534246575,0.1414141414141414,0.04,0.03,0.03,0.108,0.33029815543559937,0.8287671232876712,0.7301904633256788,0.958904109589041,146.0,990.0,0.29926723572605585,0.505257278771344,0.2766973078250885,0.17427249252796173,0.23610509932041168,0.17427249252796173,0.23610509932041168,0.8717948717948718,0.8205128205128205,0.7692307692307692,0.5894095251440064,0.5539158017707626
+CDKN1B+CDKN1A,0.04854368932038835,0.06,0.05,0.04854368932038835,0.04854368932038835,0.09979633401221996,0.06,0.05,0.065,0.06,0.33029815543559937,0.7669902912621359,0.7339322584896543,0.9514563106796117,103.0,982.0,0.29926723572605585,0.505257278771344,0.23911680281162262,0.16785940527915955,0.2394474297761917,0.16785940527915955,0.2394474297761917,1.0,1.0,0.9487179487179487,0.5894095251440064,0.5539158017707626
+CDKN1C+CDKN1B,0.06363636363636363,0.06,0.06,0.06363636363636363,0.06363636363636363,0.10681586978636826,0.06,0.06,0.07,0.064,0.33029815543559937,0.7727272727272727,0.7458140604290081,0.9545454545454546,110.0,983.0,0.29926723572605585,0.505257278771344,0.18302451074123383,0.17865359783172607,0.24654284119606018,0.17865359783172607,0.24654284119606018,0.9743589743589743,0.9743589743589743,0.9487179487179487,0.5894095251440064,0.5539158017707626
+CEBPE+CEBPA,0.38903394255874674,0.1,0.23,0.305,0.38903394255874674,0.3775303643724696,0.1,0.23,0.305,0.372,0.33029815543559937,0.9347258485639687,0.6843389989281307,0.9738903394255874,383.0,988.0,0.29926723572605585,0.505257278771344,0.7125794887542725,0.11434374749660492,0.2019038200378418,0.11434374749660492,0.2019038200378418,1.0,1.0,1.0,0.5894095251440064,0.5539158017707626
+CEBPE+CNN1,0.06802721088435375,0.06,0.08,0.06802721088435375,0.06802721088435375,0.14198782961460446,0.06,0.08,0.085,0.096,0.33029815543559937,0.7482993197278912,0.7476175001322561,0.9523809523809523,147.0,986.0,0.29926723572605585,0.505257278771344,0.0786370113492012,0.1708095520734787,0.24067263305187225,0.1708095520734787,0.24067263305187225,0.9743589743589743,0.9487179487179487,0.7948717948717949,0.5894095251440064,0.5539158017707626
+ETS2+IGDCC3,0.05217391304347826,0.08,0.05,0.05217391304347826,0.05217391304347826,0.10986775178026449,0.08,0.05,0.06,0.078,0.33029815543559937,0.6,0.6357508209143723,0.9391304347826087,115.0,983.0,0.29926723572605585,0.505257278771344,-0.04524721950292587,0.18772271275520325,0.24757909774780273,0.18772269785404205,0.24757909774780273,0.8205128205128205,0.7692307692307692,0.3076923076923077,0.5894095251440064,0.5539158017707626
+ETS2+IKZF3,0.05913978494623656,0.1,0.07,0.05913978494623656,0.05913978494623656,0.18346774193548387,0.1,0.07,0.065,0.114,0.33029815543559937,0.6989247311827957,0.7435060664157069,0.978494623655914,186.0,992.0,0.29926723572605585,0.505257278771344,0.17796382308006287,0.1700170636177063,0.2362302541732788,0.1700170636177063,0.2362302541732788,0.5128205128205128,0.46153846153846156,0.5128205128205128,0.5894095251440064,0.5539158017707626
+FEV+ISL2,0.06578947368421052,0.06,0.08,0.06578947368421052,0.06578947368421052,0.1458966565349544,0.06,0.08,0.07,0.098,0.33029815543559937,0.7697368421052632,0.7633361254038531,0.9473684210526315,152.0,987.0,0.29926723572605585,0.505257278771344,0.17916952073574066,0.17820444703102112,0.2440398633480072,0.17820444703102112,0.2440398633480072,1.0,1.0,0.9230769230769231,0.5894095251440064,0.5539158017707626
+FOSB+CEBPB,0.21568627450980393,0.12,0.17,0.185,0.21568627450980393,0.25227963525835867,0.12,0.17,0.185,0.186,0.33029815543559937,0.8862745098039215,0.6878863777851776,0.9764705882352941,255.0,987.0,0.29926723572605585,0.505257278771344,0.5117895603179932,0.14016836881637573,0.22231537103652954,0.14016836881637573,0.22231537103652954,1.0,1.0,1.0,0.5894095251440064,0.5539158017707626
+FOXA3+FOXA1,0.05,0.06,0.06,0.05,0.05,0.1334012219959267,0.06,0.06,0.075,0.076,0.33029815543559937,0.75,0.7137284058604855,0.9357142857142857,140.0,982.0,0.29926723572605585,0.505257278771344,0.14031392335891724,0.15765589475631714,0.2285369634628296,0.15765589475631714,0.2285369634628296,1.0,1.0,0.9487179487179487,0.5894095251440064,0.5539158017707626
+KLF1+BAK1,0.052083333333333336,0.04,0.052083333333333336,0.052083333333333336,0.052083333333333336,0.08934010152284264,0.04,0.05,0.05,0.056,0.33029815543559937,0.65625,0.6824349997286001,0.9166666666666666,96.0,985.0,0.29926723572605585,0.505257278771344,-0.008375725708901882,0.17321588099002838,0.23909367620944977,0.17321588099002838,0.23909367620944977,0.4871794871794872,0.6153846153846154,0.10256410256410253,0.5894095251440064,0.5539158017707626
+KLF1+CEBPA,0.3333333333333333,0.1,0.2,0.225,0.3333333333333333,0.37955465587044535,0.1,0.2,0.225,0.326,0.33029815543559937,0.8984375,0.6779425083142634,0.9765625,384.0,988.0,0.29926723572605585,0.505257278771344,0.46055611968040466,0.15729443728923798,0.2413816899061203,0.15729443728923798,0.2413816899061203,1.0,1.0,0.9743589743589743,0.5894095251440064,0.5539158017707626
+KLF1+CLDN6,0.04580152671755725,0.02,0.03,0.04580152671755725,0.04580152671755725,0.12449392712550607,0.02,0.03,0.055,0.064,0.33029815543559937,0.7633587786259542,0.6997544309203502,0.9389312977099237,131.0,988.0,0.29926723572605585,0.505257278771344,0.111509308218956,0.19790221750736237,0.2643733620643616,0.19790221750736237,0.2643733620643616,0.20512820512820518,0.3076923076923077,0.5128205128205128,0.5894095251440064,0.5539158017707626
+LYL1+CEBPB,0.06962025316455696,0.04,0.07,0.06962025316455696,0.06962025316455696,0.15182186234817813,0.04,0.07,0.08,0.096,0.33029815543559937,0.7025316455696202,0.6918626767742858,0.9493670886075949,158.0,988.0,0.29926723572605585,0.505257278771344,0.08169694989919662,0.16782453656196594,0.23627114295959473,0.16782453656196594,0.23627114295959473,1.0,0.8461538461538461,0.7692307692307692,0.5894095251440064,0.5539158017707626
+MAP2K3+ELMSAN1,0.01948051948051948,0.02,0.01,0.01948051948051948,0.01948051948051948,0.14285714285714285,0.02,0.01,0.04,0.11,0.33029815543559937,0.6948051948051948,0.7132342659355881,0.9090909090909091,154.0,980.0,0.29926723572605585,0.505257278771344,0.0429171547293663,0.16872559487819672,0.23630212247371674,0.16872559487819672,0.23630212247371674,0.9743589743589743,0.9487179487179487,0.7692307692307692,0.5894095251440064,0.5539158017707626
+MAP2K3+IKZF3,0.037037037037037035,0.06,0.03,0.037037037037037035,0.037037037037037035,0.10435663627152988,0.06,0.03,0.035,0.074,0.33029815543559937,0.7314814814814815,0.798831345858713,0.9537037037037037,108.0,987.0,0.29926723572605585,0.505257278771344,0.4110649526119232,0.16886118054389954,0.23300549387931824,0.16886118054389954,0.23300549387931824,1.0,0.9743589743589743,0.8717948717948718,0.5894095251440064,0.5539158017707626
+MAP2K3+MAP2K6,0.014084507042253521,0.02,0.014084507042253521,0.014084507042253521,0.014084507042253521,0.06829765545361875,0.02,0.01,0.02,0.056,0.33029815543559937,0.7323943661971831,0.7579607103143848,0.9436619718309859,71.0,981.0,0.29926723572605585,0.505257278771344,0.10516710579395294,0.16741803288459778,0.23477335274219513,0.16741803288459778,0.23477335274219513,0.6153846153846154,0.8205128205128205,0.9743589743589743,0.5894095251440064,0.5539158017707626
+MAP2K3+SLC38A2,0.017543859649122806,0.02,0.017543859649122806,0.017543859649122806,0.017543859649122806,0.05279187817258883,0.02,0.02,0.015,0.034,0.33029815543559937,0.8421052631578947,0.7629220779220779,0.9122807017543859,57.0,985.0,0.29926723572605585,0.505257278771344,0.2121874839067459,0.15877388417720795,0.22804735600948334,0.15877388417720795,0.22804735600948334,0.5897435897435898,0.8461538461538461,0.9743589743589743,0.5894095251440064,0.5539158017707626
+MAP2K6+ELMSAN1,0.05813953488372093,0.06,0.05813953488372093,0.05813953488372093,0.05813953488372093,0.07739307535641547,0.06,0.05,0.04,0.062,0.33029815543559937,0.6627906976744186,0.7021493500976977,0.8837209302325582,86.0,982.0,0.29926723572605585,0.505257278771344,0.029662083834409714,0.17078661918640137,0.23623931407928467,0.17078661918640137,0.23623931407928467,0.7948717948717949,0.8205128205128205,0.8205128205128205,0.5894095251440064,0.5539158017707626
+MAPK1+IKZF3,0.07317073170731707,0.14,0.1,0.07317073170731707,0.07317073170731707,0.15943491422805248,0.14,0.1,0.075,0.088,0.33029815543559937,0.6646341463414634,0.6604438882049259,0.9634146341463414,164.0,991.0,0.29926723572605585,0.505257278771344,0.025348778814077377,0.18578451871871948,0.24731183052062988,0.18578451871871948,0.24731183052062988,0.717948717948718,0.4871794871794872,0.5641025641025641,0.5894095251440064,0.5539158017707626
+PTPN12+PTPN9,0.02040816326530612,0.02,0.02040816326530612,0.02040816326530612,0.02040816326530612,0.0922920892494929,0.02,0.02,0.025,0.062,0.33029815543559937,0.8061224489795918,0.7016082747713852,0.9285714285714286,98.0,986.0,0.29926723572605585,0.505257278771344,0.1817389279603958,0.15891411900520325,0.22618001699447632,0.15891411900520325,0.22618001699447632,0.7435897435897436,0.8461538461538461,0.6923076923076923,0.5894095251440064,0.5539158017707626
+PTPN12+UBASH3A,0.06956521739130435,0.04,0.07,0.06956521739130435,0.06956521739130435,0.1065989847715736,0.04,0.07,0.065,0.078,0.33029815543559937,0.8,0.6923661275410227,0.9130434782608695,115.0,985.0,0.29926723572605585,0.505257278771344,0.1494819074869156,0.17540070414543152,0.2363496571779251,0.17540070414543152,0.2363496571779251,0.4871794871794872,0.41025641025641024,0.5384615384615384,0.5894095251440064,0.5539158017707626
+SGK1+S1PR2,0.05641025641025641,0.06,0.06,0.05641025641025641,0.05641025641025641,0.18800813008130082,0.06,0.06,0.06,0.138,0.33029815543559937,0.6871794871794872,0.698462657228238,0.9487179487179487,195.0,984.0,0.29926723572605585,0.505257278771344,0.07468250393867493,0.1918719857931137,0.2555564343929291,0.1918719857931137,0.2555564343929291,0.20512820512820518,0.8717948717948718,0.7435897435897436,0.5894095251440064,0.5539158017707626
+SGK1+TBX2,0.04918032786885246,0.1,0.06,0.04918032786885246,0.04918032786885246,0.11550151975683891,0.1,0.06,0.03,0.072,0.33029815543559937,0.7131147540983607,0.7076060118266526,0.9344262295081968,122.0,987.0,0.29926723572605585,0.505257278771344,0.14901331067085266,0.1866130381822586,0.24730084836483002,0.1866130381822586,0.24730084836483002,0.8205128205128205,0.8461538461538461,0.641025641025641,0.5894095251440064,0.5539158017707626
+SGK1+TBX3,0.01834862385321101,0.0,0.01,0.01834862385321101,0.01834862385321101,0.10233029381965553,0.0,0.01,0.015,0.058,0.33029815543559937,0.6880733944954128,0.6805027715466899,0.926605504587156,109.0,987.0,0.29926723572605585,0.505257278771344,0.18228711187839508,0.1877463310956955,0.2486482709646225,0.1877463310956955,0.2486482709646225,0.6923076923076923,0.8205128205128205,0.8974358974358975,0.5894095251440064,0.5539158017707626
+TBX3+TBX2,0.024691358024691357,0.02,0.04,0.024691358024691357,0.024691358024691357,0.15736040609137056,0.02,0.04,0.02,0.124,0.33029815543559937,0.7901234567901234,0.7589743007047635,0.9567901234567902,162.0,985.0,0.29926723572605585,0.505257278771344,0.23058994114398956,0.21626025438308716,0.2681756019592285,0.21626025438308716,0.2681756019592285,0.8717948717948718,1.0,0.9230769230769231,0.5894095251440064,0.5539158017707626
+TGFBR2+IGDCC3,0.05504587155963303,0.08,0.06,0.05504587155963303,0.05504587155963303,0.09959349593495935,0.08,0.06,0.03,0.068,0.33029815543559937,0.6880733944954128,0.6375651690339922,0.8990825688073395,109.0,984.0,0.29926723572605585,0.505257278771344,0.06332975625991821,0.1883746236562729,0.2505951523780823,0.1883746236562729,0.2505951523780823,0.4871794871794872,0.641025641025641,0.2564102564102564,0.5894095251440064,0.5539158017707626
+TGFBR2+PRTG,0.05128205128205128,0.06,0.04,0.05128205128205128,0.05128205128205128,0.1116751269035533,0.06,0.04,0.05,0.062,0.33029815543559937,0.6581196581196581,0.6395338379674735,0.9401709401709402,117.0,985.0,0.29926723572605585,0.505257278771344,0.10318620502948761,0.17879818379878998,0.2450597584247589,0.17879818379878998,0.2450597584247589,0.6153846153846154,0.6666666666666667,0.5128205128205128,0.5894095251440064,0.5539158017707626
+UBASH3B+OSR2,0.04580152671755725,0.02,0.05,0.04580152671755725,0.04580152671755725,0.12664640324214793,0.02,0.05,0.045,0.07,0.33029815543559937,0.6030534351145038,0.636700138874052,0.9541984732824428,131.0,987.0,0.29926723572605585,0.505257278771344,-0.017943568527698517,0.18036401271820068,0.24724172055721283,0.18036401271820068,0.24724172055721283,0.28205128205128205,0.23076923076923073,0.05128205128205132,0.5894095251440064,0.5539158017707626
+UBASH3B+ZBTB25,0.030927835051546393,0.04,0.030927835051546393,0.030927835051546393,0.030927835051546393,0.09302325581395349,0.04,0.03,0.035,0.054,0.33029815543559937,0.7938144329896907,0.747732817750771,0.9484536082474226,97.0,989.0,0.29926723572605585,0.505257278771344,0.25990623235702515,0.16194941103458405,0.2271558940410614,0.16194941103458405,0.2271559089422226,1.0,0.9743589743589743,0.8974358974358975,0.5894095251440064,0.5539158017707626
+ZC3HAV1+CEBPE,0.08641975308641975,0.06,0.08,0.08641975308641975,0.08641975308641975,0.16227180527383367,0.06,0.08,0.095,0.118,0.33029815543559937,0.8209876543209876,0.7384795473575855,0.9876543209876543,162.0,986.0,0.29926723572605585,0.505257278771344,0.3948254883289337,0.16430911421775818,0.23621705174446106,0.16430911421775818,0.23621705174446106,0.8461538461538461,0.8717948717948718,0.9487179487179487,0.5894095251440064,0.5539158017707626

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30-gene_noise_scale/loss_curve.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b852162ef28e157b01f5ed9dde9b1e1447de6cff03792f0ec6936413d3db768f
+size 10719440

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/eval_only/agg_results.csv

@@ -0,0 +1,10 @@
+statistic,overlap_at_N,overlap_at_50,overlap_at_100,overlap_at_200,overlap_at_500,precision_at_N,precision_at_50,precision_at_100,precision_at_200,precision_at_500,de_spearman_sig,de_direction_match,de_spearman_lfc_sig,de_sig_genes_recall,de_nsig_counts_real,de_nsig_counts_pred,pr_auc,roc_auc,pearson_delta,mse,mae,mse_delta,mae_delta,discrimination_score_l1,discrimination_score_l2,discrimination_score_cosine,pearson_edistance,clustering_agreement
+count,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0
+null_count,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+mean,0.0687149057815637,0.07009615384615388,0.07204117801259942,0.0707105259176851,0.0687149057815637,0.13346609982888166,0.06923076923076926,0.07076923076923079,0.06743589743589745,0.06723076923076925,-0.015221740472608315,0.7470488612797193,0.7576351502630989,0.9520688391366315,137.89743589743588,986.3333333333334,0.2813484798668912,0.5039338097416642,-0.09816616807037438,0.3772946603787251,0.4452836765692784,0.37729477080015034,0.4452836933808449,0.46811308349769887,0.4667981591058515,0.47600262984878366,-0.015104033722959698,0.12075294248443438
+std,0.05384035544352767,0.0452954342776042,0.05989275067839226,0.060780925117476396,0.05384035544352767,0.0719676074753807,0.045153808219918,0.060060698042835904,0.05975687358472482,0.05601807111547109,7.029602249318226e-18,0.08882782747139281,0.12346406500381771,0.028015030879046145,72.75871981447884,4.0674143689969435,1.1247363598909162e-16,1.1247363598909162e-16,0.1142131448976139,0.20924049905090392,0.19915411993246646,0.20924049545127096,0.19915412127783333,0.2792597688586586,0.27333985853690296,0.28587730554904617,3.514801124659113e-18,2.8118408997272905e-17
+min,0.0,0.0,0.0,0.0,0.0,0.032355915065722954,0.0,0.0,0.01,0.02,-0.015221740472608321,0.547945205479452,0.4665742024965326,0.8782608695652174,32.0,975.0,0.28134847986689143,0.5039338097416648,-0.27481886744499207,0.21513372659683228,0.23026183247566223,0.21513384580612183,0.23026184737682343,0.02564102564102566,0.02564102564102566,0.02564102564102566,-0.0151040337229597,0.12075294248443444
+25%,0.03636363636363636,0.04,0.03508771929824561,0.03636363636363636,0.03636363636363636,0.09634888438133875,0.04,0.03,0.04,0.038,-0.015221740472608321,0.6818181818181818,0.6924097500771367,0.9479166666666666,103.0,985.0,0.28134847986689143,0.5039338097416648,-0.15727567672729492,0.2479596734046936,0.28246796131134033,0.24795979261398315,0.28246796131134033,0.23076923076923073,0.2564102564102564,0.2564102564102564,-0.0151040337229597,0.12075294248443444
+50%,0.05555555555555555,0.06,0.06,0.05555555555555555,0.05555555555555555,0.11189516129032258,0.06,0.06,0.05,0.05,-0.015221740472608321,0.7557251908396947,0.783661735893894,0.9579439252336449,117.0,987.0,0.28134847986689143,0.5039338097416648,-0.10714814811944962,0.30672508478164673,0.36839988827705383,0.3067252039909363,0.36839988827705383,0.4358974358974359,0.4358974358974359,0.4358974358974359,-0.0151040337229597,0.12075294248443444
+75%,0.08602150537634409,0.1,0.09375,0.08602150537634409,0.08602150537634409,0.15587044534412955,0.1,0.09,0.075,0.074,-0.015221740472608321,0.8155339805825242,0.8520840046410592,0.971830985915493,158.0,989.0,0.28134847986689143,0.5039338097416648,-0.04866274446249008,0.4154452085494995,0.545539915561676,0.41544538736343384,0.545539915561676,0.6923076923076923,0.6923076923076923,0.717948717948718,-0.0151040337229597,0.12075294248443444
+max,0.2584856396866841,0.2,0.31,0.31,0.2584856396866841,0.37917087967644086,0.2,0.31,0.31,0.268,-0.015221740472608321,0.8932291666666666,0.9190682247506919,1.0,384.0,994.0,0.28134847986689143,0.5039338097416648,0.33663976192474365,1.1777018308639526,1.0532764196395874,1.1777019500732422,1.0532764196395874,0.9743589743589743,1.0,1.0,-0.0151040337229597,0.12075294248443444

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/eval_only/pred.h5ad

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a511f1478f94c16809d7b314e1a6df18f61294fb27918fcf16a0b23c685c2a57
+size 49952825

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/eval_only/real.h5ad

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d906eb6262ae9d587a091c8f6722e562182c9cd62e18f7c2faecbd7c4935ec3c
+size 75069953

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/eval_only/results.csv

@@ -0,0 +1,40 @@
+perturbation,overlap_at_N,overlap_at_50,overlap_at_100,overlap_at_200,overlap_at_500,precision_at_N,precision_at_50,precision_at_100,precision_at_200,precision_at_500,de_spearman_sig,de_direction_match,de_spearman_lfc_sig,de_sig_genes_recall,de_nsig_counts_real,de_nsig_counts_pred,pr_auc,roc_auc,pearson_delta,mse,mae,mse_delta,mae_delta,discrimination_score_l1,discrimination_score_l2,discrimination_score_cosine,pearson_edistance,clustering_agreement
+AHR+FEV,0.11682242990654206,0.1,0.16,0.125,0.11682242990654206,0.2074898785425101,0.1,0.16,0.125,0.116,-0.015221740472608321,0.8084112149532711,0.8520840046410592,0.9579439252336449,214.0,988.0,0.28134847986689143,0.5039338097416648,-0.043981004506349564,0.3413451910018921,0.4569126069545746,0.34134531021118164,0.45691266655921936,0.9743589743589743,1.0,0.9487179487179487,-0.0151040337229597,0.12075294248443444
+AHR+KLF1,0.11428571428571428,0.14,0.13,0.11428571428571428,0.11428571428571428,0.13549039433771487,0.14,0.13,0.09,0.066,-0.015221740472608321,0.7785714285714286,0.8016101861777768,0.9571428571428572,140.0,989.0,0.28134847986689143,0.5039338097416648,-0.23507823050022125,0.3427257835865021,0.45915278792381287,0.3427259027957916,0.45915281772613525,0.4358974358974359,0.3846153846153846,0.17948717948717952,-0.0151040337229597,0.12075294248443444
+BCL2L11+BAK1,0.09375,0.09375,0.09375,0.09375,0.09375,0.032355915065722954,0.06,0.03,0.045,0.038,-0.015221740472608321,0.84375,0.8434463794683776,1.0,32.0,989.0,0.28134847986689143,0.5039338097416648,0.07442901283502579,0.24253018200397491,0.3316977620124817,0.24253028631210327,0.3316977620124817,0.05128205128205132,0.02564102564102566,0.8974358974358975,-0.0151040337229597,0.12075294248443444
+BPGM+ZBTB1,0.05454545454545454,0.08,0.06,0.05454545454545454,0.05454545454545454,0.10616784630940344,0.08,0.06,0.04,0.038,-0.015221740472608321,0.6818181818181818,0.7084041684892157,0.9545454545454546,110.0,989.0,0.28134847986689143,0.5039338097416648,-0.1599692851305008,0.3571409285068512,0.47234514355659485,0.35714101791381836,0.47234517335891724,0.5641025641025641,0.5641025641025641,0.4358974358974359,-0.0151040337229597,0.12075294248443444
+CBL+PTPN12,0.038461538461538464,0.06,0.04,0.038461538461538464,0.038461538461538464,0.09634888438133875,0.06,0.04,0.045,0.038,-0.015221740472608321,0.6153846153846154,0.4665742024965326,0.9134615384615384,104.0,986.0,0.28134847986689143,0.5039338097416648,-0.16663847863674164,0.2556036412715912,0.2707608640193939,0.25560376048088074,0.2707608640193939,0.6923076923076923,0.6153846153846154,0.3846153846153846,-0.0151040337229597,0.12075294248443444
+CBL+PTPN9,0.031578947368421054,0.04,0.031578947368421054,0.031578947368421054,0.031578947368421054,0.09035532994923857,0.04,0.03,0.045,0.034,-0.015221740472608321,0.5684210526315789,0.5098407010274644,0.9368421052631579,95.0,985.0,0.28134847986689143,0.5039338097416648,-0.09738074988126755,0.4154452085494995,0.545539915561676,0.41544538736343384,0.545539915561676,0.641025641025641,0.7435897435897436,0.717948717948718,-0.0151040337229597,0.12075294248443444
+CBL+TGFBR2,0.0273972602739726,0.02,0.0273972602739726,0.0273972602739726,0.0273972602739726,0.0708502024291498,0.02,0.02,0.035,0.036,-0.015221740472608321,0.6575342465753424,0.6924097500771367,0.958904109589041,73.0,988.0,0.28134847986689143,0.5039338097416648,-0.09446369856595993,0.4138798117637634,0.5478195548057556,0.4138799011707306,0.5478195548057556,0.33333333333333337,0.33333333333333337,0.23076923076923073,-0.0151040337229597,0.12075294248443444
+CBL+UBASH3A,0.0,0.0,0.0,0.0,0.0,0.0465587044534413,0.0,0.0,0.01,0.022,-0.015221740472608321,0.7446808510638298,0.8717622571692877,0.9787234042553191,47.0,988.0,0.28134847986689143,0.5039338097416648,-0.1351209431886673,0.3813636600971222,0.5037379264831543,0.38136377930641174,0.5037379264831543,0.6923076923076923,0.8205128205128205,0.7435897435897436,-0.0151040337229597,0.12075294248443444
+CBL+UBASH3B,0.08904109589041095,0.14,0.11,0.08904109589041095,0.08904109589041095,0.1417004048582996,0.14,0.11,0.07,0.042,-0.015221740472608321,0.547945205479452,0.5069527797611008,0.958904109589041,146.0,988.0,0.28134847986689143,0.5039338097416648,-0.10714814811944962,0.5745765566825867,0.6785131096839905,0.5745766758918762,0.6785131692886353,0.4358974358974359,0.5384615384615384,0.23076923076923073,-0.0151040337229597,0.12075294248443444
+CDKN1B+CDKN1A,0.02912621359223301,0.02,0.03,0.02912621359223301,0.02912621359223301,0.10060975609756098,0.02,0.03,0.045,0.062,-0.015221740472608321,0.8155339805825242,0.9190682247506919,0.9611650485436893,103.0,984.0,0.28134847986689143,0.5039338097416648,-0.12452513724565506,0.23722562193870544,0.2739097476005554,0.237225741147995,0.2739097476005554,0.8717948717948718,0.5897435897435898,0.7435897435897436,-0.0151040337229597,0.12075294248443444
+CDKN1C+CDKN1B,0.03636363636363636,0.02,0.02,0.03636363636363636,0.03636363636363636,0.10940695296523517,0.02,0.02,0.045,0.074,-0.015221740472608321,0.8090909090909091,0.9107089723822662,0.9727272727272728,110.0,978.0,0.28134847986689143,0.5039338097416648,-0.09455454349517822,0.22628702223300934,0.23856350779533386,0.2262871414422989,0.23856352269649506,0.8974358974358975,0.5384615384615384,0.5897435897435898,-0.0151040337229597,0.12075294248443444
+CEBPE+CEBPA,0.2584856396866841,0.12,0.31,0.31,0.2584856396866841,0.3738508682328907,0.12,0.31,0.31,0.268,-0.015221740472608321,0.8929503916449086,0.8602535942363543,0.9556135770234987,383.0,979.0,0.28134847986689143,0.5039338097416648,-0.04866274446249008,0.30672508478164673,0.2823221981525421,0.3067252039909363,0.2823222577571869,0.02564102564102566,0.1282051282051282,0.33333333333333337,-0.0151040337229597,0.12075294248443444
+CEBPE+CNN1,0.06802721088435375,0.1,0.07,0.06802721088435375,0.06802721088435375,0.1458966565349544,0.1,0.07,0.08,0.092,-0.015221740472608321,0.8231292517006803,0.8962469486619458,0.9795918367346939,147.0,987.0,0.28134847986689143,0.5039338097416648,-0.11555256694555283,0.31393852829933167,0.43378910422325134,0.3139386475086212,0.43378913402557373,0.6666666666666667,0.3076923076923077,0.28205128205128205,-0.0151040337229597,0.12075294248443444
+ETS2+IGDCC3,0.08695652173913043,0.1,0.09,0.08695652173913043,0.08695652173913043,0.11189516129032258,0.1,0.09,0.06,0.05,-0.015221740472608321,0.7739130434782608,0.8359986739075524,0.9652173913043478,115.0,992.0,0.28134847986689143,0.5039338097416648,-0.03447481989860535,0.6627277731895447,0.761300802230835,0.6627278923988342,0.761300802230835,0.23076923076923073,0.23076923076923073,0.33333333333333337,-0.0151040337229597,0.12075294248443444
+ETS2+IKZF3,0.08602150537634409,0.14,0.1,0.08602150537634409,0.08602150537634409,0.1814516129032258,0.14,0.1,0.095,0.068,-0.015221740472608321,0.7795698924731183,0.7054478792034593,0.967741935483871,186.0,992.0,0.28134847986689143,0.5039338097416648,-0.26221078634262085,1.0517516136169434,0.9778569340705872,1.051751732826233,0.9778569340705872,0.6666666666666667,0.7435897435897436,0.3589743589743589,-0.0151040337229597,0.12075294248443444
+FEV+ISL2,0.06578947368421052,0.02,0.05,0.06578947368421052,0.06578947368421052,0.14661274014155712,0.02,0.05,0.07,0.066,-0.015221740472608321,0.743421052631579,0.8255491546864049,0.9539473684210527,152.0,989.0,0.28134847986689143,0.5039338097416648,-0.18080253899097443,0.2640528380870819,0.2989949882030487,0.26405295729637146,0.2989950180053711,0.8974358974358975,0.9743589743589743,0.8461538461538461,-0.0151040337229597,0.12075294248443444
+FOSB+CEBPB,0.1568627450980392,0.2,0.11,0.155,0.1568627450980392,0.25050709939148075,0.2,0.11,0.155,0.192,-0.015221740472608321,0.8823529411764706,0.8882606303658555,0.9686274509803922,255.0,986.0,0.28134847986689143,0.5039338097416648,-0.06540774554014206,0.29934367537498474,0.36839988827705383,0.2993438243865967,0.36839988827705383,0.4871794871794872,0.6153846153846154,0.4358974358974359,-0.0151040337229597,0.12075294248443444
+FOXA3+FOXA1,0.06428571428571428,0.1,0.07,0.06428571428571428,0.06428571428571428,0.13224821973550355,0.1,0.07,0.055,0.08,-0.015221740472608321,0.75,0.901255193527225,0.9285714285714286,140.0,983.0,0.28134847986689143,0.5039338097416648,-0.1105005219578743,0.2329549938440323,0.27338269352912903,0.23295509815216064,0.2733827233314514,0.4358974358974359,0.3846153846153846,0.2564102564102564,-0.0151040337229597,0.12075294248443444
+KLF1+BAK1,0.07291666666666667,0.08,0.07291666666666667,0.07291666666666667,0.07291666666666667,0.0922920892494929,0.08,0.07,0.045,0.04,-0.015221740472608321,0.6458333333333334,0.7011887314769581,0.9479166666666666,96.0,986.0,0.28134847986689143,0.5039338097416648,-0.21891900897026062,0.36979371309280396,0.4932716488838196,0.3697938323020935,0.49327167868614197,0.28205128205128205,0.2564102564102564,0.1282051282051282,-0.0151040337229597,0.12075294248443444
+KLF1+CEBPA,0.25,0.08,0.24,0.27,0.25,0.37917087967644086,0.08,0.24,0.27,0.26,-0.015221740472608321,0.8932291666666666,0.8307995818747724,0.9765625,384.0,989.0,0.28134847986689143,0.5039338097416648,-0.061934586614370346,0.2844974398612976,0.3347744047641754,0.2844974994659424,0.3347744047641754,0.23076923076923073,0.3076923076923077,0.15384615384615385,-0.0151040337229597,0.12075294248443444
+KLF1+CLDN6,0.04580152671755725,0.04,0.04,0.04580152671755725,0.04580152671755725,0.1301715438950555,0.04,0.04,0.055,0.064,-0.015221740472608321,0.7557251908396947,0.8292067051035661,0.9847328244274809,131.0,991.0,0.28134847986689143,0.5039338097416648,-0.25307101011276245,0.4211171269416809,0.5332732796669006,0.42111721634864807,0.5332733392715454,0.5897435897435898,0.8205128205128205,0.41025641025641024,-0.0151040337229597,0.12075294248443444
+LYL1+CEBPB,0.056962025316455694,0.02,0.08,0.056962025316455694,0.056962025316455694,0.15587044534412955,0.02,0.08,0.065,0.09,-0.015221740472608321,0.8227848101265823,0.9115847071032298,0.9746835443037974,158.0,988.0,0.28134847986689143,0.5039338097416648,-0.18229441344738007,0.24158596992492676,0.28246796131134033,0.2415860891342163,0.28246796131134033,0.8461538461538461,0.4871794871794872,0.5641025641025641,-0.0151040337229597,0.12075294248443444
+MAP2K3+ELMSAN1,0.012987012987012988,0.04,0.02,0.012987012987012988,0.012987012987012988,0.14979757085020243,0.04,0.02,0.02,0.062,-0.015221740472608321,0.8051948051948052,0.7557730366246674,0.961038961038961,154.0,988.0,0.28134847986689143,0.5039338097416648,0.010955821722745895,0.4610966444015503,0.6009400486946106,0.46109670400619507,0.6009401082992554,0.2564102564102564,0.3076923076923077,0.8461538461538461,-0.0151040337229597,0.12075294248443444
+MAP2K3+IKZF3,0.07407407407407407,0.08,0.06,0.07407407407407407,0.07407407407407407,0.10739614994934144,0.08,0.06,0.05,0.036,-0.015221740472608321,0.75,0.7662882362473429,0.9814814814814815,108.0,987.0,0.28134847986689143,0.5039338097416648,-0.21385297179222107,0.4999431073665619,0.5989157557487488,0.49994322657585144,0.5989157557487488,0.17948717948717952,0.28205128205128205,0.10256410256410253,-0.0151040337229597,0.12075294248443444
+MAP2K3+MAP2K6,0.028169014084507043,0.04,0.028169014084507043,0.028169014084507043,0.028169014084507043,0.06990881458966565,0.04,0.03,0.02,0.02,-0.015221740472608321,0.7323943661971831,0.6632745897496378,0.971830985915493,71.0,987.0,0.28134847986689143,0.5039338097416648,0.13404417037963867,0.2546497881412506,0.35721859335899353,0.25464990735054016,0.3572186231613159,0.05128205128205132,0.07692307692307687,0.9743589743589743,-0.0151040337229597,0.12075294248443444
+MAP2K3+SLC38A2,0.03508771929824561,0.04,0.03508771929824561,0.03508771929824561,0.03508771929824561,0.05268490374873354,0.04,0.06,0.045,0.024,-0.015221740472608321,0.7719298245614035,0.6917532467532468,0.9122807017543859,57.0,987.0,0.28134847986689143,0.5039338097416648,0.33663976192474365,0.2342057228088379,0.3242628276348114,0.23420584201812744,0.3242628276348114,0.10256410256410253,0.1282051282051282,1.0,-0.0151040337229597,0.12075294248443444
+MAP2K6+ELMSAN1,0.05813953488372093,0.06,0.05813953488372093,0.05813953488372093,0.05813953488372093,0.08198380566801619,0.06,0.06,0.05,0.042,-0.015221740472608321,0.8255813953488372,0.8137041127441264,0.9418604651162791,86.0,988.0,0.28134847986689143,0.5039338097416648,0.02608500048518181,0.49398142099380493,0.6317513585090637,0.4939815402030945,0.6317513585090637,0.1282051282051282,0.1282051282051282,0.717948717948718,-0.0151040337229597,0.12075294248443444
+MAPK1+IKZF3,0.07926829268292683,0.08,0.08,0.07926829268292683,0.07926829268292683,0.16279069767441862,0.08,0.08,0.08,0.062,-0.015221740472608321,0.7560975609756098,0.7807603098919187,0.9817073170731707,164.0,989.0,0.28134847986689143,0.5039338097416648,-0.27481886744499207,0.6549879312515259,0.7375942468643188,0.6549879312515259,0.7375942468643188,0.8717948717948718,0.8461538461538461,0.6666666666666667,-0.0151040337229597,0.12075294248443444
+PTPN12+PTPN9,0.05102040816326531,0.02,0.05102040816326531,0.05102040816326531,0.05102040816326531,0.09210526315789473,0.02,0.05,0.03,0.034,-0.015221740472608321,0.6530612244897959,0.5569145611998929,0.9285714285714286,98.0,988.0,0.28134847986689143,0.5039338097416648,-0.15727567672729492,0.2679036557674408,0.3364432454109192,0.26790374517440796,0.3364432454109192,0.641025641025641,0.7435897435897436,0.717948717948718,-0.0151040337229597,0.12075294248443444
+PTPN12+UBASH3A,0.05217391304347826,0.04,0.06,0.05217391304347826,0.05217391304347826,0.10337768679631525,0.04,0.06,0.055,0.05,-0.015221740472608321,0.6608695652173913,0.567604630560667,0.8782608695652174,115.0,977.0,0.28134847986689143,0.5039338097416648,-0.15085093677043915,0.2479596734046936,0.25695696473121643,0.24795979261398315,0.25695696473121643,0.717948717948718,0.8205128205128205,0.5897435897435898,-0.0151040337229597,0.12075294248443444
+SGK1+S1PR2,0.07692307692307693,0.14,0.11,0.07692307692307693,0.07692307692307693,0.18921668362156663,0.14,0.11,0.08,0.082,-0.015221740472608321,0.764102564102564,0.783661735893894,0.9538461538461539,195.0,983.0,0.28134847986689143,0.5039338097416648,-0.14698824286460876,0.24700455367565155,0.2739073634147644,0.2470046728849411,0.2739073634147644,0.4358974358974359,0.6923076923076923,0.46153846153846156,-0.0151040337229597,0.12075294248443444
+SGK1+TBX2,0.09836065573770492,0.12,0.11,0.09836065573770492,0.09836065573770492,0.1111111111111111,0.12,0.11,0.075,0.048,-0.015221740472608321,0.6967213114754098,0.7599896872118121,0.8934426229508197,122.0,981.0,0.28134847986689143,0.5039338097416648,-0.15363425016403198,0.23979508876800537,0.2535415589809418,0.2397952377796173,0.2535415589809418,0.46153846153846156,0.641025641025641,0.641025641025641,-0.0151040337229597,0.12075294248443444
+SGK1+TBX3,0.027522935779816515,0.06,0.03,0.027522935779816515,0.027522935779816515,0.09948717948717949,0.06,0.03,0.03,0.04,-0.015221740472608321,0.7247706422018348,0.7509871897072727,0.8899082568807339,109.0,975.0,0.28134847986689143,0.5039338097416648,-0.09961944818496704,0.23880180716514587,0.23026183247566223,0.23880194127559662,0.23026184737682343,0.23076923076923073,0.1282051282051282,0.02564102564102566,-0.0151040337229597,0.12075294248443444
+TBX3+TBX2,0.024691358024691357,0.06,0.03,0.024691358024691357,0.024691358024691357,0.15634517766497463,0.06,0.03,0.02,0.028,-0.015221740472608321,0.6728395061728395,0.6206747662861152,0.9506172839506173,162.0,985.0,0.28134847986689143,0.5039338097416648,-0.02766571380198002,0.2535446286201477,0.312412828207016,0.25354474782943726,0.312412828207016,0.17948717948717952,0.23076923076923073,0.07692307692307687,-0.0151040337229597,0.12075294248443444
+TGFBR2+IGDCC3,0.03669724770642202,0.08,0.04,0.03669724770642202,0.03669724770642202,0.09939148073022312,0.08,0.04,0.04,0.038,-0.015221740472608321,0.6422018348623854,0.6681604374724842,0.8990825688073395,109.0,986.0,0.28134847986689143,0.5039338097416648,-0.08248806744813919,0.373935729265213,0.5070279836654663,0.37393584847450256,0.5070280432701111,0.33333333333333337,0.41025641025641024,0.3076923076923077,-0.0151040337229597,0.12075294248443444
+TGFBR2+PRTG,0.05128205128205128,0.08,0.06,0.05128205128205128,0.05128205128205128,0.11324570273003033,0.08,0.06,0.045,0.05,-0.015221740472608321,0.7435897435897436,0.8064378325713858,0.9572649572649573,117.0,989.0,0.28134847986689143,0.5039338097416648,-0.09338690340518951,0.2547054588794708,0.32076728343963623,0.254705548286438,0.32076728343963623,0.8205128205128205,0.6666666666666667,0.717948717948718,-0.0151040337229597,0.12075294248443444
+UBASH3B+OSR2,0.022900763358778626,0.02,0.01,0.022900763358778626,0.022900763358778626,0.12677484787018256,0.02,0.01,0.03,0.048,-0.015221740472608321,0.8702290076335878,0.8392693088345262,0.9541984732824428,131.0,986.0,0.28134847986689143,0.5039338097416648,-0.0992603525519371,0.36252862215042114,0.4986651837825775,0.3625286817550659,0.4986652433872223,0.07692307692307687,0.05128205128205132,0.02564102564102566,-0.0151040337229597,0.12075294248443444
+UBASH3B+ZBTB25,0.05154639175257732,0.02,0.05154639175257732,0.05154639175257732,0.05154639175257732,0.09356136820925554,0.02,0.05,0.035,0.026,-0.015221740472608321,0.5979381443298969,0.5989109633633871,0.9587628865979382,97.0,994.0,0.28134847986689143,0.5039338097416648,-0.12927569448947906,1.1777018308639526,1.0532764196395874,1.1777019500732422,1.0532764196395874,0.4871794871794872,0.4358974358974359,0.28205128205128205,-0.0151040337229597,0.12075294248443444
+ZC3HAV1+CEBPE,0.05555555555555555,0.04,0.04,0.05555555555555555,0.05555555555555555,0.15869786368260427,0.04,0.04,0.07,0.096,-0.015221740472608321,0.8333333333333334,0.8549527885602453,0.9629629629629629,162.0,983.0,0.28134847986689143,0.5039338097416648,0.011173766106367111,0.21513372659683228,0.25333306193351746,0.21513384580612183,0.25333306193351746,0.33333333333333337,0.20512820512820518,0.20512820512820518,-0.0151040337229597,0.12075294248443444

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/iteration_200000/agg_results.csv

@@ -0,0 +1,10 @@
+statistic,overlap_at_N,overlap_at_50,overlap_at_100,overlap_at_200,overlap_at_500,precision_at_N,precision_at_50,precision_at_100,precision_at_200,precision_at_500,de_spearman_sig,de_direction_match,de_spearman_lfc_sig,de_sig_genes_recall,de_nsig_counts_real,de_nsig_counts_pred,pr_auc,roc_auc,pearson_delta,mse,mae,mse_delta,mae_delta,discrimination_score_l1,discrimination_score_l2,discrimination_score_cosine,pearson_edistance,clustering_agreement
+count,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0,39.0
+null_count,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0
+mean,0.11519421730128585,0.1441666666666667,0.13608619577039166,0.12199893110144551,0.11519421730128585,0.13097097118424614,0.14461538461538462,0.13615384615384615,0.11423076923076923,0.08974358974358979,0.6332418020734603,0.9324184676174031,0.8917746949131188,0.9184538727141668,137.89743589743588,979.0,0.2880575211910082,0.48935821586474293,0.8659466023628528,0.0032901372820234452,0.020664628714514084,0.0032901372611283874,0.02066462878615428,0.982905982905983,0.9855358316896778,0.9822485207100592,0.9094629991495885,0.5172253296851504
+std,0.10911679356972502,0.178098816942986,0.15915939539825893,0.1308561436072056,0.10911679356972502,0.07367382584049335,0.17790958901180168,0.1589706259628751,0.13112638771298427,0.09193954476740565,1.1247363598909162e-16,0.044847550762776356,0.03591595623842836,0.046859942919392134,72.75871981447884,6.095727580596274,5.623681799454581e-17,1.1247363598909162e-16,0.14835018982393972,0.00254428920337228,0.006301677701137848,0.0025442891910013588,0.006301678112752034,0.053699219011755825,0.04771496559382434,0.05233528622867887,1.1247363598909162e-16,1.1247363598909162e-16
+min,0.0,0.0,0.0,0.0,0.0,0.03023983315954119,0.0,0.01,0.005,0.018,0.6332418020734609,0.8028169014084507,0.7653738585436534,0.7894736842105263,32.0,959.0,0.28805752119100814,0.48935821586474293,0.3626399338245392,0.0010964160319417715,0.013331997208297253,0.0010964160319417715,0.013331997208297253,0.6923076923076923,0.7435897435897436,0.6923076923076923,0.9094629991495881,0.517225329685151
+25%,0.05504587155963303,0.06,0.05263157894736842,0.05504587155963303,0.05504587155963303,0.09304703476482618,0.06,0.05,0.05,0.044,0.6332418020734609,0.908256880733945,0.8790188213514347,0.8775510204081632,103.0,975.0,0.28805752119100814,0.48935821586474293,0.8353385329246521,0.0018225981621071696,0.015485486015677452,0.0018225981621071696,0.015485486015677452,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+50%,0.09090909090909091,0.08,0.09,0.09090909090909091,0.09090909090909091,0.11031664964249234,0.08,0.09,0.075,0.06,0.6332418020734609,0.9426229508196722,0.8925854546657469,0.9361702127659575,117.0,979.0,0.28805752119100814,0.48935821586474293,0.9191223382949829,0.002537589054554701,0.019970763474702835,0.002537589054554701,0.019970763474702835,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+75%,0.11794871794871795,0.14,0.14,0.11794871794871795,0.11794871794871795,0.150253807106599,0.14,0.14,0.11,0.088,0.6332418020734609,0.9636363636363636,0.9127565302830871,0.9523809523809523,158.0,984.0,0.28805752119100814,0.48935821586474293,0.9598571062088013,0.0036052181385457516,0.023301221430301666,0.0036052181385457516,0.023301221430301666,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+max,0.47780678851174935,0.7,0.68,0.6,0.47780678851174935,0.38119312436804853,0.7,0.68,0.6,0.44,0.6332418020734609,1.0,0.9523373052245646,0.9882352941176471,384.0,989.0,0.28805752119100814,0.48935821586474293,0.9823881387710571,0.014034540392458439,0.043725334107875824,0.014034540392458439,0.04372533783316612,1.0,1.0,1.0,0.9094629991495881,0.517225329685151

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/iteration_200000/checkpoint.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2abf1b204fe86b56eb509b961e05ba1e7d79d1550cf374803dcf4d679653698
+size 697879461

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/iteration_200000/distributional_results.csv

@@ -0,0 +1,40 @@
+perturbation,mmd,energy_distance,var_ratio_median,var_ratio_mean,var_ratio_q25,var_ratio_q75,n_active_genes,gene_corr_preservation,c2st_accuracy,knn_precision,knn_recall
+AHR+FEV,0.017871205333452156,0.6095501879310561,0.84073805809021,1.5346680879592896,0.01687859743833542,1.4509820938110352,419,0.24909744841371353,1.0,0.1640625,0.625
+AHR+KLF1,0.034357126619798894,1.1556012296560043,2.629014492034912,5.149451732635498,1.256199836730957,4.948459148406982,361,0.3365450880756923,1.0,0.1171875,0.9635922330097088
+BCL2L11+BAK1,0.02392877055553816,0.7770588944246519,2.3781304359436035,3.3928043842315674,0.8111352920532227,3.6910805702209473,287,0.0868113699172741,1.0,0.03125,1.0
+BPGM+ZBTB1,0.02522936964912484,0.7498288621276643,1.86097252368927,2.8661279678344727,0.021859455853700638,3.030987501144409,349,0.25932415112769613,1.0,0.0390625,0.9858657243816255
+CBL+PTPN12,0.016337015127273313,0.5414247486838457,1.7423911094665527,2.415642023086548,0.019121097400784492,2.6805419921875,328,0.18471136629861323,1.0,0.0625,0.9883268482490273
+CBL+PTPN9,0.01393049569562868,0.44408079996008354,1.5896856784820557,2.0730984210968018,0.019897516816854477,2.4121322631835938,339,0.26377410903863496,1.0,0.1171875,0.9786324786324786
+CBL+TGFBR2,0.017601488765992213,0.5916268587548528,1.8463736772537231,2.9335246086120605,0.5761939883232117,2.8751730918884277,301,0.19589088754208966,1.0,0.09375,0.967948717948718
+CBL+UBASH3A,0.007156902394987091,0.45373675549275916,1.6510965824127197,1.787581205368042,0.9076695442199707,2.2331206798553467,224,0.2222333329122722,1.0,0.2578125,0.98
+CBL+UBASH3B,0.015620887459537935,0.49923960837651293,1.4929242134094238,2.095428228378296,0.01539005246013403,2.5580332279205322,358,0.2432356083538353,1.0,0.0859375,0.941717791411043
+CDKN1B+CDKN1A,0.016986083613670322,0.6153617795974498,1.868277907371521,2.235821008682251,0.5309271216392517,2.6217470169067383,309,0.21387505095101278,1.0,0.0703125,0.9693877551020408
+CDKN1C+CDKN1B,0.019226830893821822,0.7384003924230473,1.917527675628662,2.821695327758789,0.7641957402229309,3.195326089859009,309,0.24837230459250903,1.0,0.078125,0.9493670886075949
+CEBPE+CEBPA,0.0073074285219678625,0.43896788193304026,0.8989853858947754,1.0896122455596924,0.005009935237467289,1.2995184659957886,532,0.6103019839382675,1.0,0.2890625,0.8041666666666667
+CEBPE+CNN1,0.02035990656723438,0.7694203872828282,1.894156575202942,2.6646556854248047,0.148182675242424,2.9743330478668213,381,0.5166442377179713,1.0,0.078125,0.9742268041237113
+ETS2+IGDCC3,0.024169647573922037,0.8477079142023403,2.3727943897247314,4.564054012298584,0.7376527786254883,3.7823691368103027,361,0.2583669157300191,1.0,0.0546875,0.9835616438356164
+ETS2+IKZF3,0.012025324345781019,0.46212375470986444,1.5302391052246094,2.7363831996917725,0.013686561957001686,2.282700777053833,385,0.31727602111259556,1.0,0.109375,0.961340206185567
+FEV+ISL2,0.006897638672713674,0.3033519381459886,1.0069315433502197,1.477606177330017,0.011266712099313736,1.559715986251831,364,0.16860932955471028,1.0,0.171875,0.8639705882352942
+FOSB+CEBPB,0.002728314392996617,0.3560066317276753,1.0908515453338623,1.3968350887298584,0.4534429609775543,1.4848634004592896,385,0.579491036488545,1.0,0.2109375,0.8235294117647058
+FOXA3+FOXA1,0.01599826934778606,0.621929598202632,1.745820164680481,2.6857924461364746,0.17485445737838745,2.8334083557128906,346,0.28284588495139895,1.0,0.109375,0.9558011049723757
+KLF1+BAK1,0.027583615702892778,0.8643188022623765,2.448317050933838,3.7869436740875244,0.47198760509490967,4.07703161239624,324,0.19351806347505712,1.0,0.0234375,0.9752321981424149
+KLF1+CEBPA,0.012981627639382237,0.6344303869555716,1.1328973770141602,1.4404727220535278,0.007249907590448856,1.715933918952942,550,0.7760439091938879,1.0,0.1171875,0.8928571428571429
+KLF1+CLDN6,0.020552156661975213,0.7275642349563594,1.8240087032318115,2.9733777046203613,0.5940459966659546,2.919407367706299,356,0.31102660067886095,1.0,0.0703125,0.9441860465116279
+LYL1+CEBPB,0.03547898980765074,1.2598850469805747,2.0194613933563232,3.0153822898864746,0.9195641279220581,3.585127353668213,355,0.39999221734436885,1.0,0.0859375,0.949685534591195
+MAP2K3+ELMSAN1,0.029516842630050777,1.0780652402789404,2.645120620727539,3.728822946548462,0.6302378177642822,4.0531086921691895,348,0.39408777226180186,1.0,0.03125,0.9793388429752066
+MAP2K3+IKZF3,0.021609600520675232,0.7117643316855382,1.769496202468872,3.9200069904327393,0.02339593693614006,2.693678855895996,338,0.23962125555710506,1.0,0.0625,0.9590909090909091
+MAP2K3+MAP2K6,0.036565771905466504,1.438551858577351,3.200063705444336,5.679604530334473,1.3887274265289307,5.795802116394043,331,0.3201346622116306,1.0,0.0078125,0.9934497816593887
+MAP2K3+SLC38A2,0.03497964398864528,1.2970835392369073,3.9019343852996826,6.116195201873779,1.7040287256240845,6.520554065704346,341,0.24996802698857934,1.0,0.078125,0.9966329966329966
+MAP2K6+ELMSAN1,0.03380768083873226,1.255449094743681,3.3686110973358154,5.070409774780273,1.2703278064727783,5.113337993621826,336,0.3081864902584166,1.0,0.0,0.9972602739726028
+MAPK1+IKZF3,0.018391710415338353,0.6576522313654216,1.7688603401184082,3.038703680038452,0.02250317670404911,2.9092376232147217,358,0.2657594075014821,1.0,0.109375,0.9393939393939394
+PTPN12+PTPN9,0.01628275425020692,0.5096647152874549,1.7910417318344116,2.648109197616577,0.019618701189756393,2.8518285751342773,347,0.3240963956797399,1.0,0.140625,0.9627118644067797
+PTPN12+UBASH3A,0.021653192814435646,0.6863582789904239,1.75233793258667,2.89522385597229,0.019937967881560326,2.9382004737854004,346,0.26509425329359443,1.0,0.078125,0.9803921568627451
+SGK1+S1PR2,0.024770572770150684,0.7476247961561882,1.080904483795166,2.303792953491211,0.00931306928396225,2.1790482997894287,426,0.33618793997393126,1.0,0.0625,0.842948717948718
+SGK1+TBX2,0.017603437942806943,0.5593371773509048,1.6168527603149414,2.599722385406494,0.37884846329689026,2.863718032836914,362,0.29163202492555734,1.0,0.0625,0.9372822299651568
+SGK1+TBX3,0.023292383447586384,0.7750004697089921,1.9750012159347534,3.356232166290283,0.837866485118866,3.100588321685791,354,0.3037391395593573,1.0,0.2109375,0.9547325102880658
+TBX3+TBX2,0.025463679402857597,0.8960550665937888,2.1132760047912598,3.958543539047241,0.6611448526382446,4.3336029052734375,406,0.37959357453541626,1.0,0.03125,0.9711042311661506
+TGFBR2+IGDCC3,0.02180076625389335,0.6999195532877458,2.003127336502075,3.499674081802368,0.5839447975158691,3.616645336151123,340,0.19584110210984473,1.0,0.0703125,0.9580152671755725
+TGFBR2+PRTG,0.014074736217469935,0.4693327599772079,1.7232533693313599,2.5774388313293457,0.6362400054931641,2.6415903568267822,343,0.18281335564872775,1.0,0.046875,0.9567307692307693
+UBASH3B+OSR2,0.02393426557287104,0.7815013155507184,2.4277689456939697,3.840965986251831,0.7632312774658203,4.080033302307129,399,0.49544318767688666,1.0,0.078125,0.9719350073855244
+UBASH3B+ZBTB25,0.019073698571834302,0.532579537855435,1.8004943132400513,3.3618240356445312,0.02690613642334938,2.8842949867248535,338,0.2401615697349634,1.0,0.0703125,0.9821428571428571
+ZC3HAV1+CEBPE,0.04901620171109028,1.8157486718160714,2.698394536972046,5.284060478210449,0.9405089616775513,5.841714859008789,404,0.6277552124695357,1.0,0.046875,0.9826589595375722

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/iteration_200000/pred.h5ad

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d17f27ff6ca1c8aecd60577e2f878f180e5c5bc614d1954bb3ef23e14be31078
+size 49952825

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/iteration_200000/real.h5ad

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d906eb6262ae9d587a091c8f6722e562182c9cd62e18f7c2faecbd7c4935ec3c
+size 75069953

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/iteration_200000/results.csv

@@ -0,0 +1,40 @@
+perturbation,overlap_at_N,overlap_at_50,overlap_at_100,overlap_at_200,overlap_at_500,precision_at_N,precision_at_50,precision_at_100,precision_at_200,precision_at_500,de_spearman_sig,de_direction_match,de_spearman_lfc_sig,de_sig_genes_recall,de_nsig_counts_real,de_nsig_counts_pred,pr_auc,roc_auc,pearson_delta,mse,mae,mse_delta,mae_delta,discrimination_score_l1,discrimination_score_l2,discrimination_score_cosine,pearson_edistance,clustering_agreement
+AHR+FEV,0.19158878504672897,0.16,0.19,0.195,0.19158878504672897,0.20871327254305977,0.16,0.19,0.195,0.132,0.6332418020734609,0.9345794392523364,0.8925854546657469,0.9626168224299065,214.0,987.0,0.28805752119100814,0.48935821586474293,0.9013275504112244,0.0070017259567976,0.02869582735002041,0.0070017259567976,0.02869582735002041,0.9743589743589743,0.9743589743589743,1.0,0.9094629991495881,0.517225329685151
+AHR+KLF1,0.1357142857142857,0.18,0.17,0.1357142857142857,0.1357142857142857,0.13516260162601626,0.18,0.17,0.11,0.082,0.6332418020734609,0.8928571428571429,0.8721739701152946,0.95,140.0,984.0,0.28805752119100814,0.48935821586474293,0.8318105936050415,0.006111051421612501,0.030300145968794823,0.006111051421612501,0.030300145968794823,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+BCL2L11+BAK1,0.0625,0.0625,0.0625,0.0625,0.0625,0.03023983315954119,0.08,0.04,0.03,0.032,0.6332418020734609,0.96875,0.9523373052245646,0.90625,32.0,959.0,0.28805752119100814,0.48935821586474293,0.49549615383148193,0.001314719207584858,0.01406504400074482,0.001314719207584858,0.01406504400074482,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+BPGM+ZBTB1,0.09090909090909091,0.12,0.09,0.09090909090909091,0.09090909090909091,0.10499490316004077,0.12,0.09,0.08,0.06,0.6332418020734609,0.9636363636363636,0.8920449677352441,0.9363636363636364,110.0,981.0,0.28805752119100814,0.48935821586474293,0.9630479216575623,0.002537589054554701,0.017403235659003258,0.002537589054554701,0.017403235659003258,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+CBL+PTPN12,0.0673076923076923,0.06,0.05,0.0673076923076923,0.0673076923076923,0.09304703476482618,0.06,0.05,0.06,0.046,0.6332418020734609,0.9519230769230769,0.9089832497599488,0.875,104.0,978.0,0.28805752119100814,0.48935821586474293,0.977382242679596,0.0010964160319417715,0.013331997208297253,0.0010964160319417715,0.013331997208297253,0.9743589743589743,1.0,1.0,0.9094629991495881,0.517225329685151
+CBL+PTPN9,0.05263157894736842,0.04,0.05263157894736842,0.05263157894736842,0.05263157894736842,0.08324768756423433,0.04,0.05,0.045,0.036,0.6332418020734609,0.9473684210526315,0.9284834401858955,0.8526315789473684,95.0,973.0,0.28805752119100814,0.48935821586474293,0.953681468963623,0.0012305708369240165,0.01380966603755951,0.0012305708369240165,0.01380966603755951,1.0,1.0,0.9743589743589743,0.9094629991495881,0.517225329685151
+CBL+TGFBR2,0.0273972602739726,0.04,0.0273972602739726,0.0273972602739726,0.0273972602739726,0.06591143151390319,0.04,0.02,0.015,0.04,0.6332418020734609,0.9315068493150684,0.8790188213514347,0.8767123287671232,73.0,971.0,0.28805752119100814,0.48935821586474293,0.9417880773544312,0.0013098922790959477,0.014323247596621513,0.0013098923955112696,0.014323247596621513,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+CBL+UBASH3A,0.0,0.0,0.0,0.0,0.0,0.0449438202247191,0.0,0.01,0.005,0.018,0.6332418020734609,1.0,0.9229879740980573,0.9361702127659575,47.0,979.0,0.28805752119100814,0.48935821586474293,0.9483551383018494,0.0013087592087686062,0.014976558275520802,0.0013087592087686062,0.014976556412875652,1.0,1.0,0.9743589743589743,0.9094629991495881,0.517225329685151
+CBL+UBASH3B,0.1095890410958904,0.08,0.13,0.1095890410958904,0.1095890410958904,0.12949640287769784,0.08,0.13,0.095,0.074,0.6332418020734609,0.8972602739726028,0.8937534976167962,0.863013698630137,146.0,973.0,0.28805752119100814,0.48935821586474293,0.9693173766136169,0.0018225981621071696,0.015270755626261234,0.0018225981621071696,0.015270755626261234,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+CDKN1B+CDKN1A,0.08737864077669903,0.06,0.07,0.08737864077669903,0.08737864077669903,0.10295616717635066,0.06,0.07,0.05,0.044,0.6332418020734609,0.9514563106796117,0.8699095022624435,0.9805825242718447,103.0,981.0,0.28805752119100814,0.48935821586474293,0.9378287196159363,0.0014515386428683996,0.015378400683403015,0.0014515385264530778,0.015378400683403015,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+CDKN1C+CDKN1B,0.05454545454545454,0.04,0.05,0.05454545454545454,0.05454545454545454,0.10520939734422881,0.04,0.05,0.05,0.052,0.6332418020734609,0.9454545454545454,0.8526693536025679,0.9363636363636364,110.0,979.0,0.28805752119100814,0.48935821586474293,0.9132230281829834,0.0019759947899729013,0.01768781617283821,0.0019759945571422577,0.01768781617283821,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+CEBPE+CEBPA,0.47780678851174935,0.66,0.68,0.6,0.47780678851174935,0.3775303643724696,0.66,0.68,0.6,0.44,0.6332418020734609,0.9817232375979112,0.909864328541876,0.9738903394255874,383.0,988.0,0.28805752119100814,0.48935821586474293,0.976327121257782,0.004681455437093973,0.026166625320911407,0.004681455437093973,0.026166627183556557,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+CEBPE+CNN1,0.17006802721088435,0.3,0.19,0.17006802721088435,0.17006802721088435,0.14242115971515767,0.3,0.19,0.145,0.098,0.6332418020734609,0.9727891156462585,0.8822202404794474,0.9523809523809523,147.0,983.0,0.28805752119100814,0.48935821586474293,0.8531714677810669,0.0037261589895933867,0.023773400112986565,0.0037261589895933867,0.023773400112986565,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+ETS2+IGDCC3,0.09565217391304348,0.12,0.11,0.09565217391304348,0.09565217391304348,0.10986775178026449,0.12,0.11,0.07,0.06,0.6332418020734609,0.9478260869565217,0.9043950492548624,0.9391304347826087,115.0,983.0,0.28805752119100814,0.48935821586474293,0.7988293170928955,0.0024004625156521797,0.019970763474702835,0.0024004625156521797,0.019970763474702835,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+ETS2+IKZF3,0.10215053763440861,0.12,0.13,0.10215053763440861,0.10215053763440861,0.1790437436419125,0.12,0.13,0.095,0.088,0.6332418020734609,0.9408602150537635,0.8917085321652976,0.946236559139785,186.0,983.0,0.28805752119100814,0.48935821586474293,0.9823881387710571,0.0014583180891349912,0.015018215402960777,0.001458318205550313,0.015018216334283352,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+FEV+ISL2,0.09210526315789473,0.06,0.1,0.09210526315789473,0.09210526315789473,0.1413934426229508,0.06,0.1,0.09,0.088,0.6332418020734609,0.9276315789473685,0.8878203046205918,0.9078947368421053,152.0,976.0,0.28805752119100814,0.48935821586474293,0.9518364071846008,0.0019144585821777582,0.016919277608394623,0.0019144585821777582,0.016919277608394623,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+FOSB+CEBPB,0.3764705882352941,0.66,0.59,0.445,0.3764705882352941,0.2550607287449393,0.66,0.59,0.445,0.258,0.6332418020734609,1.0,0.9066561943507405,0.9882352941176471,255.0,988.0,0.28805752119100814,0.48935821586474293,0.977456271648407,0.002410425106063485,0.021261680871248245,0.002410425106063485,0.021261680871248245,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+FOXA3+FOXA1,0.12857142857142856,0.24,0.16,0.12857142857142856,0.12857142857142856,0.1350253807106599,0.24,0.16,0.115,0.074,0.6332418020734609,0.9642857142857143,0.8766017931336103,0.95,140.0,985.0,0.28805752119100814,0.48935821586474293,0.891557514667511,0.003311346983537078,0.023301221430301666,0.003311346983537078,0.023301221430301666,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+KLF1+BAK1,0.052083333333333336,0.02,0.052083333333333336,0.052083333333333336,0.052083333333333336,0.08324768756423433,0.02,0.05,0.05,0.044,0.6332418020734609,0.9166666666666666,0.8878847093307279,0.84375,96.0,973.0,0.28805752119100814,0.48935821586474293,0.8811741471290588,0.0019680752884596586,0.017907410860061646,0.0019680752884596586,0.017907410860061646,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+KLF1+CEBPA,0.46875,0.7,0.63,0.54,0.46875,0.38119312436804853,0.7,0.63,0.54,0.434,0.6332418020734609,0.9765625,0.8985173185614233,0.9817708333333334,384.0,989.0,0.28805752119100814,0.48935821586474293,0.9599469900131226,0.005551111418753862,0.029670581221580505,0.005551111418753862,0.029670581221580505,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+KLF1+CLDN6,0.0916030534351145,0.1,0.07,0.0916030534351145,0.0916030534351145,0.12703252032520326,0.1,0.07,0.085,0.078,0.6332418020734609,0.9618320610687023,0.9197736493700619,0.9541984732824428,131.0,984.0,0.28805752119100814,0.48935821586474293,0.932437539100647,0.0034321732819080353,0.020545365288853645,0.0034321732819080353,0.020545365288853645,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+LYL1+CEBPB,0.189873417721519,0.36,0.23,0.189873417721519,0.189873417721519,0.150253807106599,0.36,0.23,0.155,0.11,0.6332418020734609,0.9620253164556962,0.8901968064224567,0.9367088607594937,158.0,985.0,0.28805752119100814,0.48935821586474293,0.7348770499229431,0.009552625939249992,0.03352374956011772,0.009552625939249992,0.03352374956011772,1.0,1.0,0.9230769230769231,0.9094629991495881,0.517225329685151
+MAP2K3+ELMSAN1,0.05844155844155844,0.06,0.05,0.05844155844155844,0.05844155844155844,0.13903192584963955,0.06,0.05,0.06,0.074,0.6332418020734609,0.8376623376623377,0.8501914063720967,0.8766233766233766,154.0,971.0,0.28805752119100814,0.48935821586474293,0.8099707365036011,0.002013053512200713,0.017642803490161896,0.002013053512200713,0.017642803490161896,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+MAP2K3+IKZF3,0.10185185185185185,0.12,0.1,0.10185185185185185,0.10185185185185185,0.10558375634517767,0.12,0.1,0.09,0.054,0.6332418020734609,0.9907407407407407,0.9449131135195935,0.9629629629629629,108.0,985.0,0.28805752119100814,0.48935821586474293,0.9664058089256287,0.003377813147380948,0.020242661237716675,0.003377813147380948,0.020242661237716675,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+MAP2K3+MAP2K6,0.04225352112676056,0.04,0.04225352112676056,0.04225352112676056,0.04225352112676056,0.06141248720573183,0.04,0.04,0.04,0.04,0.6332418020734609,0.8028169014084507,0.7653738585436534,0.8450704225352113,71.0,977.0,0.28805752119100814,0.48935821586474293,0.43246954679489136,0.0031695833895355463,0.022692466154694557,0.0031695833895355463,0.022692466154694557,0.9743589743589743,1.0,0.9743589743589743,0.9094629991495881,0.517225329685151
+MAP2K3+SLC38A2,0.0,0.0,0.0,0.0,0.0,0.04620123203285421,0.0,0.01,0.03,0.034,0.6332418020734609,0.8421052631578947,0.7997402597402598,0.7894736842105263,57.0,974.0,0.28805752119100814,0.48935821586474293,0.3626399338245392,0.0032979159150272608,0.024129455909132957,0.0032979159150272608,0.024129455909132957,0.9743589743589743,0.9743589743589743,0.9743589743589743,0.9094629991495881,0.517225329685151
+MAP2K6+ELMSAN1,0.05813953488372093,0.0,0.05813953488372093,0.05813953488372093,0.05813953488372093,0.07692307692307693,0.0,0.06,0.055,0.048,0.6332418020734609,0.8837209302325582,0.894297661862015,0.872093023255814,86.0,975.0,0.28805752119100814,0.48935821586474293,0.6674091815948486,0.0033246292732656,0.02223532274365425,0.0033246292732656,0.022235320881009102,0.9743589743589743,0.9743589743589743,0.9743589743589743,0.9094629991495881,0.517225329685151
+MAPK1+IKZF3,0.11585365853658537,0.04,0.1,0.11585365853658537,0.11585365853658537,0.15768056968463887,0.04,0.1,0.105,0.068,0.6332418020734609,0.9024390243902439,0.8718288112420843,0.9451219512195121,164.0,983.0,0.28805752119100814,0.48935821586474293,0.8927130699157715,0.0036052181385457516,0.021833917126059532,0.0036052181385457516,0.021833917126059532,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+PTPN12+PTPN9,0.07142857142857142,0.08,0.07142857142857142,0.07142857142857142,0.07142857142857142,0.08829568788501027,0.08,0.07,0.06,0.038,0.6332418020734609,0.8979591836734694,0.9328248753300088,0.8775510204081632,98.0,974.0,0.28805752119100814,0.48935821586474293,0.9598571062088013,0.0011219970183447003,0.013857576996088028,0.0011219970183447003,0.013857576996088028,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+PTPN12+UBASH3A,0.05217391304347826,0.06,0.06,0.05217391304347826,0.05217391304347826,0.10337768679631525,0.06,0.06,0.06,0.06,0.6332418020734609,0.8956521739130435,0.870493106845128,0.8782608695652174,115.0,977.0,0.28805752119100814,0.48935821586474293,0.9191223382949829,0.0035613691434264183,0.019410477951169014,0.0035613691434264183,0.019410477951169014,0.8717948717948718,0.8461538461538461,0.9230769230769231,0.9094629991495881,0.517225329685151
+SGK1+S1PR2,0.11794871794871795,0.1,0.14,0.11794871794871795,0.11794871794871795,0.1894093686354379,0.1,0.14,0.115,0.118,0.6332418020734609,0.9179487179487179,0.8576184578525248,0.9538461538461539,195.0,982.0,0.28805752119100814,0.48935821586474293,0.8353385329246521,0.006171041633933783,0.025686632841825485,0.006171041168272495,0.025686632841825485,0.6923076923076923,0.7435897435897436,0.6923076923076923,0.9094629991495881,0.517225329685151
+SGK1+TBX2,0.09836065573770492,0.12,0.11,0.09836065573770492,0.09836065573770492,0.11451942740286299,0.12,0.11,0.075,0.066,0.6332418020734609,0.9426229508196722,0.9307324393379983,0.9180327868852459,122.0,978.0,0.28805752119100814,0.48935821586474293,0.9189925193786621,0.0025060800835490227,0.017901940271258354,0.0025060800835490227,0.017901940271258354,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+SGK1+TBX3,0.05504587155963303,0.06,0.05,0.05504587155963303,0.05504587155963303,0.10245901639344263,0.06,0.05,0.05,0.046,0.6332418020734609,0.908256880733945,0.9127565302830871,0.9174311926605505,109.0,976.0,0.28805752119100814,0.48935821586474293,0.9049872159957886,0.004011864773929119,0.021642543375492096,0.004011864773929119,0.021642543375492096,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+TBX3+TBX2,0.06790123456790123,0.06,0.07,0.06790123456790123,0.06790123456790123,0.1523517382413088,0.06,0.07,0.08,0.09,0.6332418020734609,0.8641975308641975,0.9033925796729284,0.9197530864197531,162.0,978.0,0.28805752119100814,0.48935821586474293,0.9266531467437744,0.0029927673749625683,0.021586159244179726,0.0029927671421319246,0.021586159244179726,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+TGFBR2+IGDCC3,0.05504587155963303,0.08,0.06,0.05504587155963303,0.05504587155963303,0.10520939734422881,0.08,0.06,0.045,0.042,0.6332418020734609,0.963302752293578,0.9037931274184953,0.944954128440367,109.0,979.0,0.28805752119100814,0.48935821586474293,0.9237167239189148,0.0026932626497000456,0.0206748079508543,0.0026932626497000456,0.0206748079508543,0.9743589743589743,1.0,1.0,0.9094629991495881,0.517225329685151
+TGFBR2+PRTG,0.08547008547008547,0.14,0.1,0.08547008547008547,0.08547008547008547,0.11031664964249234,0.14,0.1,0.065,0.056,0.6332418020734609,0.9572649572649573,0.9128981488420895,0.9230769230769231,117.0,979.0,0.28805752119100814,0.48935821586474293,0.9544602036476135,0.0011664817575365305,0.014456653967499733,0.0011664817575365305,0.014456653967499733,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+UBASH3B+OSR2,0.0916030534351145,0.08,0.1,0.0916030534351145,0.0916030534351145,0.12255406797116375,0.08,0.1,0.085,0.082,0.6332418020734609,0.9236641221374046,0.8793504967418011,0.9083969465648855,131.0,971.0,0.28805752119100814,0.48935821586474293,0.7370474338531494,0.0020488190930336714,0.019415294751524925,0.0020488190930336714,0.019415294751524925,1.0,1.0,1.0,0.9094629991495881,0.517225329685151
+UBASH3B+ZBTB25,0.030927835051546393,0.02,0.030927835051546393,0.030927835051546393,0.030927835051546393,0.08512820512820513,0.02,0.05,0.06,0.044,0.6332418020734609,0.9278350515463918,0.9436015809444894,0.8556701030927835,97.0,975.0,0.28805752119100814,0.48935821586474293,0.9656861424446106,0.0016514494782313704,0.015485486015677452,0.0016514494782313704,0.015485486015677452,1.0,0.9743589743589743,0.9743589743589743,0.9094629991495881,0.517225329685151
+ZC3HAV1+CEBPE,0.2654320987654321,0.38,0.33,0.2654320987654321,0.2654320987654321,0.16142131979695432,0.38,0.33,0.255,0.152,0.6332418020734609,0.9691358024691358,0.8848201842142793,0.9814814814814815,162.0,985.0,0.28805752119100814,0.48935821586474293,0.8211876153945923,0.014034540392458439,0.043725334107875824,0.014034540392458439,0.04372533783316612,0.9230769230769231,0.9487179487179487,0.9230769230769231,0.9094629991495881,0.517225329685151

GRN/baseline/flow-fusion_differential_perceiver-norman-origin-predict_y-gamma_0.5-perturbation_function_crisper-lr_5e-05-dim_model_128-infer_top_gene_1000-split_method_additive-use_mmd_loss_True-fold_1-use_negative_edge_True-topk_30/loss_curve.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2282cffef7bf70b28f2f3fe4db4bc57d7a81f2c09f693a7213065b67ac48f30d
+size 11191256

GRN/dim1_ablation/run_dim1.py

@@ -0,0 +1,461 @@
+"""
+Training and evaluation entry point for CCFM (Cascaded Conditioned Flow Matching).
+Dim-1 ablation: identical to run_cascaded.py but wraps scGPT extractor with SlicedScGPTExtractor.
+"""
+
+import sys
+import os
+
+# Set up paths — grn_ccfm/ is the CCFM project root (one level up from dim1_ablation/)
+_ABLATION_DIR = os.path.dirname(os.path.abspath(__file__))
+_PROJECT_ROOT = os.path.join(_ABLATION_DIR, "..", "grn_ccfm")
+_PROJECT_ROOT = os.path.normpath(_PROJECT_ROOT)
+sys.path.insert(0, _PROJECT_ROOT)
+sys.path.insert(0, _ABLATION_DIR)  # for sliced_extractor
+
+# Bootstrap scDFM imports (must happen before any CCFM src imports)
+import _bootstrap_scdfm  # noqa: F401
+
+import copy
+import torch
+import torch.nn as nn
+import tyro
+import tqdm
+import numpy as np
+import pandas as pd
+import anndata as ad
+import scanpy as sc
+from torch.utils.data import DataLoader
+from tqdm import trange
+from accelerate import Accelerator, DistributedDataParallelKwargs
+from torch.optim.lr_scheduler import LinearLR, CosineAnnealingLR, SequentialLR
+
+from config.config_cascaded import CascadedFlowConfig as Config
+from src.data.data import get_data_classes
+from src.model.model import CascadedFlowModel
+from src.data.scgpt_extractor import FrozenScGPTExtractor
+from src.data.scgpt_cache import ScGPTFeatureCache
+from src.denoiser import CascadedDenoiser
+from src.utils import (
+    save_checkpoint,
+    load_checkpoint,
+    pick_eval_score,
+    process_vocab,
+    set_requires_grad_for_p_only,
+    GeneVocab,
+)
+from sliced_extractor import SlicedScGPTExtractor
+
+from cell_eval import MetricsEvaluator
+
+# Resolve scDFM directory paths
+_REPO_ROOT = os.path.normpath(os.path.join(_PROJECT_ROOT, "..", "..", "transfer", "code"))  # transfer/code/
+
+
+@torch.inference_mode()
+def test(data_sampler, denoiser, accelerator, config, vocab, data_manager,
+         batch_size=128, path_dir="./"):
+    """Evaluate: generate predictions and compute cell-eval metrics."""
+    device = accelerator.device
+    gene_ids_test = vocab.encode(list(data_sampler.adata.var_names))
+    gene_ids_test = torch.tensor(gene_ids_test, dtype=torch.long, device=device)
+
+    perturbation_name_list = data_sampler._perturbation_covariates
+    control_data = data_sampler.get_control_data()
+    inverse_dict = {v: str(k) for k, v in data_manager.perturbation_dict.items()}
+
+    all_pred_expressions = [control_data["src_cell_data"]]
+    obs_perturbation_name_pred = ["control"] * control_data["src_cell_data"].shape[0]
+    all_target_expressions = [control_data["src_cell_data"]]
+    obs_perturbation_name_real = ["control"] * control_data["src_cell_data"].shape[0]
+
+    print("perturbation_name_list:", len(perturbation_name_list))
+    for perturbation_name in perturbation_name_list:
+        perturbation_data = data_sampler.get_perturbation_data(perturbation_name)
+        target = perturbation_data["tgt_cell_data"]
+        perturbation_id = perturbation_data["condition_id"]
+        source = control_data["src_cell_data"].to(device)
+        perturbation_id = perturbation_id.to(device)
+
+        if config.perturbation_function == "crisper":
+            perturbation_name_crisper = [
+                inverse_dict[int(p_id)] for p_id in perturbation_id[0].cpu().numpy()
+            ]
+            perturbation_id = torch.tensor(
+                vocab.encode(perturbation_name_crisper), dtype=torch.long, device=device
+            )
+            perturbation_id = perturbation_id.repeat(source.shape[0], 1)
+
+        idx = torch.randperm(source.shape[0])
+        source = source[idx]
+        N = 128
+        source = source[:N]
+
+        pred_expressions = []
+        for i in trange(0, N, batch_size, desc=perturbation_name):
+            batch_source = source[i : i + batch_size]
+            batch_pert_id = perturbation_id[0].repeat(batch_source.shape[0], 1).to(device)
+
+            # Get the underlying model for generation
+            model = denoiser.module if hasattr(denoiser, "module") else denoiser
+
+            pred = model.generate(
+                batch_source,
+                batch_pert_id,
+                gene_ids_test,
+                latent_steps=config.latent_steps,
+                expr_steps=config.expr_steps,
+                method=config.ode_method,
+            )
+            pred_expressions.append(pred)
+
+        pred_expressions = torch.cat(pred_expressions, dim=0).cpu().numpy()
+        all_pred_expressions.append(pred_expressions)
+        all_target_expressions.append(target)
+        obs_perturbation_name_pred.extend([perturbation_name] * pred_expressions.shape[0])
+        obs_perturbation_name_real.extend([perturbation_name] * target.shape[0])
+
+    all_pred_expressions = np.concatenate(all_pred_expressions, axis=0)
+    all_target_expressions = np.concatenate(all_target_expressions, axis=0)
+    obs_pred = pd.DataFrame({"perturbation": obs_perturbation_name_pred})
+    obs_real = pd.DataFrame({"perturbation": obs_perturbation_name_real})
+    pred_adata = ad.AnnData(X=all_pred_expressions, obs=obs_pred)
+    real_adata = ad.AnnData(X=all_target_expressions, obs=obs_real)
+
+    eval_score = None
+    if accelerator.is_main_process:
+        evaluator = MetricsEvaluator(
+            adata_pred=pred_adata,
+            adata_real=real_adata,
+            control_pert="control",
+            pert_col="perturbation",
+            num_threads=32,
+        )
+        results, agg_results = evaluator.compute()
+        results.write_csv(os.path.join(path_dir, "results.csv"))
+        agg_results.write_csv(os.path.join(path_dir, "agg_results.csv"))
+        pred_adata.write_h5ad(os.path.join(path_dir, "pred.h5ad"))
+        real_adata.write_h5ad(os.path.join(path_dir, "real.h5ad"))
+        eval_score = pick_eval_score(agg_results, "mse")
+        print(f"Current evaluation score: {eval_score:.4f}")
+
+    return eval_score
+
+
+if __name__ == "__main__":
+    config = tyro.cli(Config)
+
+    ddp_kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
+    accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])
+    if accelerator.is_main_process:
+        print(config)
+        save_path = config.make_path()
+        os.makedirs(save_path, exist_ok=True)
+    device = accelerator.device
+
+    # === Data loading (reuse scDFM) ===
+    Data, PerturbationDataset, TrainSampler, TestDataset = get_data_classes()
+
+    scdfm_data_path = os.path.join(_REPO_ROOT, "scDFM", "data")
+    data_manager = Data(scdfm_data_path)
+    data_manager.load_data(config.data_name)
+
+    # Convert var_names from Ensembl IDs to gene symbols if needed.
+    # scDFM vocab and perturbation encoding both expect gene symbols as var_names.
+    if "gene_name" in data_manager.adata.var.columns and data_manager.adata.var_names[0].startswith("ENSG"):
+        data_manager.adata.var_names = data_manager.adata.var["gene_name"].values
+        data_manager.adata.var_names_make_unique()
+        if accelerator.is_main_process:
+            print(f"Converted var_names to gene symbols, sample: {list(data_manager.adata.var_names[:5])}")
+
+    data_manager.process_data(
+        n_top_genes=config.n_top_genes,
+        split_method=config.split_method,
+        fold=config.fold,
+        use_negative_edge=config.use_negative_edge,
+        k=config.topk,
+    )
+    train_sampler, valid_sampler, _ = data_manager.load_flow_data(batch_size=config.batch_size)
+
+    train_dataset = PerturbationDataset(train_sampler, config.batch_size)
+    dataloader = DataLoader(
+        train_dataset, batch_size=1, shuffle=False,
+        num_workers=8, pin_memory=True, persistent_workers=True,
+    )
+
+    # === Build mask path ===
+    if config.use_negative_edge:
+        mask_path = os.path.join(
+            data_manager.data_path, data_manager.data_name,
+            f"mask_fold_{config.fold}topk_{config.topk}{config.split_method}_negative_edge.pt",
+        )
+    else:
+        mask_path = os.path.join(
+            data_manager.data_path, data_manager.data_name,
+            f"mask_fold_{config.fold}topk_{config.topk}{config.split_method}.pt",
+        )
+
+    # === Vocab ===
+    orig_cwd = os.getcwd()
+    os.chdir(os.path.join(_REPO_ROOT, "scDFM"))
+    vocab = process_vocab(data_manager, config)
+    os.chdir(orig_cwd)
+
+    # Vocab is built from var_names (may be Ensembl IDs or gene symbols)
+    gene_ids = vocab.encode(list(data_manager.adata.var_names))
+    gene_ids = torch.tensor(gene_ids, dtype=torch.long, device=device)
+
+    # === Build CascadedFlowModel ===
+    vf = CascadedFlowModel(
+        ntoken=len(vocab),
+        d_model=config.d_model,
+        nhead=config.nhead,
+        d_hid=config.d_hid,
+        nlayers=config.nlayers,
+        fusion_method=config.fusion_method,
+        perturbation_function=config.perturbation_function,
+        mask_path=mask_path,
+        scgpt_dim=config.scgpt_dim,
+        bottleneck_dim=config.bottleneck_dim,
+        dh_depth=config.dh_depth,
+    )
+
+    # === Build FrozenScGPTExtractor ===
+    # var_names have been converted to gene symbols above, matching scGPT vocab.
+    hvg_gene_names = list(data_manager.adata.var_names)
+    scgpt_model_dir = os.path.join(
+        os.path.dirname(_REPO_ROOT),  # transfer/
+        config.scgpt_model_dir.replace("transfer/", ""),
+    )
+    scgpt_extractor = FrozenScGPTExtractor(
+        model_dir=scgpt_model_dir,
+        hvg_gene_names=hvg_gene_names,
+        device=device,
+        max_seq_len=config.scgpt_max_seq_len,
+        target_std=config.target_std,
+        warmup_batches=config.warmup_batches,
+    )
+    scgpt_extractor = scgpt_extractor.to(device)
+
+    # === Dim-1 ablation: wrap extractor to slice features ===
+    if config.scgpt_dim < scgpt_extractor.scgpt_d_model:
+        print(f"[Ablation] Slicing scGPT features: {scgpt_extractor.scgpt_d_model} -> {config.scgpt_dim}")
+        scgpt_extractor = SlicedScGPTExtractor(scgpt_extractor, n_dims=config.scgpt_dim)
+
+    # === Build CascadedDenoiser ===
+    denoiser = CascadedDenoiser(
+        model=vf,
+        scgpt_extractor=scgpt_extractor,
+        choose_latent_p=config.choose_latent_p,
+        latent_weight=config.latent_weight,
+        noise_type=config.noise_type,
+        use_mmd_loss=config.use_mmd_loss,
+        gamma=config.gamma,
+        poisson_alpha=config.poisson_alpha,
+        poisson_target_sum=config.poisson_target_sum,
+        t_sample_mode=config.t_sample_mode,
+        t_expr_mean=config.t_expr_mean,
+        t_expr_std=config.t_expr_std,
+        t_latent_mean=config.t_latent_mean,
+        t_latent_std=config.t_latent_std,
+        noise_beta=config.noise_beta,
+        feature_mode=config.feature_mode,
+        attn_layer=config.attn_layer,
+        attn_use_rank_norm=config.attn_use_rank_norm,
+        attn_multi_layer=config.attn_multi_layer,
+    )
+
+    # === Load scGPT cache if configured ===
+    scgpt_cache = None
+    if config.scgpt_cache_path and config.feature_mode == "attention_delta":
+        if accelerator.is_main_process:
+            print("WARNING: scGPT cache is not compatible with attention_delta mode. Ignoring cache.")
+        config.scgpt_cache_path = ""
+    if config.scgpt_cache_path:
+        scgpt_cache = ScGPTFeatureCache(
+            config.scgpt_cache_path,
+            target_std=config.target_std,
+        )
+        if accelerator.is_main_process:
+            print(f"Using pre-extracted scGPT cache: {config.scgpt_cache_path}")
+            print(f"  Cache shape: {scgpt_cache.features.shape}, cells: {len(scgpt_cache.name_to_idx)}")
+
+    # === EMA model (on same device as training model) ===
+    ema_model = copy.deepcopy(vf).to(device)
+    ema_model.eval()
+    ema_model.requires_grad_(False)
+
+    # === Optimizer & Scheduler (with warmup) ===
+    save_path = config.make_path()
+    optimizer = torch.optim.Adam(vf.parameters(), lr=config.lr)
+    warmup_scheduler = LinearLR(
+        optimizer, start_factor=1e-3, end_factor=1.0, total_iters=config.warmup_steps,
+    )
+    cosine_scheduler = CosineAnnealingLR(
+        optimizer, T_max=max(config.steps - config.warmup_steps, 1), eta_min=config.eta_min,
+    )
+    scheduler = SequentialLR(
+        optimizer, [warmup_scheduler, cosine_scheduler], milestones=[config.warmup_steps],
+    )
+
+    start_iteration = 0
+    if config.checkpoint_path != "":
+        start_iteration, _ = load_checkpoint(config.checkpoint_path, vf, optimizer, scheduler)
+        # Sync EMA with loaded weights
+        ema_model.load_state_dict(vf.state_dict())
+
+    # === Prepare with accelerator ===
+    denoiser = accelerator.prepare(denoiser)
+    optimizer, scheduler, dataloader = accelerator.prepare(optimizer, scheduler, dataloader)
+
+    inverse_dict = {v: str(k) for k, v in data_manager.perturbation_dict.items()}
+
+    # === Test-only mode ===
+    if config.test_only:
+        eval_path = os.path.join(save_path, "eval_only")
+        os.makedirs(eval_path, exist_ok=True)
+        if accelerator.is_main_process:
+            print(f"Test-only mode. Saving results to {eval_path}")
+        eval_score = test(
+            valid_sampler, denoiser, accelerator, config, vocab, data_manager,
+            batch_size=config.batch_size, path_dir=eval_path,
+        )
+        if accelerator.is_main_process and eval_score is not None:
+            print(f"Final evaluation score: {eval_score:.4f}")
+        sys.exit(0)
+
+    # === Loss logging (CSV + TensorBoard) ===
+    import csv
+    from torch.utils.tensorboard import SummaryWriter
+    if accelerator.is_main_process:
+        os.makedirs(save_path, exist_ok=True)
+        csv_path = os.path.join(save_path, 'loss_curve.csv')
+        if start_iteration > 0 and os.path.exists(csv_path):
+            csv_file = open(csv_path, 'a', newline='')
+            csv_writer = csv.writer(csv_file)
+        else:
+            csv_file = open(csv_path, 'w', newline='')
+            csv_writer = csv.writer(csv_file)
+            csv_writer.writerow(['iteration', 'loss', 'loss_expr', 'loss_latent', 'loss_mmd', 'lr'])
+        tb_writer = SummaryWriter(log_dir=os.path.join(save_path, 'tb_logs'))
+
+    # === Training loop ===
+    pbar = tqdm.tqdm(total=config.steps, initial=start_iteration)
+    iteration = start_iteration
+
+    while iteration < config.steps:
+        for batch_data in dataloader:
+            source = batch_data["src_cell_data"].squeeze(0)
+            target = batch_data["tgt_cell_data"].squeeze(0)
+            perturbation_id = batch_data["condition_id"].squeeze(0).to(device)
+
+            if config.perturbation_function == "crisper":
+                perturbation_name = [
+                    inverse_dict[int(p_id)] for p_id in perturbation_id[0].cpu().numpy()
+                ]
+                perturbation_id = torch.tensor(
+                    vocab.encode(perturbation_name), dtype=torch.long, device=device
+                )
+                perturbation_id = perturbation_id.repeat(source.shape[0], 1)
+
+            # Get the underlying denoiser for train_step
+            base_denoiser = denoiser.module if hasattr(denoiser, "module") else denoiser
+            base_denoiser.model.train()
+
+            if scgpt_cache is not None:
+                # Cache mode: sample gene subset here, look up pre-extracted features
+                # DataLoader collate wraps strings in tuples; unwrap them
+                tgt_cell_names = [n[0] if isinstance(n, (tuple, list)) else n for n in batch_data["tgt_cell_id"]]
+                input_gene_ids = torch.randperm(source.shape[-1], device=device)[:config.infer_top_gene]
+                cached_z_target = scgpt_cache.lookup(tgt_cell_names, input_gene_ids, device=device)
+                loss_dict = base_denoiser.train_step(
+                    source, target, perturbation_id, gene_ids,
+                    infer_top_gene=config.infer_top_gene,
+                    cached_z_target=cached_z_target,
+                    cached_gene_ids=input_gene_ids,
+                )
+            else:
+                loss_dict = base_denoiser.train_step(
+                    source, target, perturbation_id, gene_ids,
+                    infer_top_gene=config.infer_top_gene,
+                )
+
+            loss = loss_dict["loss"]
+            optimizer.zero_grad(set_to_none=True)
+            accelerator.backward(loss)
+            optimizer.step()
+            scheduler.step()
+
+            # === EMA update ===
+            with torch.no_grad():
+                decay = config.ema_decay
+                for ema_p, model_p in zip(ema_model.parameters(), vf.parameters()):
+                    ema_p.lerp_(model_p.data, 1 - decay)
+
+            if iteration % config.print_every == 0:
+                save_path_ = os.path.join(save_path, f"iteration_{iteration}")
+                os.makedirs(save_path_, exist_ok=True)
+                if accelerator.is_main_process:
+                    print(f"Saving iteration {iteration} checkpoint...")
+                    # Save EMA model (used for inference) and training state
+                    save_checkpoint(
+                        model=ema_model,
+                        optimizer=optimizer,
+                        scheduler=scheduler,
+                        iteration=iteration,
+                        eval_score=None,
+                        save_path=save_path_,
+                        is_best=False,
+                    )
+                # Evaluate with EMA weights
+                # Only evaluate at the start and the last checkpoint
+                if iteration == 0 or iteration + config.print_every >= config.steps:
+                    # Swap EMA weights into denoiser for evaluation
+                    orig_state = copy.deepcopy(vf.state_dict())
+                    vf.load_state_dict(ema_model.state_dict())
+
+                    eval_score = test(
+                        valid_sampler, denoiser, accelerator, config, vocab, data_manager,
+                        batch_size=config.batch_size, path_dir=save_path_,
+                    )
+
+                    # Restore training weights
+                    vf.load_state_dict(orig_state)
+
+                    if accelerator.is_main_process and eval_score is not None:
+                        tb_writer.add_scalar('eval/score', eval_score, iteration)
+
+            # --- Per-iteration loss logging ---
+            if accelerator.is_main_process:
+                current_lr = scheduler.get_last_lr()[0]
+                csv_writer.writerow([
+                    iteration, loss.item(),
+                    loss_dict["loss_expr"].item(),
+                    loss_dict["loss_latent"].item(),
+                    loss_dict["loss_mmd"].item(),
+                    current_lr,
+                ])
+                if iteration % 100 == 0:
+                    csv_file.flush()
+                tb_writer.add_scalar('loss/train', loss.item(), iteration)
+                tb_writer.add_scalar('loss/expr', loss_dict["loss_expr"].item(), iteration)
+                tb_writer.add_scalar('loss/latent', loss_dict["loss_latent"].item(), iteration)
+                tb_writer.add_scalar('loss/mmd', loss_dict["loss_mmd"].item(), iteration)
+                tb_writer.add_scalar('lr', current_lr, iteration)
+
+            accelerator.wait_for_everyone()
+
+            pbar.update(1)
+            pbar.set_description(
+                f"loss: {loss.item():.4f} (expr: {loss_dict['loss_expr'].item():.4f}, "
+                f"latent: {loss_dict['loss_latent'].item():.4f}, "
+                f"mmd: {loss_dict['loss_mmd'].item():.4f}), iter: {iteration}"
+            )
+            iteration += 1
+            if iteration >= config.steps:
+                break
+
+    # === Close logging ===
+    if accelerator.is_main_process:
+        csv_file.close()
+        tb_writer.close()

GRN/dim1_ablation/run_eval_iter60000.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+#PJM -L rscgrp=b-batch
+#PJM -L gpu=1
+#PJM -L elapse=4:00:00
+#PJM -N grn_dim1_eval
+#PJM -j
+#PJM -o /home/hp250092/ku50001222/qian/aivc/lfj/GRN/dim1_ablation/logs/dim1_eval_%j.out
+
+module load cuda/12.2.2
+module load cudnn/8.9.7
+module load gcc-toolset/12
+
+source /home/hp250092/ku50001222/qian/aivc/lfj/stack_env/bin/activate
+
+cd /home/hp250092/ku50001222/qian/aivc/lfj/GRN/dim1_ablation
+
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256
+
+CKPT=/home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/dim1_ablation/grn-norman-f1-topk30-negTrue-d512-lr5e-05-lw1.0-lp0.4-ema0.9999-ln-wu2000-rk4-online-attn_L11/iteration_60000/checkpoint.pt
+
+echo "=========================================="
+echo "Job ID:    $PJM_JOBID"
+echo "Job Name:  $PJM_JOBNAME"
+echo "Start:     $(date)"
+echo "Node:      $(hostname)"
+echo "GPU:       $(nvidia-smi --query-gpu=name,memory.total --format=csv,noheader 2>/dev/null || echo 'N/A')"
+echo "Eval checkpoint: $CKPT"
+echo "=========================================="
+
+accelerate launch --num_processes=1 run_dim1.py \
+    --data-name norman \
+    --d-model 512 \
+    --d-hid 2048 \
+    --nhead 8 \
+    --nlayers 4 \
+    --batch-size 48 \
+    --lr 5e-5 \
+    --steps 50000 \
+    --fusion-method differential_perceiver \
+    --perturbation-function crisper \
+    --noise-type Gaussian \
+    --infer-top-gene 1000 \
+    --n-top-genes 5000 \
+    --use-mmd-loss \
+    --gamma 0.5 \
+    --split-method additive \
+    --fold 1 \
+    --scgpt-dim 1 \
+    --bottleneck-dim 512 \
+    --latent-weight 1.0 \
+    --choose-latent-p 0.4 \
+    --dh-depth 2 \
+    --print-every 5000 \
+    --topk 30 \
+    --use-negative-edge \
+    --ema-decay 0.9999 \
+    --t-sample-mode logit_normal \
+    --t-expr-mean 0.0 \
+    --t-expr-std 1.0 \
+    --t-latent-mean 0.0 \
+    --t-latent-std 1.0 \
+    --warmup-steps 2000 \
+    --ode-method rk4 \
+    --feature-mode attention_delta \
+    --attn-layer 11 \
+    --attn-use-rank-norm \
+    --result-path /home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/dim1_ablation \
+    --checkpoint-path "$CKPT" \
+    --test-only
+
+echo "=========================================="
+echo "Finished:  $(date)"
+echo "=========================================="