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