长序列建模：六大方案效率大比拼

可视化演示

动态演示长序列建模的核心机制，通过输入/处理/存储/输出四种模式展示关键概念与交互流程。

标准注意力：全场大点名

假设你管理一条传送带，上面快速滑过 10 万件包裹。标准注意力就像一位极其认真的分拣员：每处理一件包裹，都要把它跟其余 9 万 9999 件逐一比对标签、确认关联。100 件包裹时，全场点名不过 1 万次，小意思；当包裹变成 5 万件，比对数冲上 25 亿，再勤劳的分拣员也顶不住。

在 Transformer 眼里，序列就是一排包裹，每个 token 有一个“姓名牌”——向量。注意力机制让每个 token 发出一个查询向量 Q，去匹配所有 token 的键向量 K，算出与谁最相关；再把相关度当权重，把值向量 V 加权融合回来。这套「全局两两交互」让任意两个词无论隔多远都能直接对话，也是 Transformer 建模能力的根基。

假设序列长度是 n、向量维度是 d，第一步就要构造 n×n 的相似度矩阵，里面有 n² 个格子要算、要存。时间和内存随之变成 O(n²·d) 与 O(n²)。序列 1024 个 token 时还算体面；到 16 384（16K）时，仅注意力矩阵按 float32 计算就要占约 1GB 显存，点积次数超过 2.6 亿——这就是长序列场景下“二次爆炸”的由来。

$$\displaystyle \text{Attention}(Q,K,V)=\text{softmax}\left(\frac{QK^{\mathsf{T}}}{\sqrt{d_k}}\right)V$$

1. 查询-键点积：每个查询向量与所有键向量两两点积，得到 n×n 的相似度矩阵。

$$QK^{\mathsf{T}}:\ \mathbb{R}^{n\times d}\times\mathbb{R}^{d\times n}\to\mathbb{R}^{n\times n}$$

2. 缩放稳定：除以 √d_k，防止维度增大时点积数值过大、softmax 梯度消失。

$$\frac{QK^{\mathsf{T}}}{\sqrt{d_k}}$$

3. 归一化权重：对每一行做 softmax，让所有注意力权重之和为 1。

$$\text{softmax}(x)_i=\frac{e^{x_i}}{\sum_j e^{x_j}}$$

4. 加权融合：用归一化后的权重对 V 加权求和，得到每个 token 的新表示。

$$\text{softmax}(\cdot)\cdot V\ \in\ \mathbb{R}^{n\times d}$$

所以标准注意力是“短文本的王者、长文本的瓶颈”。就像全场点名适合几十人的小型仓库，一旦到了双十一的十万级流水线，就必须把策略换掉。

稀疏注意力：给点名名单划重点

经理给分拣员出了个主意：别跟全仓库的人打招呼。传送带上的包裹有个规律——绝大多数只跟离自己最近的一小撮有关系：信封和里面的优惠券相关，跟 5 米外那箱轮胎八竿子打不着。于是规定：只比对相邻的包裹，再额外随机抽查几个远处的“重点包裹”，其他的统统略过。

这对应到稀疏注意力：在 n×n 的注意力矩阵上盖一层“掩码帘子” M，帘子上只有一小部分格子能透过光。放行的格子不是瞎挑的，而是遵循结构化规律——保留相邻格子照顾局部依赖，再按固定步长放行一些“全局锚点”照顾远程信息。被遮住的格子，相似度直接设为负无穷，经过 softmax 后权重为 0，计算也被跳过。

效率完全由帘子上透光的格子数量决定。设局部窗口宽 w、全局抽样步长 s，总连接数约为 O(n(w + n/s))；取 w 和 s 都等于 √n，复杂度降到 O(n√n)；若只留窗口加少量全局锚点，能进一步逼近 O(n)。Longformer、BigBird 就是靠这类掩码结构把序列长度推到几万级别的。

$$\displaystyle A' = M \odot \text{softmax}\left(\frac{QK^{\mathsf{T}}}{\sqrt{d_k}}\right),\qquad \|M\|_0 = O(n\sqrt{n})$$

1. 掩码矩阵：M 是与注意力矩阵同形状的 0-1 矩阵，1 表示放行、0 表示遮住。

