Upload folder using huggingface_hub

train/CCFM/pca_emb/_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()

train/CCFM/pca_emb/config/config_cascaded.py

@@ -0,0 +1,101 @@
+from dataclasses import dataclass
+import os
+
+
+@dataclass
+class CascadedFlowConfig:
+    # === Base (same as scDFM FlowConfig) ===
+    model_type: str = "cascaded"
+    batch_size: int = 96
+    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/att_svd"
+    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
+
+    # === SVD latent (replaces bilinear_head_dim from grn_att_only) ===
+    latent_dim: int = 128
+    dh_depth: int = 2
+    latent_weight: float = 1.0
+    choose_latent_p: float = 0.4
+    target_std: float = 1.0
+    use_variance_weight: bool = False
+
+    # === SVD dictionary ===
+    svd_dict_path: str = ""  # path to svd_dict_*.pt from compute_svd_dict.py
+
+    # === 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 = 30  # per-row top-K for delta attention sparsification (on full 5035 cols)
+
+    # === Cascaded noise (LatentForcing dino_first_cascaded_noised) ===
+    noise_beta: float = 0.25
+
+    # === EMA ===
+    ema_decay: float = 0.9999
+
+    # === Logit-normal time-step sampling ===
+    t_sample_mode: str = "logit_normal"
+    t_expr_mean: float = 0.0
+    t_expr_std: float = 1.0
+    t_latent_mean: float = 0.0
+    t_latent_std: float = 1.0
+
+    # === LR warmup ===
+    warmup_steps: int = 2000
+
+    # === Inference ===
+    latent_steps: int = 20
+    expr_steps: int = 20
+    ode_method: str = "rk4"
+    eval_batch_size: int = 8
+
+    def __post_init__(self):
+        if self.data_name == "norman_umi_go_filtered":
+            self.n_top_genes = 5054
+        if self.data_name == "norman":
+            self.n_top_genes = 5000
+
+    # Experiment name override (if set, used instead of auto-generated name)
+    exp_name: str = ""
+
+    def make_path(self):
+        if self.exp_name:
+            return os.path.join(self.result_path, self.exp_name)
+        t_mode = "ln" if self.t_sample_mode == "logit_normal" else "uni"
+        exp_name = (
+            f"svd-{self.data_name}-f{self.fold}"
+            f"-topk{self.topk}-neg{self.use_negative_edge}"
+            f"-d{self.d_model}-ld{self.latent_dim}-dh{self.dh_depth}"
+            f"-lr{self.lr}"
+            f"-lw{self.latent_weight}-lp{self.choose_latent_p}"
+            f"-dtk{self.delta_topk}"
+            f"-ema{self.ema_decay}-{t_mode}-wu{self.warmup_steps}"
+            f"-{self.ode_method}"
+        )
+        return os.path.join(self.result_path, exp_name)

train/CCFM/pca_emb/run_pca_emb.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+#PJM -L rscgrp=b-batch
+#PJM -L gpu=1
+#PJM -L elapse=48:00:00
+#PJM -N pca_emb
+#PJM -j
+#PJM -o logs/pca_emb_%j.out
+
+module load cuda/12.2.2
+module load cudnn/8.9.7
+module load gcc-toolset/12
+
+source /home/pj24002027/ku50002536/Takoai/lfj/lfj/stack_env/bin/activate
+
+cd /home/pj24002027/ku50002536/Takoai/lfj/lfj/GRN/pca_emb
+
+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 "=========================================="
+
+# --- PCA-emb 1D latent: Δ_attn @ gene_emb -> PCA(1) -> flow matching ---
+# 关键修改 vs svd_baseline:
+#   --latent-dim 1 (128 -> 1)
+#   --svd-dict-path 改为 PCA-emb dict
+#   --result-path 输出到 result/pca_emb
+
+accelerate launch --num_processes=1 scripts/run_cascaded.py \
+    --data-name norman \
+    --d-model 128 \
+    --d-hid 512 \
+    --nhead 8 \
+    --nlayers 4 \
+    --batch-size 96 \
+    --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 \
+    --latent-dim 1 \
+    --dh-depth 2 \
+    --latent-weight 1.0 \
+    --choose-latent-p 0.4 \
+    --print-every 5000 \
+    --topk 30 \
+    --use-negative-edge \
+    --delta-topk 30 \
+    --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 \
+    --eval-batch-size 8 \
+    --sparse-cache-path /home/pj24002027/ku50002536/Takoai/lfj/lfj/GRN/grn_ccfm/cache/norman_attn_L11_sparse.h5 \
+    --svd-dict-path /home/pj24002027/ku50002536/Takoai/lfj/lfj/GRN/pca_emb/cache/pca_emb_dict_norman_f1.pt \
+    --exp-name pca_emb_1d \
+    --result-path /home/pj24002027/ku50002536/Takoai/lfj/lfj/GRN/result/pca_emb
+
+echo "=========================================="
+echo "Finished:  $(date)"
+echo "=========================================="

train/CCFM/pca_emb/run_pca_emb_dict.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+#PJM -L rscgrp=b-batch
+#PJM -L gpu=1
+#PJM -L elapse=4:00:00
+#PJM -N pca_emb_dict
+#PJM -j
+#PJM -o logs/pca_emb_dict_%j.out
+
+module load cuda/12.2.2
+module load cudnn/8.9.7
+module load gcc-toolset/12
+
+source /home/pj24002027/ku50002536/Takoai/lfj/lfj/stack_env/bin/activate
+
+cd /home/pj24002027/ku50002536/Takoai/lfj/lfj/GRN/pca_emb
+
+echo "=========================================="
+echo "Job ID:    $PJM_JOBID"
+echo "Job Name:  $PJM_JOBNAME"
+echo "Start:     $(date)"
+echo "Node:      $(hostname)"
+echo "=========================================="
+
+python scripts/compute_pca_emb_dict.py \
+    --data-name norman \
+    --fold 1 \
+    --split-method additive \
+    --topk 30 \
+    --use-negative-edge \
+    --n-top-genes 5000 \
+    --sparse-cache-path /home/pj24002027/ku50002536/Takoai/lfj/lfj/GRN/grn_ccfm/cache/norman_attn_L11_sparse.h5 \
+    --scgpt-model-dir /home/pj24002027/ku50002536/Takoai/lfj/lfj/transfer/data/scGPT_pretrained \
+    --n-pairs-per-condition 50 \
+    --delta-topk 30 \
+    --rows-per-pair 500 \
+    --output-path cache/pca_emb_dict_norman_f1.pt
+
+echo "=========================================="
+echo "Finished:  $(date)"
+echo "=========================================="

train/CCFM/pca_emb/scripts/compute_pca_emb_dict.py

