train/SB/SA7/scripts/run_sacfm.py

"""
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()