D3Medium★ 工业基石 (核心高频)Part D · 注意力机制与 Transformer 核心组件

GQA / MQA 分组查询注意力(共享 KV 头)

⚡闪卡盲测➔

大幅降低自回归解码阶段 KV Cache 显存占用的关键创新,MHA 到 MQA 的完美折中。

⏱️ 时间复杂度: O(B * H_q * S^2 * D_k) 计算量微弱节省
💾 空间复杂度: KV Cache 显存开销降为原先的 H_kv / H_q
🎯 免登录实战自测闭环(先做再看答案)
按「机制回忆 → 关键行填空 → 边界反例 → 追问与错题记录」顺序自测,进度自动保存在本地。
Step 1 · 机制口述与数值稳定性自检
Step 2 · 核心代码关键行补全
import numpy as np
def repeat_kv(x: np.ndarray, num_rep: int) -> np.ndarray:
"""
将 KV 头重复展开以对齐 Query 头的数量。
x 形状: (B, H_kv, S, D_k)
返回: (B, H_q, S, D_k),其中 H_q = H_kv * num_rep
"""
if num_rep == 1:
return x
B, H_kv, S, D_k = x.shape
# 增加扩展维度并广播
x =
x = np.repeat(x, num_rep, axis=2) # (B, H_kv, num_rep, S, D_k)
return x.reshape(B, H_kv * num_rep, S, D_k)
def grouped_query_attention(
q: np.ndarray, # (B, H_q, S, D_k)
k: np.ndarray, # (B, H_kv, S, D_k)
v: np.ndarray, # (B, H_kv, S, D_k)
is_causal: bool = True
) -> np.ndarray:
B, H_q, S, D_k = q.shape
H_kv = k.shape[1]
assert H_q % H_kv == 0, "Query 头数必须是 KV 头数的整数倍"
num_rep = H_q // H_kv
# 将 KV 广播扩展为与 Q 头数相同
k_expanded = repeat_kv(k, num_rep) # (B, H_q, S, D_k)
v_expanded = repeat_kv(v, num_rep) # (B, H_q, S, D_k)
# 执行常规多头注意力点积
scores = np.matmul(q, k_expanded.swapaxes(-1, -2)) / np.sqrt(D_k)
if is_causal:
mask = np.triu(np.ones((S, S), dtype=bool), k=1)
scores = np.where(mask, -1e9, scores)
scores_max = np.max(scores, axis=-1, keepdims=True)
probs = np.exp(scores - scores_max)
probs /= np.sum(probs, axis=-1, keepdims=True)
return
Step 3 · 反例与边界断言核对
Step 4 · 面试追问盲答与错题记录
Q1: DeepSeek-V2 / V3 提出的 MLA(Multi-Head Latent Attention)相比 GQA 又带来了什么突破?
下一题: KV Cache 自回归生成推理(增量更新与状态拼接) →
💡

实战一句话记忆口诀

头多显存吃不消,多组共享一组刀,广播对齐算点积,显存直缩四分之一

📐 核心数学公式与机理推导

HQ 个 Query 头分为 G 组,每组共享 1 个 Key/Value 头,KV 显存缩减至 1HQ/HKVH_Q \text{ 个 Query 头分为 } G \text{ 组,每组共享 } 1 \text{ 个 Key/Value 头,KV 显存缩减至 } \frac{1}{H_Q / H_{KV}}
### KV Cache 带宽墙与架构演进
在大模型推理生成时,瓶颈不在于算力(FLOPS),而在于显存访存带宽(Memory Bandwidth Bound)。每次自回归生成 1 个 Token,都要将全量上下文的 KV Cache 从 HBM 读到 SRAM。
- MHA(标准多头):HQ=HKVH_Q = H_{KV},每个 Q 头拥有独立的 KV 头,显存占用大;
- MQA(Multi-Query Attention):HKV=1H_{KV} = 1,所有 Q 头共享同一个单一的 Key/Value 头,显存降到最低,但表达能力略有折损;
- GQA(Grouped-Query Attention):将 HQH_Q 个 Query 头均匀划分为 GG 个组,每个组内共享一个 KV 头(即 HKV=GH_{KV} = G)。
在 LLaMA-2-70B、LLaMA-3(HQ=32,HKV=8H_Q=32, H_{KV}=8)中,KV Cache 显存直接缩减为原先的 14\frac{1}{4},同时性能无损。

