transfer/code/CCFM/scripts/run_cascaded.py

"""
Training and evaluation entry point for CCFM (Cascaded Conditioned Flow Matching).
Based on scDFM's run.py with cascaded denoiser integration.

Conditioning signals: control expression + perturbation_id.
scGPT latent features are an auxiliary generation target (like DINO in LatentForcing),
generated from noise at inference — not a conditioning signal.
"""

import sys
import os

# Set up paths — CCFM project root must be on sys.path for config/ and src/ imports
_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 CCFM 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
from src.model.model import CascadedFlowModel
from src.data.scgpt_extractor import FrozenScGPTExtractor
from src.data.scgpt_cache import ScGPTFeatureCache
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.dirname(_PROJECT_ROOT)  # transfer/code/


@torch.inference_mode()
def test(data_sampler, denoiser, accelerator, config, vocab, data_manager,
         batch_size=128, 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"))
        eval_score = pick_eval_score(agg_results, "mse")
        print(f"Current evaluation 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 (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.
    # scDFM vocab and perturbation encoding both expect gene symbols as var_names.
    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)

    train_dataset = PerturbationDataset(train_sampler, config.batch_size)
    dataloader = DataLoader(
        train_dataset, batch_size=1, shuffle=False,
        num_workers=8, pin_memory=True, persistent_workers=True,
    )

    # === 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)

    # Vocab is built from var_names (may be Ensembl IDs or gene symbols)
    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_model * 4,
        nlayers=config.nlayers,
        fusion_method=config.fusion_method,
        perturbation_function=config.perturbation_function,
        mask_path=mask_path,
        scgpt_dim=config.scgpt_dim,
        bottleneck_dim=config.bottleneck_dim,
        dh_depth=config.dh_depth,
    )

    # === Build FrozenScGPTExtractor ===
    # var_names have been converted to gene symbols above, matching scGPT vocab.
    hvg_gene_names = list(data_manager.adata.var_names)
    scgpt_model_dir = os.path.join(
        os.path.dirname(_REPO_ROOT),  # transfer/
        config.scgpt_model_dir.replace("transfer/", ""),
    )
    scgpt_extractor = FrozenScGPTExtractor(
        model_dir=scgpt_model_dir,
        hvg_gene_names=hvg_gene_names,
        device=device,
        max_seq_len=config.scgpt_max_seq_len,
        target_std=config.target_std,
        warmup_batches=config.warmup_batches,
    )
    scgpt_extractor = scgpt_extractor.to(device)

    # === Build CascadedDenoiser ===
    denoiser = CascadedDenoiser(
        model=vf,
        scgpt_extractor=scgpt_extractor,
        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,
    )

    # === Load scGPT cache if configured ===
    scgpt_cache = None
    if config.scgpt_cache_path:
        scgpt_cache = ScGPTFeatureCache(
            config.scgpt_cache_path,
            target_std=config.target_std,
        )
        if accelerator.is_main_process:
            print(f"Using pre-extracted scGPT cache: {config.scgpt_cache_path}")
            print(f"  Cache shape: {scgpt_cache.features.shape}, cells: {len(scgpt_cache.name_to_idx)}")

    # === EMA model (on same device as training 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)
        # Sync EMA with loaded weights
        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.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:
            source = batch_data["src_cell_data"].squeeze(0)
            target = batch_data["tgt_cell_data"].squeeze(0)
            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.shape[0], 1)

            # Get the underlying denoiser for train_step
            base_denoiser = denoiser.module if hasattr(denoiser, "module") else denoiser
            base_denoiser.model.train()

            if scgpt_cache is not None:
                # Cache mode: sample gene subset here, look up pre-extracted features
                # DataLoader collate wraps strings in tuples; unwrap them
                tgt_cell_names = [n[0] if isinstance(n, (tuple, list)) else n for n in batch_data["tgt_cell_id"]]
                input_gene_ids = torch.randperm(source.shape[-1], device=device)[:config.infer_top_gene]
                cached_z_target = scgpt_cache.lookup(tgt_cell_names, input_gene_ids, device=device)
                loss_dict = base_denoiser.train_step(
                    source, target, perturbation_id, gene_ids,
                    infer_top_gene=config.infer_top_gene,
                    cached_z_target=cached_z_target,
                    cached_gene_ids=input_gene_ids,
                )
            else:
                loss_dict = base_denoiser.train_step(
                    source, target, perturbation_id, gene_ids,
                    infer_top_gene=config.infer_top_gene,
                )

            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 EMA model (used for inference) and training state
                    save_checkpoint(
                        model=ema_model,
                        optimizer=optimizer,
                        scheduler=scheduler,
                        iteration=iteration,
                        eval_score=None,
                        save_path=save_path_,
                        is_best=False,
                    )
                # Evaluate with EMA weights
                # Only evaluate at the start and the last checkpoint
                if iteration == 0 or iteration + config.print_every >= config.steps:
                    # Swap EMA weights into denoiser for evaluation
                    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.batch_size, path_dir=save_path_,
                    )

                    # Restore training weights
                    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)

            # --- Per-iteration loss logging ---
            if accelerator.is_main_process:
                current_lr = scheduler.get_last_lr()[0]
                csv_writer.writerow([
                    iteration, loss.item(),
                    loss_dict["loss_expr"].item(),
                    loss_dict["loss_latent"].item(),
                    loss_dict["loss_mmd"].item(),
                    current_lr,
                ])
                if iteration % 100 == 0:
                    csv_file.flush()
                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

    # === Close logging ===
    if accelerator.is_main_process:
        csv_file.close()
        tb_writer.close()