@@ -0,0 +1,325 @@
+"""
+Offline PCA-emb dictionary computation for grn_svd (latent_dim=1).
+
+Pipeline:
+  1. Load sparse attention cache + scGPT gene embeddings
+  2. Sample (control, perturbed) pairs, compute sparse delta attention
+  3. Project delta through gene_emb: delta_512d = sparse_delta @ gene_emb
+  4. Center + PCA on 512D features -> first principal component v
+  5. Compute combined weight: w = gene_emb @ v (5035, 1)
+  6. Save as dict compatible with grn_svd format
+
+Math: (Δ_attn @ gene_emb) @ v = Δ_attn @ (gene_emb @ v) = Δ_attn @ w
+      -> _sparse_project(W=w) gives (B, G, 1), same structure as SVD dict.
+
+Usage:
+    python scripts/compute_pca_emb_dict.py \
+        --data-name norman --fold 1 --split-method additive \
+        --topk 30 --use-negative-edge \
+        --sparse-cache-path .../norman_attn_L11_sparse.h5 \
+        --scgpt-model-dir .../scGPT_pretrained \
+        --n-pairs-per-condition 50 \
+        --output-path cache/pca_emb_dict_norman_f1.pt
+"""
+
+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 argparse
+import json
+import numpy as np
+import torch
+import h5py
+from sklearn.decomposition import PCA
+
+from src.data.data import get_data_classes
+from src.data.sparse_raw_cache import _read_sparse_batch
+
+_REPO_ROOT = os.path.normpath(os.path.join(_PROJECT_ROOT, "..", "..", "transfer", "code"))
+
+
+def load_scgpt_gene_embeddings(scgpt_model_dir, hvg_gene_names):
+    """
+    Load scGPT gene embeddings for HVG genes without importing the full scGPT package.
+
+    Returns:
+        gene_emb: (G_full, 512) float32 tensor, zero for genes not in vocab
+        valid_mask: (G_full,) bool — True for genes in scGPT vocab
+    """
+    # Load vocab
+    vocab_path = os.path.join(scgpt_model_dir, "vocab.json")
+    with open(vocab_path, "r") as f:
+        scgpt_vocab = json.load(f)
+
+    # Map HVG genes to scGPT token IDs
+    hvg_to_scgpt = []
+    for gene in hvg_gene_names:
+        hvg_to_scgpt.append(scgpt_vocab.get(gene, -1))
+    hvg_to_scgpt = torch.tensor(hvg_to_scgpt, dtype=torch.long)
+    valid_mask = hvg_to_scgpt >= 0
+
+    # Load model args to get d_model
+    with open(os.path.join(scgpt_model_dir, "args.json"), "r") as f:
+        model_args = json.load(f)
+    d_model = model_args.get("embsize", 512)
+
+    # Load checkpoint — extract only embedding weights
+    ckpt_path = os.path.join(scgpt_model_dir, "best_model.pt")
+    ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False)
+    # scGPT stores encoder as nn.Embedding; key is "encoder.embedding.weight"
+    emb_weight = None
+    for key in ckpt:
+        if "encoder" in key and "weight" in key:
+            if ckpt[key].dim() == 2 and ckpt[key].shape[1] == d_model:
+                emb_weight = ckpt[key]
+                print(f"  Found embedding weights: key='{key}', shape={emb_weight.shape}")
+                break
+    if emb_weight is None:
+        raise RuntimeError(f"Cannot find encoder embedding weights in {ckpt_path}")
+
+    # Build gene_emb: (G_full, D), zero for missing genes
+    G_full = len(hvg_gene_names)
+    gene_emb = torch.zeros(G_full, d_model)
+    valid_ids = hvg_to_scgpt[valid_mask]
+    gene_emb[valid_mask] = emb_weight[valid_ids].float()
+
+    n_valid = valid_mask.sum().item()
+    n_missing = G_full - n_valid
+    print(f"  Gene embeddings: {n_valid}/{G_full} valid, {n_missing} missing (zero)")
+
+    return gene_emb, valid_mask.numpy()
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="Compute PCA-emb dictionary for grn_svd (1D)")
+    p.add_argument("--data-name", type=str, default="norman")
+    p.add_argument("--sparse-cache-path", type=str, required=True)
+    p.add_argument("--scgpt-model-dir", type=str, required=True,
+                   help="Path to scGPT pretrained model dir (contains vocab.json, args.json, best_model.pt)")
+    p.add_argument("--fold", type=int, default=1)
+    p.add_argument("--split-method", type=str, default="additive")
+    p.add_argument("--topk", type=int, default=30, help="GRN graph topk for scDFM process_data")
+    p.add_argument("--use-negative-edge", action="store_true", default=True)
+    p.add_argument("--n-top-genes", type=int, default=5000)
+    p.add_argument("--n-pairs-per-condition", type=int, default=50)
+    p.add_argument("--delta-topk", type=int, default=30, help="Per-row top-K on delta")
+    p.add_argument("--rows-per-pair", type=int, default=500,
+                   help="Gene rows to sample per pair (0 = all)")
+    p.add_argument("--output-path", type=str, required=True)
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    # === 1. Load scDFM data to get train/test split ===
+    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(args.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=args.n_top_genes,
+        split_method=args.split_method,
+        fold=args.fold,
+        use_negative_edge=args.use_negative_edge,
+        k=args.topk,
+    )
+    train_sampler, _, _ = data_manager.load_flow_data(batch_size=32)
+
+    train_conditions = train_sampler._perturbation_covariates
+    adata = train_sampler.adata
+    ctrl_mask = adata.obs["perturbation_covariates"] == "control+control"
+    if ctrl_mask.sum() == 0:
+        ctrl_mask = adata.obs["condition"].isin(["control", "ctrl"])
+    ctrl_cell_ids = list(adata.obs_names[ctrl_mask])
+
+    cond_to_cells = {}
+    for cond in train_conditions:
+        cond_mask = adata.obs["perturbation_covariates"] == cond
+        cond_to_cells[cond] = list(adata.obs_names[cond_mask])
+
+    print(f"Training conditions: {len(train_conditions)}")
+    print(f"Control cells: {len(ctrl_cell_ids)}")
+
+    # === 2. Load scGPT gene embeddings ===
+    hvg_gene_names = list(data_manager.adata.var_names)
+    print(f"\nLoading scGPT gene embeddings...")
+    gene_emb, valid_gene_mask = load_scgpt_gene_embeddings(
+        args.scgpt_model_dir, hvg_gene_names
+    )
+    D = gene_emb.shape[1]  # 512
+    print(f"  gene_emb shape: {gene_emb.shape}, D={D}")
+
+    # === 3. Open HDF5 cache ===
+    h5 = h5py.File(args.sparse_cache_path, "r")
+    h5_values = h5["attn_values"]
+    h5_indices = h5["attn_indices"]
+    cell_names_all = h5["cell_names"].asstr()[:]
+    name_to_idx = {name: i for i, name in enumerate(cell_names_all)}
+    G_full = h5_values.shape[1]
+    K_sparse = h5_values.shape[2]
+
+    print(f"\nCache: {len(name_to_idx)} cells, G_full={G_full}, K_sparse={K_sparse}")
+
+    ctrl_in_cache = [c for c in ctrl_cell_ids if c in name_to_idx]
+    print(f"Control cells in cache: {len(ctrl_in_cache)}")
+
+    # === 4. Stratified sampling: collect delta_512d = sparse_delta @ gene_emb ===
+    all_delta_512d = []  # list of (chunk_size, D) tensors
+    delta_topk = args.delta_topk
+    rows_per_pair = args.rows_per_pair if args.rows_per_pair > 0 else G_full
+    rng = np.random.RandomState(42)
+
+    for cond_idx, cond in enumerate(train_conditions):
+        pert_cell_ids = cond_to_cells.get(cond, [])
+        pert_cell_ids = [c for c in pert_cell_ids if c in name_to_idx]
+        if not pert_cell_ids or not ctrl_in_cache:
+            continue
+
+        n_pairs = min(args.n_pairs_per_condition, len(pert_cell_ids), len(ctrl_in_cache))
+        src_sample = [ctrl_in_cache[i] for i in rng.choice(len(ctrl_in_cache), n_pairs, replace=True)]
+        tgt_sample = [pert_cell_ids[i] for i in rng.choice(len(pert_cell_ids), n_pairs, replace=True)]
+
+        if rows_per_pair < G_full:
+            gene_idx = np.sort(rng.choice(G_full, rows_per_pair, replace=False))
+        else:
+            gene_idx = np.arange(G_full)
+
+        sv, si, tv, ti = _read_sparse_batch(
+            h5_values, h5_indices, name_to_idx,
+            src_sample, tgt_sample, gene_idx)
+
+        for p in range(n_pairs):
+            for chunk_start in range(0, len(gene_idx), 100):
+                chunk_end = min(chunk_start + 100, len(gene_idx))
+
+                s_v = torch.from_numpy(sv[p, chunk_start:chunk_end].astype(np.float32))
+                s_i = torch.from_numpy(si[p, chunk_start:chunk_end].astype(np.int64))
+                t_v = torch.from_numpy(tv[p, chunk_start:chunk_end].astype(np.float32))
+                t_i = torch.from_numpy(ti[p, chunk_start:chunk_end].astype(np.int64))
+
+                c_len = chunk_end - chunk_start
+
+                # Scatter to dense
+                src_dense = torch.zeros(c_len, G_full)
+                tgt_dense = torch.zeros(c_len, G_full)
+                src_dense.scatter_(-1, s_i, s_v)
+                tgt_dense.scatter_(-1, t_i, t_v)
+
+                delta = tgt_dense - src_dense  # (c_len, G_full)
+
+                # Per-row top-K (same sparsification as SVD dict)
+                _, topk_idx = delta.abs().topk(delta_topk, dim=-1)
+                topk_vals = delta.gather(-1, topk_idx)  # (c_len, delta_topk)
+
+                # Project through gene_emb: delta_512d = sparse_delta @ gene_emb
+                # Equivalent to: sum_k topk_vals[r,k] * gene_emb[topk_idx[r,k]]
+                delta_512d = torch.zeros(c_len, D)
+                for k in range(delta_topk):
+                    col_idx = topk_idx[:, k]             # (c_len,)
+                    val = topk_vals[:, k:k+1]             # (c_len, 1)
+                    emb_k = gene_emb[col_idx]             # (c_len, D)
+                    delta_512d = delta_512d + val * emb_k  # (c_len, D)
+
+                all_delta_512d.append(delta_512d)
+
+        if (cond_idx + 1) % 10 == 0:
+            n_rows = sum(t.shape[0] for t in all_delta_512d)
+            print(f"  Processed {cond_idx + 1}/{len(train_conditions)} conditions, {n_rows} rows")
+
+    h5.close()
+
+    # === 5. Concatenate and fit PCA ===
+    X = torch.cat(all_delta_512d, dim=0).numpy()  # (N_rows, 512)
+    print(f"\nTotal delta_512d samples: {X.shape[0]} x {X.shape[1]}")
+
+    print("Fitting PCA (with centering)...")
+    pca = PCA(n_components=1, random_state=42)
+    pca.fit(X)
+
+    v = pca.components_[0]  # (512,) — first principal component
+    explained = pca.explained_variance_ratio_[0]
+    print(f"  Explained variance ratio: {explained:.4f} ({explained * 100:.1f}%)")
+    print(f"  PC1 norm: {np.linalg.norm(v):.6f}")
+    print(f"  Data mean norm: {np.linalg.norm(pca.mean_):.4f}")
+
+    # === 6. Compute combined projection weight: w = gene_emb @ v ===
+    v_tensor = torch.from_numpy(v.astype(np.float32))             # (512,)
+    w = (gene_emb @ v_tensor).unsqueeze(1)                         # (G_full, 1)
+    print(f"\n  w = gene_emb @ v: shape={w.shape}")
+    print(f"  w stats: mean={w.mean():.6f}, std={w.std():.6f}, "
+          f"range=[{w.min():.4f}, {w.max():.4f}]")
+
+    # === 7. Global scalar scaling ===
+    # Project all sampled data through w to compute global std
+    # z_1d = delta_sparse @ w, but we already have delta_512d, so z_1d = X @ v
+    z_1d = torch.from_numpy((X @ v).astype(np.float32))  # (N_rows,)
+
+    z_std = z_1d.std().item()
+    global_scale = 1.0 / z_std
+    print(f"\n  Pre-scaling z_1d stats: mean={z_1d.mean():.4f}, std={z_std:.4f}")
+
+    # Apply scaling to W (same convention as compute_svd_dict.py)
+    W_scaled = w * global_scale
+
+    # Verify
+    z_scaled = z_1d * global_scale
+    print(f"  Post-scaling z_1d stats: mean={z_scaled.mean():.4f}, std={z_scaled.std():.4f}")
+    print(f"  Post-scaling range: [{z_scaled.min():.2f}, {z_scaled.max():.2f}]")
+
+    # Robust scaling if needed
+    extreme_ratio = (z_scaled.abs() > 5.0).float().mean().item()
+    print(f"  |z| > 5.0: {extreme_ratio:.4%}")
+
+    if extreme_ratio > 0.01:
+        q99 = z_scaled.abs().quantile(0.99).item()
+        robust_factor = q99 / 3.0
+        W_scaled = W_scaled / robust_factor
+        global_scale = global_scale / robust_factor
+        z_robust = z_1d * global_scale
+        print(f"  Robust scaling applied: 99th={q99:.2f} -> +/-3.0")
+        print(f"  After robust: std={z_robust.std():.4f}, "
+              f"range=[{z_robust.min():.2f}, {z_robust.max():.2f}]")
+
+    # Zero invalid gene rows
+    W_scaled[~torch.from_numpy(valid_gene_mask)] = 0.0
+
+    # === 8. Save (compatible with grn_svd dict format) ===
+    os.makedirs(os.path.dirname(args.output_path) or ".", exist_ok=True)
+    save_dict = {
+        "W": W_scaled,                                        # (G_full, 1) float32
+        "global_scale": global_scale,                         # float scalar
+        "valid_gene_mask": valid_gene_mask,                   # (G_full,) bool
+        "explained_variance_ratio": pca.explained_variance_ratio_,  # (1,)
+        "singular_values": np.sqrt(pca.explained_variance_),  # (1,)
+        "n_components": 1,
+        "delta_topk": args.delta_topk,
+        "data_name": args.data_name,
+        "fold": args.fold,
+        "n_pairs_per_condition": args.n_pairs_per_condition,
+        "n_rows": X.shape[0],
+        # PCA-emb specific metadata
+        "pca_component": v,                                   # (512,) PC direction
+        "pca_mean": pca.mean_,                                # (512,) centering vector
+        "gene_emb_shape": list(gene_emb.shape),               # [5035, 512]
+    }
+    torch.save(save_dict, args.output_path)
+
+    print(f"\nSaved PCA-emb dictionary to {args.output_path}")
+    print(f"  W: {W_scaled.shape}, global_scale: {global_scale:.6f}")
+    print(f"  Explained variance: {explained:.4f}")
+
+
+if __name__ == "__main__":
+    main()

