lfj-code / GRN /regfm /src /model /model.py

Upload folder using huggingface_hub

9f5e507 verified 7 months ago

8.31 kB

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

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