Upload folder using huggingface_hub

GRN/grn_sacfm/_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/grn_sacfm/config/config_sacfm.py

@@ -0,0 +1,75 @@
+"""SA-CFM config — simplified from SBConfig, no learned sigma / score / SDE."""
+
+import os
+from dataclasses import dataclass
+
+
+@dataclass
+class SACFMConfig:
+    # === Base model ===
+    model_type: str = "sacfm"
+    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 ===
+    data_name: str = "norman"
+    perturbation_function: str = "crisper"
+    noise_type: str = "Gaussian"
+    print_every: int = 5000
+    mode: str = "predict_y"
+    result_path: str = "/home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/sacfm"
+    fusion_method: str = "differential_perceiver"
+    infer_top_gene: int = 1000
+    n_top_genes: int = 5000
+    checkpoint_path: str = ""
+
+    # === MMD loss ===
+    gamma: float = 0.5
+    use_mmd_loss: bool = True
+
+    # === Data split ===
+    split_method: str = "additive"
+    fold: int = 1
+    use_negative_edge: bool = True
+    topk: int = 30
+
+    # === SA-CFM specific ===
+    sigma_scale: float = 0.3       # sigma_aug = sigma_scale * gene_pert_std
+    sigma_min_clip: float = 0.01   # lower bound for sigma_aug
+    sigma_max_clip: float = 2.0    # upper bound for sigma_aug
+    gene_weight_alpha: float = 2.0 # gene importance weight strength
+    use_ot: bool = False           # use OT coupling (default off, same as scDFM)
+
+    # === Training ===
+    ema_decay: float = 0.9999
+    warmup_steps: int = 2000
+
+    # === ODE inference ===
+    ode_method: str = "rk4"
+    ode_steps: int = 20
+    eval_batch_size: int = 32
+
+    # === Experiment ===
+    exp_name: str = "sacfm_baseline"
+
+    def __post_init__(self):
+        if self.data_name == "norman":
+            self.n_top_genes = 5000
+
+    def make_path(self):
+        name = (
+            f"sacfm-{self.data_name}-f{self.fold}"
+            f"-d{self.d_model}-ss{self.sigma_scale}-gw{self.gene_weight_alpha}"
+        )
+        if self.exp_name:
+            name = self.exp_name
+        return os.path.join(self.result_path, name)

GRN/grn_sacfm/run_sacfm.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+#PJM -L rscgrp=b-batch
+#PJM -L gpu=1
+#PJM -L elapse=12:00:00
+#PJM -j
+#PJM -N sacfm
+
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256
+
+source /home/hp250092/ku50001222/qian/aivc/lfj/stack_env/bin/activate
+cd /home/hp250092/ku50001222/qian/aivc/lfj/GRN/grn_sacfm
+
+python scripts/run_sacfm.py \
+    --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 \
+    --data-name norman \
+    --infer-top-gene 1000 \
+    --n-top-genes 5000 \
+    --noise-type Gaussian \
+    --gamma 0.5 \
+    --use-mmd-loss \
+    --split-method additive \
+    --fold 1 \
+    --use-negative-edge \
+    --topk 30 \
+    --ema-decay 0.9999 \
+    --warmup-steps 2000 \
+    --ode-method rk4 \
+    --ode-steps 20 \
+    --sigma-scale 0.3 \
+    --gene-weight-alpha 2.0 \
+    --result-path /home/hp250092/ku50001222/qian/aivc/lfj/GRN/result/sacfm \
+    --exp-name sacfm_ss03_gw2

GRN/grn_sacfm/scripts/run_sacfm.py

