transfer/code/scDFM/src/models/origin/model.py

import torch
import torch.nn as nn
from torch import Tensor
from typing import Optional, Dict
import math
from timm.models.vision_transformer import PatchEmbed, Attention, Mlp

import pdb

from .layers import GeneadaLN, ContinuousValueEncoder, GeneEncoder, BatchLabelEncoder, TimestepEmbedder, ExprDecoder
from .blocks import MultiheadDiffAttn, modulate , CrossAttentionTransformerLayer
class Block(nn.Module):
    """
    A DiT block with adaptive layer norm zero (adaLN-Zero) conditioning.
    """
    def __init__(self, hidden_size, num_heads, mlp_ratio=4.0, **block_kwargs):
        super().__init__()
        self.norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
        self.attn = Attention(hidden_size, num_heads=num_heads, qkv_bias=True, **block_kwargs)
        self.norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
        mlp_hidden_dim = int(hidden_size * mlp_ratio)
        approx_gelu = lambda: nn.GELU(approximate="tanh")
        self.mlp = Mlp(in_features=hidden_size, hidden_features=mlp_hidden_dim, act_layer=approx_gelu, drop=0)
        self.adaLN_modulation = nn.Sequential(
            nn.SiLU(),
            nn.Linear(hidden_size, 6 * hidden_size, bias=True)
        )

    def forward(self, x, c):
        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(c).chunk(6, dim=1)
        x = x + gate_msa.unsqueeze(1) * self.attn(modulate(self.norm1(x), shift_msa, scale_msa))
        x = x + gate_mlp.unsqueeze(1) * self.mlp(modulate(self.norm2(x), shift_mlp, scale_mlp))
        return x

class DifferentialTransformerBlock(nn.Module):
    def __init__(self, hidden_size, num_heads, depth, mlp_ratio=4.0, cross=False, **block_kwargs):
        super().__init__()
        self.norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
        self.attn = MultiheadDiffAttn(hidden_size, num_heads, depth, cross=cross)
        self.norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
        mlp_hidden_dim = int(hidden_size * mlp_ratio)
        approx_gelu = lambda: nn.GELU(approximate="tanh")
        self.mlp = Mlp(in_features=hidden_size, hidden_features=mlp_hidden_dim, act_layer=approx_gelu, drop=0)
        self.adaLN_modulation = nn.Sequential(
            nn.SiLU(),
            nn.Linear(hidden_size, 6 * hidden_size, bias=True)
        )

    def forward(self, y, x, c):
        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(c).chunk(6, dim=1)
        y = y + gate_msa.unsqueeze(1) * self.attn(modulate(self.norm1(y), shift_msa, scale_msa), x)
        y = y + gate_mlp.unsqueeze(1) * self.mlp(modulate(self.norm2(y), shift_mlp, scale_mlp))
        return y

class PerceiverBlock(nn.Module):
    def __init__(self, d_in, d_latent, heads=8, mlp_ratio=4, dropout=0.0):
        super().__init__()
        self.ln_z1 = nn.LayerNorm(d_latent)
        self.q = nn.Linear(d_latent, d_latent)
        self.k = nn.Linear(d_in, d_latent)
        self.v = nn.Linear(d_in, d_latent)
        
        self.q2 = nn.Linear(d_latent, d_latent)
        self.k2 = nn.Linear(d_latent, d_latent)
        self.v2 = nn.Linear(d_latent, d_latent)
        self.cross = nn.MultiheadAttention(d_latent, heads, dropout=dropout, batch_first=True)

        self.ln_z2 = nn.LayerNorm(d_latent)
        self.self_attn = nn.MultiheadAttention(d_latent, heads, dropout=dropout, batch_first=True)
        self.ln_z3 = nn.LayerNorm(d_latent)
        self.mlp = nn.Sequential(
            nn.Linear(d_latent, int(mlp_ratio * d_latent)), nn.GELU(),
            nn.Linear(int(mlp_ratio * d_latent), d_latent)
        )
        self.adaLN_modulation = nn.Sequential(
            nn.SiLU(),
            nn.Linear(d_latent, 6 * d_latent, bias=True)
        )
    
        
    def forward(self, z, x, t):
        shift_self, scale_self, gate_self, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(t).chunk(6, dim=1)
        z = z + self.cross(self.q(self.ln_z1(z)),
                           self.k(x), self.v(x))[0]

        z = modulate(self.ln_z2(z), shift_self, scale_self)
        z = z + gate_self.unsqueeze(1) * self.self_attn(self.q2(z), self.k2(z), self.v2(z))[0]

        z = z + gate_mlp.unsqueeze(1) * self.mlp(modulate(self.ln_z3(z), shift_mlp, scale_mlp))
        return z