train/CCFM/pca_emb/scripts/run_cascaded.py

@@ -0,0 +1,437 @@
+"""
+Training and evaluation entry point for grn_svd.
+
+Uses SVD-projected (B, G, 128) as latent target with SparseDeltaCache.
+SVD dictionary W is loaded as a frozen register_buffer on GPU.
+"""
+
+import sys
+import os
+
+# Set up paths
+_PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, _PROJECT_ROOT)
+
+# Bootstrap scDFM imports (must happen before any 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, GRNDatasetWrapper
+from src.model.model import CascadedFlowModel
+from src.data.sparse_raw_cache import SparseDeltaCache
+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 cell_eval import MetricsEvaluator
+
+# Resolve scDFM directory paths
+_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=8, 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"))
+        df = agg_results.to_pandas()
+        eval_score = None
+        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"Current evaluation score: {eval_score:.4f}")
+        else:
+            print("Warning: no valid eval metric available (NaN in predictions)")
+
+    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.
+    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)
+
+    # === 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)
+
+    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,
+        latent_dim=config.latent_dim,
+        dh_depth=config.dh_depth,
+    )
+
+    # === Build SparseDeltaCache ===
+    sparse_cache = SparseDeltaCache(config.sparse_cache_path, delta_top_k=config.delta_topk)
+
+    # === DataLoader with GRNDatasetWrapper (sparse triplets from workers) ===
+    base_dataset = PerturbationDataset(train_sampler, config.batch_size)
+    train_dataset = GRNDatasetWrapper(base_dataset, sparse_cache, gene_ids.cpu(), config.infer_top_gene)
+    dataloader = DataLoader(
+        train_dataset, batch_size=1, shuffle=False,
+        num_workers=8, pin_memory=True, persistent_workers=True,
+    )
+
+    # === Build CascadedDenoiser (loads SVD dict as register_buffer) ===
+    denoiser = CascadedDenoiser(
+        model=vf,
+        sparse_cache=sparse_cache,
+        svd_dict_path=config.svd_dict_path,
+        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,
+        use_variance_weight=config.use_variance_weight,
+    )
+
+    # === EMA 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)
+        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.eval_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:
+            # Sparse triplets from GRNDatasetWrapper (cache I/O done in worker)
+            source_sub = batch_data["src_cell_data"].squeeze(0).to(device)      # (B, G_sub)
+            target_sub = batch_data["tgt_cell_data"].squeeze(0).to(device)      # (B, G_sub)
+            delta_values = batch_data["delta_values"].squeeze(0).to(device)     # (B, G_sub, K) → GPU
+            delta_indices = batch_data["delta_indices"].squeeze(0).to(device)   # (B, G_sub, K) → GPU
+            gene_ids_sub = batch_data["gene_ids_sub"].squeeze(0).to(device)     # (G_sub,)
+            input_gene_ids = batch_data["input_gene_ids"].squeeze(0)            # (G_sub,) CPU
+            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_sub.shape[0], 1)
+
+            # Get the underlying denoiser for train_step
+            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)  # (B, G_sub)
+
+            loss_dict = base_denoiser.train_step(
+                source_sub, target_sub, perturbation_id, gene_input,
+                delta_values=delta_values, delta_indices=delta_indices,
+                input_gene_ids=input_gene_ids,
+            )
+
+            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_checkpoint(
+                        model=ema_model,
+                        optimizer=optimizer,
+                        scheduler=scheduler,
+                        iteration=iteration,
+                        eval_score=None,
+                        save_path=save_path_,
+                        is_best=False,
+                    )
+                # (Evaluation moved to after training loop)
+
+            # --- Per-iteration loss logging ---
+            if accelerator.is_main_process:
+                current_lr = scheduler.get_last_lr()[0]
+                # CSV: every 100 steps
+                if iteration % 100 == 0:
+                    csv_writer.writerow([
+                        iteration, loss.item(),
+                        loss_dict["loss_expr"].item(),
+                        loss_dict["loss_latent"].item(),
+                        loss_dict["loss_mmd"].item(),
+                        current_lr,
+                    ])
+                    csv_file.flush()
+                # TensorBoard: every step
+                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
+
+    # === Final checkpoint + evaluation at end of training ===
+    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 final checkpoint at iteration {iteration}...")
+        save_checkpoint(
+            model=ema_model,
+            optimizer=optimizer,
+            scheduler=scheduler,
+            iteration=iteration,
+            eval_score=None,
+            save_path=save_path_,
+            is_best=False,
+        )
+
+    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)
+
+    # === Close logging ===
+    if accelerator.is_main_process:
+        csv_file.close()
+        tb_writer.close()

