注意力机制

本页介绍深度学习中的注意力机制（Attention Mechanism）：它最初是为了解决 seq2seq 翻译的长句瓶颈而提出的，后来发展为自注意力，成为 Transformer（见 Transformer 架构）的核心组件。理解注意力机制是理解现代大模型的前提。

阅读建议：本文面向”计算机专业但第一次接触 AI”的读者。遇到不熟悉的术语（向量内积、归一化、梯度等）可先翻到本页末尾的术语表查阅，正文中也会在术语首次出现时给出一两句内联解释。

核心直觉

注意力的本质极其简单：加权平均。面对一堆信息，模型学会”看哪里、各看多少”，然后按权重把它们融合成一个向量。三种关键形态：

• seq2seq 瓶颈（2014 之前）：编码器（encoder，把输入序列编码为向量的网络）把整句话压缩成一个固定向量，解码器（decoder，逐个生成输出词的网络）只能靠这一个向量工作——句子一长就记不住开头。Bahdanau 等人的破局思路：不要只取最后状态，而是把编码器所有时刻的状态加权融合，解码时每生成一个词，动态决定该”关注”编码器的哪些位置。
• 注意力分数 = 相关度打分：用一个函数衡量”当前查询 q”和”每个候选信息 k_i”有多相关，得到一组分数，softmax 归一化（normalize，即缩放成加起来等于 1 的概率分布）成权重，再用权重对所有信息 v_i 做加权平均。
• 自注意力 vs 交叉注意力：自注意力（self-attention）是”自己看自己”——同一个序列内部各位置互相打分；交叉注意力（cross-attention）是”看别人”——解码器去看编码器的输出。注意力机制本身只是一种”动态加权聚合”的通用算子（operator，可理解为一种可计算的数学运算）。

一个生活类比：你在图书馆找资料。你心里有一个”问题”（Query），每本书的封面标题是”键”（Key），书的内容是”值”（Value）。你用问题和每本书的标题对比，越相关的书你越仔细看——注意力机制就是把这个”按相关度分配精力”的过程变成了可学习的数学运算。

原理图解

注意力机制的核心流程

三种注意力打分函数

打分方式	公式（纯文本）	特点
Dot-product（点积）	score(q, k) = q · k	最简单，计算最快，Transformer 用的就是它（再除以 √d 缩放）
General（通用）	score(q, k) = q^T W k	在 q 和 k 之间加一个可学习矩阵 W，更灵活
Additive（加性，Bahdanau 原版）	score(q, k) = v^T tanh(W1 q + W2 k)	用一个小前馈网络算分，适合 q 和 k 维度不同的场景

向量内积（dot product）是什么？ 两个等长向量对应位置相乘再求和，例如 [1,2]·[3,4] = 1×3 + 2×4 = 11。它衡量两个向量的”方向相似度”——越相似值越大。注意力的打分本质上就是在算”查询向量和键向量的相似度”。

Softmax 的数学推导

Softmax 把任意实数分数转换成一组加起来等于 1 的正数权重，可看作”软”版的 max（取最大值）。对分数向量 $z = [z_1, z_2, \ldots, z_n]$，其定义为：

$$\text{softmax}(z_i) = \frac{\exp(z_i)}{\sum_j \exp(z_j)}$$

为什么用指数函数 exp？ 三个原因：

1. 保证为正：exp 对任何实数输入都返回正数，适合做概率。
2. 放大差距：指数函数对大值进一步放大，让”最相关”的项获得明显更高的权重，起到类似”软 argmax”的效果。
3. 可微（differentiable）：exp 的导数仍是 exp，这对用梯度下降（gradient descent，即沿误差减少方向逐步调整参数的训练方法）训练模型至关重要——可微意味着梯度（gradient，即函数变化率）处处存在且容易计算。

softmax 的雅可比矩阵（Jacobian，输出对输入的偏导数矩阵）推导：令 $s_i = \text{softmax}(z_i)$，对 $z_j$ 求偏导：

• 当 $i = j$：$\frac{\partial s_i}{\partial z_j} = s_i(1 - s_i)$
• 当 $i \neq j$：$\frac{\partial s_i}{\partial z_j} = -s_i \cdot s_j$

写成矩阵形式：$\mathbf{J} = \text{diag}(\mathbf{s}) - \mathbf{s} \cdot \mathbf{s}^T$。这个公式在反向传播（backpropagation，从输出往输入逐层传递梯度的算法）中会反复用到，是注意力层梯度计算的基础。