class DiffPerceiverBlock(nn.Module):
    def __init__(self,hidden_size, num_heads, depth, mlp_ratio=4.0):
        super().__init__()
        self.diff_self_attn = DifferentialTransformerBlock(hidden_size, num_heads, depth, mlp_ratio=mlp_ratio,cross=True)
        self.diff_cross_attn = DifferentialTransformerBlock(hidden_size, num_heads, depth, mlp_ratio=mlp_ratio,cross=False)
        
    def forward(self, y, x, c):
        y = self.diff_self_attn(y, y, c)
        y = self.diff_cross_attn(y, x, c)
        return y

class model(nn.Module):
    def __init__(self,
                 ntoken: int = 6000,
                 d_model: int = 512,
                 nhead: int = 8,
                 d_hid: int = 2048,
                 nlayers: int = 8, # 8
                 dropout: float = 0.1,
                 fusion_method: str = 'cross', # concat, add, cross
                 perturbation_function: str = 'crisper',
                 use_perturbation_interaction: bool = True,
                 mask_path: str = None,
                 ):
        super().__init__()
        self.t_embedder = TimestepEmbedder(d_model)
        self.perturbation_embedder = BatchLabelEncoder(ntoken, d_model,)
        self.fusion_method = fusion_method
        self.perturbation_function = perturbation_function
        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.value_encoder_1 = ContinuousValueEncoder(d_model, dropout)
        self.value_encoder_2 = ContinuousValueEncoder(d_model, dropout)
        self.encoder = GeneEncoder(ntoken, d_model,use_perturbation_interaction=use_perturbation_interaction,mask_path=mask_path)
        self.use_perturbation_interaction = use_perturbation_interaction
        # if use_perturbation_interaction:
        #     self.perturbation_interaction = CrossAttentionTransformerLayer(d_model, nhead, mlp_ratio=4.0, dropout=dropout)
        
        if self.fusion_method == 'differential_transformer':
            self.blocks = nn.ModuleList([
                DifferentialTransformerBlock(d_model, nhead, i, mlp_ratio=4.0) for i in range(nlayers)
            ])
        elif self.fusion_method == 'differential_perceiver':
            self.blocks = nn.ModuleList([
                DiffPerceiverBlock(d_model, nhead, i, mlp_ratio=4.0) for i in range(nlayers)
            ])
        elif self.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"Invalid fusion method: {self.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 task with embedding prediction
        self.p_mask_embed = nn.Parameter(torch.randn(d_model))  # (d_model,)
        self.p_head = nn.Sequential(
            nn.LayerNorm(d_model),
            nn.Linear(d_model, d_model)
        )

        self.final_layer = ExprDecoder(d_model, explicit_zero_prob=False, use_batch_labels=True)
        self.initialize_weights()

    def initialize_weights(self):
        # Initialize transformer layers:
        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)
    
     
    def get_perturbation_emb(self, perturbation_id=None, perturbation_emb=None,
                             cell_1=None, use_mask: bool=False):
        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)  # (B,d)
        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"):
        if t.dim() == 0:
            t = t.repeat(cell_1.size(0))
        
        gene_emb = self.encoder(gene_id)
        # gene_emb_all = self.encoder(gene_id_all)
        gene_emb_all = gene_emb
        value_emb_1 = self.value_encoder_1(cell_1)
        value_emb_2 = self.value_encoder_2(cell_2)
        
        value_emb_1 = value_emb_1 + gene_emb
        value_emb_2 = value_emb_2 + gene_emb_all
        
        value_emb = torch.cat([value_emb_1, value_emb_2], dim=-1)
        value_emb = self.fusion_layer(value_emb)
            
        t_emb = self.t_embedder(t)

        x = value_emb

        perturbation_emb = self.get_perturbation_emb(perturbation_id, perturbation_emb, cell_1)

        for i,block in enumerate(self.blocks):
            x = self.gene_adaLN[i](gene_emb, x)
            perturbation_exp = perturbation_emb[:, None, :].expand(-1, x.size(1), -1)  # (B, T, emb)
            x = torch.cat([x, perturbation_exp], dim=-1)
            x = self.adapter_layer[i](x)
            x = block(x, value_emb_2, t_emb)

        
        if mode=="predict_p":
            x_pooling = x.mean(dim=1) 
            return self.p_head(x_pooling)
        
        x = torch.cat([x, perturbation_emb[:, None, :].expand(-1, x.size(1), -1)], dim=-1)
        x = self.final_layer(x)

        return x['pred']


    
if __name__ == "__main__":
    model = model(ntoken=100, d_model=128, nhead=8, d_hid=128, nlayers=12)
    batch_size = 10
    gene_id = torch.randint(0, 100, (batch_size, 10))
    x = torch.randn(batch_size, 10)
    t = torch.randint(0, 100, (batch_size,))
    y = torch.randn(batch_size, 10)
    perturbation = torch.randint(0, 100, (batch_size,2))

    output = model(gene_id, x, t, y, perturbation)
    pdb.set_trace()