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

KV Cache 自回归生成推理(增量更新与状态拼接)

⚡闪卡盲测➔

将自回归推理复杂度由 O(S^2) 降至 O(S) 的工程生命线,Prefill 预填充与 Decode 增量步骤实现。

⏱️ 时间复杂度: Decode 单步计算复杂度仅 O(S * D),极大加速生成速度
💾 空间复杂度: O(B * H * S * D) 随序列长度线性持久驻留显存
🎯 免登录实战自测闭环(先做再看答案)
按「机制回忆 → 关键行填空 → 边界反例 → 追问与错题记录」顺序自测,进度自动保存在本地。
Step 1 · 机制口述与数值稳定性自检
Step 2 · 核心代码关键行补全
import numpy as np
class KVCacheManager:
def __init__(self, max_seq_len: int, num_heads: int, head_dim: int):
self.max_seq_len =
self.num_heads = num_heads
self.head_dim = head_dim
self.current_len = 0
# 预分配连续显存 Buffer: (B, H, max_S, D_k)
self.k_cache = None
self.v_cache = None
def step(self, q_t: np.ndarray, k_t: np.ndarray, v_t: np.ndarray) -> np.ndarray:
"""
单步自回归更新。
参数:
q_t: (B, H, 1, D_k) 单个当前 Token 的 Query
k_t: (B, H, 1, D_k) 当前 Token 的 Key
v_t: (B, H, 1, D_k) 当前 Token 的 Value
返回:
out_t: (B, H, 1, D_k)
"""
B = q_t.shape[0]
if self.k_cache is None:
self.k_cache = np.zeros((B, self.num_heads, self.max_seq_len, self.head_dim), dtype=q_t.dtype)
self.v_cache = np.zeros((B, self.num_heads, self.max_seq_len, self.head_dim), dtype=v_t.dtype)
pos = self.current_len
assert pos < self.max_seq_len, "超出最大序列缓存上限"
# 1. 写入当前时间步数据
self.k_cache[:, :, pos:pos+1, :] = k_t
self.v_cache[:, :, pos:pos+1, :] = v_t
self.current_len += 1
# 2. 截取有效历史: (B, H, current_len, D_k)
k_valid = self.k_cache[:, :, :self.current_len, :]
v_valid = self.v_cache[:, :, :self.current_len, :]
# 3. 单步点积注意力: (B, H, 1, D_k) @ (B, H, D_k, current_len) -> (B, H, 1, current_len)
scores = np.matmul(q_t, k_valid.swapaxes(-1, -2)) / np.sqrt(self.head_dim)
# 注意:此处 q_t 为最新 Token,它能看到所有已存在的历史,因此无需再加因果掩码!
scores_max = np.max(scores, axis=-1, keepdims=True)
exp_s = np.exp(scores - scores_max)
attn_probs = exp_s / np.sum(exp_s, axis=-1, keepdims=True)
# 4. 加权聚合: (B, H, 1, current_len) @ (B, H, current_len, D_k) -> (B, H, 1, D_k)
return
Step 3 · 反例与边界断言核对
Step 4 · 面试追问盲答与错题记录
Q1: PagedAttention 如何解决原生 KV Cache 的显存碎片与分配开销?
下一题: Cross-Attention 跨模态/跨序列注意力 →
💡

实战一句话记忆口诀

预填存全局,生成走单步,缓存切片点点积,单步零掩因果聚

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

Knew=Concat(Kpast,Kt),Vnew=Concat(Vpast,Vt),Qt∈RB×1×DK_{\text{new}} = \mathrm{Concat}(K_{\text{past}}, K_t), \quad V_{\text{new}} = \mathrm{Concat}(V_{\text{past}}, V_t), \quad Q_t \in \mathbb{R}^{B \times 1 \times D}
### 从二次重复计算到增量缓存
在因果自回归生成第 tt 个词时:
- QtQ_t 仅代表当前的第 tt 个词向量(长度为 1);
- 它需要和历史所有 1∼t1 \sim t 个位置的 Key 发生点积,并对所有 Value 进行加权。
如果每次都将前 t−1t-1 个词重新输入前向网络,计算复杂度将从 1+2+⋯+N=O(N2)1 + 2 + \dots + N = O(N^2) 爆炸。
KV Cache 解法:
1. Prefill 阶段(首字生成):输入完整的 Prompt(长度为 SS),一次性计算并保存所有位置的 K,VK, V 放入全局缓存;
2. Decode 阶段(逐步生成):每次只传入新生成的单个 Token(S=1S=1),只计算该单一位置的 qt,kt,vtq_t, k_t, v_t;
3. 将 kt,vtk_t, v_t 追加拼接至缓存,此时 qtq_t 与整个 KpastK_{\text{past}} 进行点积求和得到当前输出。单步复杂度从 O(t)O(t) 降为仅需单次向量矩阵乘。

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