数值稳定的 softmax 实现：当 z 中某个值很大时，exp(z) 会溢出（overflow）。标准技巧是先减去最大值——这不改变结果（分子分母同乘一个常数约掉），但把所有指数的输入压到 ≤ 0：

def softmax_stable(z):
    z = z - np.max(z)          # 减去最大值，防止 exp 溢出
    exp_z = np.exp(z)
    return exp_z / np.sum(exp_z)

为什么除以 √d_k？——完整的数学解释

为什么 Transformer 要除以 √d？ 这或许是初学者最容易”记下公式却不懂原因”的一个细节。下面给出严格的概率推导。

假设查询向量 q 和键向量 k 的各分量是独立同分布（i.i.d.）的随机变量，均值为 0、方差为 1（这是神经网络初始化后常见的情形——权重矩阵的初始设计就是让输入输出的方差稳定）。它们的点积 q·k 是 d_k 个独立项的乘积之和：

$$\text{score} = \sum_{i=1}^{d_k} q_i \cdot k_i$$

每项 q_i·k_i 的均值为 0（因为 E[q_i]·E[k_i] = 0），方差为 1（两个独立标准正态变量乘积的方差）。由方差的可加性：

$$\text{Var}(\text{score}) = d_k \quad\quad \text{sd}(\text{score}) = \sqrt{d_k}$$

当 d_k 很大（如 64 或 128）时，score 的标准差会很大，导致点积的绝对值经常很大。而 softmax 在输入值很大时，输出会接近 one-hot（一个 1、其余全是 0），进入饱和区——此时梯度（∂s_i/∂z_j）几乎为零（因为 s_i≈1 或 ≈0 时雅可比矩阵元素都趋近于 0），训练就停滞了。

除以 √d_k 恰好让方差恢复到 1：

$$\text{Var}\left(\frac{\text{score}}{\sqrt{d_k}}\right) = \frac{\text{Var}(\text{score})}{d_k} = 1$$

这就是 “scaled” dot-product attention 中缩放（scale）的数学依据——让分数的数值范围在训练全程保持稳定，避免 softmax 饱和。这也解释了为什么打分函数表里说”Transformer 用的就是它（再除以 √d 缩放）”。

自注意力 vs 交叉注意力

权重矩阵（weight matrix）是什么？ 神经网络中可学习的二维参数数组，形状如”输入维度 × 输出维度”。输入向量乘以权重矩阵（矩阵乘法）就完成了一次线性变换——这正是神经网络”学习”的核心载体。在注意力中，原始输入先经过三个不同的权重矩阵 W_Q、W_K、W_V 投影成 Q、K、V。

多头注意力的维度计算

多头注意力（Multi-Head Attention，MHA）把 Q、K、V “拆”成 h 份并行算注意力再拼回来。理解维度变换是看懂 Transformer 实现的关键。设模型维度 d_model = 512、头数 h = 8：

输入 X : (seq_len, 512)
   │  乘以 W_Q / W_K / W_V（各 512×512）
   ▼
Q, K, V : 各 (seq_len, 512)
   │  reshape 成 (seq_len, 8, 64) 再转置成 (8, seq_len, 64)
   ▼                    ↑ 每个头维度 d_k = 512/8 = 64
每个头独立做 Scaled Dot-Product Attention
   │  output_i : (seq_len, 64)，共 8 个
   ▼
拼接 concat : (seq_len, 512)   ← 8 个 (seq_len,64) 沿最后一维拼回 512
   │  乘以输出权重矩阵 W_O (512×512)
   ▼
最终输出 : (seq_len, 512)

关键等式：d_model = h × d_k。每个头的维度 d_k = d_model / h。总参数量和计算量与单头注意力基本相当——多头不是”更贵”，而是”更多视角”。实践中 d_k 常取 64 或 128，h 取 8、16 或 32。

动手实践

numpy 手写 Scaled Dot-Product Attention

注意力最核心的 10 行：查询 q、键 k、值 v，算分数 → softmax → 加权平均。

import numpy as np

def softmax(x, axis=-1):
    x = x - np.max(x, axis=axis, keepdims=True)  # 数值稳定：减最大值防溢出
    return np.exp(x) / np.sum(np.exp(x), axis=axis, keepdims=True)

