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

import pdb
import torch
import torch.nn as nn
from torch import Tensor
from typing import Optional, Dict, Tuple
import math
from .rotary import apply_rotary_emb

def lambda_init_fn(depth):
    return 0.8 - 0.6 * math.exp(-0.3 * depth)

def repeat_kv(x: torch.Tensor, n_rep: int) -> torch.Tensor:
    """torch.repeat_interleave(x, dim=1, repeats=n_rep)"""
    bs, n_kv_heads, slen, head_dim = x.shape
    if n_rep == 1:
        return x
    return (
        x[:, :, None, :, :]
        .expand(bs, n_kv_heads, n_rep, slen, head_dim)
        .reshape(bs, n_kv_heads * n_rep, slen, head_dim)
    )

def modulate(x, shift, scale):
    return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1)

class RMSNorm(nn.Module):
    def __init__(self, dim: int, eps: float = 1e-6, elementwise_affine=True, memory_efficient=False):
        super().__init__()
        self.dim = dim
        self.eps = eps
        self.elementwise_affine = elementwise_affine
        if self.elementwise_affine:
            self.weight = nn.Parameter(torch.ones(dim))
        else:
            self.register_parameter('weight', None)

    def _norm(self, x):
        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)

    def forward(self, x):
        output = self._norm(x.float()).type_as(x)
        if self.weight is not None:
            output = output * self.weight
        return output

    def extra_repr(self) -> str:
        return f'dim={self.dim}, eps={self.eps}, elementwise_affine={self.elementwise_affine}'
    
    
