transfer/code/ori_scDFM/src/script/run.py

import accelerate
import torch
import torch.nn as nn
import tyro
from config.config_flow import FlowConfig as Config
import torch.nn.functional as F
import time
from torch.utils.data import Dataset, DataLoader
import jax
import random
from src.data_process.data import Data, PerturbationDataset
from src.flow_matching.ot import OTPlanSampler
from src.flow_matching.path import AffineProbPath
from src.flow_matching.solver import ODESolver
from src.models.instantiate_model import instantiate_model
from src.tokenizer.gene_tokenizer import GeneVocab
from src.models.perturbation.moduls import PerturbationEmbedding
import pdb
import tqdm
from src.flow_matching.path.scheduler import CondOTScheduler
import scanpy as sc
import os
from src.data_process.utils import build_generated_anndata

import json
from accelerate import Accelerator,DistributedDataParallelKwargs
import torchdiffeq
from tqdm import trange
import numpy as np
from cell_eval import MetricsEvaluator
import anndata as ad
import pandas as pd
from src.utils.utils import save_checkpoint, load_checkpoint, make_lognorm_poisson_noise, pick_eval_score, process_vocab, set_requires_grad_for_p_only, get_perturbation_emb

ot_sampler = OTPlanSampler(method="exact") 
path = AffineProbPath(scheduler=CondOTScheduler())

def gaussian_kernel(x, y, sigma=1.0):
    beta = 1.0 / (2.0 * sigma**2)
    dist = torch.cdist(x, y, p=2) ** 2
    return torch.exp(-beta * dist)

def mmd_loss(pred, tgt, sigma=1.0):
    xx = gaussian_kernel(pred, pred, sigma).mean(dim=(1))
    yy = gaussian_kernel(tgt, tgt, sigma).mean(dim=(1))
    xy = gaussian_kernel(pred, tgt, sigma).mean(dim=(1))
    return (xx + yy - 2 * xy).mean()

def pairwise_sq_dists(X, Y):
    # X:[m,d], Y:[n,d] -> [m,n]
    return torch.cdist(X, Y, p=2)**2

@torch.no_grad()
def median_sigmas(X, scales=(0.5, 1.0, 2.0, 4.0)):
    Z = X
    D2 = pairwise_sq_dists(Z, Z)
    tri = D2[~torch.eye(D2.size(0), dtype=bool, device=D2.device)]
    m = torch.median(tri).clamp_min(1e-12)          
    s2 = torch.tensor(scales, device=Z.device) * m 
    sigmas = torch.sqrt(s2)                
    return [float(s.item()) for s in sigmas]

def mmd2_unbiased_multi_sigma(X, Y, sigmas):
    """
    """
    m, n = X.size(0), Y.size(0)
    Dxx = pairwise_sq_dists(X, X)   # [m,m]
    Dyy = pairwise_sq_dists(Y, Y)   # [n,n]
    Dxy = pairwise_sq_dists(X, Y)   # [m,n]

    vals = []
    for sigma in sigmas:
        beta = 1.0 / (2.0 * (sigma ** 2) + 1e-12)
        Kxx = torch.exp(-beta * Dxx)
        Kyy = torch.exp(-beta * Dyy)
        Kxy = torch.exp(-beta * Dxy)

        term_xx = (Kxx.sum() - Kxx.diag().sum()) / (m * (m - 1) + 1e-12)
        term_yy = (Kyy.sum() - Kyy.diag().sum()) / (n * (n - 1) + 1e-12)
        term_xy = Kxy.mean()  # / (m*n)
        vals.append(term_xx + term_yy - 2.0 * term_xy)

    return torch.stack(vals).mean()