def attention(Q, K, V):
    d_k = K.shape[-1]                  # 键向量维度
    scores = Q @ K.T / np.sqrt(d_k)    # 1. 缩放点积打分
    weights = softmax(scores)          # 2. softmax 归一化为权重
    output = weights @ V               # 3. 用权重对 V 加权平均
    return output, weights

# 假设序列长度 3，向量维度 4
Q = K = V = np.random.randn(3, 4)
out, w = attention(Q, K, V)
print("权重矩阵（每行加起来 = 1）:\n", np.round(w, 3))
# 某次输出示例:
# [[0.576 0.211 0.213]
#  [0.249 0.423 0.328]
#  [0.255 0.337 0.408]]

权重矩阵的第 i 行表示”第 i 个词把多少注意力分给了每个词”。对角线通常较大（自己最像自己），但模型会学到把注意力分给真正相关的词——这正是 Transformer 能捕捉长距离依赖的关键。

numpy 手写多头注意力（Multi-Head Attention）

把上面的单头逻辑扩展成多头，理解维度变换：

import numpy as np

def softmax(x, axis=-1):
    x = x - np.max(x, axis=axis, keepdims=True)
    return np.exp(x) / np.sum(np.exp(x), axis=axis, keepdims=True)

def scaled_dot_product_attention(Q, K, V):
    d_k = Q.shape[-1]
    scores = Q @ K.swapaxes(-2, -1) / np.sqrt(d_k)   # (..., seq, seq)
    weights = softmax(scores, axis=-1)
    return weights @ V                                # (..., seq, d_v)

def multi_head_attention(X, W_Q, W_K, W_V, W_O, num_heads):
    # X: (seq_len, d_model),  W_*: (d_model, d_model)
    seq_len, d_model = X.shape
    d_k = d_model // num_heads

    # 1. 线性投影
    Q = X @ W_Q   # (seq_len, d_model)
    K = X @ W_K
    V = X @ W_V

    # 2. reshape 成 (num_heads, seq_len, d_k)
    def split_heads(t):
        return t.reshape(seq_len, num_heads, d_k).transpose(1, 0, 2)
    Q, K, V = split_heads(Q), split_heads(K), split_heads(V)

    # 3. 每个头独立做注意力
    attn_out = scaled_dot_product_attention(Q, K, V)  # (num_heads, seq_len, d_k)

    # 4. 拼接回 (seq_len, d_model)
    concat = attn_out.transpose(1, 0, 2).reshape(seq_len, d_model)

    # 5. 输出投影
    return concat @ W_O

# 演示
d_model, num_heads, seq_len = 8, 2, 4
np.random.seed(0)
X    = np.random.randn(seq_len, d_model)
W_Q  = np.random.randn(d_model, d_model) * 0.1
W_K  = np.random.randn(d_model, d_model) * 0.1
W_V  = np.random.randn(d_model, d_model) * 0.1
W_O  = np.random.randn(d_model, d_model) * 0.1
out  = multi_head_attention(X, W_Q, W_K, W_V, W_O, num_heads)
print("MHA 输出形状:", out.shape)   # (4, 8)

PyTorch 对照：内置 API 的等价写法

实际工程中你几乎不会手写上面的代码，而是用 PyTorch 内置算子（速度更快、数值更稳定）：

import torch
import torch.nn.functional as F

# PyTorch 2.0+ 的融合 SDPA 算子，底层自动调用 FlashAttention 加速
Q = torch.randn(2, 8, 10, 64)   # (batch, heads, seq_len, d_k)
K = torch.randn(2, 8, 10, 64)
V = torch.randn(2, 8, 10, 64)

output = F.scaled_dot_product_attention(Q, K, V)
print(output.shape)  # torch.Size([2, 8, 10, 64])

scaled_dot_product_attention（SDPA）算子：PyTorch 2.0 引入的融合（fused）实现——把打分、缩放、softmax、加权平均编译成一个高效的 GPU kernel（底层计算单元），避免反复读写显存。它会根据硬件和张量形状自动选择 FlashAttention、memory-efficient attention 或朴素实现。

加入因果掩码（Causal Mask）——GPT 类自回归模型的关键

自回归（autoregressive，即”根据已生成内容预测下一个词”）模型在解码时不能”看到未来”，需要用一个三角掩码（mask）把未来位置的注意力分数设为负无穷，softmax 后这些位置权重为 0：