$$M\in\{0,1\}^{n\times n}$$

2. 逐元素放行：用 ⊙ 做逐元素相乘，只有 M=1 的位置保留相似度。

$$(M\odot A)_{ij}=M_{ij}A_{ij}$$

3. 非零数量：掩码中 1 的总数就是实际计算的连接数，它决定复杂度。

$$\|M\|_0 = O(n\sqrt{n})$$

稀疏注意力像“重点抽查”，把长序列的计算量一下子拉了下来。但它有个隐忧：掩码是开工前就拍板的，万一真正重要的关系恰好落在被遮住的格子里，这份信息就永远丢了。省了力气，却可能漏掉关键线索。

线性注意力：先写摘要再查摘要

另一位分拣员想出更巧的办法：与其让每件包裹挨个认识全场，不如让每件包裹先在共享黑板上写一行“自我介绍”，汇总成一张整条流水线的摘要表。之后每件包裹只需读一次摘要表，就能大致掌握全局——认识世界的成本从“两两见面”降到了“读一张表”。

数学上，线性注意力用“核技巧”改写 softmax 里的 QKᵀ：把 q、k 先映射到新空间 φ(q)、φ(k)，再用内积近似原来的相似度。关键转折在于：乘法的顺序可以交换。先对所有键做“键-值聚合”，得到一个与序列长度无关的小矩阵；再让每个查询去读这个小矩阵——这就是“先写摘要、再查摘要”。

具体地说，先算 d×d 的聚合矩阵 S = Σⱼ φ(kⱼ)vⱼᵀ，它把整条序列压缩成一张“摘要”；之后每个查询只需做 O(d²) 的矩阵乘法，不必再遍历所有 n 个键。时间从 O(n²d) 降到 O(nd²)，在 d 固定时就是 O(n)。Performer、Linear Transformer 等模型都走这条路。

$$\displaystyle \text{Attn}_i = \frac{\phi(q_i)^{\mathsf{T}}\sum_{j=1}^{n}\phi(k_j)v_j^{\mathsf{T}}}{\phi(q_i)^{\mathsf{T}}\sum_{j=1}^{n}\phi(k_j)}$$

1. 特征映射：用核函数 φ 把 q、k 映射到更高维的特征空间。

$$\phi(q_i),\ \phi(k_j)$$

2. 键值聚合：先对所有 j 求和，把“键-值对”整体压缩成 d×d 的摘要矩阵。

$$S=\sum_{j=1}^{n}\phi(k_j)v_j^{\mathsf{T}}$$

3. 查询读出：查询只需与摘要矩阵相乘，不再依赖具体某个键。

$$\phi(q_i)^{\mathsf{T}} S$$

4. 分母归一化：用所有键的特征和做归一化，模拟 softmax 的分母。

$$z = \phi(q_i)^{\mathsf{T}}\sum_{j=1}^{n}\phi(k_j)$$

但摘要终究是摘要：它丢失了“哪个键在哪个位置”的精确对齐——就像黑板写着“全场有 30 件红色包裹”，却没法告诉某件包裹红色包裹具体在哪个传送带、离它多远。这就是线性注意力的“信息瓶颈”：快，但细节被磨平了。

滑动窗口：只跟眼前的包裹搭档

如果包裹之间的相关性高度“局部化”——一句话里，每个词主要跟前后的词发生关系——那干脆把注意力圈在一个移动的小窗口里好了。分拣员只看一臂之内的包裹，够得着就比对，够不着就放过。

滑动窗口注意力为每个 token 保留左右各 w 个邻居，窗口之外的键直接不看。复杂度从 O(n²) 瞬间掉到 O(n·w)，其中 w 是超参数，通常取 256 或 512，远小于 n。它押注的先验是：自然语言、图像、音频里，相邻元素的关系远比远处元素紧密——“猫”和“抓”往往只隔几个字。

窗口虽小，信息却可以通过堆层“接力”传播：第一层里 1 号 token 和 5 号不直接相连，但第二层窗口如果相对错开一点，两层之后感受野就能覆盖到更远的距离，这和卷积网络的原理如出一辙。代价也随之而来：远程信息要经过许多跳才能抵达，传递中强度和精度都会打折，这就是“远程传播衰减”。

