File size: 6,211 Bytes
9f5e507 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 | """
RegFMDenoiser: single-flow training and inference for RegFM.
No cascaded time steps, no latent ODE — just scDFM flow + L_reg.
"""
import torch
import torch.nn.functional as F
import torchdiffeq
from src._scdfm_imports import AffineProbPath, CondOTScheduler, make_lognorm_poisson_noise
from src.loss import compute_reg_loss, get_lambda_reg
class RegFMDenoiser:
"""Handles train_step and generation for RegFM."""
def __init__(self, model, config, valid_mask=None):
"""
Args:
model: RegFMModel instance
config: RegFMConfig
valid_mask: (G_full,) bool tensor — True = gene valid in scGPT vocab
"""
self.model = model
self.config = config
self.path = AffineProbPath(scheduler=CondOTScheduler())
self.valid_mask_full = valid_mask
def _sample_time(self, B, device):
"""Sample timesteps using logit-normal or uniform."""
if self.config.t_sample_mode == "logit_normal":
u = torch.randn(B, device=device) * self.config.t_std + self.config.t_mean
t = torch.sigmoid(u)
else:
t = torch.rand(B, device=device)
return t.clamp(1e-5, 1.0 - 1e-5)
def train_step(self, batch, step, gene_ids, accelerator):
"""
One training step of RegFM.
Args:
batch: dict from GRNDatasetWrapper with keys:
src_cell_data (B, G_sub), tgt_cell_data (B, G_sub),
condition_id (B, 2), z_target (B, G_sub, G_sub),
gene_ids_sub (G_sub,), input_gene_ids (G_sub,)
step: current training iteration (for λ_reg schedule)
gene_ids: full gene_ids tensor (G_full,) on device
accelerator: HuggingFace Accelerator
Returns:
dict with loss, loss_vel, loss_reg, loss_mmd, lambda_reg_eff
"""
device = accelerator.device
cfg = self.config
source = batch["src_cell_data"].to(device)
target = batch["tgt_cell_data"].to(device)
delta_attn = batch["z_target"].to(device)
gene_ids_sub = batch["gene_ids_sub"].to(device)
input_gene_ids = batch["input_gene_ids"]
perturbation_id = batch["condition_id"].to(device)
B = source.shape[0]
# --- Flow matching path ---
t = self._sample_time(B, device)
if cfg.noise_type == "Gaussian":
noise = torch.randn_like(target)
else:
noise = make_lognorm_poisson_noise(
target_log=source,
alpha=cfg.poisson_alpha,
per_cell_L=cfg.poisson_target_sum if cfg.poisson_target_sum > 0 else 1e4,
)
path_sample = self.path.sample(t=t, x_0=noise, x_1=target)
x_t = path_sample.x_t
v_target = path_sample.dx_t
# --- Forward ---
gene_input = gene_ids_sub.unsqueeze(0).expand(B, -1)
v_pred, R_pred = self.model(
gene_input, x_t, t, source, perturbation_id=perturbation_id,
gene_id_all=gene_input, mode="predict_y",
)
# --- L_vel ---
loss_vel = F.mse_loss(v_pred, v_target)
# --- L_reg ---
valid_sub = None
if self.valid_mask_full is not None:
valid_sub = self.valid_mask_full[input_gene_ids.cpu()].to(device)
loss_reg = compute_reg_loss(
R_pred, delta_attn, valid_mask=valid_sub,
sparse_weight=cfg.sparse_reg_weight,
)
lambda_eff = get_lambda_reg(
step, cfg.lambda_reg, cfg.lambda_reg_zero_steps, cfg.lambda_reg_ramp_steps
)
# --- L_mmd (optional) ---
loss_mmd = torch.tensor(0.0, device=device)
if cfg.use_mmd_loss and cfg.gamma > 0:
x1_hat = x_t + v_pred * (1.0 - t).unsqueeze(-1)
loss_mmd = self._mmd_loss(x1_hat, target)
# --- Total ---
loss = loss_vel + lambda_eff * loss_reg + cfg.gamma * loss_mmd
return {
"loss": loss,
"loss_vel": loss_vel.item(),
"loss_reg": loss_reg.item(),
"loss_mmd": loss_mmd.item(),
"lambda_reg_eff": lambda_eff,
}
@staticmethod
def _mmd_loss(x_pred, x_target):
"""Multi-scale MMD loss (same as scDFM)."""
from scdfm_src.loss.metrics import median_sigmas, mmd2_unbiased_multi_sigma
sigmas = median_sigmas(x_target, scales=(0.5, 1.0, 2.0, 4.0))
return mmd2_unbiased_multi_sigma(x_pred, x_target, sigmas)
@torch.no_grad()
def generate(self, source, perturbation_id, gene_ids_sub, steps=None, method=None):
"""
Generate expression predictions via single-stage ODE.
Args:
source: (B, G_sub) control expression
perturbation_id: (B, 2) perturbation IDs
gene_ids_sub: (G_sub,) vocab-encoded gene IDs
steps: ODE integration steps (default: config.ode_steps)
method: ODE method (default: config.ode_method)
Returns:
x_pred: (B, G_sub) predicted expression, clamped >= 0
"""
cfg = self.config
steps = steps or cfg.ode_steps
method = method or cfg.ode_method
device = source.device
B = source.shape[0]
if cfg.noise_type == "Gaussian":
x_init = torch.randn_like(source)
else:
x_init = make_lognorm_poisson_noise(
target_log=source, alpha=cfg.poisson_alpha,
per_cell_L=cfg.poisson_target_sum if cfg.poisson_target_sum > 0 else 1e4,
)
gene_input = gene_ids_sub.unsqueeze(0).expand(B, -1)
def ode_fn(t_scalar, x):
t_batch = t_scalar.expand(B).to(device)
v, _R = self.model(
gene_input, x, t_batch, source,
perturbation_id=perturbation_id,
gene_id_all=gene_input, mode="predict_y",
)
return v
traj = torchdiffeq.odeint(
ode_fn, x_init,
torch.linspace(0, 1, steps, device=device),
method=method, atol=1e-4, rtol=1e-4,
)
return torch.clamp(traj[-1], min=0)
|