import numpy as np

def causal_attention(Q, K, V):
    d_k = K.shape[-1]
    scores = Q @ K.T / np.sqrt(d_k)

    # 构造下三角掩码：上三角（未来位置）设为 -inf
    mask = np.triu(np.ones_like(scores, dtype=bool), k=1)
    scores = np.ma.array(scores, mask=mask).filled(-np.inf)

    weights = softmax(scores)
    return weights @ V

这个掩码机制正是 GPT/LLaMA 等大语言模型能”一个词一个词往后生成”的底层保障。

训练技巧与工程实践

• 缩放不能省：哪怕 d_k 只有 16，忘记除以 √d_k 在深层网络里也可能导致训练不稳定。现代框架的 SDPA 算子默认已包含缩放，但如果你手写注意力层，务必记得。
• 初始化要控制方差：W_Q、W_K、W_V 的初始化要让投影后的 Q、K 方差稳定在 1 附近，否则缩放的数学前提（“假设 q_i、k_i 方差为 1”）就不成立了。常用 Xavier 或 Kaiming 初始化。
• dropout 的位置：注意力权重（softmax 之后）上加 dropout（随机丢弃一部分神经元，防过拟合的正则化手段）是 Transformer 的标配，dropout 率常用 0.1。注意 dropout 要在 softmax 之后、加权平均之前。
• padding 掩码（padding mask）：批处理（batch）时短序列要补零（pad），但注意力不应关注 padding 位置——把这些位置的分数设为 -∞ 即可。这与因果掩码是两套独立的掩码逻辑。
• 梯度检查（gradient checking）：如果你自己实现了一个新的注意力变体，务必用 PyTorch 的 torch.autograd.gradcheck 验证反向传播梯度是否正确——注意力层的梯度推导极易出错。
• 混合精度训练（mixed precision / fp16 / bf16）：现代大模型几乎都在半精度（16 位浮点）下训练。bfloat16（bf16）比 float16（fp16）动态范围更大，更适合注意力的数值范围，推荐优先使用。softmax 内部仍建议用 fp32 累加以保证数值稳定。

实践要点

• 注意力 ≠ 自注意力：注意力是一个通用机制（谁看谁都行），自注意力是其特例（同一序列内部互看）。Bahdanau 最早用的是解码器→编码器的交叉注意力。
• 多头注意力 = 多个独立的注意力头并行：一个头可能学到”语法关注”（关注主语），另一个学到”语义关注”（关注相关名词）。Transformer 用 8 或 16 个头，各看不同侧面。
• 复杂度是 O(n²)：n 个位置两两打分，所以原始自注意力在超长序列上很贵。后续的稀疏注意力、线性注意力（Longformer、FlashAttention 等）就是来缓解这个问题的——详见下方 2025–2026 进展。
• 注意力权重 ≠ 可解释性：很多人以为注意力权重代表”模型看哪里所以这么决策”，但研究表明权重和最终预测的关系很微妙，不能简单当作因果解释。

典型应用

• 机器翻译对齐（Bahdanau 2014 / Luong 2015）：最早的用途。翻译”the cat sat on the mat”时，生成”猫”那一刻注意力集中在”cat”上，生成”垫子”时集中在”mat”上——这解决了 RNN 长句遗忘问题，翻译质量大幅提升。
• 图像描述生成（Show, Attend and Tell 2015）：生成每个英文词时，注意力决定”看图的哪个区域”。生成”鸟”时关注鸟的主体区域，生成”树枝”时关注背景——让模型能定位并描述图像内容。
• Transformer 的基石：2017 年 Vaswani 等人发现，把 RNN 整个丢掉、纯用自注意力堆叠，效果反而更好且能完全并行训练。这就是 Transformer，后来的一切（BERT、GPT、ViT、CLIP）都建立在注意力之上。
• 文档问答 / 阅读理解：给定一篇长文和问题，注意力让模型”定位”到文中包含答案的句子再抽取答案，这是早期 QA 系统的核心范式。
• 视觉 Transformer（ViT）：把图像切成小方块（patch），每个 patch 当作一个”词”，用自注意力让 patch 之间互相关注——这套思路让 Transformer 从自然语言跨界到了计算机视觉。

2025–2026 的最新进展