$$\displaystyle \text{Attn}(q_i)=\text{softmax}\left(\frac{q_i^{\mathsf{T}}K_{[i-w:i+w]}}{\sqrt{d_k}}\right)V_{[i-w:i+w]}$$

1. 截取窗口：取第 i 个 token 前后各 w 个键和值，形成局部片段。

$$K_{[i-w:i+w]},\ V_{[i-w:i+w]}$$

2. 窗口内匹配：只在 2w+1 个键上计算相似度并做 softmax。

$$\frac{q_i^{\mathsf{T}}K_{[i-w:i+w]}}{\sqrt{d_k}}$$

3. 总复杂度：n 个 token 各算 2w 次，合计约为 O(nw)。

$$n\times 2w = O(nw),\quad w\ll n$$

滑动窗口是工业界的“性价比之选”，不少长文本模型都用它当骨干。它的哲学像是与邻为伴——把大部分精力留给身边的包裹，偶尔抬头眺望全局，但绝不同全仓库每个人都深交。

循环机制：一人一笔记，顺序接力

还有一位分拣员，不用黑板也不用点名。他手里只攥着一个小笔记本，从流水线头走到尾：每路过一件包裹就停下来读一读，然后在笔记本上更新一行“到目前为止的全局印象”。走完全程，本子还是那本本子，但字迹记录下了整条线的精华。

这就是循环机制的本质：用一个固定大小的状态向量 hₜ 压缩从第 1 到第 t 个 token 的全部历史。每一步只做一次状态更新 hₜ = f(hₜ₋₁, xₜ)，想了解过去，读一下当前状态即可，不需要回头翻任何旧 token。因此内存占用始终是 O(d) 的常数，与序列长度 n 彻底脱钩。

代价同样醒目：状态必须“一步赶一步”地更新，第 t 步严格依赖第 t-1 步，没法像窗口、分块那样把 n 个 token 摊给 GPU 的几千个核并行算。再长的序列也只能串行处理，训练效率上不占优；更麻烦的是，信息在反复“压缩—传递”中不断损耗，越早出现的 token 越容易被遗忘——最早的包裹留下的印象，常常最模糊。

$$\displaystyle h_t = f(h_{t-1}, x_t),\qquad o_t = g(h_t)$$

1. 状态更新：用上一步的状态和当前输入，算出一个新的状态向量。

$$h_t = f(h_{t-1}, x_t)$$

2. 输出生成：每一步从当前状态中读出本轮输出。

$$o_t = g(h_t)$$

3. 恒定内存：全程只维护一个 d 维向量，内存与序列长度无关。

$$O(d)$$

循环机制像“一个人从头干到尾”的管理方式：内存极小、思路连贯，但没法靠加人手提速，记性也不太好。它启发了一众新架构（如 RWKV、状态空间模型）把序列当“流”来处理，至今仍是超长序列的一条重要路线。

分块注意力：小组内部开会，组长对外碰头

既然全场点名太累、两人传话太慢，能不能把流水线切成若干小组？每组 8 件或 16 件包裹，组内做完整的“两两核对”，组与组之间只通过每组的“组长摘要”交换信息。开会效率：组内人人签到，组外只听汇报。

分块注意力正是这个思路：把 n 个 token 切成长度为 b 的若干个块，每个块内部跑标准全连接注意力；为了让块间信息流动起来，每个块的开头会放几个“边界 token”（或从块内提取摘要向量），让所有块在算注意力时都能“看见”这些共享的边界信息。

复杂度很容易算：每块内部是 b² 次两两交互，共有 n/b 个块，合计 O(n·b)；再叠加块间边界的少量开销，整体远低于 O(n²)。分块方案还特别“工程友好”——它不改注意力算子本身，只是把大矩阵切成小矩阵，可以完整复用高度优化的 flash-attention 内核，做长文本预训练非常顺手。

$$\displaystyle \text{Block}_i = \text{Attention}\left(Q_i,\ [K_i; K_{\text{bnd}}],\ [V_i; V_{\text{bnd}}]\right)$$

1. 块划分：把 n 个 token 切成 c = n/b 个长度 b 的块。

$$n = c\times b$$