@@ -0,0 +1,380 @@
+"""
+Training and evaluation entry point for SA-CFM.
+
+Source-Anchored Conditional Flow Matching:
+- x_0 = source + data-driven sigma * eps (not pure noise)
+- Standard affine flow matching (no bridge / SDE)
+- Gene-weighted velocity loss
+- ODE inference from clean source
+"""
+
+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_sacfm import SACFMConfig as Config
+from src.data.data import get_data_classes
+from src._scdfm_imports import ScDFMModel, save_checkpoint, load_checkpoint, process_vocab, GeneVocab
+from src.denoiser import SACFMDenoiser
+from cell_eval import MetricsEvaluator
+
+_REPO_ROOT = os.path.normpath(os.path.join(_PROJECT_ROOT, "..", "..", "transfer", "code"))
+
+
+def compute_gene_stats(train_sampler, config, device):
+    """Pre-compute per-gene perturbation statistics from training data."""
+    adata = train_sampler.adata
+    ctrl_mask = adata.obs["is_control"].values.astype(bool)
+    ctrl_X = adata[ctrl_mask].X
+    ctrl_mean = np.asarray(ctrl_X.mean(axis=0)).flatten()
+
+    pert_names = adata.obs["perturbation_covariates"].unique()
+    pert_names = [p for p in pert_names if p != "control+control"]
+
+    pert_effects = []
+    for pn in pert_names:
+        mask = adata.obs["perturbation_covariates"] == pn
+        pert_mean = np.asarray(adata[mask].X.mean(axis=0)).flatten()
+        pert_effects.append(pert_mean - ctrl_mean)
+
+    pert_effects = np.stack(pert_effects)           # (n_pert, G)
+    gene_pert_std = pert_effects.std(axis=0)        # (G,)
+
+    # Sigma augmentation: scaled per-gene perturbation std
+    sigma_aug = np.clip(
+        config.sigma_scale * gene_pert_std,
+        config.sigma_min_clip, config.sigma_max_clip,
+    )
+    sigma_aug = torch.tensor(sigma_aug, dtype=torch.float32, device=device)
+
+    # Gene importance weight: upweight DE genes
+    median_std = np.median(gene_pert_std[gene_pert_std > 0])
+    gene_weight = 1.0 + config.gene_weight_alpha * (gene_pert_std / max(median_std, 1e-8))
+    gene_weight = torch.tensor(gene_weight, dtype=torch.float32, device=device)
+
+    return sigma_aug, gene_weight
+
+
+@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)
+            base_denoiser = denoiser.module if hasattr(denoiser, "module") else denoiser
+            pred = base_denoiser.generate(
+                bs, bp, gene_ids_test,
+                steps=config.ode_steps,
+                method=config.ode_method,
+            )
+            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 ("pearson_delta", "mse", "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)
+
+    # === Pre-compute per-gene statistics ===
+    if accelerator.is_main_process:
+        print("Computing per-gene perturbation statistics...")
+    sigma_aug, gene_weight = compute_gene_stats(train_sampler, config, device)
+    if accelerator.is_main_process:
+        print(f"  sigma_aug: mean={sigma_aug.mean():.4f}, std={sigma_aug.std():.4f}, "
+              f"min={sigma_aug.min():.4f}, max={sigma_aug.max():.4f}")
+        print(f"  gene_weight: mean={gene_weight.mean():.4f}, max={gene_weight.max():.4f}")
+        n_active = (sigma_aug > config.sigma_min_clip + 1e-6).sum().item()
+        print(f"  Active genes (sigma > clip): {n_active}/{len(sigma_aug)}")
+
+    # === 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 model (reuse scDFM model directly, no SBModel) ===
+    vf = ScDFMModel(
+        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,
+    )
+
+    # === Build SA-CFM denoiser ===
+    denoiser = SACFMDenoiser(
+        model=vf,
+        sigma_aug=sigma_aug,
+        gene_weight=gene_weight,
+        noise_type=config.noise_type,
+        use_mmd_loss=config.use_mmd_loss,
+        gamma=config.gamma,
+    )
+
+    # === Dataset & DataLoader ===
+    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,
+    )
+
+    # === 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_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).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, input_gene_ids_pos,
+            )
+
+            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_mmd"].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/mmd', loss_dict["loss_mmd"].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"mmd={loss_dict['loss_mmd'].item():.3f}"
+            )
+            iteration += 1
+            if iteration >= config.steps:
+                break
+
+    if accelerator.is_main_process:
+        csv_file.close()
+        tb_writer.close()

GRN/grn_sacfm/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 Model (direct reuse, no modifications) ===
+ScDFMModel = _model.model
+
+# === 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

GRN/grn_sacfm/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/grn_sacfm/src/denoiser.py