train/CCFM/pca_emb/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)

train/CCFM/pca_emb/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,)
+        }

train/CCFM/pca_emb/src/data/sparse_raw_cache.py

@@ -0,0 +1,199 @@
+"""
+SparseDeltaCache — Returns sparse delta triplets (indices, values) for SVD projection.
+
+Each gene row's delta attention is computed across ALL G_full=5035 columns,
+then per-row top-K sparsification selects the K most important interactions.
+The SVD projection (delta @ W) happens on GPU, not here.
+
+Multi-process safe: each DataLoader worker lazily opens its own HDF5 handle.
+
+HDF5 layout (from precompute_sparse_attn.py):
+    /attn_values        (N, G_full, K) float16  — top-K attention values per row
+    /attn_indices       (N, G_full, K) int16    — column indices in G_full space
+    /cell_names         (N,) string
+    /valid_gene_mask    (G_full,) bool
+"""
+
+import os
+import h5py
+import numpy as np
+import torch
+
+
+def _read_sparse_batch(h5_values, h5_indices, name_to_idx,
+                       src_cell_names, tgt_cell_names, gene_idx_np=None):
+    """
+    Shared HDF5 reading logic for sparse caches.
+
+    Returns:
+        src_vals, src_idxs, tgt_vals, tgt_idxs: numpy arrays (B, G_sub, K)
+    """
+    seen = {}
+    unique_names = []
+    for n in src_cell_names + tgt_cell_names:
+        if n not in seen:
+            seen[n] = len(unique_names)
+            unique_names.append(n)
+
+    unique_h5_idx = [name_to_idx[n] for n in unique_names]
+    sorted_order = np.argsort(unique_h5_idx)
+    sorted_h5_idx = [unique_h5_idx[i] for i in sorted_order]
+
+    raw_vals = h5_values[sorted_h5_idx]
+    raw_idxs = h5_indices[sorted_h5_idx]
+
+    unsort = np.argsort(sorted_order)
+    raw_vals = raw_vals[unsort]
+    raw_idxs = raw_idxs[unsort]
+
+    if gene_idx_np is not None:
+        raw_vals = raw_vals[:, gene_idx_np, :]
+        raw_idxs = raw_idxs[:, gene_idx_np, :]
+
+    src_map = [seen[n] for n in src_cell_names]
+    tgt_map = [seen[n] for n in tgt_cell_names]
+    return raw_vals[src_map], raw_idxs[src_map], raw_vals[tgt_map], raw_idxs[tgt_map]
+
+
+class SparseDeltaCache:
+    """
+    Returns sparse delta triplets for GPU-side SVD projection.
+
+    Lookup flow:
+    1. Read src/tgt sparse attention: (G_full, K=300) values + indices
+    2. Select gene subset rows
+    3. Scatter to dense: (B, G_sub, G_full) — chunked to avoid OOM
+    4. Delta = tgt_dense - src_dense (full G_full columns, NOT G_sub)
+    5. Per-row top-K on G_full columns
+    6. Return (delta_values, delta_indices) sparse triplets
+    """
+
+    def __init__(self, h5_path, delta_top_k=30):
+        self.h5_path = h5_path
+        self.delta_top_k = delta_top_k
+
+        # Read metadata only, then close — safe for fork
+        with h5py.File(h5_path, "r") as h5:
+            self.G_full = h5["attn_values"].shape[1]
+            self.K_sparse = h5["attn_values"].shape[2]
+            cell_names = h5["cell_names"].asstr()[:]
+            self.name_to_idx = {name: i for i, name in enumerate(cell_names)}
+            if "valid_gene_mask" in h5:
+                self.valid_gene_mask = h5["valid_gene_mask"][:].astype(bool)
+            else:
+                self.valid_gene_mask = np.ones(self.G_full, dtype=bool)
+
+        # Per-process HDF5 handle (lazily opened)
+        self._h5 = None
+        self._attn_values = None
+        self._attn_indices = None
+        self._pid = None
+
+        print(f"  SparseDeltaCache: {len(self.name_to_idx)} cells, "
+              f"G_full={self.G_full}, K_sparse={self.K_sparse}, delta_topk={self.delta_top_k}")
+        print(f"  valid genes: {self.valid_gene_mask.sum()}/{self.G_full}")
+
+    def _ensure_h5_open(self):
+        """Ensure current process has its own HDF5 file handle."""
+        pid = os.getpid()
+        if self._h5 is None or self._pid != pid:
+            if self._h5 is not None:
+                try:
+                    self._h5.close()
+                except Exception:
+                    pass
+            self._h5 = h5py.File(self.h5_path, "r")
+            self._attn_values = self._h5["attn_values"]
+            self._attn_indices = self._h5["attn_indices"]
+            self._pid = pid
+
+    def get_missing_gene_mask(self, gene_indices=None):
+        """
+        Return missing gene mask (True = missing/invalid).
+        Pure numpy operation — no HDF5 I/O needed.
+        """
+        mask = torch.from_numpy(~self.valid_gene_mask)  # True = missing
+        if gene_indices is not None:
+            return mask[gene_indices.cpu()]
+        return mask
+
+    def lookup_delta(self, src_cell_names, tgt_cell_names, gene_indices, device=None):
+        """
+        Compute sparse delta attention triplets for SVD projection.
+
+        Args:
+            src_cell_names: list of str, control cell identifiers
+            tgt_cell_names: list of str, perturbation cell identifiers
+            gene_indices: (G_sub,) tensor, gene subset row indices
+            device: target torch device (usually CPU for DataLoader workers)
+
+        Returns:
+            delta_values:  (B, G_sub, delta_topk) float32 — top-K delta values per row
+            delta_indices: (B, G_sub, delta_topk) int16   — column indices in G_full space
+        """
+        self._ensure_h5_open()
+
+        if device is None:
+            device = torch.device("cpu")
+
+        B = len(src_cell_names)
+        gene_idx_np = gene_indices.cpu().numpy()
+        G_sub = len(gene_idx_np)
+        K = self.delta_top_k
+
+        # Read sparse data from HDF5 (uses per-process handle)
+        # gene_idx_np selects ROWS only — we keep all G_full columns
+        sv_np, si_np, tv_np, ti_np = _read_sparse_batch(
+            self._attn_values, self._attn_indices, self.name_to_idx,
+            src_cell_names, tgt_cell_names, gene_idx_np)
+
+        src_vals = torch.from_numpy(sv_np.astype(np.float32)).to(device)  # (B, G_sub, K_sparse)
+        src_idxs = torch.from_numpy(si_np.astype(np.int64)).to(device)
+        tgt_vals = torch.from_numpy(tv_np.astype(np.float32)).to(device)
+        tgt_idxs = torch.from_numpy(ti_np.astype(np.int64)).to(device)
+
+        # Output sparse triplets
+        out_values = torch.zeros(B, G_sub, K, device=device)
+        out_indices = torch.zeros(B, G_sub, K, dtype=torch.int16, device=device)
+
+        # Process in chunks (100 rows per chunk) to limit memory
+        chunk_size = 100
+        for c_start in range(0, G_sub, chunk_size):
+            c_end = min(c_start + chunk_size, G_sub)
+
+            sv = src_vals[:, c_start:c_end, :]  # (B, c_len, K_sparse)
+            si = src_idxs[:, c_start:c_end, :]
+            tv = tgt_vals[:, c_start:c_end, :]
+            ti = tgt_idxs[:, c_start:c_end, :]
+            c_len = c_end - c_start
+
+            # Scatter sparse entries to dense attention rows: (B, c_len, G_full)
+            src_dense = torch.zeros(B, c_len, self.G_full, device=device)
+            tgt_dense = torch.zeros(B, c_len, self.G_full, device=device)
+            src_dense.scatter_(-1, si, sv)
+            tgt_dense.scatter_(-1, ti, tv)
+
+            # Delta on FULL G_full columns (no column subsetting!)
+            delta = tgt_dense - src_dense  # (B, c_len, G_full)
+
+            # Per-row top-K on G_full columns
+            _, topk_idx = delta.abs().topk(K, dim=-1)        # (B, c_len, K)
+            topk_vals = delta.gather(-1, topk_idx)            # (B, c_len, K)
+
+            out_values[:, c_start:c_end, :] = topk_vals
+            out_indices[:, c_start:c_end, :] = topk_idx.short()
+
+        return out_values, out_indices  # (B, G_sub, K) float32, (B, G_sub, K) int16
+
+    def close(self):
+        if self._h5 is not None:
+            try:
+                self._h5.close()
+            except Exception:
+                pass
+            self._h5 = None
+            self._attn_values = None
+            self._attn_indices = None
+
+    def __del__(self):
+        self.close()

