Sparse Attention：让Transformer处理超长序列

可视化演示

展示Dense全注意力矩阵O(n²)与Sparse稀疏模式（条纹型/块状/轴向）的连接结构对比及复杂度优化效果，切换模式理解超长序列注意力降本原理。

注意力复杂度困境

设想你举办一场盛大的答谢宴，请了 100 位宾客。如果规则要求“每位宾客都必须与在场所有宾客逐一握手寒暄”，那么全场要完成接近 5000 次握手；宾客加到 1000 人，握手次数飙到约 50 万次；加到 10000 人，就是接近 5000 万次。宾客规模稍有增长，人力预算就彻底失控。这不是策划不努力，而是规则本身决定了成本呈平方级暴增。

Transformer 的自注意力也是同样的“全员寒暄”协议。序列中的每个 Token（可以理解为一个词或一个图像块）都要和所有其他 Token 互相打听“你是什么内容”，再按相关性加权汇总所有人的信息。Token 数量翻倍时，注意力得分矩阵从 \( n \times n \) 变成 \( 2n \times 2n \)，计算量和显存占用都要翻 4 倍。这就是为什么处理一篇 8000 Token 的长文档时，全连接注意力会立刻让 GPU 显存告急。

在具体实现中，注意力机制把每个 Token 编码成三个向量：Query（我想找什么）、Key（我是什么）、Value（我能提供什么）。通过 Query 与所有 Key 做点积，得到一张 \( n \times n \) 的“相关度表”，再按相关度加权求和 Value。这张表的规模和平方级复杂度，构成了 Transformer 处理长序列时的最大瓶颈。

宴会策划方被“全员握手”的规则压得喘不过气。要破局，就不能再让每位宾客和所有人寒暄，而必须修改社交规则本身——这正是稀疏注意力登场的理由。

稀疏模式设计

精明的主办方决定改规则：不再强制全员寒暄，而是给每位宾客发一张“社交清单”，上面明确列出应该与哪些人交谈。只要清单设计得合理，交流效率就能大幅提升，宾客也不会因为被冷落而抱怨。

Sparse Attention 就是给注意力机制发清单。它提前规定每个 Token 只与哪些位置的 Token 交互，这些连接模式是固定且结构化的，不是随机决定，所以既能大幅压缩计算量，又不至于丢失关键信息。所谓“稀疏”，指的就是注意力矩阵中只有少部分位置允许有值，其余位置直接跳过，不参与计算。

实现上最常见的手段是掩码（mask），也就是一张“许可名单”：允许的连接位置记为有效，其余位置在计算时被屏蔽。每个 Token 平均只关注 \( s(n) \) 个位置，总计算量就从 \( O(n^2) \) 降到了 \( O(n \times s(n)) \)。下面要讲的条纹型、块状、轴向三种模式，就是三张风格迥异的“社交清单”。

“社交清单”决定了宴会的成本，也决定了你会错过哪些消息。接下来三种模式，正是对“该跟谁聊”这个问题的三种不同回答。

条纹型稀疏

宴会现场的宾客按长条座椅排成一行。主办方规定：每位宾客只需要和前后左右 \( w \) 个座位的宾客交流。离得太远的人，就让邻座替我传话——这样既省了体力，又不至于完全脱离社交网络。

条纹型稀疏，也叫滑动窗口注意力（Sliding Window Attention）。每个 Token 只与位于它前后 \( w \) 范围内的 Token 计算注意力，反映在注意力矩阵上，就是只保留沿主对角线延伸的一条“条纹”。窗口之外的位置一律屏蔽，复杂度主要取决于窗口宽度 \( w \)，而不是序列总长 \( n \)。

文本数据天然具有强大的局部性：一个词和紧挨着它的几个词之间的相关性，远高于和十万八千里外的词的相关性。因此条纹型在语言建模中性价比极高。同时，通过叠加多层滑窗注意力，每一层的感受野会逐步扩大，远处信息可以通过中间 Token 一格格“接力”传递过来，不必依赖单层的直接连接。

这就像长桌宴上的“邻座接力”：虽然离得远的宾客素未谋面，但一句话通过若干位邻座的口耳相传，最终能传遍全场。条纹型用最小的社交成本，保住了消息在局部范围内的快速流通。

块状稀疏

主办方这次的方案是把宴席分成若干张圆桌。每位宾客只需与本桌其他宾客寒暄，跨桌交流一概省略。想认识其他桌的朋友？请同桌的“话痨”代为引荐，或者等服务员上菜时顺便带句话。

块状稀疏（Blockwise Sparse Attention）把序列切分成固定大小的块，每个 Token 只与本块内的 Token 交互。它和条纹型的关键区别在于：块状看重的是“同组归属”，而不是“空间距离近”。两个 Token 哪怕物理上离得很远，只要被分到同一个块，依然可以建立直接连接。

在工程实现上，块状模式天然适合 GPU 的矩阵分块乘法。GPU 会把数据按块加载到片上内存，块内的完整注意力矩阵正好可以用高性能矩阵运算一次算完，避免频繁的显存随机访问。因此块状稀疏在不牺牲太多信息的前提下，通常能达到比条纹型更高的硬件吞吐。

分桌制让宴会成本从“全员寒暄”骤降为“同桌寒暄”，代价是跨桌信息被切断。因此，块的大小和位置选择，永远是与数据语义相互妥协的结果——下一节我们会看到另一种更聪明的妥协方式。

轴向稀疏

