GRN/regfm/src/denoiser.py

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