train/CCFM/pca_emb/src/denoiser.py

@@ -0,0 +1,375 @@
+"""
+CascadedDenoiser for grn_svd — uses SVD-projected (B, G, 128) as latent target.
+
+Key changes from grn_att_only:
+- SVD dictionary W (5035, 128) as frozen register_buffer on GPU
+- _sparse_project(): GPU-based loop-of-K gather+accumulate
+- 1D missing mask (not 2D)
+- Simplified masked MSE loss (no non-zero reweighting)
+- reconstruct_grn(): inverse projection for GRN visualization
+"""
+
+import torch
+import torch.nn as nn
+import torchdiffeq
+
+from ._scdfm_imports import AffineProbPath, CondOTScheduler, make_lognorm_poisson_noise
+from .model.model import CascadedFlowModel
+from .data.sparse_raw_cache import SparseDeltaCache
+
+
+# Shared flow matching path
+flow_path = AffineProbPath(scheduler=CondOTScheduler())
+
+
+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 CascadedDenoiser(nn.Module):
+    """
+    Cascaded denoiser with SVD-projected latent target.
+
+    Training: Cascaded time-step sampling, GPU-side SVD projection.
+    Inference: Two-stage cascaded generation in 128-dim latent space.
+    """
+
+    def __init__(
+        self,
+        model: CascadedFlowModel,
+        sparse_cache: SparseDeltaCache,
+        svd_dict_path: str,
+        choose_latent_p: float = 0.4,
+        latent_weight: float = 1.0,
+        noise_type: str = "Gaussian",
+        use_mmd_loss: bool = True,
+        gamma: float = 0.5,
+        poisson_alpha: float = 0.8,
+        poisson_target_sum: float = 1e4,
+        # Logit-normal time-step sampling
+        t_sample_mode: str = "logit_normal",
+        t_expr_mean: float = 0.0,
+        t_expr_std: float = 1.0,
+        t_latent_mean: float = 0.0,
+        t_latent_std: float = 1.0,
+        # Cascaded noise
+        noise_beta: float = 0.25,
+        # Variance-weighted latent loss
+        use_variance_weight: bool = False,
+    ):
+        super().__init__()
+        self.model = model
+        self.sparse_cache = sparse_cache
+        self.choose_latent_p = choose_latent_p
+        self.latent_weight = latent_weight
+        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.t_sample_mode = t_sample_mode
+        self.t_expr_mean = t_expr_mean
+        self.t_expr_std = t_expr_std
+        self.t_latent_mean = t_latent_mean
+        self.t_latent_std = t_latent_std
+        self.noise_beta = noise_beta
+        self.use_variance_weight = use_variance_weight
+
+        # Load SVD dictionary as frozen buffer (moves with model to GPU)
+        svd_dict = torch.load(svd_dict_path, map_location="cpu", weights_only=False)
+        self.register_buffer("W", svd_dict["W"].float())             # (G_full, 128)
+        self.register_buffer("global_scale_sq",
+            torch.tensor(svd_dict["global_scale"] ** 2).float())     # scalar
+        self.latent_dim = self.W.shape[1]
+
+        # Variance-weighted latent loss: w_i = evr_i / sum(evr)
+        if use_variance_weight:
+            evr = torch.from_numpy(svd_dict["explained_variance_ratio"]).float()
+            w = evr / evr.sum()  # (latent_dim,) normalized to sum=1
+            self.register_buffer("latent_dim_weights", w)
+            print(f"  Variance weighting ON: top={w[0]:.4f}, bot={w[-1]:.4f}, "
+                  f"ratio={w[0]/w[-1]:.1f}x")
+
+        print(f"  SVD dict loaded: W {self.W.shape}, "
+              f"global_scale={svd_dict['global_scale']:.6f}")
+
+    def _sparse_project(self, delta_values, delta_indices):
+        """
+        Sparse GPU projection: delta @ W via loop-of-K gather+accumulate.
+
+        Args:
+            delta_values:  (B, G_sub, K) float32 — top-K delta values (on GPU)
+            delta_indices: (B, G_sub, K) int16   — column indices in G_full space (on GPU)
+
+        Returns:
+            z_target: (B, G_sub, latent_dim=128)
+        """
+        assert delta_values.device == self.W.device, \
+            f"Device mismatch: delta on {delta_values.device}, W on {self.W.device}"
+
+        B, G_sub, K = delta_values.shape
+        z_target = torch.zeros(B, G_sub, self.latent_dim, device=delta_values.device)
+
+        indices_long = delta_indices.long()  # (B, G_sub, K)
+        for k in range(K):
+            col_idx = indices_long[:, :, k]               # (B, G_sub)
+            val = delta_values[:, :, k:k+1]               # (B, G_sub, 1)
+            w_k = self.W[col_idx]                          # (B, G_sub, latent_dim)
+            z_target = z_target + val * w_k                # broadcast + accumulate
+
+        return z_target
+
+    def reconstruct_grn(self, z: torch.Tensor) -> torch.Tensor:
+        """
+        Inverse projection: 128-dim latent → approximate delta attention (sparse GRN).
+
+        Math: W_saved = V × s (V orthonormal, s = global_scale)
+              Forward:  z = delta @ W = delta @ Vs
+              Inverse:  delta ≈ z @ V^T / s = z @ W^T / s^2
+
+        Args:
+            z: (B, G, 128) — latent from ODE generation
+        Returns:
+            (B, G, G_full) — approximate delta attention per gene
+        """
+        return z @ self.W.T / self.global_scale_sq
+
+    def sample_t(self, n: int, device: torch.device):
+        """Cascaded time-step sampling — dino_first_cascaded mode."""
+        if self.t_sample_mode == "logit_normal":
+            t_latent = torch.sigmoid(torch.randn(n, device=device) * self.t_latent_std + self.t_latent_mean)
+            t_expr = torch.sigmoid(torch.randn(n, device=device) * self.t_expr_std + self.t_expr_mean)
+        else:
+            t_latent = torch.rand(n, device=device)
+            t_expr = torch.rand(n, device=device)
+
+        choose_latent_mask = torch.rand(n, device=device) < self.choose_latent_p
+
+        t_latent_expr = torch.rand_like(t_latent) * self.noise_beta + (1.0 - self.noise_beta)
+        t_latent = torch.where(choose_latent_mask, t_latent, t_latent_expr)
+        t_expr = torch.where(choose_latent_mask, torch.zeros_like(t_expr), t_expr)
+
+        w_expr = (~choose_latent_mask).float()
+        w_latent = choose_latent_mask.float()
+
+        return t_expr, t_latent, w_expr, w_latent
+
+    def _make_expr_noise(self, source: torch.Tensor) -> torch.Tensor:
+        """Create noise for expression flow."""
+        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 train_step(
+        self,
+        source: torch.Tensor,           # (B, G_sub) — already subsetted
+        target: torch.Tensor,            # (B, G_sub)
+        perturbation_id: torch.Tensor,   # (B, 2)
+        gene_input: torch.Tensor,        # (B, G_sub) vocab-encoded gene IDs
+        delta_values: torch.Tensor,      # (B, G_sub, K) on GPU
+        delta_indices: torch.Tensor,     # (B, G_sub, K) int16 on GPU
+        input_gene_ids: torch.Tensor,    # (G_sub,) positional indices for missing mask
+    ) -> dict:
+        """Single training step with SVD-projected latent target."""
+        B = source.shape[0]
+        device = source.device
+        G_sub = source.shape[-1]
+
+        # 1. GPU-side SVD projection: sparse → dense 128-dim
+        z_target = self._sparse_project(delta_values, delta_indices)  # (B, G_sub, 128)
+
+        # 2. Missing gene mask — 1D only
+        missing = self.sparse_cache.get_missing_gene_mask(input_gene_ids)  # (G_sub,) bool
+        missing_dev = missing.to(device)
+
+        # 3. Cascaded time sampling
+        t_expr, t_latent, w_expr, w_latent = self.sample_t(B, device)
+
+        # 4. Expression flow path
+        noise_expr = self._make_expr_noise(source)
+        path_expr = flow_path.sample(t=t_expr, x_0=noise_expr, x_1=target)
+
+        # 5. Latent flow path — (B, G_sub, 128)
+        noise_latent = torch.randn_like(z_target)
+        # 1D missing mask: zero entire gene rows
+        noise_latent[:, missing_dev, :] = 0.0
+
+        z_flat = z_target.reshape(B, G_sub * self.latent_dim)
+        noise_flat = noise_latent.reshape(B, G_sub * self.latent_dim)
+        path_latent_flat = flow_path.sample(t=t_latent, x_0=noise_flat, x_1=z_flat)
+
+        class _LatentPath:
+            pass
+        path_latent = _LatentPath()
+        path_latent.x_t = path_latent_flat.x_t.reshape(B, G_sub, self.latent_dim)
+        path_latent.dx_t = path_latent_flat.dx_t.reshape(B, G_sub, self.latent_dim)
+
+        # 6. Model forward
+        pred_v_expr, pred_v_latent = self.model(
+            gene_input, source, path_expr.x_t, path_latent.x_t,
+            t_expr, t_latent, perturbation_id,
+        )
+
+        # 7. Losses
+        # Expression loss (unchanged from grn_att_only)
+        loss_expr_per_sample = ((pred_v_expr - path_expr.dx_t) ** 2).mean(dim=-1)  # (B,)
+        loss_expr = (loss_expr_per_sample * w_expr).sum() / w_expr.sum().clamp(min=1)
+
+        # Latent loss — masked MSE over 128-dim SVD latent
+        loss_elem = (pred_v_latent - path_latent.dx_t) ** 2  # (B, G_sub, 128)
+        if self.use_variance_weight:
+            loss_per_gene = (loss_elem * self.latent_dim_weights).sum(dim=-1)  # (B, G_sub)
+        else:
+            loss_per_gene = loss_elem.mean(dim=-1)  # (B, G_sub) — uniform over 128 dims
+        loss_per_gene[:, missing_dev] = 0.0     # zero out missing genes
+        n_valid = (~missing_dev).sum().clamp(min=1)
+        loss_latent_per_sample = loss_per_gene.sum(dim=-1) / n_valid  # (B,)
+        loss_latent = (loss_latent_per_sample * w_latent).sum() / w_latent.sum().clamp(min=1)
+
+        loss = loss_expr + self.latent_weight * loss_latent
+
+        # Optional MMD loss on expression
+        _mmd_loss = torch.tensor(0.0, device=device)
+        if self.use_mmd_loss and w_expr.sum() > 0:
+            expr_mask = w_expr > 0
+            if expr_mask.any():
+                x1_hat = (
+                    path_expr.x_t[expr_mask]
+                    + pred_v_expr[expr_mask] * (1 - t_expr[expr_mask]).unsqueeze(-1)
+                )
+                sigmas = median_sigmas(target[expr_mask], scales=(0.5, 1.0, 2.0, 4.0))
+                _mmd_loss = mmd2_unbiased_multi_sigma(x1_hat, target[expr_mask], sigmas)
+                loss = loss + _mmd_loss * self.gamma
+
+        return {
+            "loss": loss,
+            "loss_expr": loss_expr.detach(),
+            "loss_latent": loss_latent.detach(),
+            "loss_mmd": _mmd_loss.detach(),
+        }
+
+    @torch.no_grad()
+    def generate(
+        self,
+        source: torch.Tensor,           # (B, G)
+        perturbation_id: torch.Tensor,   # (B, 2)
+        gene_ids: torch.Tensor,          # (B, G) or (G,)
+        latent_steps: int = 20,
+        expr_steps: int = 20,
+        method: str = "rk4",
+    ) -> torch.Tensor:
+        """
+        Two-stage cascaded generation in 128-dim latent space.
+
+        Returns: (B, G) generated expression values
+        """
+        B, G = source.shape
+        device = source.device
+
+        if gene_ids.dim() == 1:
+            gene_ids = gene_ids.unsqueeze(0).expand(B, -1)
+
+        # 1D missing mask
+        missing = self.sparse_cache.get_missing_gene_mask(torch.arange(G))
+
+        # Initialize latent noise in 128-dim (NOT G×G!)
+        z_t = torch.randn(B, G, self.latent_dim, device=device)
+        if missing is not None:
+            z_t[:, missing, :] = 0.0
+        x_t = self._make_expr_noise(source)
+
+        if method == "rk4":
+            # === Stage 1: Latent generation (t_latent: 0->1, t_expr=0) ===
+            t_zero = torch.zeros(B, device=device)
+            t_one = torch.ones(B, device=device)
+
+            def latent_vf(t, z):
+                v_expr, v_latent = self.model(
+                    gene_ids, source, x_t, z,
+                    t_zero, t.expand(B), perturbation_id,
+                )
+                if missing is not None:
+                    v_latent[:, missing, :] = 0.0
+                return v_latent
+
+            z_t = torchdiffeq.odeint(
+                latent_vf, z_t,
+                torch.linspace(0, 1, latent_steps + 1, device=device),
+                method="rk4", atol=1e-4, rtol=1e-4,
+            )[-1]
+
+            # === Stage 2: Expression generation (t_expr: 0->1, t_latent=1) ===
+            def expr_vf(t, x):
+                v_expr, v_latent = self.model(
+                    gene_ids, source, x, z_t,
+                    t.expand(B), t_one, perturbation_id,
+                )
+                return v_expr
+
+            x_t = torchdiffeq.odeint(
+                expr_vf, x_t,
+                torch.linspace(0, 1, expr_steps + 1, device=device),
+                method="rk4", atol=1e-4, rtol=1e-4,
+            )[-1]
+
+        else:  # euler
+            t_latent_schedule = torch.cat([
+                torch.linspace(0, 1, latent_steps + 1, device=device),
+                torch.ones(expr_steps, device=device),
+            ])
+            t_expr_schedule = torch.cat([
+                torch.zeros(latent_steps + 1, device=device),
+                torch.linspace(0, 1, expr_steps + 1, device=device)[1:],
+            ])
+
+            for i in range(latent_steps + expr_steps):
+                t_lat = t_latent_schedule[i]
+                t_lat_next = t_latent_schedule[i + 1]
+                t_exp = t_expr_schedule[i]
+                t_exp_next = t_expr_schedule[i + 1]
+
+                v_expr, v_latent = self.model(
+                    gene_ids, source, x_t, z_t,
+                    t_exp.expand(B), t_lat.expand(B), perturbation_id,
+                )
+
+                x_t = x_t + (t_exp_next - t_exp) * v_expr
+                z_t = z_t + (t_lat_next - t_lat) * v_latent
+                if missing is not None:
+                    z_t[:, missing, :] = 0.0
+
+        return torch.clamp(x_t, min=0)