如果宴会宾客不是坐长条桌，而是整整齐齐排成方形方阵——就像婚礼草坪上按列摆放的椅子——主办方可以采取一个更巧妙的做法：第一轮交流，每位宾客只与同一排的宾客握手；第二轮交流，每位宾客只与同一列的宾客点头致意。两轮下来，每个人都能接收到来自整行和整列的信息，相当于覆盖了整个方阵。

轴向稀疏注意力（Axial Attention）就是专门针对这种二维乃至高维结构设计的。普通注意力会把一张 \( H \times W \) 的特征图强行拉成一维序列，序列长度立刻变成 \( HW \)，在全连接模式下开销是 \( (HW)^2 \)，完全不可接受。轴向注意力把它拆成两次一维注意力：一次沿高度轴（对每一行做序列注意力），一次沿宽度轴（对每一列做序列注意力）。

用一个 64×64 的图像特征图举例：全连接注意力需要对 4096 个 Token 两两计算，而轴向方案只需要先做 64 次长度为 64 的行注意力，再做 64 次长度为 64 的列注意力。总计算量从 \( O(16M) \) 级别降到了 \( O(4096 \times 128) \)，足足省了两三个数量级。这也是视觉 Transformer 和图像生成模型常用的稀疏策略。

方阵宾客用“横排握手 + 竖排点头”完成了对全场的间接覆盖。当数据自带天然的二维结构时，轴向方案几乎就是为它量身定做的社交礼仪。

实践选型与对比

最终宴会策划组要拍板：用邻座寒暄（条纹）、同桌寒暄（块状）还是方阵接力（轴向）？答案取决于宾客怎么坐、来宾名单有多长，以及你雇得起多少服务员——也就是 GPU 算力与显存预算。

一句话选型原则：文本与长文档通常优先选条纹型或块状；图像、视频等高维数据优先选轴向；若担心全局信息缺失，可以额外加几个全局 Token 作为“主持人”，让所有人只跟主持人广播。三种模式也可以组合拼接，设计出自适应混合方案，但复杂度也随之上升。

从计算量看，条纹型 \( O(nw) \) 在短距离依赖强的文本上性价比最高；块状 \( O(nb) \) 的 GPU 吞吐通常更好；轴向 \( O(HW(H+W)) \) 在高分辨率视觉任务上优势显著。从精度看，主流稀疏注意力模型都能把性能控制在接近全注意力的水平，远优于简单粗暴的随机丢弃。真正决定上限的，是所选稀疏模式与数据分布是否匹配。

三种“寒暄方案”没有绝对优劣。宴会的最终效果取决于策划者是否读懂了宾客结构：长桌宴席用邻座接力，圆桌酒会用同桌寒暄，方阵草坪用横竖点头——稀疏注意力的选型，本质上就是一场关于结构与预算的匹配游戏。

AI 应用场景

Python 演示

import numpy as np def dense_attention(Q, K, V):    # 全连接注意力: 每个 token 与所有 token 交互    scores = Q @ K.T    weights = np.exp(scores - scores.max(axis=-1, keepdims=True))    weights = weights / weights.sum(axis=-1, keepdims=True)    return weights @ V def stripe_attention(Q, K, V, w=3):    # 条纹型稀疏: 每个 token 只关注前后 w 个邻居    n = Q.shape[0]    out = np.zeros_like(V)    for i in range(n):        lo = max(0, i - w)        hi = min(n, i + w + 1)        idx = np.arange(lo, hi)        s = Q[i] @ K[idx].T        p = np.exp(s - s.max())        p = p / p.sum()        out[i] = p @ V[idx]    return out def block_attention(Q, K, V, b=8):    # 块状稀疏: 每个 token 只关注同一块内的 token    n = Q.shape[0]    out = np.zeros_like(V)    for i in range(n):        blk = (i // b) * b        hi = min(n, blk + b)        idx = np.arange(blk, hi)        s = Q[i] @ K[idx].T        p = np.exp(s - s.max())        p = p / p.sum()        out[i] = p @ V[idx]    return out def count_connections(n, mode, **kw):    # 统计各种模式的连接总数, 用于对比计算量    if mode == 'dense':        return n * n    if mode == 'stripe':        return n * (2 * kw.get('w', 3) + 1)    if mode == 'block':        return n * kw.get('b', 8)    return 0 if __name__ == '__main__':    N, D = 64, 16    rng = np.random.default_rng(0)    Q = rng.standard_normal((N, D))    K = rng.standard_normal((N, D))    V = rng.standard_normal((N, D))     outs = {        'dense': dense_attention(Q, K, V),        'stripe': stripe_attention(Q, K, V, w=3),        'block': block_attention(Q, K, V, b=8),    }    for name, o in outs.items():        print(name, 'output shape:', o.shape)     conns = {        'dense': count_connections(N, 'dense'),        'stripe': count_connections(N, 'stripe', w=3),        'block': count_connections(N, 'block', b=8),    }    print('connections:', conns)

1. scores = Q @ K.T一次性算出所有 Token 两两间的相关度得分，形成 \( n \times n \) 矩阵。
2. weights = weights / weights.sum(axis=-1, keepdims=True)对每一行做归一化，等价于 Softmax 的数值稳定版本。
3. lo = max(0, i - w); hi = min(n, i + w + 1)把关注范围裁剪到窗口内，避免索引越界。
4. idx = np.arange(lo, hi)用索引切片代替全量矩阵，只让当前 Token 和窗口内 Key 做点积。
5. blk = (i // b) * b计算当前 Token 所属块的起始下标，实现“同块相连、跨块断开”。
6. count_connections快速估算三种模式各产生多少连接，n=64 时分别是 4096、448、512。

常见误区

面试题