# === Appended from canonical.py === import math import torch import torch.nn.functional as F from torch import nn # Import for Rotary Positional Embeddings, a common technique in modern Transformers. # Its use is mentioned in the paper's experimental setup (Section 3.3). from kernel.rotary import apply_rotary_emb try: # Attempt to import FusedRMSNorm from Apex for optimized performance. # This is an efficiency optimization and doesn't change the mathematical function. from apex.normalization import FusedRMSNorm as RMSNorm except ModuleNotFoundError: # Fallback to a standard RMSNorm implementation if Apex is not available. print("No fused RMSNorm") from rms_norm import RMSNorm # Assuming rms_norm.py contains a PyTorch RMSNorm implementation # --- Helper Function for Grouped-Query Attention (GQA) --- def repeat_kv(x: torch.Tensor, n_rep: int) -> torch.Tensor: """ Repeats Key (K) and Value (V) tensors for Grouped-Query Attention (GQA). In GQA, multiple query heads can share the same key/value head, reducing computation and memory for K and V projections compared to Multi-Head Attention (MHA). This function is equivalent to torch.repeat_interleave(x, dim=1, repeats=n_rep) if the input `x` was shaped (bs, n_kv_heads, slen * head_dim) and then reshaped, but here it operates on x with shape (bs, n_kv_heads, slen, head_dim) by expanding and reshaping. The dim 1 here refers to the head dimension after transpose. Args: x (torch.Tensor): Input Key or Value tensor after transposing to (batch_size, num_kv_heads_or_values, sequence_length, head_dimension_component). For K, num_kv_heads_or_values is 2 * num_kv_heads (for K1, K2). For V, num_kv_heads_or_values is num_kv_heads. n_rep (int): Number of times to repeat each K/V head group. This is typically num_query_heads / num_kv_heads. Returns: torch.Tensor: Repeated K/V tensor. Shape for K: (batch_size, 2 * num_heads, sequence_length, head_dimension). Shape for V: (batch_size, num_heads, sequence_length, 2 * head_dimension). Paper Correspondence: - The paper mentions the use of Grouped-Query Attention (GQA) in the __init__ comments of the MultiheadDiffAttn class description (though not in the main text of Section 2.1). - This is a standard GQA implementation detail. """ bs, n_kv_heads_component, slen, head_dim_component = x.shape # Note: n_kv_heads_component is the number of K/V groups to be repeated. if n_rep == 1: # If n_rep is 1, it means num_query_heads == num_kv_heads (no GQA, or MHA setup). # No repetition needed. return x # Expand and reshape to achieve repetition: # 1. Add a new dimension for repetition: x[:, :, None, :, :] # Shape becomes (bs, n_kv_heads_component, 1, slen, head_dim_component) # 2. Expand along this new dimension: .expand(bs, n_kv_heads_component, n_rep, slen, head_dim_component) # This copies the K/V head data `n_rep` times. # Shape becomes (bs, n_kv_heads_component, n_rep, slen, head_dim_component) # 3. Reshape to combine n_kv_heads_component and n_rep: .reshape(bs, n_kv_heads_component * n_rep, slen, head_dim_component) # This results in the desired shape where the original K/V groups are now repeated to match query head groups. return ( x[:, :, None, :, :] .expand(bs, n_kv_heads_component, n_rep, slen, head_dim_component) .reshape(bs, n_kv_heads_component * n_rep, slen, head_dim_component) ) # --- Helper Function for Lambda Initialization --- def lambda_init_fn(depth: int) -> float: """ Calculates the initial value for the static component of lambda ($\lambda_{init}$) based on the layer depth. This function is used to initialize `self.lambda_init` in the `MultiheadDiffAttn` class. Args: depth (int): Current layer index (assumed to be 0-indexed by the caller). Returns: float: The initial value for $\lambda_{init}$. Paper Correspondence: - This function directly implements the formula provided in Section 2.1 of the paper, just below Equation (2): $\lambda_{init} = 0.8 - 0.6 \times \exp(-0.3 \cdot (l-1))$ - In this code, `depth` corresponds to `(l-1)` from the paper's formula, where `l` is the 1-indexed layer number. """ return 0.8 - 0.6 * math.exp(-0.3 * depth) # --- Multi-Head Differential Attention Module --- class MultiheadDiffAttn(nn.Module): def __init__( self, embed_dim: int, # Dimension of input embeddings (d_model in the paper). depth: int, # Current layer index (0-indexed), used for lambda_init_fn. num_heads: int, # Number of differential attention heads (h in the paper). num_kv_heads: int =None, # Number of Key/Value heads for GQA. If None, defaults to num_heads (MHA). ): super().__init__() self.embed_dim = embed_dim # d_model # `num_heads` (h in the paper) for DIFF Transformer is typically set to half # of a baseline Transformer's number of attention heads to maintain similar # parameter counts and computational complexity, as mentioned in Section 2.1 and 3.1. # This `num_heads` refers to the number of differential attention units. self.num_heads = num_heads # `num_kv_heads` is for Grouped-Query Attention (GQA). # If not specified (None), it defaults to `num_heads`, implying Multi-Head Attention (MHA) # where each differential head has its own K, V projections (before splitting into K1/K2). self.num_kv_heads = num_kv_heads if num_kv_heads is not None else num_heads # Repetition factor for GQA, calculated as num_query_heads / num_kv_heads. # Here, num_query_heads is effectively self.num_heads (number of differential units). self.n_rep = self.num_heads // self.num_kv_heads # `head_dim` (d in the paper) is the dimension for EACH of Q1, Q2, K1, K2 vectors. # Paper (Section 2.1) states: # $Q_1, Q_2, K_1, K_2 \in \mathbb{R}^{N \times d}$ # $V \in \mathbb{R}^{N \times 2d}$ # And for Multi-Head: $h = d_{model} / (2d)$. Rearranging for d: $d = d_{model} / (2h)$. # In code: self.head_dim = embed_dim / (num_heads * 2). self.head_dim = embed_dim // num_heads // 2 # Scaling factor for attention scores, $1/\sqrt{d}$, as per Equation (1). self.scaling = self.head_dim ** -0.5 # --- Linear Projections for Q, K, V --- # These correspond to $W^Q, W^K, W^V$ in Equation (1) of the paper. # Bias is set to False, a common practice in modern Transformers (e.g., LLaMA), # and mentioned in Appendix B of the paper for their baseline Transformer. # Query projection: $XW^Q$. Projects `embed_dim` to `embed_dim`. # The output of this projection will be reshaped to form Q1 and Q2 components # for each of the `num_heads` differential attention heads. # Total projected query dim = num_heads * 2 * head_dim = embed_dim. self.q_proj = nn.Linear(embed_dim, embed_dim, bias=False) # Key projection: $XW^K$. Projects `embed_dim` to `embed_dim // n_rep`. # `embed_dim // n_rep` is equivalent to `num_kv_heads * 2 * head_dim`. # This provides the dimensions for K1 and K2 for each of the `num_kv_heads`. self.k_proj = nn.Linear(embed_dim, embed_dim // self.n_rep, bias=False) # Value projection: $XW^V$. Projects `embed_dim` to `embed_dim // n_rep`. # `embed_dim // n_rep` is equivalent to `num_kv_heads * 2 * head_dim`. # The paper states $V \in \mathbb{R}^{N \times 2d}$ per head. So for each of the `num_kv_heads`, # the value vector dimension is `2 * head_dim`. self.v_proj = nn.Linear(embed_dim, embed_dim // self.n_rep, bias=False) # Output projection: $W^O$ in Equation (3) of the paper. # Projects the concatenated head outputs back to `embed_dim`. self.out_proj = nn.Linear(embed_dim, embed_dim, bias=False) # --- Lambda Parameters for Differential Attention --- # These parameters are used to compute the learnable scalar $\lambda$ # as defined in Equation (2) of the paper: # $\lambda = \exp(\lambda_{q_1} \cdot \lambda_{k_1}) - \exp(\lambda_{q_2} \cdot \lambda_{k_2}) + \lambda_{init}$ # Static component $\lambda_{init}$, calculated based on layer depth. `depth` is current layer index. self.lambda_init = lambda_init_fn(depth) # Learnable vectors $\lambda_{q1}, \lambda_{k1}, \lambda_{q2}, \lambda_{k2} \in \mathbb{R}^{d}$ # where d is `self.head_dim`. # The initialization method (normal distribution with mean=0, std=0.1) is a # practical choice and not specified in the paper's core algorithm description. 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)) # --- Normalization Layer --- # This corresponds to $LN(head_i)$ in Equation (3) and is visualized as "GroupNorm" # in Figure 2 of the paper, applied independently to each head's output. # It's applied to the result of $(A_1 - \lambda A_2)V$ for each head. # The dimension of this per-head output is $2 \times \text{head\_dim}$ (the dimension of V for that head). # `eps=1e-5` is a standard epsilon value for RMSNorm. # `elementwise_affine=True` means RMSNorm has learnable gain and bias parameters. self.subln = RMSNorm(2 * self.head_dim, eps=1e-5, elementwise_affine=True) def forward( self, x: torch.Tensor, # Input tensor: (batch_size, sequence_length, embed_dim) rel_pos: tuple, # Positional embeddings (e.g., from RoPE). Passed as a tuple of (cos, sin) attn_mask: torch.Tensor =None, # Attention mask (e.g., for causal decoding) ): bsz, tgt_len, _ = x.size() # bsz: batch_size, tgt_len: target sequence length # embed_dim is also x.size(-1) but not explicitly captured from size() here. src_len = tgt_len # Assuming self-attention, or cross-attention where src_len == tgt_len # 1. Project Queries, Keys, Values # Paper Correspondence: $Q = XW^Q, K = XW^K, V = XW^V$ from Eq (1) (conceptually). # q, k, v here are the full projections before reshaping into heads and Q1/Q2 etc. q = self.q_proj(x) # Shape: (bsz, tgt_len, embed_dim) k = self.k_proj(x) # Shape: (bsz, src_len, embed_dim // n_rep) v = self.v_proj(x) # Shape: (bsz, src_len, embed_dim // n_rep) # 2. Reshape Q, K, V for Multi-Head Processing # Q: (bsz, tgt_len, 2 * num_heads, head_dim) # The `2 * num_heads` dimension effectively contains Q1 and Q2 components for all `num_heads`. q = q.view(bsz, tgt_len, 2 * self.num_heads, self.head_dim) # K: (bsz, src_len, 2 * num_kv_heads, head_dim) # The `2 * num_kv_heads` dimension contains K1 and K2 components for all `num_kv_heads`. k = k.view(bsz, src_len, 2 * self.num_kv_heads, self.head_dim) # V: (bsz, src_len, num_kv_heads, 2 * head_dim) # Each of the `num_kv_heads` has a value vector of dimension `2 * head_dim` (as V is $2d$ per head). v = v.view(bsz, src_len, self.num_kv_heads, 2 * self.head_dim) # 3. Apply Rotary Positional Embeddings (RoPE) # Paper Correspondence: RoPE is mentioned in experimental setups (e.g., Section 3.3) # but not in the core algorithm description in Section 2.1. Its use here is a # standard architectural choice for modern Transformers to inject positional information. # `interleaved=True` is a specific RoPE implementation detail. q = apply_rotary_emb(q, *rel_pos, interleaved=True) k = apply_rotary_emb(k, *rel_pos, interleaved=True) # Note: RoPE is typically applied after reshaping to (bsz, num_heads_total, seq_len, head_dim_component). # The current application is on q(bsz, tgt_len, 2*num_h, h_dim) and k(bsz, src_len, 2*num_kv_h, h_dim). # The apply_rotary_emb function must be compatible with this shape, likely operating on the last two dims. # `offset` is used for creating a causal mask if `attn_mask` is None. # For self-attention, src_len == tgt_len, so offset is 0. offset = src_len - tgt_len # 4. Transpose and Repeat K, V for GQA # Transpose Q to (bsz, 2 * num_heads, tgt_len, head_dim) q = q.transpose(1, 2) # Transpose K to (bsz, 2 * num_kv_heads, src_len, head_dim) then repeat for GQA. # Resulting K shape: (bsz, 2 * num_heads, src_len, head_dim) k = repeat_kv(k.transpose(1, 2), self.n_rep) # Transpose V to (bsz, num_kv_heads, src_len, 2 * head_dim) then repeat for GQA. # Resulting V shape: (bsz, num_heads, src_len, 2 * head_dim) v = repeat_kv(v.transpose(1, 2), self.n_rep) # At this point: # q: (bsz, 2 * num_heads, tgt_len, head_dim) -> Q1s and Q2s for all diff_heads # k: (bsz, 2 * num_heads, src_len, head_dim) -> K1s and K2s for all diff_heads (after GQA repeat) # v: (bsz, num_heads, src_len, 2*head_dim) -> Vs for all diff_heads (after GQA repeat) # 5. Compute Raw Attention Scores (before softmax) # This computes $Q K^T / \sqrt{d}$. q = q * self.scaling # Apply $1/\sqrt{d}$ scaling to queries # attn_weights shape: (bsz, 2 * num_heads, tgt_len, src_len) # This tensor contains the raw scores for both $Q_1K_1^T/\sqrt{d}$ and $Q_2K_2^T/\sqrt{d}$ # interleaved along the `2 * num_heads` dimension. attn_weights = torch.matmul(q, k.transpose(-1, -2)) # 6. Apply Attention Mask if attn_mask is None: # Create a causal mask if no mask is provided. # This prevents attention to future positions in a sequence. # `torch.triu` creates an upper triangle matrix. `diagonal=1+offset` ensures causality. # For self-attention (offset=0), diagonal is 1 (strict upper triangle). attn_mask = torch.triu( torch.zeros([tgt_len, src_len], device=attn_weights.device, dtype=torch.float) # Ensure same device .fill_(float("-inf")) # Fill with -infinity for masked positions .type_as(attn_weights), # Ensure same dtype as attn_weights 1 + offset, ) # This mask will be (tgt_len, src_len) and broadcastable. # Handle potential NaNs that might arise from masking or other operations. # This is a robustness measure. attn_weights = torch.nan_to_num(attn_weights) # Additive mask application. attn_weights = attn_weights + attn_mask # Additive mask # 7. Apply Softmax to get attention probabilities # Softmax is applied over the `src_len` dimension (dim=-1). # Using float32 for softmax computation can improve numerical stability, then cast back. attn_weights = F.softmax(attn_weights, dim=-1, dtype=torch.float32).type_as( attn_weights # Cast back to original type (e.g. float16 if using mixed precision) ) # attn_weights now contains softmax probabilities for both A1 and A2 components, interleaved. # Shape: (bsz, 2 * num_heads, tgt_len, src_len) # 8. Calculate the full lambda value (scalar) # Implements Equation (2) from the paper: # $\lambda = \exp(\lambda_{q_1} \cdot \lambda_{k_1}) - \exp(\lambda_{q_2} \cdot \lambda_{k_2}) + \lambda_{init}$ # The dot product `torch.sum(self.lambda_q1 * self.lambda_k1, dim=-1)` is over `head_dim`. # The result `lambda_full` is a scalar that will be shared by all heads in this layer. 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 # 9. Separate A1_probs and A2_probs and compute differential attention scores # Reshape attn_weights to explicitly separate the two components (A1 and A2) for each head. # (bsz, 2 * num_heads, tgt_len, src_len) -> (bsz, num_heads, 2, tgt_len, src_len) attn_weights = attn_weights.view(bsz, self.num_heads, 2, tgt_len, src_len) # Extract A1 probabilities (index 0 of the new dimension) # Extract A2 probabilities (index 1 of the new dimension) # Compute the differential attention scores: $A_1 - \lambda A_2$ # This is the core of the differential attention mechanism from Equation (1) of the paper. attn_weights = attn_weights[:, :, 0] - lambda_full * attn_weights[:, :, 1] # attn_weights shape now: (bsz, num_heads, tgt_len, src_len) # 10. Compute Weighted Sum with Values (V) # This calculates $(A_1 - \lambda A_2)V$ for each head. # attn_weights shape: (bsz, num_heads, tgt_len, src_len) # v (after GQA repeat): (bsz, num_heads, src_len, 2 * head_dim) # attn shape: (bsz, num_heads, tgt_len, 2 * head_dim) attn = torch.matmul(attn_weights, v) # 11. Apply Head-wise Normalization (RMSNorm) # Paper Correspondence: This is $LN(head_i)$ in Equation (3) and referred to as # GroupNorm in Figure 2 (implying normalization per head). # RMSNorm normalizes over the last dimension (which is $2 \times \text{head\_dim}$). attn = self.subln(attn) # attn shape: (bsz, num_heads, tgt_len, 2 * head_dim) # 12. Apply fixed scaling factor $(1 - \lambda_{init})$ # Paper Correspondence: This matches Equation (3): $\overline{head_i} = (1 - \lambda_{init}) \cdot LN(head_i)$. # This scaling is applied to align gradient flow with standard Transformers (Appendix G). attn = attn * (1 - self.lambda_init) # 13. Concatenate Heads and Reshape for Output Projection # Transpose to bring sequence length before heads: (bsz, tgt_len, num_heads, 2 * head_dim) # Reshape to combine head outputs into a single dimension: (bsz, tgt_len, num_heads * 2 * head_dim) # Since num_heads * 2 * head_dim = embed_dim, final shape is (bsz, tgt_len, embed_dim). # Paper Correspondence: This implements $Concat(\overline{head_1}, ..., \overline{head_h})$ from Eq (3). attn = attn.transpose(1, 2).reshape(bsz, tgt_len, self.num_heads * 2 * self.head_dim) # 14. Final Output Projection # Paper Correspondence: Multiplies by $W^O$ as in Equation (3). attn = self.out_proj(attn) # Shape: (bsz, tgt_len, embed_dim) return attn