2. 拼接边界：把共享的边界 token 的键值拼到块内序列上。

$$[K_i; K_{\text{bnd}}],\ [V_i; V_{\text{bnd}}]$$

3. 块内注意力：在每个块内部执行标准 softmax 注意力。

$$\text{Block}_i = \text{Attention}(Q_i, \cdot, \cdot)$$

4. 总复杂度：c 个块 × 每块 b² 次交互，得 O(nb)。

$$\frac{n}{b}\times b^2 = O(nb)$$

分块像是现代公司管理：小组内部充分协作，小组之间靠管理层对齐。它在“看得全”和“算得快”之间找到了不错的折中点，因此成为当下长文本模型最主流的主干方案之一，而且常与滑动窗口混着用——块内开窗，块间放锚点。

复杂度对比：六张账单摆上桌

六种方案都讲完了，该把账单摊到桌上算总账。就像六个分拣方案在双十一当天同时试跑，我们记两笔账：一笔是“干活耗时的增长曲线”（时间复杂度），一笔是“占用的场地大小”（内存占用）。

理论复杂度是选型的罗盘——它告诉我们当 n 变大时，成本是“爬山”还是“缓坡”。把六种方案并排放进一张表，谁在超长序列下会爆炸，谁还能从容呼吸，一目了然。

| 方案 | 时间复杂度 | 内存占用 | 全局建模能力 |

|---|---|---|---|

| 标准注意力 | O(n²·d) | O(n²) | ★★★ |

| 稀疏注意力 | O(n√n·d) | O(n√n) | ★★☆ |

| 线性注意力 | O(n·d²) | O(n·d) | ★★☆ |

| 滑动窗口 | O(n·w·d) | O(n·w) | ★☆☆ |

| 循环机制 | O(n·d²) | O(d) | ★★☆ |

| 分块注意力 | O(n·b·d) | O(n·b) | ★★☆ |

表格是理论，落到真实 GPU 上还要看常数因子与工程实现。标准注意力拥有一套深度优化的 flash-attention 内核，实际跑起来可能比“纸面更快却缺乏优化”的方案还利索；线性注意力的矩阵乘法也可能因为算子不熟而跑不满硬件。所以正确的姿势是：用理论复杂度定方向，用实测基准定细节。

$$\displaystyle O(n^2)\ \gg\ O(n\sqrt{n})\ \gg\ O(nw)\sim O(nb)\ \gtrsim\ O(n)$$

1. 二次阶梯：n² 随序列长度二次爆炸，属于成本最高的悬崖。

$$O(n^2)$$

2. 中间阶梯：n√n 是“半程登山”，比平方缓和，但仍是亚二次里的高位。

$$O(n\sqrt{n})$$

3. 线性阶梯：当 w、b 是固定常数时，窗口与分块都是 O(n)。

$$O(nw)\sim O(nb)\sim O(n)$$

4. 常数系数：循环与线性纯属 O(n)，区别仅在隐藏常数与并行度。

$$O(n)$$

回到流水线：当 n=100 时，全场点名可能是最快的方案，因为省掉了所有组织成本；当 n=10 万时，点名方案直接瘫痪，只有写摘要、看邻居这类线性方案还能喘气。复杂度曲线说了一句朴素的话：序列越长，越要压连接。

选型指南：不同仓库选不同策略

既然没有银弹，管理者要学会“看菜下饭”：你的仓库有多少件包裹（序列长度）？客户要不要“全场关联”的结论（全局建模需求）？场地多大（显存）？多少个分拣员能同时上阵（并行度）？

一个实用的经验法则是：n 不超过 2K 时，直接上标准注意力，简单又强；2K 到 10K，优先考虑滑动窗口和分块注意力，它们对长文档、长视频都够用且稳健；超过 10K 甚至到 100K 的超长序列，线性注意力、循环机制或稀疏全局锚点这类“亚线性”方案才值得出手。

同时要掂量任务性质：需要精确指代关系与远程检索（比如长文档问答），标准/稀疏注意力更稳；需要流式逐 token 输出（比如实时转录），循环机制更顺手。现实世界极少单打独斗——主流长文本模型普遍是“混合架构”：局部窗口 + 全局稀疏锚点，或者浅层滑窗 + 深层全连接。选型不是六选一，而是把六种材料按需拼装。

