mcy98's picture
Upload folder using huggingface_hub
2d13eb2 verified
Raw History Blame Contribute Delete
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