train/CCFM/pca_emb/scripts/run_cascaded.py

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