单步输入: q_t, k_t, v_t: (B, H, 1, D_k) -> 写入 cache[pos] -> 截取 valid: (B, H, current_len, D_k) -> 点积加权 -> (B, H, 1, D_k)

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

  • Decode 单步时,Query 只有一个词,所有已缓存历史均在其之前,因此在单步推断中因果掩码天然满足,无需增加 triu 掩码矩阵
  • 在实际大模型服务框架(如 vLLM)中,为解决动态增长内存碎片问题,普遍采用 PagedAttention 虚拟分页内存管理

💻 完整参考代码实现

import numpy as np

class KVCacheManager:
    def __init__(self, max_seq_len: int, num_heads: int, head_dim: int):
        self.max_seq_len = max_seq_len
        self.num_heads = num_heads
        self.head_dim = head_dim
        self.current_len = 0
        
        # 预分配连续显存 Buffer: (B, H, max_S, D_k)
        self.k_cache = None
        self.v_cache = None
        
    def step(self, q_t: np.ndarray, k_t: np.ndarray, v_t: np.ndarray) -> np.ndarray:
        """
        单步自回归更新。
        参数:
            q_t: (B, H, 1, D_k) 单个当前 Token 的 Query
            k_t: (B, H, 1, D_k) 当前 Token 的 Key
            v_t: (B, H, 1, D_k) 当前 Token 的 Value
        返回:
            out_t: (B, H, 1, D_k)
        """
        B = q_t.shape[0]
        if self.k_cache is None:
            self.k_cache = np.zeros((B, self.num_heads, self.max_seq_len, self.head_dim), dtype=q_t.dtype)
            self.v_cache = np.zeros((B, self.num_heads, self.max_seq_len, self.head_dim), dtype=v_t.dtype)
            
        pos = self.current_len
        assert pos < self.max_seq_len, "超出最大序列缓存上限"
        
        # 1. 写入当前时间步数据
        self.k_cache[:, :, pos:pos+1, :] = k_t
        self.v_cache[:, :, pos:pos+1, :] = v_t
        self.current_len += 1
        
        # 2. 截取有效历史: (B, H, current_len, D_k)
        k_valid = self.k_cache[:, :, :self.current_len, :]
        v_valid = self.v_cache[:, :, :self.current_len, :]
        
        # 3. 单步点积注意力: (B, H, 1, D_k) @ (B, H, D_k, current_len) -> (B, H, 1, current_len)
        scores = np.matmul(q_t, k_valid.swapaxes(-1, -2)) / np.sqrt(self.head_dim)
        
        # 注意:此处 q_t 为最新 Token,它能看到所有已存在的历史,因此无需再加因果掩码!
        scores_max = np.max(scores, axis=-1, keepdims=True)
        exp_s = np.exp(scores - scores_max)
        attn_probs = exp_s / np.sum(exp_s, axis=-1, keepdims=True)
        
        # 4. 加权聚合: (B, H, 1, current_len) @ (B, H, current_len, D_k) -> (B, H, 1, D_k)
        return np.matmul(attn_probs, v_valid)

🧪 本地测试与正确性断言

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

import numpy as np
kv_mgr = KVCacheManager(max_seq_len=10, num_heads=2, head_dim=4)
B = 1
# 模拟自回归生成 3 个 Token
for t in range(3):
    q_t = np.random.randn(B, 2, 1, 4)
    k_t = np.random.randn(B, 2, 1, 4)
    v_t = np.random.randn(B, 2, 1, 4)
    out_t = kv_mgr.step(q_t, k_t, v_t)
    assert out_t.shape == (B, 2, 1, 4)
assert kv_mgr.current_len == 3
print("✓ KV Cache 增量自回归推理自测通过")

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

Q1:PagedAttention 如何解决原生 KV Cache 的显存碎片与分配开销?
原生连续预分配内存必须预留每个请求的最大可能长度(如 4k),造成巨大的显存空闲浪费(内部碎片),且随着批次释放存在物理断裂(外部碎片)。PagedAttention 借鉴操作系统虚拟内存思想,将 KV Cache 拆成固定大小的物理块(Block,如 16 个 Token 一页),通过逻辑块到物理块的分页映射表按需动态挂载,将显存浪费率从 >60% 压降至 <4%。
⚡
想检验本题的肌肉记忆?进入 3 阶闪卡主动回忆盲测
隐藏答案遮罩,自测:审题锚点 ➔ 数理公式机理 ➔ 工业标杆代码与连环追问。3 分钟攻破认知盲区!
🎯 立即在闪卡中盲测此题➔
← 上一题: GQA / MQA 分组查询注意力(共享 KV 头)返回 Part D 与全部 105 题下一题: Cross-Attention 跨模态/跨序列注意力 →