@@ -0,0 +1,172 @@
+"""
+SACFMDenoiser — Source-Anchored Conditional Flow Matching.
+
+Training: x_0 = source + sigma_aug * eps (noisy source, not pure noise).
+          Standard affine path: x_t = (1-t)*x_0 + t*target.
+          Velocity target: dx_t = target - x_0.
+          Gene-weighted MSE loss.
+
+Inference: ODE from clean source (no noise, no SDE).
+"""
+
+import torch
+import torch.nn as nn
+import torchdiffeq
+
+from ._scdfm_imports import AffineProbPath, 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 SACFMDenoiser(nn.Module):
+    """
+    Source-Anchored Conditional Flow Matching Denoiser.
+
+    Key differences from scDFM baseline:
+    - x_0 = source + sigma_aug * eps (not pure noise)
+    - Gene-weighted velocity loss
+    - Inference starts from clean source
+
+    Key differences from SB:
+    - No SigmaNet (sigma_aug is fixed, data-driven)
+    - No ScoreDecoder
+    - No SDE inference
+    - No bridge formulation (standard affine path)
+    """
+
+    def __init__(
+        self,
+        model: nn.Module,
+        sigma_aug: torch.Tensor,       # (G,) per-gene augmentation noise
+        gene_weight: torch.Tensor,      # (G,) per-gene loss weight
+        noise_type: str = "Gaussian",
+        use_mmd_loss: bool = True,
+        gamma: float = 0.5,
+    ):
+        super().__init__()
+        self.model = model
+        self.noise_type = noise_type
+        self.use_mmd_loss = use_mmd_loss
+        self.gamma = gamma
+
+        # Fixed per-gene tensors (not learned)
+        self.register_buffer("sigma_aug", sigma_aug)
+        self.register_buffer("gene_weight", gene_weight)
+
+        # Standard affine flow matching path (same as scDFM)
+        self.flow_path = AffineProbPath(scheduler=CondOTScheduler())
+
+    def train_step(
+        self,
+        source: torch.Tensor,          # (B, G_sub) control expression
+        target: torch.Tensor,          # (B, G_sub) perturbed expression
+        perturbation_id: torch.Tensor, # (B, n_pert)
+        gene_input: torch.Tensor,      # (B, G_sub) vocab-encoded gene IDs
+        input_gene_ids: torch.Tensor,  # (G_sub,) indices into full gene set
+    ) -> dict:
+        B = source.shape[0]
+        device = source.device
+
+        # 1. Sample time (uniform, clamped away from boundaries)
+        t = torch.rand(B, device=device).clamp(1e-5, 1 - 1e-5)
+
+        # 2. Look up per-gene sigma and weight for current gene subset
+        sigma_sub = self.sigma_aug[input_gene_ids]      # (G_sub,)
+        weight_sub = self.gene_weight[input_gene_ids]    # (G_sub,)
+
+        # 3. Source-anchored x_0 with data-driven augmentation noise
+        eps = torch.randn_like(source)
+        x_0 = source + sigma_sub.unsqueeze(0) * eps     # (B, G_sub)
+
+        # 4. Standard affine flow matching (reuses scDFM AffineProbPath)
+        #    x_t = (1-t)*x_0 + t*target
+        #    dx_t = target - x_0 = (target - source) - sigma * eps
+        path_sample = self.flow_path.sample(t=t, x_0=x_0, x_1=target)
+
+        # 5. Model forward (scDFM convention: cell_1=x_t, cell_2=source)
+        pred_v = self.model(
+            gene_input, path_sample.x_t, path_sample.t, source,
+            perturbation_id, gene_input, mode="predict_y",
+        )
+
+        # 6. Gene-weighted velocity loss
+        loss_v = (weight_sub.unsqueeze(0) * (pred_v - path_sample.dx_t) ** 2).mean()
+
+        # 7. MMD loss (optional, same as scDFM baseline)
+        loss_mmd = torch.tensor(0.0, device=device)
+        if self.use_mmd_loss:
+            t_col = t.unsqueeze(-1)
+            x1_hat = path_sample.x_t + pred_v * (1 - t_col)
+            sigmas_mmd = median_sigmas(target, scales=(0.5, 1.0, 2.0, 4.0))
+            loss_mmd = mmd2_unbiased_multi_sigma(x1_hat, target, sigmas_mmd)
+
+        loss = loss_v + self.gamma * loss_mmd
+
+        return {
+            "loss": loss,
+            "loss_v": loss_v.detach(),
+            "loss_mmd": loss_mmd.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 = 20,
+        method: str = "rk4",
+    ) -> torch.Tensor:
+        """Generate perturbed expression via PF-ODE starting from clean source."""
+        B, G = source.shape
+        device = source.device
+
+        if gene_ids.dim() == 1:
+            gene_ids = gene_ids.unsqueeze(0).expand(B, -1)
+
+        # Start from clean source (no augmentation noise at inference)
+        x_0 = source.clone()
+
+        def ode_func(t_scalar, x):
+            t_batch = torch.full((B,), t_scalar.item(), device=device)
+            pred_v = self.model(
+                gene_ids, x, t_batch, source,
+                perturbation_id, gene_ids, mode="predict_y",
+            )
+            return pred_v
+
+        t_span = torch.linspace(0, 1, steps, device=device)
+        trajectory = torchdiffeq.odeint(
+            ode_func, x_0, t_span,
+            method=method, atol=1e-4, rtol=1e-4,
+        )
+        return torch.clamp(trajectory[-1], min=0)

GRN/grn_sacfm/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,
+)