train/CCFM/pca_emb/src/model/layers.py

@@ -0,0 +1,121 @@
+"""
+Latent layers for grn_svd: LatentEmbedder, LatentDecoderBlock, LatentDecoder.
+Adapted from GRN/grn_ccfm/src/model/layers.py for SVD-projected 128-dim latent space.
+"""
+
+import torch
+import torch.nn as nn
+
+
+class LatentEmbedder(nn.Module):
+    """
+    Projects z_t (B, G, latent_dim) to (B, G, d_model).
+    When latent_dim == d_model: LayerNorm + Linear (identity-like).
+    When latent_dim != d_model: Linear bottleneck without LayerNorm
+    (LayerNorm on dim=1 destroys the signal).
+    """
+
+    def __init__(self, latent_dim: int = 128, d_model: int = 128):
+        super().__init__()
+        if latent_dim == d_model:
+            self.proj = nn.Sequential(
+                nn.LayerNorm(latent_dim),
+                nn.Linear(latent_dim, d_model),
+            )
+        else:
+            self.proj = nn.Sequential(
+                nn.Linear(latent_dim, d_model),
+                nn.GELU(),
+                nn.Linear(d_model, d_model),
+            )
+
+    def forward(self, z: torch.Tensor) -> torch.Tensor:
+        """z: (B, G, latent_dim) -> (B, G, d_model)"""
+        return self.proj(z)
+
+
+class LatentDecoderBlock(nn.Module):
+    """
+    AdaLN-conditioned transformer block for latent decoder head.
+    6-way modulation: shift/scale/gate for self-attention and MLP.
+    Copied from CCFM (GRN/grn_ccfm/src/model/layers.py).
+    """
+
+    def __init__(self, hidden_size: int, num_heads: int = 4, mlp_ratio: float = 4.0,
+                 hidden_size_c: int = None):
+        super().__init__()
+        hidden_size_c = hidden_size_c or hidden_size
+        self.norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.attn = nn.MultiheadAttention(hidden_size, num_heads, batch_first=True)
+        self.norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        mlp_hidden = int(hidden_size * mlp_ratio)
+        self.mlp = nn.Sequential(
+            nn.Linear(hidden_size, mlp_hidden),
+            nn.GELU(),
+            nn.Linear(mlp_hidden, hidden_size),
+        )
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size_c, 6 * hidden_size, bias=True),
+        )
+
+    def forward(self, x: torch.Tensor, c: torch.Tensor) -> torch.Tensor:
+        """
+        x: (B, G, hidden_size)
+        c: (B, hidden_size_c) — conditioning vector (t_expr + t_latent + pert_emb)
+        """
+        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = (
+            self.adaLN_modulation(c).chunk(6, dim=1)
+        )
+        # Self-attention with AdaLN
+        h = self.norm1(x)
+        h = h * (1 + scale_msa.unsqueeze(1)) + shift_msa.unsqueeze(1)
+        h = self.attn(h, h, h)[0]
+        x = x + gate_msa.unsqueeze(1) * h
+        # MLP with AdaLN
+        h = self.norm2(x)
+        h = h * (1 + scale_mlp.unsqueeze(1)) + shift_mlp.unsqueeze(1)
+        h = self.mlp(h)
+        x = x + gate_mlp.unsqueeze(1) * h
+        return x
+
+
+class LatentDecoder(nn.Module):
+    """
+    Decodes backbone output (B, G, d_model) to latent velocity (B, G, latent_dim).
+    Uses AdaLN blocks conditioned on c for timestep/perturbation awareness.
+    """
+
+    def __init__(self, d_model: int = 128, latent_dim: int = 128,
+                 dh_depth: int = 2, num_heads: int = 4,
+                 hidden_size_c: int = None):
+        super().__init__()
+        hidden_size_c = hidden_size_c or d_model
+
+        self.dh_proj = nn.Linear(d_model, d_model)
+
+        if dh_depth > 0:
+            self.dh_blocks = nn.ModuleList([
+                LatentDecoderBlock(d_model, num_heads=num_heads, hidden_size_c=hidden_size_c)
+                for _ in range(dh_depth)
+            ])
+        else:
+            self.dh_blocks = nn.ModuleList()
+
+        self.final = nn.Sequential(
+            nn.LayerNorm(d_model),
+            nn.Linear(d_model, d_model),
+            nn.GELU(),
+            nn.Linear(d_model, latent_dim),
+        )
+
+    def forward(self, x: torch.Tensor, c: torch.Tensor) -> torch.Tensor:
+        """
+        x: (B, G, d_model) — backbone output
+        c: (B, d_model) — conditioning vector
+        Returns: (B, G, latent_dim=128) — predicted latent velocity
+        """
+        h = self.dh_proj(x)
+        for block in self.dh_blocks:
+            h = block(h, c)
+        return self.final(h)