class MultiheadDiffAttn_Origin(nn.Module):
    def __init__(
        self,
        embed_dim,
        depth, # current layer index
        num_heads,
        num_kv_heads=None,
    ):
        super().__init__()
        self.embed_dim = embed_dim
        
        # arg num_heads set to half of baseline Transformer's num_heads
        # for e.g., to compare with a baseline Transformer with 16 heads, pass in num_heads=8 for DIFF Transformer
        self.num_heads = num_heads
        
        # arg num_kv_heads set to half of baseline Transformer's num_kv_heads if use GQA
        # for e.g., to compare with a baseline Transformer with 16 heads and 8 kv_heads, 
        # pass in num_heads=8, num_kv_heads=4 for DIFF Transformer
        # if use MHA, pass in num_kv_heads=None
        self.num_kv_heads = num_kv_heads if num_kv_heads is not None else num_heads
        self.n_rep = self.num_heads // self.num_kv_heads
        
        self.head_dim = embed_dim // num_heads // 2
        self.scaling = self.head_dim ** -0.5
        
        self.q_proj = nn.Linear(embed_dim, embed_dim, bias=False)
        self.k_proj = nn.Linear(embed_dim, embed_dim // self.n_rep, bias=False)
        self.v_proj = nn.Linear(embed_dim, embed_dim // self.n_rep, bias=False)
        self.out_proj = nn.Linear(embed_dim, embed_dim, bias=False)

        # depth means current layer index
        self.lambda_init = lambda_init_fn(depth)
        self.lambda_q1 = nn.Parameter(torch.zeros(self.head_dim, dtype=torch.float32).normal_(mean=0,std=0.1))
        self.lambda_k1 = nn.Parameter(torch.zeros(self.head_dim, dtype=torch.float32).normal_(mean=0,std=0.1))
        self.lambda_q2 = nn.Parameter(torch.zeros(self.head_dim, dtype=torch.float32).normal_(mean=0,std=0.1))
        self.lambda_k2 = nn.Parameter(torch.zeros(self.head_dim, dtype=torch.float32).normal_(mean=0,std=0.1))

        self.subln = RMSNorm(2 * self.head_dim, eps=1e-5, elementwise_affine=True)
    
    def forward(
        self,
        x,
        rel_pos,
        attn_mask=None,
    ):
        bsz, tgt_len, embed_dim = x.size()
        src_len = tgt_len

        q = self.q_proj(x)
        k = self.k_proj(x)
        v = self.v_proj(x)

        q = q.view(bsz, tgt_len, 2 * self.num_heads, self.head_dim)
        k = k.view(bsz, src_len, 2 * self.num_kv_heads, self.head_dim)
        v = v.view(bsz, src_len, self.num_kv_heads, 2 * self.head_dim)

        q = apply_rotary_emb(q, *rel_pos, interleaved=True)
        k = apply_rotary_emb(k, *rel_pos, interleaved=True)

        offset = src_len - tgt_len
        q = q.transpose(1, 2)
        k = repeat_kv(k.transpose(1, 2), self.n_rep)
        v = repeat_kv(v.transpose(1, 2), self.n_rep)
        q *= self.scaling
        attn_weights = torch.matmul(q, k.transpose(-1, -2))
        attn_weights = torch.nan_to_num(attn_weights)
        attn_weights = torch.nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).type_as(
            attn_weights
        )

        lambda_1 = torch.exp(torch.sum(self.lambda_q1 * self.lambda_k1, dim=-1).float()).type_as(q)
        lambda_2 = torch.exp(torch.sum(self.lambda_q2 * self.lambda_k2, dim=-1).float()).type_as(q)
        lambda_full = lambda_1 - lambda_2 + self.lambda_init
        attn_weights = attn_weights.view(bsz, self.num_heads, 2, tgt_len, src_len)
        attn_weights = attn_weights[:, :, 0] - lambda_full * attn_weights[:, :, 1]
        
        attn = torch.matmul(attn_weights, v)
        attn = self.subln(attn)
        attn = attn * (1 - self.lambda_init)
        attn = attn.transpose(1, 2).reshape(bsz, tgt_len, self.num_heads * 2 * self.head_dim)

        attn = self.out_proj(attn)
        return attn
    
class MultiheadDiffAttn(nn.Module):
    def __init__(
        self,
        embed_dim,
        num_heads,
        depth, # current layer index
        cross=False,
    ):
        super().__init__()
        self.embed_dim = embed_dim
        self.cross = cross
        # The code `pdb.set_trace()` is setting a breakpoint in the code using the Python debugger
        # (pdb). When the code is executed, it will pause the program's execution at that point and
        # allow you to interactively debug the program.
        # pdb.set_trace()
        self.num_heads = num_heads
        self.head_dim = embed_dim // num_heads
        self.scaling = self.head_dim ** -0.5

        self.q_proj_1 = nn.Linear(embed_dim, embed_dim, bias=False)
        self.k_proj_1 = nn.Linear(embed_dim, embed_dim, bias=False)
        self.q_proj_2 = nn.Linear(embed_dim, embed_dim, bias=False)
        self.k_proj_2 = nn.Linear(embed_dim, embed_dim, bias=False)
        self.v_proj = nn.Linear(embed_dim, embed_dim, bias=False)
        self.out_proj = nn.Linear(embed_dim, embed_dim, bias=False)

        # depth means current layer index
        self.lambda_init = lambda_init_fn(depth)
        self.lambda_q1 = nn.Parameter(torch.zeros(self.head_dim, dtype=torch.float32).normal_(mean=0,std=0.1))
        self.lambda_k1 = nn.Parameter(torch.zeros(self.head_dim, dtype=torch.float32).normal_(mean=0,std=0.1))
        self.lambda_q2 = nn.Parameter(torch.zeros(self.head_dim, dtype=torch.float32).normal_(mean=0,std=0.1))
        self.lambda_k2 = nn.Parameter(torch.zeros(self.head_dim, dtype=torch.float32).normal_(mean=0,std=0.1))

        self.subln = RMSNorm(self.head_dim, eps=1e-5, elementwise_affine=True)

    def forward(
        self,
        noisy_y,
        x,
    ):
        bsz, tgt_len, embed_dim = x.size()
        src_len = tgt_len
        
        if self.cross:
            q_1 = self.q_proj_1(noisy_y)
            k_1 = self.k_proj_1(x)
            q_2 = self.q_proj_2(noisy_y)
            k_2 = self.k_proj_2(x)
        else:
            q_1 = self.q_proj_1(noisy_y)
            k_1 = self.k_proj_1(noisy_y)
            q_2 = self.q_proj_2(x)
            k_2 = self.k_proj_2(x)
        v = self.v_proj(noisy_y)

        q_1 = q_1.view(bsz, tgt_len, self.num_heads, self.head_dim)
        k_1 = k_1.view(bsz, src_len, self.num_heads, self.head_dim)
        q_2 = q_2.view(bsz, tgt_len, self.num_heads, self.head_dim)
        k_2 = k_2.view(bsz, src_len, self.num_heads, self.head_dim)

        v = v.view(bsz, src_len, self.num_heads, self.head_dim)


        q_1 = q_1.transpose(1, 2)
        q_2 = q_2.transpose(1, 2)
        k_1 = k_1.transpose(1, 2)
        k_2 = k_2.transpose(1, 2)
        q_1 *= self.scaling
        q_2 *= self.scaling

        attn_weights_1 = torch.matmul(q_1, k_1.transpose(-1, -2))
        attn_weights_2 = torch.matmul(q_2, k_2.transpose(-1, -2))

        with torch.amp.autocast('cuda', enabled=False):
            attn_weights_1 = torch.nn.functional.softmax(attn_weights_1, dim=-1)
            attn_weights_2 = torch.nn.functional.softmax(attn_weights_2, dim=-1)

        lambda_1 = torch.exp(torch.sum(self.lambda_q1 * self.lambda_k1, dim=-1).float()).type_as(q_1)
        lambda_2 = torch.exp(torch.sum(self.lambda_q2 * self.lambda_k2, dim=-1).float()).type_as(q_1)

        lambda_full = lambda_1 - lambda_2 + self.lambda_init

        # Fuse differential subtraction with value projection via distributive law:
        #   (A - λB) @ v  =  A@v - λ * (B@v)
        # Avoids materializing the combined (B, H, N, N) attention matrix.
        vt = v.transpose(1, 2)
        attn = torch.matmul(attn_weights_1, vt) - lambda_full * torch.matmul(attn_weights_2, vt)
        # attn: (bsz, num_heads, tgt_len, head_dim)        
        attn = self.subln(attn)
        attn = attn * (1 - self.lambda_init)
        attn = attn.transpose(1, 2).reshape(bsz, tgt_len, self.num_heads * self.head_dim)

        attn = self.out_proj(attn)
        return attn  



class CrossAttentionTransformerLayer(nn.Module):
    """
    One-layer Transformer block with ONLY cross-attention:
      - Pre-norm -> Multihead cross-attention (Q=tgt, K/V=memory)
      - Residual
      - Pre-norm -> FeedForward (MLP)
      - Residual

    Shapes (batch_first=True):
      tgt:    (B, T_tgt, d_model)
      memory: (B, T_mem, d_model)
    """
    def __init__(
        self,
        d_model: int,
        nhead: int,
        mlp_ratio: int = 4,
        dropout: float = 0.1,
        activation: str = "gelu",
        batch_first: bool = True
    ):
        super().__init__()
        self.batch_first = batch_first

        # Cross attention: Q from tgt, K/V from memory
        self.cross_attn = nn.MultiheadAttention(
            embed_dim=d_model, num_heads=nhead, dropout=dropout, batch_first=batch_first
        )
        self.cross_attn_dropout = nn.Dropout(dropout)
        self.norm1 = nn.LayerNorm(d_model)

        # Feedforward
        self.linear1 = nn.Linear(d_model, int(mlp_ratio * d_model))
        self.linear2 = nn.Linear(int(mlp_ratio * d_model), d_model)
        self.ffn_dropout = nn.Dropout(dropout)
        self.norm2 = nn.LayerNorm(d_model)

        if activation == "relu":
            self.activation = nn.ReLU()
        elif activation == "gelu":
            self.activation = nn.GELU()
        else:
            raise ValueError(f"Unsupported activation: {activation}")

    def forward(
        self,
        tgt: torch.Tensor,
        memory: torch.Tensor,
        attn_mask: Optional[torch.Tensor] = None,
        memory_key_padding_mask: Optional[torch.Tensor] = None,
        need_weights: bool = False,
        average_attn_weights: bool = True,
    ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
        """
        Args:
            tgt: (B, T_tgt, d_model)
            memory: (B, T_mem, d_model)
            attn_mask: optional mask applied to (tgt_len, mem_len) or (B*nhead, tgt_len, mem_len)
            memory_key_padding_mask: (B, T_mem) with True for positions to mask
            need_weights: return attention weights
            average_attn_weights: average heads if True

        Returns:
            out: (B, T_tgt, d_model)
            attn: (B, T_tgt, T_mem) or (B, nhead, T_tgt, T_mem) if need_weights else None
        """
        # --- Cross Attention (pre-norm) ---
        x = self.norm1(tgt)
        attn_out, attn_w = self.cross_attn(
            query=x,
            key=memory,
            value=memory,
            attn_mask=attn_mask,
            key_padding_mask=memory_key_padding_mask,
            need_weights=need_weights,
            average_attn_weights=average_attn_weights,
        )
        x = tgt + self.cross_attn_dropout(attn_out)

        # --- Feedforward (pre-norm) ---
        y = self.norm2(x)
        y = self.linear2(self.ffn_dropout(self.activation(self.linear1(y))))
        out = x + self.ffn_dropout(y)

        return out, attn_w if need_weights else None
# class PerceiverDiffTransBlock(nn.Module):
#     def __init__(self, d_in, d_latent, heads=8, mlp_ratio=4):
#         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=0.1, batch_first=True)

#         self.ln_z2 = nn.LayerNorm(d_latent)
#         self.self_attn = nn.MultiheadAttention(d_latent, heads, dropout=0.1, 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.Dropout(0.1),
#             nn.Linear(int(mlp_ratio * d_latent), d_latent),
#             nn.Dropout(0.1),
#         )
#         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