GRN/regfm/src/loss.py

"""RegFM loss functions: L_reg with magnitude weighting and hard negative mining."""

import torch
import torch.nn.functional as F


def compute_reg_loss(
    R_pred: torch.Tensor,
    delta_attn: torch.Tensor,
    valid_mask: torch.Tensor = None,
    sparse_weight: float = 0.01,
) -> torch.Tensor:
    """
    Regulatory structure supervision loss.

    Handles:
    1. Diagonal exclusion (self-loops not part of GRN)
    2. Missing gene masking (genes absent from scGPT vocab)
    3. Magnitude-weighted MSE on non-zero entries (strong edges get more gradient)
    4. Hard negative mining on zero entries (only penalize top false positives)

    Args:
        R_pred:       (B, G, G) predicted interaction matrix (already tanh-bounded)
        delta_attn:   (B, G, G) ground truth delta attention (sparse)
        valid_mask:   (G,) bool tensor, True = gene valid in scGPT vocab. None = all valid.
        sparse_weight: weight for hard negative sparsity loss
    Returns:
        loss: scalar tensor
    """
    B, G, _ = R_pred.shape

    # 1. Exclude diagonal (self-loops)
    diag_mask = torch.eye(G, dtype=torch.bool, device=R_pred.device)
    R_pred = R_pred.masked_fill(diag_mask.unsqueeze(0), 0.0)
    delta_attn = delta_attn.masked_fill(diag_mask.unsqueeze(0), 0.0)

    # 2. Missing gene masking (zero out rows/columns of invalid genes)
    if valid_mask is not None:
        inv = ~valid_mask  # inv = True for missing/invalid genes
        R_pred = R_pred.clone()
        R_pred[:, inv, :] = 0.0
        R_pred[:, :, inv] = 0.0
        delta_attn = delta_attn.clone()
        delta_attn[:, inv, :] = 0.0
        delta_attn[:, :, inv] = 0.0

    # 3. Non-zero entries: magnitude-weighted MSE
    mask_nz = delta_attn != 0
    n_nonzero = mask_nz.sum().item()

    if n_nonzero > 0:
        residual = (R_pred[mask_nz] - delta_attn[mask_nz]).pow(2)
        mag_weights = delta_attn[mask_nz].abs()
        mag_weights = mag_weights / mag_weights.sum()
        loss_nz = (mag_weights * residual).sum()
    else:
        loss_nz = R_pred.new_tensor(0.0)

    # 4. Zero entries: hard negative mining (top-K by |R_pred|)
    mask_zero = ~mask_nz
    if valid_mask is not None:
        valid_2d = valid_mask.unsqueeze(0).unsqueeze(2) & valid_mask.unsqueeze(0).unsqueeze(1)
        mask_zero = mask_zero & valid_2d
    # Also exclude diagonal from zero mask
    mask_zero = mask_zero & ~diag_mask.unsqueeze(0)

    if mask_zero.any():
        zero_preds = R_pred[mask_zero]
        n_hard = max(min(3 * n_nonzero, len(zero_preds)), 1)
        _, hard_idx = zero_preds.abs().topk(n_hard)
        loss_sparse = zero_preds[hard_idx].pow(2).mean()
    else:
        loss_sparse = R_pred.new_tensor(0.0)

    return loss_nz + sparse_weight * loss_sparse


def get_lambda_reg(step: int, lambda_reg: float,
                   zero_steps: int, ramp_steps: int) -> float:
    """Two-phase λ_reg schedule: zero → linear ramp → constant."""
    if step < zero_steps:
        return 0.0
    elif step < zero_steps + ramp_steps:
        return lambda_reg * (step - zero_steps) / ramp_steps
    else:
        return lambda_reg