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