注意力机制在 2024-2026 年经历了一轮”效率革命”，核心矛盾始终是：O(n²) 复杂度限制了上下文长度，而大模型又迫切需要更长的上下文。下面是几个值得关注的方向。

高效注意力内核：FlashAttention 系列与 Ring Attention

FlashAttention（2022 起，Dao 等人）通过”分块计算 + 避免中间矩阵落地显存”把注意力的显存读写量大幅降低，让同样的 GPU 能训练更长序列。

• FlashAttention-2（2023）：优化了并行度和 warp 级调度，速度比 v1 再快约 2 倍，已成为主流大模型训练的默认配置。
• FlashAttention-3（2024，针对 Hopper 架构 H100 GPU）：利用异步化（asynchronous，让不同计算单元并行工作）和低精度（fp8）进一步把速度推到接近硬件理论上限，是 2025 年训练超长上下文模型（如 Gemini、GPT-4 级）的关键基础设施。
• Ring Attention / Strip Attention（2023-2025）：把超长序列切分到多张 GPU 上，各 GPU 按环形拓扑传递 K/V 块，实现”跨设备序列并行”。这让单次前向能处理百万级 token 的上下文（如 Gemini 1.5 的 100 万 token 窗口）。

KV Cache 与注意力变体：MQA、GQA、MLA

在自回归生成（inference）阶段，已生成部分的 K 和 V 可以缓存（cache）起来避免重算，这就是 KV Cache。但 KV Cache 随序列长度线性增长，在长上下文 + 大批量推理时成为显存瓶颈，于是出现了”让多个查询头共享同一组 K/V”的变体：

变体	全称	做法	代表模型
MHA	Multi-Head Attention	每个查询头有独立的 K/V 头（原始方案）	Transformer, BERT
MQA	Multi-Query Attention	所有查询头共享同一组 K/V，大幅省显存但略降质量	PaLM, Falcon
GQA	Grouped-Query Attention	把查询头分成若干组，组内共享 K/V——MHA 与 MQA 的折中	LLaMA 2/3, Mistral
MLA	Multi-head Latent Attention	把 K/V 压缩成低秩潜变量再展开，显存效率更高	DeepSeek-V2/V3

为什么这些变体很重要？ 大模型推理时的成本和延迟主要由 KV Cache 的显存占用决定。GQA 已成为 2024-2025 年开源大模型的事实标准（LLaMA 3、Mistral、Qwen 等几乎都用 GQA），它在”质量几乎不降”的前提下把 KV Cache 压缩到原来的 1/h（h 为组数）。

稀疏注意力与线性注意力

为了突破 O(n²)：

• 滑动窗口注意力（Sliding Window Attention）：每个位置只关注周围固定大小（如 4096）的窗口，复杂度降到 O(n)。Mistral、Gemma 等模型采用，配合分层堆叠可兼顾局部精度与长序列。
• Native Sparse Attention（NSA，DeepSeek 2025）：把”粗粒度全局 + 细粒度局部 + 选择性压缩”三路注意力融合，在不损失质量的前提下把超长上下文（128K+）的推理成本降一个数量级，是 2025 年长上下文方向的重要进展。
• 线性注意力（Linear Attention）：用核函数（kernel trick）把 softmax(QK^T)V 改写成可结合的形式，把复杂度从 O(n²) 降到 O(n)。缺点是表达能力通常弱于标准 softmax 注意力。

注意力的挑战者：状态空间模型（SSM）与混合架构

2024-2025 年最重要的架构辩论之一：注意力是否是唯一的长序列建模方案？

• Mamba / S4 等状态空间模型（State Space Model, SSM）：用一条可学习的”状态通道”替代注意力，推理时是纯 RNN 式的 O(1) 每步计算，长序列效率极高。Mamba（2023）让 SSM 在语言建模上首次接近 Transformer。
• 混合架构（Hybrid Architecture）：2024-2025 年的趋势是”不二选一”——在同一模型里交替堆叠注意力层和 SSM/Mamba 层。代表如 Jamba（AI21）、Zamba（Zyphra）以及部分 GPT-4 级闭源模型据传也采用混合设计。注意力负责全局关联，SSM 负责高效的长程传递，各取所长。
• 但注意力还没被取代：截至 2025-2026，主流大规模预训练（frontier-scale pretraining）仍以注意力 + GQA/FlashAttention 为主导，SSM/混合架构在小到中规模和特定任务（长文本、语音）上表现亮眼，但尚未在大规模通用预训练上全面超越纯 Transformer。