train/CCFM/pca_emb/src/model/model.py

@@ -0,0 +1,219 @@
+"""
+CascadedFlowModel for grn_svd.
+
+Key changes from grn_att_only:
+- Latent target: SVD-projected (B, G, 128) instead of raw (B, G, G)
+- Latent encoder: LatentEmbedder(LayerNorm+Linear) instead of z_t @ gene_emb
+- Latent decoder: LatentDecoder(AdaLN, conditioned on c) instead of BilinearLatentDecoder
+"""
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+from typing import Optional, Tuple
+
+from .layers import LatentEmbedder, LatentDecoder
+from .._scdfm_imports import (
+    GeneadaLN,
+    ContinuousValueEncoder,
+    GeneEncoder,
+    BatchLabelEncoder,
+    TimestepEmbedder,
+    ExprDecoder,
+    DifferentialTransformerBlock,
+    PerceiverBlock,
+    DiffPerceiverBlock,
+)
+
+
+class CascadedFlowModel(nn.Module):
+    """
+    Cascaded Flow Model with SVD-projected latent target.
+
+    Inputs:
+        gene_id:         (B, G)       gene token IDs
+        cell_1:          (B, G)       source (control) expression
+        x_t:             (B, G)       noised target expression (expression flow)
+        z_t:             (B, G, 128)  noised SVD-projected latent (latent flow)
+        t_expr:          (B,)         expression flow timestep
+        t_latent:        (B,)         latent flow timestep
+        perturbation_id: (B, 2)       perturbation token IDs
+
+    Outputs:
+        pred_v_expr:   (B, G)     predicted expression velocity
+        pred_v_latent: (B, G, 128)  predicted latent velocity
+    """
+
+    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,
+        latent_dim: int = 128,
+        dh_depth: int = 2,
+    ):
+        super().__init__()
+        self.d_model = d_model
+        self.fusion_method = fusion_method
+        self.perturbation_function = perturbation_function
+
+        # === Timestep embedders (separate for expr and latent) ===
+        self.t_expr_embedder = TimestepEmbedder(d_model)
+        self.t_latent_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.use_perturbation_interaction = use_perturbation_interaction
+        self.fusion_layer = nn.Sequential(
+            nn.Linear(2 * d_model, d_model),
+            nn.GELU(),
+            nn.Linear(d_model, d_model),
+            nn.LayerNorm(d_model),
+        )
+
+        # === Latent stream: LatentEmbedder (LayerNorm + Linear) ===
+        self.latent_embedder = LatentEmbedder(latent_dim, 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)
+        ])
+
+        # === Expression decoder head (reused from scDFM) ===
+        self.final_layer = ExprDecoder(d_model, explicit_zero_prob=False, use_batch_labels=True)
+
+        # === Latent decoder head: AdaLN + MLP -> (B, G, latent_dim) ===
+        self.latent_decoder = LatentDecoder(
+            d_model=d_model, latent_dim=latent_dim,
+            dh_depth=dh_depth, num_heads=max(nhead // 2, 1),
+            hidden_size_c=d_model,
+        )
+
+        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)
+
+    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)  # (B, d)
+        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)
+        cell_1: Tensor,          # (B, G) source expression
+        x_t: Tensor,             # (B, G) noised expression
+        z_t: Tensor,             # (B, G, 128) noised SVD-projected latent
+        t_expr: Tensor,          # (B,)
+        t_latent: Tensor,        # (B,)
+        perturbation_id: Optional[Tensor] = None,  # (B, 2)
+    ) -> Tuple[Tensor, Tensor]:
+        if t_expr.dim() == 0:
+            t_expr = t_expr.repeat(cell_1.size(0))
+        if t_latent.dim() == 0:
+            t_latent = t_latent.repeat(cell_1.size(0))
+
+        # === 1. Expression stream embedding (aligned with scDFM) ===
+        gene_emb = self.encoder(gene_id)  # (B, G, d_model)
+        val_emb_1 = self.value_encoder_1(x_t)
+        val_emb_2 = self.value_encoder_2(cell_1) + gene_emb
+        expr_tokens = self.fusion_layer(torch.cat([val_emb_1, val_emb_2], dim=-1)) + gene_emb
+
+        # === 2. Latent stream: LatentEmbedder (LayerNorm + Linear) ===
+        # z_t: (B, G, 128) — already in d_model space via SVD projection
+        latent_tokens = self.latent_embedder(z_t)  # (B, G, d_model)
+
+        # === 3. Element-wise addition ===
+        x = expr_tokens + latent_tokens  # (B, G, d_model)
+
+        # === 4. Conditioning vector ===
+        t_expr_emb = self.t_expr_embedder(t_expr)
+        t_latent_emb = self.t_latent_embedder(t_latent)
+        pert_emb = self.get_perturbation_emb(perturbation_id, cell_1=cell_1)
+        c = t_expr_emb + t_latent_emb + pert_emb
+
+        # === 5. 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)
+
+        # === 6a. Expression decoder head ===
+        x_with_pert = torch.cat([x, pert_emb[:, None, :].expand(-1, x.size(1), -1)], dim=-1)
+        pred_v_expr = self.final_layer(x_with_pert)["pred"]  # (B, G)
+
+        # === 6b. Latent decoder head (AdaLN, conditioned on c) ===
+        pred_v_latent = self.latent_decoder(x, c)  # (B, G, 128)
+
+        return pred_v_expr, pred_v_latent

train/CCFM/pca_emb/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,
+)