""" RegFMModel: scDFM backbone + RegulatoryHead + VelocityGate. Parameter names for backbone components match ori_scDFM exactly, enabling direct weight loading from scDFM baseline checkpoints. """ import torch import torch.nn as nn from src._scdfm_imports import ( GeneEncoder, ContinuousValueEncoder, GeneadaLN, BatchLabelEncoder, TimestepEmbedder, ExprDecoder, DiffPerceiverBlock, DifferentialTransformerBlock, PerceiverBlock, ) from src.model.layers import RegulatoryHead, VelocityGate class RegFMModel(nn.Module): """ Regulatory Flow Matching model. Forward returns: v: (B, G) — final velocity = α·v_reg + (1-α)·v_int R: (B, G, G) — predicted interaction matrix (for L_reg supervision) """ def __init__( self, ntoken: int = 512, d_model: int = 128, nhead: int = 8, d_hid: int = 512, nlayers: int = 4, dropout: float = 0.1, fusion_method: str = "differential_perceiver", perturbation_function: str = "crisper", use_perturbation_interaction: bool = True, mask_path: str = None, # RegFM-specific d_r: int = 32, gate_init_bias: float = -3.0, ): super().__init__() self.perturbation_function = perturbation_function self._gate_init_bias = gate_init_bias # === Backbone (parameter names match ori_scDFM for warm start) === self.encoder = GeneEncoder( ntoken, d_model, use_perturbation_interaction=use_perturbation_interaction, mask_path=mask_path, ) self.value_encoder_1 = ContinuousValueEncoder(d_model, dropout) self.value_encoder_2 = ContinuousValueEncoder(d_model, dropout) self.fusion_layer = nn.Sequential( nn.Linear(2 * d_model, d_model), nn.GELU(), nn.Linear(d_model, d_model), nn.LayerNorm(d_model), ) self.t_embedder = TimestepEmbedder(d_model) self.perturbation_embedder = BatchLabelEncoder(ntoken, d_model) # Transformer blocks if fusion_method == "differential_perceiver": self.blocks = nn.ModuleList( [DiffPerceiverBlock(d_model, nhead, i, mlp_ratio=4.0) for i in range(nlayers)] ) elif fusion_method == "differential_transformer": self.blocks = nn.ModuleList( [DifferentialTransformerBlock(d_model, nhead, i, mlp_ratio=4.0) for i in range(nlayers)] ) elif fusion_method == "perceiver": self.blocks = nn.ModuleList( [PerceiverBlock(d_model, d_model, heads=nhead, mlp_ratio=4.0, dropout=0.1) for _ in range(nlayers)] ) else: raise ValueError(f"Unknown fusion_method: {fusion_method}") self.gene_adaLN = nn.ModuleList( [GeneadaLN(d_model, dropout) for _ in range(nlayers)] ) self.adapter_layer = nn.ModuleList([ nn.Sequential( nn.Linear(2 * d_model, d_model), nn.LeakyReLU(), nn.Dropout(dropout), nn.Linear(d_model, d_model), nn.LeakyReLU(), ) for _ in range(nlayers) ]) # predict_p auxiliary head (kept for compatibility) self.p_mask_embed = nn.Parameter(torch.randn(d_model)) self.p_head = nn.Sequential(nn.LayerNorm(d_model), nn.Linear(d_model, d_model)) # === v_int head (ExprDecoder, same as scDFM's self.final_layer) === self.final_layer = ExprDecoder(d_model, explicit_zero_prob=False, use_batch_labels=True) # === RegFM additions === self.reg_head = RegulatoryHead(d_model, d_r) self.velocity_gate = VelocityGate(d_model, gate_init_bias) self.initialize_weights() def initialize_weights(self): def _basic_init(module): if isinstance(module, nn.Linear): torch.nn.init.xavier_uniform_(module.weight) if module.bias is not None: nn.init.constant_(module.bias, 0) self.apply(_basic_init) # Re-apply gate bias after global init nn.init.zeros_(self.velocity_gate.mlp[-1].weight) nn.init.constant_(self.velocity_gate.mlp[-1].bias, self._gate_init_bias) def get_perturbation_emb(self, perturbation_id=None, perturbation_emb=None, cell_1=None, use_mask: bool = False): """Identical to scDFM model.get_perturbation_emb for compatibility.""" if use_mask: B = cell_1.size(0) return self.p_mask_embed[None, :].expand(B, -1).to(cell_1.device, dtype=cell_1.dtype) assert perturbation_emb is None or perturbation_id is None if perturbation_id is not None: if self.perturbation_function == "crisper": perturbation_emb = self.encoder(perturbation_id) else: perturbation_emb = self.perturbation_embedder(perturbation_id) perturbation_emb = perturbation_emb.mean(1) elif perturbation_emb is not None: perturbation_emb = perturbation_emb.to(cell_1.device, dtype=cell_1.dtype) if perturbation_emb.dim() == 1: perturbation_emb = perturbation_emb.unsqueeze(0) if perturbation_emb.size(0) == 1: perturbation_emb = perturbation_emb.expand(cell_1.shape[0], -1).contiguous() perturbation_emb = self.perturbation_embedder.enc_norm(perturbation_emb) return perturbation_emb def forward(self, gene_id, cell_1, t, cell_2, perturbation_id=None, gene_id_all=None, perturbation_emb=None, mode="predict_y"): """ Args: gene_id: (B, G) vocab-encoded gene IDs cell_1: (B, G) noised target expression x_t t: (B,) or scalar — flow timestep cell_2: (B, G) source/control expression perturbation_id: (B, 2) perturbation condition IDs gene_id_all: unused (kept for API compatibility) perturbation_emb: optional precomputed perturbation embedding mode: "predict_y" (default) or "predict_p" Returns: if mode == "predict_y": (v, R) v: (B, G) — gated velocity: α·v_reg + (1-α)·v_int R: (B, G, G) — predicted interaction matrix if mode == "predict_p": (B, d_model) """ if t.dim() == 0: t = t.repeat(cell_1.size(0)) # --- Backbone (identical to scDFM) --- gene_emb = self.encoder(gene_id) # (B, G, d_model) value_emb_1 = self.value_encoder_1(cell_1) + gene_emb # x_t encoding value_emb_2 = self.value_encoder_2(cell_2) + gene_emb # source encoding value_emb = torch.cat([value_emb_1, value_emb_2], dim=-1) value_emb = self.fusion_layer(value_emb) # (B, G, d_model) t_emb = self.t_embedder(t) # (B, d_model) pert_emb = self.get_perturbation_emb(perturbation_id, perturbation_emb, cell_1) x = value_emb for i, block in enumerate(self.blocks): x = self.gene_adaLN[i](gene_emb, x) pert_exp = pert_emb[:, None, :].expand(-1, x.size(1), -1) x = torch.cat([x, pert_exp], dim=-1) x = self.adapter_layer[i](x) x = block(x, value_emb_2, t_emb) h = x # backbone output: (B, G, d_model) # --- predict_p mode (auxiliary task, unchanged) --- if mode == "predict_p": return self.p_head(h.mean(dim=1)) # --- v_int: intrinsic velocity (same as scDFM) --- x_dec = torch.cat([h, pert_emb[:, None, :].expand(-1, h.size(1), -1)], dim=-1) v_int = self.final_layer(x_dec)["pred"] # (B, G) # --- v_reg, R: regulatory velocity (RegFM) --- v_reg, R = self.reg_head(h) # (B, G), (B, G, G) # --- Gated mixing --- alpha = self.velocity_gate(h, pert_emb, t_emb) # (B, G) v = alpha * v_reg + (1.0 - alpha) * v_int # (B, G) return v, R