def train_step(source, target, perturbation_id, vf, criterion, accelerator, noise_type='Poisson', mode="predict_y"):
    B = source.shape[0]
    device = accelerator.device

    input_gene_ids = torch.randperm(source.shape[-1], device=device)[:config.infer_top_gene]
    source = source[:,input_gene_ids]
    target = target[:,input_gene_ids]
    gene = gene_ids.repeat(B,1).to(device)
    gene_input = gene[:,input_gene_ids]

    if mode=="predict_y":
        # source, target = ot_sampler.sample_plan(source, target)
        t = torch.rand(B, device=device)
        if noise_type=="Gaussian":
            target_noise = torch.randn_like(source)
            if gene_noise_weight is not None:
                target_noise = target_noise * gene_noise_weight[input_gene_ids]
        elif noise_type=="Poisson":
            target_noise = make_lognorm_poisson_noise(
                target_log=source,
                alpha=getattr(config, "poisson_alpha", 0.8),
                per_cell_L=getattr(config, "poisson_target_sum", 1e4),  # e.g., 1e4 or None
            )
        path_x1 = path.sample(t=t, x_0=target_noise, x_1=target)
        predicted_x_t_velocity = vf(gene_input,path_x1.x_t, path_x1.t,source,perturbation_id, gene_input, mode=mode)
        loss = ((predicted_x_t_velocity - path_x1.dx_t)**2).mean()
        
        if config.use_mmd_loss:
            x1_hat = path_x1.x_t + predicted_x_t_velocity*(1-t).unsqueeze(-1)
            sigmas = median_sigmas(target, scales=(0.5,1.0,2.0,4.0))
            
            _mmd_loss = mmd2_unbiased_multi_sigma(x1_hat, target, sigmas)
            # _mmd_loss = mmd_loss(x1_hat, target)
            loss = loss + _mmd_loss * config.gamma

    elif mode=="predict_p":
        t_p = torch.ones(B, device=device)  # Or uniform(0.7,1.0)
        predicted_p_embed = vf(gene_input, target, t_p, source, perturbation_id, gene_input, mode=mode)
        if hasattr(vf, "module"):
            base_vf = vf.module
        else:
            base_vf = vf
        p_embed_gt = base_vf.get_perturbation_emb(perturbation_id=perturbation_id, cell_1=source)
        pred = F.normalize(predicted_p_embed, dim=-1)
        tgt  = F.normalize(p_embed_gt.detach(), dim=-1)
        loss = 1 - (pred * tgt).sum(dim=-1).mean()  # cosine distance
    
    return loss

@torch.inference_mode()
def test(data_sampler, vf, accelerator,  batch_size=128, path='./',vocab=None,scheme='mse'):
    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()
    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]
    count = 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']
        source = source.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):
            batch_perturbation_id = perturbation_id[0].repeat(source[i:i+batch_size].shape[0],1)
            
            batch_perturbation_id = batch_perturbation_id.to(accelerator.device)
            
            pred_expression = generate_sample(wrapped_vf,source[i:i+batch_size],batch_perturbation_id,vf,gene_ids=gene_ids_test,gene_all=gene_ids_test)
            pred_expressions.append(pred_expression)
            
        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])
        # count += 1
        # if count > 3:
        #     break

    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 = ad.AnnData(X=all_pred_expressions, obs=obs_pred)
    real = ad.AnnData(X=all_target_expressions, obs=obs_real)
    

    eval_score = None
    if accelerator.is_main_process:
        evaluator = MetricsEvaluator(
            adata_pred=pred,
            adata_real=real,
            control_pert="control",
            pert_col="perturbation",
            num_threads=32,
        )
        (results, agg_results) = evaluator.compute()
        
        results.write_csv(os.path.join(path, 'results.csv'))
        agg_results.write_csv(os.path.join(path, 'agg_results.csv'))
        pred.write_h5ad(os.path.join(path, 'pred.h5ad'))
        real.write_h5ad(os.path.join(path, 'real.h5ad'))

        eval_score = pick_eval_score(agg_results, scheme)
        print(f"Current evaluation score: {eval_score:.4f}")
    
    return eval_score

def wrapped_vf(target,t,source,perturbation_id,vf,gene_ids, gene_all):
    
    gene = gene_ids.repeat(source.shape[0],1).to(device)
    predicted_x_t_velocity = vf(gene,target,t,source,perturbation_id,gene_all)
    
    return predicted_x_t_velocity

