GRN/regfm/scripts/run_regfm.py

"""
RegFM training and evaluation script.
Usage: accelerate launch scripts/run_regfm.py [config overrides via tyro]
"""

import sys
import os

# Bootstrap scDFM modules before any local imports
sys.path.insert(0, os.path.normpath(os.path.join(os.path.dirname(__file__), "..")))
import _bootstrap_scdfm  # noqa: E402, F401

import copy
import csv
import time

import torch
import tyro
from accelerate import Accelerator, DistributedDataParallelKwargs
from torch.utils.data import DataLoader
from tqdm import trange
import numpy as np
import anndata as ad
import pandas as pd
from torch.utils.tensorboard import SummaryWriter

from config.config_regfm import RegFMConfig
from src.model.model import RegFMModel
from src.denoiser import RegFMDenoiser
from src.data.data import get_data_classes, GRNDatasetWrapper
from src.data.sparse_raw_cache import SparseRawDeltaCache
from src._scdfm_imports import GeneVocab, process_vocab
from cell_eval import MetricsEvaluator


# ──────────────────────────────────────────────────
# Evaluation
# ──────────────────────────────────────────────────

@torch.inference_mode()
def evaluate(denoiser, data_sampler, accelerator, vocab, config, save_dir,
             data_manager=None, batch_size=8):
    """Run cell-eval on all test perturbations."""
    device = accelerator.device
    model = denoiser.model
    model.eval()

    gene_ids_test = torch.tensor(
        vocab.encode(list(data_sampler.adata.var_names)), dtype=torch.long, device=device
    )
    control_data = data_sampler.get_control_data()
    perturbation_list = data_sampler._perturbation_covariates
    inverse_dict = {v: str(k) for k, v in data_manager.perturbation_dict.items()} if data_manager else {}

    all_pred = [control_data["src_cell_data"]]
    all_real = [control_data["src_cell_data"]]
    obs_pred = ["control"] * control_data["src_cell_data"].shape[0]
    obs_real = ["control"] * control_data["src_cell_data"].shape[0]

    for pert_name in perturbation_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_names = [inverse_dict[int(p)] for p in pert_id[0].cpu().numpy()]
            pert_id = torch.tensor(
                vocab.encode(pert_names), dtype=torch.long, device=device
            ).repeat(source.shape[0], 1)

        idx = torch.randperm(source.shape[0])
        source = source[idx]
        N = min(128, source.shape[0])
        source = source[:N]

        preds = []
        for i in range(0, N, batch_size):
            batch_src = source[i : i + batch_size]
            batch_pid = pert_id[0].repeat(batch_src.shape[0], 1).to(device)
            pred = denoiser.generate(batch_src, batch_pid, gene_ids_test)
            preds.append(pred.cpu())

        pred_expr = torch.cat(preds, dim=0).numpy()
        all_pred.append(pred_expr)
        all_real.append(target)
        obs_pred.extend([pert_name] * pred_expr.shape[0])
        obs_real.extend([pert_name] * target.shape[0])

    all_pred = np.concatenate(all_pred, axis=0)
    all_real_np = np.concatenate(
        [r if isinstance(r, np.ndarray) else r.numpy() for r in all_real], axis=0
    )
    pred_adata = ad.AnnData(X=all_pred, obs=pd.DataFrame({"perturbation": obs_pred}))
    real_adata = ad.AnnData(X=all_real_np, obs=pd.DataFrame({"perturbation": obs_real}))

    eval_score = None
    if accelerator.is_main_process:
        os.makedirs(save_dir, exist_ok=True)
        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(save_dir, "results.csv"))
        agg_results.write_csv(os.path.join(save_dir, "agg_results.csv"))
        eval_score = agg_results["mean"].to_list()
        print(f"  Eval agg: {dict(zip(agg_results.columns, [c for c in agg_results.row(0)]))}")

    model.train()
    return eval_score


# ──────────────────────────────────────────────────
# Main
# ──────────────────────────────────────────────────

