Download annotations/annotation_2/Diff-Transformer/multihead_diffattn.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 19.3 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_2/Diff-Transformer/multihead_diffattn.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_2/Diff-Transformer/multihead_diffattn.py
-
curl -L -o multihead_diffattn.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_2/Diff-Transformer/multihead_diffattn.py
19.3 kB
| # === 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 | |