$$\displaystyle \text{方案} \approx \begin{cases} \text{标准注意力} & n \leq 2000 \\ \text{滑动窗口/分块} & 2000 < n < 10000 \\ \text{线性/循环} & n \geq 10000 \end{cases}$$

1. 短序列区间：n 不超过 2K 时，标准注意力复杂度可接受且效果最好。

$$n \leq 2000 \Rightarrow \text{标准注意力}$$

2. 中长序列区间：2K 到 10K 之间，用滑窗或分块平衡效率与全局性。

$$2000 < n < 10000 \Rightarrow \text{滑动窗口/分块}$$

3. 超长序列区间：超过 10K 时，只有线性注意力和循环机制能撑住成本。

$$n \geq 10000 \Rightarrow \text{线性/循环机制}$$

最后回到那句话：没有最好的注意力，只有最合适的注意力。管理者的智慧，是看清自己仓库的规模与需求，在“看得全”和“算得快”之间，找到那个精妙的平衡点。

AI 应用场景

Python 演示

import numpy as npimport time rng = np.random.default_rng(42)D = 32  def softmax_attention(q, k, v):    s = q @ k.T / np.sqrt(D)    w = np.exp(s - s.max(axis=-1, keepdims=True))    w /= w.sum(axis=-1, keepdims=True)    return w @ v  def sliding_attention(q, k, v, w=8):    n = q.shape[0]    out = np.zeros_like(q)    for i in range(n):        lo, hi = max(0, i - w), min(n, i + w + 1)        s = q[i] @ k[lo:hi].T / np.sqrt(D)        s = np.exp(s - s.max())        s /= s.sum()        out[i] = s @ v[lo:hi]    return out  def linear_attention(q, k, v):    phi = lambda x: np.maximum(x, 0.0) + 0.01    s = phi(k).T @ v    z = phi(k).sum(axis=0)    y = phi(q) @ s    return y / (phi(q) @ z)[:, None]  def chunked_attention(q, k, v, b=8):    n = q.shape[0]    out = np.zeros_like(q)    for i in range(0, n, b):        out[i:i + b] = softmax_attention(q[i:i + b], k[i:i + b], v[i:i + b])    return out  def bench(fn, q, k, v, reps=20):    fn(q, k, v)    t0 = time.perf_counter()    for _ in range(reps):        fn(q, k, v)    return (time.perf_counter() - t0) / reps * 1000  def main():    print("n\t标准(ms)\t滑窗(ms)\t线性(ms)\t分块(ms)")    for n in [64, 128, 256, 512]:        q = rng.normal(size=(n, D))        k = rng.normal(size=(n, D))        v = rng.normal(size=(n, D))        t = [bench(softmax_attention, q, k, v),             bench(sliding_attention, q, k, v),             bench(linear_attention, q, k, v),             bench(chunked_attention, q, k, v)]        print(f"{n}\t" + "\t".join(f"{x:.3f}" for x in t))  if __name__ == "__main__":    main()

1. s = q @ k.T / np.sqrt(D)一步算出 n×n 相似度矩阵，这是标准注意力二次复杂度的根源。
2. phi = lambda x: np.maximum(x, 0.0) + 0.01用 ReLU 变体做核函数，把点积替换成特征空间内积。
3. s = phi(k).T @ v线性注意力的灵魂：先把所有键值聚合，与序列长度无关的摘要矩阵就此诞生。
4. y = phi(q) @ s每个查询只需读一次摘要，复杂度从 O(n²) 降到 O(n)。
5. out[i] = s @ v[lo:hi]滑窗只在局部片段上做 softmax 加权融合。
6. out[i:i + b] = softmax_attention(q[i:i + b], k[i:i + b], v[i:i + b])分块方案直接复用标准注意力，工程上最省事。
7. for n in [64, 128, 256, 512]:用递增长度观察各方案耗时的增长斜率，n 翻倍时标准注意力约慢 4 倍，线性方案只慢 2 倍。
8. return (time.perf_counter() - t0) / reps * 1000多次计时取平均，减少系统噪声，让对比更可信。

常见误区

面试题