@torch.no_grad()
def generate_sample(wrapped_vf,source,condition_vec=None,vf=None,gene_ids=None,gene_all=None,steps=20,method="rk4"):

    noise_type = config.noise_type
    if noise_type=="Gaussian":
        target_noise = torch.randn(source.shape[0],config.infer_top_gene,device=source.device)
        if gene_noise_weight is not None:
            target_noise = target_noise * gene_noise_weight[:config.infer_top_gene]
    elif noise_type=="Poisson":
        target_noise = make_lognorm_poisson_noise(
            target_log=source,
            alpha=getattr(config, "poisson_alpha", 0.8),
            per_cell_L=getattr(config, "poisson_target_sum", 1e4),
        )
        
    traj = torchdiffeq.odeint(lambda t,x: wrapped_vf(x,t,source,condition_vec,vf,gene_ids,gene_all),
                              target_noise,
                              torch.linspace(0,1,steps).to(source.device),
                              atol=1e-4,
                              rtol=1e-4,
                              method=method)
    # t = torch.linspace(0,1,steps).to(source.device)
    # traj = [target_noise + 0.8*wrapped_vf(target_noise,t,source,condition_vec,vf,gene_ids,gene_all)]
    
    return torch.clamp(traj[-1], min=0)
    
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_manager = Data('./data')

    data_manager.load_data(config.data_name)
    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, test_dl = 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)  # batch_size=1 因为每个getitem本身就是一个batch
    if config.use_negative_edge:
        mask_path = os.path.join(data_manager.data_path, data_manager.data_name,'mask_fold_'+str(config.fold)+'topk_'+str(config.topk)+config.split_method+'_negative_edge'+'.pt')
    else:
        mask_path = os.path.join(data_manager.data_path, data_manager.data_name,'mask_fold_'+str(config.fold)+'topk_'+str(config.topk)+config.split_method+'.pt')

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

    vf = instantiate_model(config.model_type,
                           ntoken = ntoken,
                           d_model = config.d_model,
                           d_perturbation = config.d_model,
                           fusion_method = config.fusion_method,
                           perturbation_function = config.perturbation_function,
                           mask_path = mask_path
                           )
    if accelerator.is_main_process:
        total_params = sum(p.numel() for p in vf.parameters())
        print(f"[DIM CHECK] ntoken={ntoken}, d_model={config.d_model}, "
              f"d_hid={int(4*config.d_model)}, nhead=8, total_params={total_params:,}")
        for name, p in vf.named_parameters():
            if p.dim() >= 2:
                print(f"  {name}: {tuple(p.shape)}")

    model_path = config.make_path()
    
    save_path = config.make_path()
    best_loss = float('inf')

    # === Gene-specific noise scale ===
    gene_noise_weight = None
    if config.gene_noise_scale:
        if accelerator.is_main_process:
            print("Computing per-gene noise scale from training data...")
        _deltas = []
        _count = 0
        for _batch in dataloader:
            _src = _batch['src_cell_data'].squeeze(0)
            _tgt = _batch['tgt_cell_data'].squeeze(0)
            _deltas.append((_tgt - _src).cpu())
            _count += 1
            if _count >= 100:
                break
        _deltas = torch.cat(_deltas, 0)  # (N, G)
        _gene_std = _deltas.std(dim=0).clamp(min=1e-6)  # (G,)
        gene_noise_weight = (_gene_std / _gene_std.median()).clamp(0.1, 3.0).to(device)
        if accelerator.is_main_process:
            print(f"  gene_noise_weight: min={gene_noise_weight.min():.3f}, "
                  f"max={gene_noise_weight.max():.3f}, "
                  f"median={gene_noise_weight.median():.3f}, "
                  f"genes>1.5: {(gene_noise_weight > 1.5).sum().item()}, "
                  f"genes<0.5: {(gene_noise_weight < 0.5).sum().item()}")
        del _deltas, _gene_std

    criterion = nn.MSELoss()
    optimizer = torch.optim.Adam(vf.parameters(), lr=config.lr)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=config.steps, eta_min=config.eta_min)

    if config.checkpoint_path != '':
        _, _ = load_checkpoint(config.checkpoint_path, vf, optimizer, scheduler)
    start_iteration = 0
    vf = accelerator.prepare(vf)
    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, vf, accelerator, batch_size=config.batch_size, path=eval_path, vocab=vocab)
        if accelerator.is_main_process and eval_score is not None:
            print(f"Final evaluation score: {eval_score:.4f}")
        import sys
        sys.exit(0)

    # --- Loss logging (CSV + TensorBoard) ---
    import csv
    from torch.utils.tensorboard import SummaryWriter
    if accelerator.is_main_process:
        csv_file = open(os.path.join(save_path, 'loss_curve.csv'), 'w', newline='')
        csv_writer = csv.writer(csv_file)
        csv_writer.writerow(['iteration', 'loss', 'lr'])
        tb_writer = SummaryWriter(log_dir=os.path.join(save_path, 'tb_logs'))

    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)
            
            
            set_requires_grad_for_p_only(vf, p_only=config.mode)
            loss = train_step(source, target, perturbation_id, vf, criterion, accelerator, noise_type=config.noise_type, mode=config.mode)
            optimizer.zero_grad(set_to_none=True)
            accelerator.backward(loss)
            optimizer.step()
            scheduler.step()

            
            # --- Per-iteration loss logging ---
            if accelerator.is_main_process:
                current_lr = scheduler.get_last_lr()[0]
                csv_writer.writerow([iteration, loss.item(), current_lr])
                if iteration % 100 == 0:
                    csv_file.flush()
                tb_writer.add_scalar('loss/train', loss.item(), iteration)
                tb_writer.add_scalar('lr', current_lr, iteration)

            if iteration % config.print_every == 0 and iteration > 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}'s checkpoint...")

                    save_checkpoint(
                        model=accelerator.unwrap_model(vf),
                        optimizer=optimizer,
                        scheduler=scheduler,
                        iteration=iteration,
                        eval_score=None,
                        save_path=save_path_,
                        is_best=False
                    )
                # Only evaluate at the last checkpoint
                is_last = (iteration + config.print_every >= config.steps)
                if is_last:
                    eval_score = test(valid_sampler, vf, accelerator, batch_size=config.batch_size, path=save_path_,vocab=vocab)
                    if accelerator.is_main_process and eval_score is not None:
                        tb_writer.add_scalar('eval/score', eval_score, iteration)

            accelerator.wait_for_everyone()

            pbar.update(1)
            pbar.set_description(f'loss: {loss.item():.4f}, iteration: {iteration}')
            iteration += 1

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