""" CascadedDenoiser for grn_dense4 — pre-computed 4-dim row statistics as latent target. Key changes from grn_scalar: - No _aggregate() — stats already computed in DataLoader workers - train_step receives z_stats (B, G_sub, 4) directly - latent_dim fixed at 4 """ import torch import torch.nn as nn import torchdiffeq from ._scdfm_imports import AffineProbPath, CondOTScheduler, make_lognorm_poisson_noise from .model.model import CascadedFlowModel from .data.sparse_raw_cache import SparseRawDeltaCache flow_path = AffineProbPath(scheduler=CondOTScheduler()) def pairwise_sq_dists(X, Y): return torch.cdist(X, Y, p=2) ** 2 @torch.no_grad() def median_sigmas(X, scales=(0.5, 1.0, 2.0, 4.0)): D2 = pairwise_sq_dists(X, X) 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=X.device) * m return [float(s.item()) for s in torch.sqrt(s2)] def mmd2_unbiased_multi_sigma(X, Y, sigmas): m, n = X.size(0), Y.size(0) Dxx = pairwise_sq_dists(X, X) Dyy = pairwise_sq_dists(Y, Y) Dxy = pairwise_sq_dists(X, Y) 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() vals.append(term_xx + term_yy - 2.0 * term_xy) return torch.stack(vals).mean() class CascadedDenoiser(nn.Module): """ Cascaded denoiser with pre-computed 4-dim row statistics as latent target. Stats [mean, std, max, min] are computed in DataLoader workers (CPU side). """ def __init__( self, model: CascadedFlowModel, sparse_cache: SparseRawDeltaCache, warmup_batches: int = 200, z_normalize: bool = True, choose_latent_p: float = 0.4, latent_weight: float = 1.0, noise_type: str = "Gaussian", use_mmd_loss: bool = True, gamma: float = 0.5, poisson_alpha: float = 0.8, poisson_target_sum: float = 1e4, t_sample_mode: str = "logit_normal", t_expr_mean: float = 0.0, t_expr_std: float = 1.0, t_latent_mean: float = 0.0, t_latent_std: float = 1.0, noise_beta: float = 0.25, ): super().__init__() self.model = model self.sparse_cache = sparse_cache self.latent_dim = 4 self.z_normalize = z_normalize self.choose_latent_p = choose_latent_p self.latent_weight = latent_weight self.noise_type = noise_type self.use_mmd_loss = use_mmd_loss self.gamma = gamma self.poisson_alpha = poisson_alpha self.poisson_target_sum = poisson_target_sum self.t_sample_mode = t_sample_mode self.t_expr_mean = t_expr_mean self.t_expr_std = t_expr_std self.t_latent_mean = t_latent_mean self.t_latent_std = t_latent_std self.noise_beta = noise_beta # Running stats for z normalization self.register_buffer("running_mean", torch.zeros(4)) self.register_buffer("running_var", torch.ones(4)) self.register_buffer("running_count", torch.tensor(0, dtype=torch.long)) self.warmup_batches = warmup_batches self._stats_frozen = False @torch.no_grad() def _update_running_stats(self, z): """Update per-dim running mean/var during warmup. z: (B, G, 4)""" if self._stats_frozen: return flat = z.detach().reshape(-1, 4) # (N, 4) batch_mean = flat.mean(dim=0) # (4,) batch_var = flat.var(dim=0) # (4,) n = flat.shape[0] old_count = self.running_count.item() new_count = old_count + n delta = batch_mean - self.running_mean self.running_mean += delta * n / new_count self.running_var = ( self.running_var * old_count + batch_var * n + delta ** 2 * old_count * n / new_count ) / new_count self.running_count.fill_(new_count) approx_batches = new_count / max(n, 1) if approx_batches >= self.warmup_batches: self._stats_frozen = True print(f"[Denoiser] Running stats frozen: " f"mean={self.running_mean.tolist()}, " f"std={self.running_var.sqrt().tolist()}") def _normalize_z(self, z): """Per-dim normalization. z: (B, G, 4)""" if not self.z_normalize: return z std = self.running_var.sqrt().clamp(min=1e-6) # (4,) return (z - self.running_mean) / std def sample_t(self, n, device): if self.t_sample_mode == "logit_normal": t_latent = torch.sigmoid(torch.randn(n, device=device) * self.t_latent_std + self.t_latent_mean) t_expr = torch.sigmoid(torch.randn(n, device=device) * self.t_expr_std + self.t_expr_mean) else: t_latent = torch.rand(n, device=device) t_expr = torch.rand(n, device=device) choose_latent_mask = torch.rand(n, device=device) < self.choose_latent_p t_latent_expr = torch.rand_like(t_latent) * self.noise_beta + (1.0 - self.noise_beta) t_latent = torch.where(choose_latent_mask, t_latent, t_latent_expr) t_expr = torch.where(choose_latent_mask, torch.zeros_like(t_expr), t_expr) w_expr = (~choose_latent_mask).float() w_latent = choose_latent_mask.float() return t_expr, t_latent, w_expr, w_latent def _make_expr_noise(self, source): if self.noise_type == "Gaussian": return torch.randn_like(source) elif self.noise_type == "Poisson": return make_lognorm_poisson_noise( target_log=source, alpha=self.poisson_alpha, per_cell_L=self.poisson_target_sum, ) else: raise ValueError(f"Unknown noise_type: {self.noise_type}") def train_step( self, source: torch.Tensor, # (B, G_sub) target: torch.Tensor, # (B, G_sub) perturbation_id: torch.Tensor, # (B, 2) gene_input: torch.Tensor, # (B, G_sub) z_stats: torch.Tensor, # (B, G_sub, 4) — pre-computed in worker input_gene_ids: torch.Tensor, # (G_sub,) ) -> dict: B = source.shape[0] G_sub = source.shape[-1] device = source.device # 1. z_target is pre-computed stats — just normalize z_target = z_stats if self.training: self._update_running_stats(z_target) z_target = self._normalize_z(z_target) # (B, G_sub, 4) # 2. Missing gene mask missing = self.sparse_cache.get_missing_gene_mask(input_gene_ids) missing_dev = missing.to(device) # 3. Cascaded time sampling t_expr, t_latent, w_expr, w_latent = self.sample_t(B, device) # 4. Expression flow path noise_expr = self._make_expr_noise(source) path_expr = flow_path.sample(t=t_expr, x_0=noise_expr, x_1=target) # 5. Latent flow path — (B, G_sub, 4) noise_latent = torch.randn_like(z_target) noise_latent[:, missing_dev, :] = 0.0 z_target_masked = z_target.clone() z_target_masked[:, missing_dev, :] = 0.0 z_flat = z_target_masked.reshape(B, G_sub * 4) noise_flat = noise_latent.reshape(B, G_sub * 4) path_latent_flat = flow_path.sample(t=t_latent, x_0=noise_flat, x_1=z_flat) class _LatentPath: pass path_latent = _LatentPath() path_latent.x_t = path_latent_flat.x_t.reshape(B, G_sub, 4) path_latent.dx_t = path_latent_flat.dx_t.reshape(B, G_sub, 4) # 6. Model forward pred_v_expr, pred_v_latent = self.model( gene_input, source, path_expr.x_t, path_latent.x_t, t_expr, t_latent, perturbation_id, ) # 7. Losses loss_expr_per_sample = ((pred_v_expr - path_expr.dx_t) ** 2).mean(dim=-1) loss_expr = (loss_expr_per_sample * w_expr).sum() / w_expr.sum().clamp(min=1) loss_per_gene = ((pred_v_latent - path_latent.dx_t) ** 2).mean(dim=-1) # (B, G_sub) loss_per_gene[:, missing_dev] = 0.0 n_valid = (~missing_dev).sum().clamp(min=1) loss_latent_per_sample = loss_per_gene.sum(dim=-1) / n_valid loss_latent = (loss_latent_per_sample * w_latent).sum() / w_latent.sum().clamp(min=1) loss = loss_expr + self.latent_weight * loss_latent _mmd_loss = torch.tensor(0.0, device=device) if self.use_mmd_loss and w_expr.sum() > 0: expr_mask = w_expr > 0 if expr_mask.any(): x1_hat = ( path_expr.x_t[expr_mask] + pred_v_expr[expr_mask] * (1 - t_expr[expr_mask]).unsqueeze(-1) ) sigmas = median_sigmas(target[expr_mask], scales=(0.5, 1.0, 2.0, 4.0)) _mmd_loss = mmd2_unbiased_multi_sigma(x1_hat, target[expr_mask], sigmas) loss = loss + _mmd_loss * self.gamma return { "loss": loss, "loss_expr": loss_expr.detach(), "loss_latent": loss_latent.detach(), "loss_mmd": _mmd_loss.detach(), } @torch.no_grad() def generate(self, source, perturbation_id, gene_ids, latent_steps=20, expr_steps=20, method="rk4"): B, G = source.shape device = source.device if gene_ids.dim() == 1: gene_ids = gene_ids.unsqueeze(0).expand(B, -1) missing = self.sparse_cache.get_missing_gene_mask(torch.arange(G)) z_t = torch.randn(B, G, 4, device=device) if missing is not None: z_t[:, missing, :] = 0.0 x_t = self._make_expr_noise(source) if method == "rk4": t_zero = torch.zeros(B, device=device) t_one = torch.ones(B, device=device) def latent_vf(t, z): v_expr, v_latent = self.model( gene_ids, source, x_t, z, t_zero, t.expand(B), perturbation_id, ) if missing is not None: v_latent[:, missing, :] = 0.0 return v_latent z_t = torchdiffeq.odeint( latent_vf, z_t, torch.linspace(0, 1, latent_steps + 1, device=device), method="rk4", atol=1e-4, rtol=1e-4, )[-1] def expr_vf(t, x): v_expr, v_latent = self.model( gene_ids, source, x, z_t, t.expand(B), t_one, perturbation_id, ) return v_expr x_t = torchdiffeq.odeint( expr_vf, x_t, torch.linspace(0, 1, expr_steps + 1, device=device), method="rk4", atol=1e-4, rtol=1e-4, )[-1] else: # euler t_latent_schedule = torch.cat([ torch.linspace(0, 1, latent_steps + 1, device=device), torch.ones(expr_steps, device=device), ]) t_expr_schedule = torch.cat([ torch.zeros(latent_steps + 1, device=device), torch.linspace(0, 1, expr_steps + 1, device=device)[1:], ]) for i in range(latent_steps + expr_steps): t_lat = t_latent_schedule[i] t_lat_next = t_latent_schedule[i + 1] t_exp = t_expr_schedule[i] t_exp_next = t_expr_schedule[i + 1] v_expr, v_latent = self.model( gene_ids, source, x_t, z_t, t_exp.expand(B), t_lat.expand(B), perturbation_id, ) x_t = x_t + (t_exp_next - t_exp) * v_expr z_t = z_t + (t_lat_next - t_lat) * v_latent if missing is not None: z_t[:, missing, :] = 0.0 return torch.clamp(x_t, min=0)