GRN/grn_dense4/src/denoiser.py

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