给初学者的建议：先彻底搞懂标准的缩放点积注意力——上面这些变体和挑战者，本质上都是在”质量 vs 效率 vs 实现复杂度”三角之间做不同的取舍。理解了原版，再去看这些进展会事半功倍。

典型类库与工具

类库	语言	说明
PyTorch nn.MultiheadAttention	Python	内置的多头注意力实现，支持因果掩码、键值 padding 掩码
torch.nn.functional.scaled_dot_product_attention	Python	PyTorch 2.0+ 的融合 SDPA 算子，自动启用 FlashAttention 加速
flash-attn（FlashAttention）	Python	Dao 等人维护的高效注意力库，支持长序列、多 GPU，2025 年最新为 v3
transformers (HuggingFace)	Python	注意力权重可视化、注意力头分析工具一应俱全
bertviz	Python	专门可视化 Transformer 注意力头的交互式工具
einops	Python	用爱因斯坦求和简化多头注意力的张量变换
triton	Python	OpenAI 的 GPU kernel DSL，FlashAttention 即用 Triton 实现，自定义高效注意力算子的首选

术语表

术语	英文	解释
注意力机制	Attention	对一组信息按相关度加权融合的通用机制
查询/键/值	Query / Key / Value	注意力的三要素：Q 是当前查询，K 用于打分，V 是被加权的内容
向量内积	Dot Product / Inner Product	两个等长向量对应位置相乘再求和，衡量方向相似度
缩放点积注意力	Scaled Dot-Product Attention	Transformer 的核心算子：softmax(QK^T/√d) V
自注意力	Self-Attention	Q、K、V 来自同一序列，序列内部位置互相关注
交叉注意力	Cross-Attention	Q 来自一个序列（如解码器），K/V 来自另一个序列（如编码器）
多头注意力	Multi-Head Attention	多组独立注意力并行计算，各自学习不同的关注模式
加性注意力	Additive Attention	Bahdanau 原版打分方式，用前馈网络计算相关度
权重矩阵	Weight Matrix	神经网络中可学习的二维参数数组，完成线性变换
归一化	Normalization	把数值缩放到某个固定范围（如加起来等于 1）的运算
梯度	Gradient	函数输出对输入的偏导数，指示参数该往哪个方向调整以降低误差
反向传播	Backpropagation	从输出层往输入层逐层计算梯度的算法，是训练神经网络的核心
softmax	Softmax	把一组实数转成”加起来等于 1 的正数概率分布”的函数
因果掩码	Causal Mask	自回归解码时屏蔽”未来”位置的三角掩码，保证只能看到已生成内容
KV Cache	KV Cache	自回归推理时缓存已计算过的 K/V，避免重复计算、加速生成
分组查询注意力	Grouped-Query Attention (GQA)	多个查询头共享一组 K/V 头，平衡质量与显存效率，LLaMA 3 等主流模型采用
状态空间模型	State Space Model (SSM)	用递推状态通道替代注意力的架构，推理高效，Mamba 是其代表
FlashAttention	FlashAttention	通过分块和减少显存读写来加速注意力的 GPU kernel，2025 年最新为 v3

延伸阅读

• Bahdanau et al. (2014) “Neural Machine Translation by Jointly Learning to Align and Translate”：注意力机制的奠基论文，解决 seq2seq 翻译的瓶颈问题。
• Luong et al. (2015) “Effective Approaches to Attention-based Neural Machine Translation”：提出 dot-product 和 general 两种更简单的打分方式。
• Vaswani et al. (2017) “Attention Is All You Need”：纯注意力堆叠的 Transformer，彻底取代 RNN。深入解析见 Transformer 架构。
• Dao et al. (2022-2024) FlashAttention / FlashAttention-2 / FlashAttention-3 系列：高效注意力硬件实现，是现代大模型长上下文训练的基石。
• Ainslie et al. (2023) “GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints”：分组查询注意力的提出，现已成为开源大模型标配。
• DeepSeek-AI (2025) Native Sparse Attention 论文：超长上下文稀疏注意力的最新进展。
• Gu & Dao (2023) Mamba 论文：状态空间模型对注意力架构的有力挑战。
• Transformer 的完整讲解见 Transformer 架构；RNN 与 seq2seq 的背景见 RNN 循环神经网络；序列建模的整体背景见 深度学习概览。