🔄 张量维度与形状流转说明

k: (B, H_kv, S, D_k) -> repeat_kv -> (B, H_q, S, D_k) -> 与 q: (B, H_q, S, D_k) 点积 -> (B, H_q, S, D_k)

🛡️ 数值稳定性自检与边界要点

  • 在实际底层 CUDA / Triton 实现中,无需物理上执行 repeat 显存拷贝,直接在读取指针寻址时做模运算索引即可
  • KV Cache 存储时只需存储原始的 H_kv 形状,显存占用严格减少为 H_kv / H_q

💻 完整参考代码实现

import numpy as np

def repeat_kv(x: np.ndarray, num_rep: int) -> np.ndarray:
    """
    将 KV 头重复展开以对齐 Query 头的数量。
    x 形状: (B, H_kv, S, D_k)
    返回: (B, H_q, S, D_k),其中 H_q = H_kv * num_rep
    """
    if num_rep == 1:
        return x
    B, H_kv, S, D_k = x.shape
    # 增加扩展维度并广播
    x = x[:, :, np.newaxis, :, :]  # (B, H_kv, 1, S, D_k)
    x = np.repeat(x, num_rep, axis=2)  # (B, H_kv, num_rep, S, D_k)
    return x.reshape(B, H_kv * num_rep, S, D_k)

def grouped_query_attention(
    q: np.ndarray,      # (B, H_q, S, D_k)
    k: np.ndarray,      # (B, H_kv, S, D_k)
    v: np.ndarray,      # (B, H_kv, S, D_k)
    is_causal: bool = True
) -> np.ndarray:
    B, H_q, S, D_k = q.shape
    H_kv = k.shape[1]
    assert H_q % H_kv == 0, "Query 头数必须是 KV 头数的整数倍"
    num_rep = H_q // H_kv
    
    # 将 KV 广播扩展为与 Q 头数相同
    k_expanded = repeat_kv(k, num_rep)  # (B, H_q, S, D_k)
    v_expanded = repeat_kv(v, num_rep)  # (B, H_q, S, D_k)
    
    # 执行常规多头注意力点积
    scores = np.matmul(q, k_expanded.swapaxes(-1, -2)) / np.sqrt(D_k)
    if is_causal:
        mask = np.triu(np.ones((S, S), dtype=bool), k=1)
        scores = np.where(mask, -1e9, scores)
    
    scores_max = np.max(scores, axis=-1, keepdims=True)
    probs = np.exp(scores - scores_max)
    probs /= np.sum(probs, axis=-1, keepdims=True)
    return np.matmul(probs, v_expanded)

🧪 本地测试与正确性断言

可直接复制到本地 Python / Jupyter 验证:

import numpy as np
B, S, D_k = 2, 4, 8
H_q = 8
H_kv = 2  # 4 个 Q 头共享 1 个 KV 头
q = np.random.randn(B, H_q, S, D_k)
k = np.random.randn(B, H_kv, S, D_k)
v = np.random.randn(B, H_kv, S, D_k)
out = grouped_query_attention(q, k, v)
assert out.shape == (B, H_q, S, D_k), "输出形状不正确"
print("✓ GQA 分组查询注意力自测通过")

🎯 核心工程追问与标准应答

Q1:DeepSeek-V2 / V3 提出的 MLA(Multi-Head Latent Attention)相比 GQA 又带来了什么突破?
GQA 是直接在头维度上做简单共享,仍需存储完整精度的特征;MLA 则是使用低秩矩阵分解将 Key 和 Value 联合压缩为一个极小的隐层潜变量(Latent Vector),并在解压前结合解耦 RoPE,将 KV Cache 压缩比推至前所未有的极限(约为原生 MHA 的 1/10 显存)。
⚡
想检验本题的肌肉记忆?进入 3 阶闪卡主动回忆盲测
隐藏答案遮罩,自测:审题锚点 ➔ 数理公式机理 ➔ 工业标杆代码与连环追问。3 分钟攻破认知盲区!
🎯 立即在闪卡中盲测此题➔
← 上一题: Multi-Head Attention 多头注意力(MHA 分头与拼接)返回 Part D 与全部 105 题下一题: KV Cache 自回归生成推理(增量更新与状态拼接) →