File size: 6,017 Bytes
9651517 | 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 | """
SACFMDenoiser — Source-Anchored Conditional Flow Matching.
Training: x_0 = source + sigma_aug * eps (noisy source, not pure noise).
Standard affine path: x_t = (1-t)*x_0 + t*target.
Velocity target: dx_t = target - x_0.
Gene-weighted MSE loss.
Inference: ODE from clean source (no noise, no SDE).
"""
import torch
import torch.nn as nn
import torchdiffeq
from ._scdfm_imports import AffineProbPath, 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 SACFMDenoiser(nn.Module):
"""
Source-Anchored Conditional Flow Matching Denoiser.
Key differences from scDFM baseline:
- x_0 = source + sigma_aug * eps (not pure noise)
- Gene-weighted velocity loss
- Inference starts from clean source
Key differences from SB:
- No SigmaNet (sigma_aug is fixed, data-driven)
- No ScoreDecoder
- No SDE inference
- No bridge formulation (standard affine path)
"""
def __init__(
self,
model: nn.Module,
sigma_aug: torch.Tensor, # (G,) per-gene augmentation noise
gene_weight: torch.Tensor, # (G,) per-gene loss weight
noise_type: str = "Gaussian",
use_mmd_loss: bool = True,
gamma: float = 0.5,
):
super().__init__()
self.model = model
self.noise_type = noise_type
self.use_mmd_loss = use_mmd_loss
self.gamma = gamma
# Fixed per-gene tensors (not learned)
self.register_buffer("sigma_aug", sigma_aug)
self.register_buffer("gene_weight", gene_weight)
# Standard affine flow matching path (same as scDFM)
self.flow_path = AffineProbPath(scheduler=CondOTScheduler())
def train_step(
self,
source: torch.Tensor, # (B, G_sub) control expression
target: torch.Tensor, # (B, G_sub) perturbed expression
perturbation_id: torch.Tensor, # (B, n_pert)
gene_input: torch.Tensor, # (B, G_sub) vocab-encoded gene IDs
input_gene_ids: torch.Tensor, # (G_sub,) indices into full gene set
) -> dict:
B = source.shape[0]
device = source.device
# 1. Sample time (uniform, clamped away from boundaries)
t = torch.rand(B, device=device).clamp(1e-5, 1 - 1e-5)
# 2. Look up per-gene sigma and weight for current gene subset
sigma_sub = self.sigma_aug[input_gene_ids] # (G_sub,)
weight_sub = self.gene_weight[input_gene_ids] # (G_sub,)
# 3. Source-anchored x_0 with data-driven augmentation noise
eps = torch.randn_like(source)
x_0 = source + sigma_sub.unsqueeze(0) * eps # (B, G_sub)
# 4. Standard affine flow matching (reuses scDFM AffineProbPath)
# x_t = (1-t)*x_0 + t*target
# dx_t = target - x_0 = (target - source) - sigma * eps
path_sample = self.flow_path.sample(t=t, x_0=x_0, x_1=target)
# 5. Model forward (scDFM convention: cell_1=x_t, cell_2=source)
pred_v = self.model(
gene_input, path_sample.x_t, path_sample.t, source,
perturbation_id, gene_input, mode="predict_y",
)
# 6. Gene-weighted velocity loss
loss_v = (weight_sub.unsqueeze(0) * (pred_v - path_sample.dx_t) ** 2).mean()
# 7. MMD loss (optional, same as scDFM baseline)
loss_mmd = torch.tensor(0.0, device=device)
if self.use_mmd_loss:
t_col = t.unsqueeze(-1)
x1_hat = path_sample.x_t + pred_v * (1 - t_col)
sigmas_mmd = median_sigmas(target, scales=(0.5, 1.0, 2.0, 4.0))
loss_mmd = mmd2_unbiased_multi_sigma(x1_hat, target, sigmas_mmd)
loss = loss_v + self.gamma * loss_mmd
return {
"loss": loss,
"loss_v": loss_v.detach(),
"loss_mmd": loss_mmd.detach(),
}
@torch.no_grad()
def generate(
self,
source: torch.Tensor, # (B, G)
perturbation_id: torch.Tensor, # (B, n_pert)
gene_ids: torch.Tensor, # (B, G) or (G,)
steps: int = 20,
method: str = "rk4",
) -> torch.Tensor:
"""Generate perturbed expression via PF-ODE starting from clean source."""
B, G = source.shape
device = source.device
if gene_ids.dim() == 1:
gene_ids = gene_ids.unsqueeze(0).expand(B, -1)
# Start from clean source (no augmentation noise at inference)
x_0 = source.clone()
def ode_func(t_scalar, x):
t_batch = torch.full((B,), t_scalar.item(), device=device)
pred_v = self.model(
gene_ids, x, t_batch, source,
perturbation_id, gene_ids, mode="predict_y",
)
return pred_v
t_span = torch.linspace(0, 1, steps, device=device)
trajectory = torchdiffeq.odeint(
ode_func, x_0, t_span,
method=method, atol=1e-4, rtol=1e-4,
)
return torch.clamp(trajectory[-1], min=0)
|