def main():
    config = tyro.cli(RegFMConfig)
    ddp_kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
    accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])
    device = accelerator.device

    # --- Data (follow grn_att_only/ori_scDFM pattern: 3-step init) ---
    _REPO_ROOT = os.path.normpath(
        os.path.join(os.path.dirname(__file__), "..", "..", "..", "transfer", "code")
    )
    _SCDFM_ROOT = os.path.join(_REPO_ROOT, "scDFM")

    Data, PerturbationDataset, TrainSampler, TestDataset = get_data_classes()

    scdfm_data_path = os.path.join(_SCDFM_ROOT, "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 (must chdir to scDFM for vocab path resolution) ---
    orig_cwd = os.getcwd()
    os.chdir(_SCDFM_ROOT)
    vocab = process_vocab(data_manager, config)
    os.chdir(orig_cwd)

    gene_ids = torch.tensor(
        vocab.encode(list(data_manager.adata.var_names)), dtype=torch.long, device=device
    )

    # --- Sparse cache ---
    sparse_cache = SparseRawDeltaCache(config.sparse_cache_path, delta_top_k=config.delta_topk)
    # get_missing_gene_mask() returns True=missing; invert to True=valid for compute_reg_loss
    _missing = sparse_cache.get_missing_gene_mask()
    if isinstance(_missing, torch.Tensor):
        valid_mask = ~_missing.bool()
    else:
        valid_mask = ~torch.from_numpy(_missing).bool()

    # --- Dataset + DataLoader ---
    base_dataset = PerturbationDataset(train_sampler, config.batch_size)
    dataset = GRNDatasetWrapper(base_dataset, sparse_cache, gene_ids.cpu(), config.infer_top_gene)
    dataloader = DataLoader(
        dataset, batch_size=1, shuffle=False,
        num_workers=8, pin_memory=True, persistent_workers=True,
    )
    if accelerator.is_main_process:
        print(f"DataLoader ready: {len(dataset)} batches, num_workers=8")

    model = RegFMModel(
        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,
        use_perturbation_interaction=config.use_negative_edge,
        mask_path=mask_path,
        d_r=config.d_r,
        gate_init_bias=config.gate_init_bias,
    )

    # Warm start from scDFM baseline
    if config.pretrained_backbone:
        state = torch.load(config.pretrained_backbone, map_location="cpu")
        if "model_state_dict" in state:
            state = state["model_state_dict"]
        missing, unexpected = model.load_state_dict(state, strict=False)
        if accelerator.is_main_process:
            print(f"Warm start: loaded {len(state) - len(missing)} params, "
                  f"missing {len(missing)} (RegFM additions), unexpected {len(unexpected)}")

    # EMA
    if accelerator.is_main_process:
        print("Creating EMA model...")
    ema_model = copy.deepcopy(model).to(device)

    # --- Denoiser ---
    denoiser = RegFMDenoiser(model, config, valid_mask=valid_mask)

    # --- Optimizer + Scheduler ---
    optimizer = torch.optim.Adam(model.parameters(), lr=config.lr)
    scheduler_warmup = torch.optim.lr_scheduler.LinearLR(
        optimizer, start_factor=1e-4, total_iters=config.warmup_steps
    )
    scheduler_cosine = torch.optim.lr_scheduler.CosineAnnealingLR(
        optimizer, T_max=config.steps - config.warmup_steps, eta_min=config.eta_min
    )
    scheduler = torch.optim.lr_scheduler.SequentialLR(
        optimizer, [scheduler_warmup, scheduler_cosine], milestones=[config.warmup_steps]
    )

    # Accelerate
    if accelerator.is_main_process:
        print("Calling accelerator.prepare()...")
    model, optimizer, dataloader, scheduler = accelerator.prepare(
        model, optimizer, dataloader, scheduler
    )

    # Resume from checkpoint
    start_step = 0
    if config.checkpoint_path and os.path.exists(config.checkpoint_path):
        ckpt = torch.load(config.checkpoint_path, map_location="cpu")
        model.load_state_dict(ckpt["model_state_dict"])
        ema_model.load_state_dict(ckpt["ema_model_state_dict"])
        optimizer.load_state_dict(ckpt["optimizer_state_dict"])
        if "scheduler_state_dict" in ckpt:
            scheduler.load_state_dict(ckpt["scheduler_state_dict"])
        start_step = ckpt.get("step", 0)
        if accelerator.is_main_process:
            print(f"Resumed from step {start_step}")

    # --- Output dir ---
    save_dir = config.make_path()
    os.makedirs(save_dir, exist_ok=True)

    # Test-only mode
    if config.test_only:
        denoiser_eval = RegFMDenoiser(ema_model.to(device), config, valid_mask=valid_mask)
        evaluate(denoiser_eval, valid_sampler, accelerator, vocab, config, save_dir,
                 data_manager=data_manager, batch_size=config.eval_batch_size)
        return

    # --- Logging ---
    csv_path = os.path.join(save_dir, "loss_curve.csv")
    csv_fields = ["step", "loss", "loss_vel", "loss_reg", "loss_mmd", "lambda_reg_eff", "lr"]
    tb_writer = None
    if accelerator.is_main_process:
        with open(csv_path, "w", newline="") as f:
            csv.DictWriter(f, csv_fields).writeheader()
        tb_writer = SummaryWriter(log_dir=os.path.join(save_dir, "tb_logs"))

    # ──────────────────────────────────────────────────
    # Training loop
    # ──────────────────────────────────────────────────
    model.train()
    if accelerator.is_main_process:
        print("Starting training loop...")
    data_iter = iter(dataloader)
    t_start = time.time()

    for step in range(start_step, config.steps):
        try:
            batch_data = next(data_iter)
        except StopIteration:
            data_iter = iter(dataloader)
            batch_data = next(data_iter)

        # Squeeze batch dim from DataLoader (batch_size=1 wrapping)
        batch = {}
        for k, v in batch_data.items():
            if isinstance(v, torch.Tensor) and v.dim() > 0:
                batch[k] = v.squeeze(0) if v.shape[0] == 1 else v
            else:
                batch[k] = v

        optimizer.zero_grad()
        result = denoiser.train_step(batch, step, gene_ids, accelerator)
        accelerator.backward(result["loss"])
        optimizer.step()
        scheduler.step()

        # EMA update
        with torch.no_grad():
            for p_ema, p_model in zip(ema_model.parameters(), model.parameters()):
                p_ema.data.mul_(config.ema_decay).add_(p_model.data, alpha=1.0 - config.ema_decay)

        # TensorBoard: every step
        if accelerator.is_main_process and tb_writer is not None:
            tb_writer.add_scalar("loss/total", result["loss"].item(), step)
            tb_writer.add_scalar("loss/vel", result["loss_vel"], step)
            tb_writer.add_scalar("loss/reg", result["loss_reg"], step)
            tb_writer.add_scalar("loss/mmd", result["loss_mmd"], step)
            tb_writer.add_scalar("schedule/lambda_reg", result["lambda_reg_eff"], step)
            tb_writer.add_scalar("schedule/lr", optimizer.param_groups[0]["lr"], step)

        # Console + CSV: every 100 steps
        if accelerator.is_main_process and step % 100 == 0:
            lr = optimizer.param_groups[0]["lr"]
            elapsed = time.time() - t_start
            print(
                f"[{step:>6d}/{config.steps}] "
                f"loss={result['loss'].item():.4f} "
                f"vel={result['loss_vel']:.4f} "
                f"reg={result['loss_reg']:.4f} "
                f"mmd={result['loss_mmd']:.4f} "
                f"λ={result['lambda_reg_eff']:.4f} "
                f"lr={lr:.2e} "
                f"({elapsed:.0f}s)"
            )
            with open(csv_path, "a", newline="") as f:
                csv.DictWriter(f, csv_fields).writerow({
                    "step": step,
                    "loss": result["loss"].item(),
                    "loss_vel": result["loss_vel"],
                    "loss_reg": result["loss_reg"],
                    "loss_mmd": result["loss_mmd"],
                    "lambda_reg_eff": result["lambda_reg_eff"],
                    "lr": lr,
                })

        # Checkpoint + Evaluate
        if step > 0 and step % config.print_every == 0:
            accelerator.wait_for_everyone()
            if accelerator.is_main_process:
                ckpt_dir = os.path.join(save_dir, f"checkpoint_{step}")
                os.makedirs(ckpt_dir, exist_ok=True)
                torch.save({
                    "step": step,
                    "model_state_dict": accelerator.unwrap_model(model).state_dict(),
                    "ema_model_state_dict": ema_model.state_dict(),
                    "optimizer_state_dict": optimizer.state_dict(),
                    "scheduler_state_dict": scheduler.state_dict(),
                }, os.path.join(ckpt_dir, "checkpoint.pt"))
                print(f"Saved checkpoint at step {step}")

    # Final checkpoint + evaluate
    accelerator.wait_for_everyone()
    if accelerator.is_main_process:
        torch.save({
            "step": config.steps,
            "model_state_dict": accelerator.unwrap_model(model).state_dict(),
            "ema_model_state_dict": ema_model.state_dict(),
            "optimizer_state_dict": optimizer.state_dict(),
            "scheduler_state_dict": scheduler.state_dict(),
        }, os.path.join(save_dir, "final_checkpoint.pt"))
        if tb_writer is not None:
            tb_writer.close()
        print("Training complete.")

    denoiser_eval = RegFMDenoiser(ema_model.to(device), config, valid_mask=valid_mask)
    eval_dir = os.path.join(save_dir, f"eval_{config.steps}")
    evaluate(denoiser_eval, valid_sampler, accelerator, vocab, config, eval_dir,
             data_manager=data_manager, batch_size=config.eval_batch_size)


if __name__ == "__main__":
    main()