深度解读 📅 2026-11-21 ✍️ MagicNetWorld 编辑部

把注意力摊平成矩阵:SSM 与注意力的对偶,以及 Mamba-2 快在哪

选择性状态空间模型(SSM)常被当成「另一种 RNN」,其实它的递推、卷积、矩阵三种写法在数学上是同一件事:当衰减对状态维是标量时,整段前向就是一个下三角半可分矩阵乘输入。本文从连续时间方程推到离散递推,说明 Mamba 的「选择性」为什么让卷积失效、Mamba-2 又为什么能把计算还给矩阵乘:把状态矩阵约束成标量乘单位阵后,矩阵可以分块,块内是下三角遮罩的 Q×Q 矩阵乘,块间只传一次状态。文中 FLOP 与状态体积的数字按公式现算(注意力与 SSM 的交叉点在序列长度等于状态维数),三种算法的一致性用纯 numpy 实算验证,最大绝对误差 ≤6.7e-16;全部为解析/模拟结果,非真机实测。

状态空间模型Mamba线性注意力长上下文推理成本

先把账摆出来:为什么有人想换掉注意力

生成第 tt 个 token 时,注意力要把前面所有 token 的 Key 和 Value 都读一遍:单个 Query 与 LL 个 Key 做内积约 2Ld2Ld 次乘加,再对 Value 加权求和又约 2Ld2Ld,合计约 4Ld4Ld。这是单步 decode 的账。若一次算完整段 LL 个 token(训练或 prefill),每个 token 都要与全部历史比对,单层单头的总量才是 4L2d4L^2d——序列翻倍,整段计算翻四倍。两个口径差一个 LL 因子,后文表格用的是后者。

状态空间模型(State Space Model,下称 SSM)走的是另一条路:它把「历史」压成一个固定大小的状态向量,每来一个新 token 只做一次「状态更新 + 读一次状态」,单步代价约 4Nd4Nd,与历史长度无关。摊到整段 LL 个 token,单层计算量是 4LNd4LNd,其中 NN 是状态维数。整段口径下两条曲线只在 L=NL=N 处相交:序列比状态维长,SSM 就便宜。

这个账很容易被讲成「SSM 比 Transformer 省」,但它省的是每层的乘加次数,不是全部成本。真实的推理系统里还有显存带宽、kernel 启动、并行度、精度,以及最容易被忽略的一条——你为了省这些乘加,丢掉了什么表达能力。2023 年底的 Mamba 论文就是在回答后半个问题:之前的线性模型为什么打不过注意力,以及怎么补。

本文按一条线索走:先把连续时间的 SSM 离散成递推,再看 Mamba 的「选择性」改了什么,然后证明(并实测)递推、卷积、矩阵三种写法是同一件事,最后说明 Mamba-2 的对偶框架如何把这份计算重新变成 GPU 喜欢的矩阵乘。

符号与约定

后文所有公式都基于下面这套记号。为避免混淆,Aˉ\bar A 表示离散化之后的矩阵,AA 表示连续时间的矩阵;下标 tt 表示第几个 token。

符号含义维度备注
LL序列长度(token 数)标量训练时通常几千到几万
dd通道数(单层有效宽度)标量注意力里指全部头的 head 维度之和;单头时即该头维度
NNSSM 状态维数标量常见取 16~128 量级
utu_t第 tt 个 token 的输入dd一个向量
xtx_t第 tt 步之后的状态d×Nd\times N每通道各自一份状态
yty_t第 tt 个 token 的输出dd与输入同维
AA连续时间状态矩阵d×Nd\times N 的每通道矩阵对角时每通道一支
Aˉt\bar A_t离散化后的状态转移同上选择性下随 tt 变
Δt\Delta_t步长(离散化间隔)dd选择性下随 token 变
Bt,CtB_t, C_t输入/输出投影d×Nd\times N选择性下随 token 变
QQ分块大小(chunk size)标量块内做 Q×QQ\times Q 矩阵乘

一句话记住三者的关系:递推是它的定义,卷积是它在参数不随时间变时的加速形式,矩阵是它最一般的代数形式。

从微分方程到递推

SSM 的原型是一组线性常微分方程,S4 论文里的写法是:

x′(t)=Ax(t)+Bu(t),y(t)=Cx(t)+Du(t)x'(t) = A x(t) + B u(t), \qquad y(t) = C x(t) + D u(t)

其中 x(t)x(t) 是连续时间的隐状态。要让计算机算,必须离散化。最常用的是零阶保持(zero-order hold):假设在一个步长 Δ\Delta 内输入不变,解这个线性方程,得到精确的离散转移:

Aˉ=exp⁡(ΔA),Bˉ=(ΔA)−1(exp⁡(ΔA)−I) ΔB\bar A = \exp(\Delta A), \qquad \bar B = (\Delta A)^{-1}\big(\exp(\Delta A) - I\big)\,\Delta B

当 Δ\Delta 很小时,exp⁡(ΔA)≈I+ΔA\exp(\Delta A)\approx I+\Delta A,于是 Aˉ≈I+ΔA\bar A \approx I + \Delta A、Bˉ≈ΔB\bar B\approx \Delta B。工程实现里经常直接用这个近似(也叫欧拉离散化),因为它的代价低、数值行为也好分析。写成递推:

xt=Aˉt xt−1+Bˉt ut,yt=Ct xtx_t = \bar A_t\, x_{t-1} + \bar B_t\, u_t, \qquad y_t = C_t\, x_t

到这一步为止,它和 RNN 的差别只在「转移矩阵是线性的、且被精心参数化」。真正的分水岭是 Aˉ\bar A 怎么选——S4 用的是 HiPPO 一类有特殊结构的矩阵,保证长程记忆在数学上可控;这一点在第三节还会回来。

为什么「线性」很重要

注意 xtx_t 对 xt−1x_{t-1} 是线性的,没有任何非线性激活。这意味着整段前向可以写成一个矩阵乘法:把输入序列堆成列向量,输出就是某个下三角矩阵乘它。线性带来的第二个好处是:状态可以合并,两个相邻区间的状态可以「接起来」,于是并行扫描(parallel scan)成立。

代价也很直接:没有门控、没有非线性,状态只能做「加权累积」,不能做「按内容选择」。这正是 Mamba 要补的那一刀。

选择性:让参数随 token 变

Mamba 论文对前人工作的诊断很干脆:这些次二次复杂度的模型(线性注意力、门控卷积、循环模型、结构化 SSM)在语言这种离散模态上打不过注意力,关键弱点在于无法做基于内容的推理。修法是把 SSM 的参数变成输入的函数:

Bt=LinearB(ut),Ct=LinearC(ut),Δt=softplus(LinearΔ(ut))B_t = \mathrm{Linear}_B(u_t),\qquad C_t = \mathrm{Linear}_C(u_t),\qquad \Delta_t = \mathrm{softplus}\big(\mathrm{Linear}_\Delta(u_t)\big)

Δt\Delta_t 过 softplus 是为了保证步长为正;BtB_t、CtC_t 随输入变,意味着「写进状态多少」和「从状态读出多少」都由当前 token 决定。这里的方向最容易搞反:Δ\Delta 变大时 Aˉ=exp⁡(ΔA)\bar A=\exp(\Delta A) 更接近零,旧状态被重置、当前输入被写得更多;Δ\Delta 变小时 Aˉ\bar A 接近单位阵,旧状态被保留、当前输入几乎被忽略。也就是说**「遗忘历史」对应的是大 Δ\Delta,不是小 Δ\Delta**。论文把它描述为「沿序列维选择性地传播或遗忘信息」,落地到实现上就是这一条。

这里有一个容易被忽略的代价,它也是全文的转折点:参数一旦依赖输入,系统就不再是时间不变的(LTI)。第三节那个漂亮的卷积加速就失效了。Mamba 论文自己写得很清楚:这一改动使得高效卷积无法使用,于是他们改在递推模式下设计一个硬件感知的并行算法。

换句话说,Mamba 的第一版是「用更贵的训练算法换更强的表达能力」;Mamba-2 要解决的是「怎么把这份贵算回来」。中间那一步,得先把「同一递推」的三种写法摆在一起看。

三种写法是同一件事

先看卷积形式。当 Aˉ,Bˉ,Cˉ\bar A,\bar B,\bar C 不随 tt 变时,把递推展开:

xt=∑j=0tAˉ t−jBˉ uj⟹yt=∑j=0t(CˉAˉ t−jBˉ)ujx_t = \sum_{j=0}^{t} \bar A^{\,t-j}\bar B\, u_j \quad\Longrightarrow\quad y_t = \sum_{j=0}^{t}\big(\bar C \bar A^{\,t-j}\bar B\big)u_j

定义长度为 LL 的核:

Kˉ=(CˉBˉ, CˉAˉBˉ, CˉAˉ2Bˉ, …, CˉAˉL−1Bˉ)\bar K = \big(\bar C\bar B,\ \bar C\bar A\bar B,\ \bar C\bar A^{2}\bar B,\ \dots,\ \bar C\bar A^{L-1}\bar B\big)

于是整段前向就是一次因果卷积 y=Kˉ∗uy = \bar K * u。这就是 S4 能高效训练的根基:卷积可以用 FFT 或分块算法并行算,训练不必逐 token 串行。

需要强调的是 KK 与输入无关——核只由参数决定。在 LTI 假设下,这个性质严格成立;一旦参数随 token 变,每一步的「核」都不同,卷积形式要么退化成逐点计算,要么需要显式构造一个 L×LL\times L 的矩阵。

我写了一段纯 numpy 的验证脚本(exp-2026-11-21-ssd.py,种子 20261121,L=64L=64、d=3d=3、N=4N=4):

  • LTI 情形下,递推与卷积的逐元素最大绝对误差 1.67e-16(就是双精度舍入误差);
  • 把衰减按通道取标量、其余参数随 token 变之后,递推与「半可分矩阵乘」的最大绝对误差 6.66e-16;
  • 用分块算法(Q=16Q=16,共 4 块)复算同一条递推,最大绝对误差 5.55e-16。

三条都落在机器精度上,说明它们不是「近似等价」,而是同一个算子的三种求值顺序。

同一递推的三种算法:递推、卷积、半可分矩阵
图 1 同一递推的三种算法(本文自绘)。这张图想说明的一件事:递推、卷积、矩阵不是三个模型,而是同一个算子的三种求值顺序,选哪种取决于「参数是否随输入变」与「要不要并行」。

对角化:S4 绕的那一大圈,S4D 省掉了什么

S4 的核心技术难点不在递推本身,而在「怎么让 Aˉ\bar A 好算」。S4 论文的抽象写得很准确:他们提出了一种新的参数化,用低秩修正来条件化 AA,使它能够被稳定地对角化,从而把 SSM 化为一个被充分研究过的 Cauchy 核计算。原因不难理解:对角矩阵的幂和对数都好算(逐元素),非对角矩阵的高次幂在数值上很快失控。

随后的 S4D 论文(arXiv:2206.11893)把话说得更直白:把状态矩阵限制成完全对角,并配上以逼近 S4 矩阵为目标的初始化,就能保住 S4 的性能,参数化与初始化也简单得多。注意这条结论绑定该特定初始化,不是「任意对角矩阵都行」。这一结论对工程影响很大——对角之后,每个通道的 NN 个状态彼此独立,递推就是 NN 条互不干扰的一维线性递推:

xt,n=at,n xt−1,n+bt,n utx_{t,n} = a_{t,n}\, x_{t-1,n} + b_{t,n}\, u_t

注意这里 xt,nx_{t,n} 是标量、utu_t 是标量(单个通道内),整个通道的计算是 NN 个并行的标量递推。这既解释了为什么 SSM 的 kernel 能写得很紧,也解释了它为什么能用并行扫描:标量递推的结合律最简单。

对偶:把整段前向写成一个下三角矩阵

现在做最关键的一步——把递推展开成矩阵。对第 ii 个输出、第 jj 个输入,贡献是「从 jj 到 ii 一路乘过来的衰减」乘以 jj 处的写入量与 ii 处的读出量:

Mij=Ci⊤(∏k=j+1iAˉk)Bˉj(i≥j),Mij=0 (i<j)M_{ij} = C_i^{\top}\Big(\prod_{k=j+1}^{i}\bar A_k\Big)\bar B_j \quad (i\ge j), \qquad M_{ij}=0\ (i<j)

于是 y=Muy = M u。MM 是下三角的,因为因果性:第 ii 个输出只能看见 j≤ij\le i 的输入。这类矩阵在数值线性代数里有名字——半可分矩阵(semiseparable matrix):严格落在主对角线下方、且不跨主对角线的那些子块(完全位于下三角区域内的连续行区间 × 列区间)秩不超过 NN。这是对子块的约束,不是「整张矩阵的秩不超过 NN」。

这句话就是 Mamba-2 那篇《Transformers are SSMs》的全部起点:SSM 的前向等于一个半可分矩阵乘输入,而注意力也等于一个矩阵乘输入(只是那个矩阵是 QK⊤QK^{\top} 遮罩后的结果)。两者的差别落在「矩阵的结构」上:SSM 的矩阵有低秩子块结构,注意力的矩阵是满秩的(在一般情况下)。

在 L=64L=64 的验证里,这个下三角矩阵的非零元素占比是 0.5078(64×65/264\times65/2 除以 64264^2)。序列越长,这个比例越接近二分之一——所以「稠密矩阵乘」在渐近意义上并不比注意力省;它省在结构上:真正参与计算的只是那些秩不超过 NN 的下三角子块。

标量衰减:让矩阵可以因式分解

Mamba-2 的关键约束是把状态转移写成标量乘单位阵:

Aˉt=atI\bar A_t = a_t I

这样一来,从 jj 到 ii 的衰减只依赖位置、不依赖状态维,可以提出来:

Mij=(∏k=j+1iak)⋅(Ci⊤Bˉj)⟹M=L∘(CB⊤)M_{ij} = \Big(\prod_{k=j+1}^{i} a_k\Big)\cdot\big(C_i^{\top}\bar B_j\big) \quad\Longrightarrow\quad M = L \circ \big(C B^{\top}\big)

其中 LL 是「衰减遮罩矩阵」(Lij=∏k=j+1iakL_{ij}=\prod_{k=j+1}^{i}a_k,i≥ji\ge j),∘\circ 是逐元素乘。这一步的意义在于:CB⊤C B^{\top} 是一个普通的矩阵乘,可以直接交给 tensor core;衰减只是一个逐元素的权重。Mamba-2 论文把这个框架叫状态空间对偶(SSD),并报告其核心层比 Mamba 快 2~8 倍。

必须说清一个边界:这个因式分解严格成立于「衰减对状态维是标量」。如果每个状态维的衰减各不相同(at,na_{t,n} 随 nn 变),上面的 LL 就不再是标量矩阵,矩阵形式只能按通道分别写。我的验证脚本按通道各建一张 (L,L)(L,L) 矩阵,正是为了把这条约束显式化,而不是含糊地说「都等价」。

分块:块内二次,块间线性

有了 M=L∘(CB⊤)M = L\circ(CB^{\top}),就可以分块。把长度 LL 切成 C=L/QC=L/Q 块,每块 QQ 个 token。对块内的输出,只有块内输入能贡献(对角块内是下三角);跨块的贡献全部通过块首状态 HH 传递:

Yintra=(Lblock∘(CB⊤))Ublock,Yinter=(decay-to-block-start) HY_{\text{intra}} = \big(L_{\text{block}} \circ (C B^{\top})\big)U_{\text{block}}, \qquad Y_{\text{inter}} = \big(\text{decay-to-block-start}\big)\,H

其中 UblockU_{\text{block}} 是该块内的输入矩阵(Q×dQ\times d):块内的 Q×QQ\times Q 遮罩只作用在本块上,跨块信息全部走状态。两项相加就是该块的输出;块末状态再由块内递推得到,传给下一块。计算量是:

2LQNd⏟构造块内 CB⊤+2LQd⏟块内输出+2LNd⏟状态读写+O(LNlog⁡(L/Q))⏟块间扫描\underbrace{2LQNd}_{\text{构造块内 }CB^{\top}} + \underbrace{2LQd}_{\text{块内输出}} + \underbrace{2LNd}_{\text{状态读写}} + \underbrace{O\big(LN\log(L/Q)\big)}_{\text{块间扫描}}

这张账要记全:块内那次「下三角矩阵乘」并不只是 Q×QQ\times Q 乘输入,构造 CB⊤CB^{\top} 本身要沿 NN 维收缩(2LQNd2LQNd);块状态一读一写各约 2LNd2LNd;块间还要一次扫描。前面若只写 2LQd+2LNd2LQd+2LNd,那只是矩阵乘那两项的简化口径,不是完整前向成本。

块与块之间也可以再扫一次(原文给出的深度是 O(log⁡(L/Q))O(\log(L/Q))),纯串行只是最简单的实现选择;每块内部的 Q×QQ\times Q 矩阵乘则可以完全并行、且形状规则——这正是 GPU 擅长的形态。Mamba 第一版的并行扫描是 work-efficient 的(工作量 O(L)O(L)、深度 O(log⁡L)O(\log L)),但每一步都很小、kernel 融合难;SSD 的做法是把「能变成大矩阵乘的部分」尽量变成大矩阵乘,让访存与 tile 形状对上硬件。

分块扫描:切块、块内下三角矩阵乘、块间状态传递、拼接输出
图 2 分块扫描的四个步骤(本文自绘)。这张图想说明的一件事:$$O(L^2)$$ 的块内矩阵乘和 $$O(LN)$$ 的块间状态传递被拆开后,慢的那部分只剩「每块一次」,其余都变成 GPU 友好的规则矩阵乘。

验证里 Q=16Q=16、L=64L=64,分块结果与整段递推的最大绝对误差 5.55e-16。误差量级说明:分块不是近似,它只是把同一个和式换了求和顺序。

账:FLOP 与状态体积

下面这张表按公式现算,不是实测。取单层、d=2048d=2048、状态维 N=64N=64、fp16 存 KV:

序列长度 LL注意力 FLOPs 4L2d4L^2dSSM FLOPs 4LNd4LNd倍数KV 体积(fp16)SSM 状态(fp32)
10248.59e95.37e816×8 MiB512 KiB
40961.37e112.15e964×32 MiB512 KiB
163842.20e128.59e9256×128 MiB512 KiB
327688.80e121.72e10512×256 MiB512 KiB

(注意 8.59e9 在表中出现两次:L=1024L=1024 的注意力、L=16384L=16384 的 SSM,按列头区分。)

三件事值得记下来:

第一,交叉点就是 L=NL=N。4L2d=4LNd⇒L=N4L^2d = 4LNd \Rightarrow L=N。状态维越大,SSM 的优势区间越晚出现——这也解释了为什么 NN 通常不会取到几千。

第二,SSM 的状态体积与序列长度无关(每层 d⋅Nd\cdot N 个数),而 KV 缓存随 LL 线性增长。上表最后一行,32768 个 token 时两者相差 512 倍。这个差别在长上下文服务里比 FLOP 更致命,因为它决定「一张卡能同时挂多少个会话」。

第三,这些数字都不含访存与并行效率。FLOP 少 512 倍不等于快 512 倍:SSM 的每一步都是小 kernel,若不能融合,访存会成为瓶颈;反过来注意力的大矩阵乘 MFU 很高。Mamba-2 报告的 2~8 倍是核心层的加速,不是端到端 512 倍——把解析账当成实测值是最常见的误读。

与注意力的对照:不是替代,是分工

维度注意力选择性 SSM(Mamba-2 形态)
每层计算4L2d4L^2d块内 2LQd2LQd + 块间 2LNd2LNd
推理时每 token要读全部历史 KV只读写固定状态
状态体积随 LL 线性增长d⋅Nd\cdot N 常数
训练并行方式整段矩阵乘分块矩阵乘 + 块间扫描
表达上的强项精确检索、复制、长距对齐压缩式记忆、平滑衰减
主要弱点长序列成本状态容量固定,无法无损保留全部历史

最后一行值得展开。注意力可以做到「精确地取回第 137 个 token 的某个值」,因为那对 KV 一直原样躺着;SSM 的状态是有损压缩,容量固定为 d⋅Nd\cdot N。序列越长,压缩比越高,信息越可能被后来的写入覆盖。这不是实现缺陷,而是模型结构的直接推论。

Mamba 论文里那句「Mamba-3B 在预训练与下游评测上超过同尺寸 Transformer、匹配两倍尺寸」是在语言建模的常规评测上说的,不等于它在检索类任务上也占优。工程上更稳妥的读法是:两者互补,一边擅长压缩式记忆,一边擅长精确查找。

并行扫描:递推也能并行

「递推」这个词容易让人以为必须串行。其实线性递推可以并行化,靠的是一个结合律。把每一步写成一个「仿射变换」:

xt=atxt−1+ct⟺(xt1)=(atct01)(xt−11)x_t = a_t x_{t-1} + c_t \quad\Longleftrightarrow\quad \begin{pmatrix} x_t \\ 1\end{pmatrix} = \begin{pmatrix} a_t & c_t \\ 0 & 1\end{pmatrix} \begin{pmatrix} x_{t-1} \\ 1\end{pmatrix}

两个相邻变换可以合并成一个:

(a2,c2)∘(a1,c1)=(a2a1, a2c1+c2)(a_2, c_2)\circ(a_1, c_1) = (a_2 a_1,\ a_2 c_1 + c_2)

这个运算满足结合律,所以可以用前缀和式的树形归约(scan)在 O(log⁡L)O(\log L) 深度内算出全部前缀状态,总工作量仍是 O(L)O(L)。换句话说:递推的串行只是「求值顺序」的一种,不是数学上的限制。

Mamba 论文的做法是「在递推模式下设计硬件感知的并行算法」——把 scan 的中间结果尽量留在片上、把多个小 kernel 融合成一次,减少每步的访存开销。这也是第一版 Mamba 的工程难点:算法本身是标准的,难的是让它跑满 GPU。

对比一下两条路线:

路线并行深度每步粒度实现难度
并行扫描(Mamba v1)O(log⁡L)O(\log L)小(逐元素)需要手写融合 kernel
分块矩阵乘(Mamba-2)段间 O(log⁡(L/Q))O(\log(L/Q)) + 段内满并行大(Q×QQ\times Q)直接复用现有矩阵乘

后者并不「更聪明」,它只是把串行部分压到最少、把并行部分做成硬件的形状。这也是为什么 Mamba-2 的核心层能报 2~8 倍——收益主要来自形状与访存,不来自算法本身变了。

一个 20 行的最小实现

为了让上面的式子落地,下面是验证脚本里最核心的递推部分(逐通道、对角状态、选择性参数)。其中 at=exp⁡(ΔtA)a_t=\exp(\Delta_t A) 由对角状态矩阵与步长逐元素算出;BtB_t 在此不含 Δ\Delta,与正文 Bˉ≈ΔB\bar B\approx\Delta B 的约定对应时再乘上 Δt\Delta_t。

def selective_scan(u, a_t, dt_t, B_t, C_t):
    """u: (L,d)  a_t: (L,d)  B_t,C_t: (L,d,N);返回 (L,d)"""
    L, d = u.shape
    x = np.zeros((d, B_t.shape[-1]))
    out = []
    for t in range(L):
        x = a_t[t][:, None] * x + dt_t[t][:, None] * B_t[t] * u[t][:, None]
        out.append((C_t[t] * x).sum(axis=1))
    return np.array(out)

这段代码的价值不在性能,而在它是「定义」:所有加速实现(卷积、矩阵、分块)算出来的都必须是同一个结果。我的等价性验证就是拿它当基准,去比另外两种写法。

状态维 N 与块大小 Q 怎么选

两个超参常被问起:状态维 NN 取多大、分块大小 QQ 取多大。它们都不是「越大越好」,各自有一条代价曲线。

先看 NN。由 Mij=Ci⊤(∏Aˉk)BˉjM_{ij}=C_i^{\top}(\prod \bar A_k)\bar B_j 可知,MM 的每个非对角子块秩不超过 NN。所以 NN 决定的是这个下三角矩阵能用多低的秩去逼近历史:NN 越大,能记住的「独立方向」越多,但状态体积 d⋅Nd\cdot N 与每步计算 4LNd4LNd 也线性增长。表里交叉点 L=NL=N 就是这个意思——如果序列只有 128 个 token,把 NN 取到 512 反而更贵。

再看 QQ。按只算矩阵乘的口径,块内代价是 2LQd2LQd、块间是 2LNd2LNd,成本对 QQ 单调递增(∂/∂Q=2Ld>0\partial/\partial Q = 2Ld > 0)——所以不能从这两项解出最优点。真正决定 QQ 的是另外两件事:块间扫描的深度 log⁡(L/Q)\log(L/Q)(QQ 越大段数越少、并行度越差),以及矩阵乘的 tile 形状是否规整。

Mamba-2 原文把块大小取到与状态维同量级,是为了让分块矩阵乘落到整齐的形状上,属于硬件取向的经验取值,不是上面那条 FLOP 式子的最优解。真实实现还要叠加 SRAM 容量、tile 形状与 kernel 启动开销。

选择偏小的后果偏大的后果本文推算的平衡点
NN历史压缩太狠,容量不足状态体积与每步计算线性上涨与目标序列长度同量级
QQ段数多,扫描深度大并行度差、tile 不规整Q≈NQ\approx N(经验值)

一句话总结这套记号:状态维 NN 决定「能记住多少个独立方向」,块大小 QQ 决定「串行段有多少」——两个旋钮都不是越大越好,也不是从 FLOP 式子解出来的。

和线性注意力的关系:同一个「固定状态」

如果把线性注意力的因果形式写出来:

yt=ϕ(qt)⊤∑j≤tϕ(kj)vj⊤=ϕ(qt)⊤St,St=St−1+ϕ(kt)vt⊤y_t = \phi(q_t)^{\top}\sum_{j\le t}\phi(k_j)v_j^{\top} = \phi(q_t)^{\top} S_t, \qquad S_t = S_{t-1} + \phi(k_t)v_t^{\top}

StS_t 是一个固定大小的矩阵,每来一个 token 做一次外积累加——这和 SSM 的「固定状态 + 每步更新」是同一个骨架。两者的区别集中在三点:

  1. 衰减:SSM 的转移矩阵让历史按位置指数衰减;线性注意力默认不衰减(累加),要靠额外技巧引入遗忘。
  2. 选择:Mamba 让写入量 BtB_t、读出量 CtC_t、步长 Δt\Delta_t 都由当前 token 决定;线性注意力通常只让 query/key 参与。
  3. 求值方式:SSM 有卷积与半可分矩阵两条额外的求值路径,线性注意力主要靠「先累加状态再乘」这一条。

所以「SSM 是线性注意力的近亲」这句话是站得住的。再进一步:无衰减的线性注意力就是 at=1a_t=1 的特例,它同样能写成因果遮罩矩阵乘、也照样可以分块——SSD 的贡献不是「发明了分块」,而是把这类结构统一到半可分矩阵的语言里,并说明衰减与状态维如何进入这个分解。

长上下文服务里的三个实际问题

把公式换成运维问题,通常落到三个数上。

第一,每 token 的 KV 字节数。 单层、fp16、d=2048d=2048 时是 2×2048×2=81922\times2048\times2 = 8192 字节 = 8 KiB。32 层就是 256 KiB/token;一个 32k token 的会话约 8 GiB。这个数决定了一张 80 GB 卡能挂几个长会话——注意它和 batch 里的 token 总数成正比,与请求数无关。

第二,prefill 与 decode 的成本形状不同。 prefill 是「一次算很多 token」,矩阵大、MFU 高;decode 是「一次算一个 token」,每个请求都要把历史 KV 读一遍,受显存带宽限制而不是算力限制。SSM 的 decode 只读固定状态(上表:512 KiB/层),这就是它在小 batch、长上下文场景里最被看重的地方。

第三,状态是有损的,容量要提前规划。 d⋅Nd\cdot N 是硬上限:想记住更多历史,只能加大 NN(更贵)或减少压缩(更长状态)。这条约束没法靠工程优化绕过——它写在模型结构里。

把这三个数和本文的 FLOP 表放在一起,结论会变得很具体:如果你的瓶颈是 decode 的显存带宽与并发会话数,固定状态架构的收益是结构性的;如果瓶颈是 prefill 的大矩阵算力,注意力的 MFU 优势会抵消掉相当一部分账面差距。 这也是为什么实际系统里越来越多地出现两者混用的形态——而不是整体替换。

边界与未解

写到这里,有几件事必须承认没说清。

其一,选择性 SSM 的「选择」是逐 token、逐通道的线性投影,它能学到的选择规则受限于这个函数族。Mamba 论文的贡献是证明这一刀足够把语言建模补上来,但它并没有证明这是最优的选择机制。

其二,SSD 的对偶把「状态矩阵是标量乘单位阵」当成前提。这个约束换来了分块算法与 2~8 倍核心层加速,也换走了「每个状态维独立衰减」的自由度。两者之间的取舍在论文里是设计选择,不是定理。

其三,本文没有讨论训练侧的显存与反向传播代价。分块算法让前向变成矩阵乘,但反向仍需保存中间状态;这部分开销在长序列训练里往往比前向更贵,本文未做量化。

其四,递推、卷积、矩阵三种写法的等价性对任意固定的 Aˉ\bar A 都成立(零初态 LTI);但「M=L∘(CB⊤)M=L\circ(CB^{\top}) 这种单个标量遮罩的因式分解」只在标量衰减(At=atIA_t=a_tI)下成立。若每状态维衰减不同,矩阵仍存在,只是要按通道分别写,分块算法也要改写。

其五,本文所有数字都来自解析公式或纯 numpy 的等价性验证,没有任何真机吞吐、MFU 或显存占用的实测。要把这些账变成生产决策,还差一步:在目标硬件上跑同一 batch、同一序列长度,量出实际的 tokens/s 与尾延迟。

三个常见误解

读完公式,有三个结论特别容易被误用,这里逐个拆。

误解一:线性复杂度意味着一定更快。 复杂度只描述渐近趋势,不描述常数。本文的 FLOP 表里,交叉点是 L=NL=N;如果实际序列只有一百多个 token,SSM 反而更贵。更要紧的是常数因子:注意力的每个大矩阵乘都能买到很高的 MFU,而 SSM 的递推段若不能融合,访存会成为主项。把「O(L)O(L)」直接翻译成「快」,是拿渐近当实测。

误解二:状态「记住」了全部历史。 状态只有 d⋅Nd\cdot N 个数,历史有 LL 个 dd 维向量。线性映射把 LL 维压成 NN 维,压缩比是 L/NL/N。这意味着两段不同的历史可能被压成同一个状态——它不是缓存,而是摘要。理解这一点,就不会把 SSM 的「长上下文」误解成「无损长记忆」。

误解三:有了 SSM 就不需要注意力。 Mamba 论文说的是在语言建模评测上匹配或超过同尺寸 Transformer,这不等于在检索、精确复制、长距对齐这些任务上同样占优。本文第四节已经指出:注意力能精确取回第 137 个 token 的原值,SSM 做不到。工程上正确的问法不是「谁替代谁」,而是「我的负载更像压缩式记忆还是精确查找」。

对偶视角能帮你做的三件事

第一,读实现时能对上号。不管是并行扫描、卷积、还是分块矩阵乘,任何一个 SSM kernel 本质上都在算 y=Muy=Mu 的某种求值顺序;看到代码里的「衰减乘、外积累加、遮罩」就该反应过来它们分别在实现 LL、CB⊤CB^{\top} 与因果三角。

第二,估容量时不用猜。给定 dd、NN、层数与精度,状态体积就是 d⋅N×d\cdot N\times 字节数,与序列长度无关;KV 缓存则是 2Ld×2Ld\times 字节数,与序列长度成正比。把这两个数和卡的显存放在一起,就能直接算出「能挂几个会话」。

第三,看清取舍的边界。Q≈NQ\approx N 是从两项代价相等读出来的;L=NL=N 是从两条复杂度曲线相交读出来的。这些数不经实测就能拿到,用来做初筛足够;但它们不能替代实测——真正的 MFU、尾延迟与显存峰值,只有跑起来才知道。

手算三步:把矩阵写出来

抽象公式最怕停在符号上。这里取最小的例子:单通道、单状态维(N=1N=1)、步长 Δ=1\Delta=1、A=−1A=-1、B=C=1B=C=1,于是 a=e−1=0.367879a=e^{-1}=0.367879。输入取三个数 u=(2, 1, 0.5)u=(2,\ 1,\ 0.5)。\n\n先交代口径:本例用欧拉近似 Bˉ=ΔB=1\bar B=\Delta B=1,不是精确零阶保持。若用精确 ZOH,Bˉ=(ΔA)−1(eΔA−1)ΔB=1−e−1=0.632121\bar B=(\Delta A)^{-1}(e^{\Delta A}-1)\Delta B=1-e^{-1}=0.632121,状态与输出会变成另一组数(约 1.2642 / 1.0972 / 0.7197)。两组都自洽,但对应不同离散化约定,不能混用。

按递推走:

x1=2,x2=0.367879×2+1=1.7358,x3=0.367879×1.7358+0.5=1.1386x_1 = 2,\qquad x_2 = 0.367879\times2 + 1 = 1.7358,\qquad x_3 = 0.367879\times1.7358 + 0.5 = 1.1386

输出等于状态(因为 C=1C=1),所以 y=(2, 1.7358, 1.1386)y=(2,\ 1.7358,\ 1.1386)。

再按矩阵走。衰减矩阵的每一行是「从 jj 到 ii 的累积衰减」,下三角、其余为零:

M=(1000.367879100.1353350.3678791)M= \begin{pmatrix} 1 & 0 & 0\\ 0.367879 & 1 & 0\\ 0.135335 & 0.367879 & 1 \end{pmatrix}

第三行乘输入:0.135335×2+0.367879×1+1×0.5=1.13860.135335\times2 + 0.367879\times1 + 1\times0.5 = 1.1386,与递推完全一致。注意左上角那个 0.1353350.135335 就是 a2a^2——离得越远,权重越小,这正是「衰减」在矩阵里的样子。

这个 3×3 的例子把三件事同时展示了出来:因果性(上三角全零)、低秩结构(N=1N=1 时严格下三角区域的子块秩为 1,而整张矩阵的秩仍是 3)、以及「递推与矩阵只是换个顺序求和」。把 NN 加到 4、LL 加到 64,就是验证脚本里那组误差 ≤6.7e-16 的实验。

和其他次二次路线放在一起看

「比注意力便宜」的路线不止 SSM 一条,它们的取舍点各不相同:

路线状态/索引规模每 token 解码代价能否精确取回历史训练并行形态
稀疏/滑窗注意力随窗口大小增长与窗口成正比窗口内可以矩阵乘,形状规则
线性注意力固定(d×dvd\times d_v)常数不能(有损)累加 + 矩阵乘
选择性 SSM固定(d×Nd\times N)常数不能(有损)分块矩阵乘 + 段间扫描

三行放在一起,规律很清楚:想精确取回历史,就必须让「可寻址的东西」随历史增长(注意力保存全部 KV,稀疏注意力保存一个可增长的索引);想让成本与长度脱钩,就只能接受有损压缩。SSM 站在第二列,它的独特之处不是「更省」,而是它把「压缩」写成了一个可以做矩阵分解的线性算子——于是省下来的计算还能被硬件高效执行。

选择哪一行,取决于任务对「精确取回」的依赖程度,而不是取决于哪篇论文的倍数更大。

三个容易记错的数字,以及它们的准确出处

本文引用了三篇论文的倍数,这里把它们各自的语境写清楚,免得读者拿去当自己场景的预期。

5× 吞吐(Mamba,2023-12 首发 / 2024-05 修订)。 摘要原文的表述是「比 Transformer 高 5 倍吞吐,并在序列长度上线性扩展」。它的比较基准是 Transformer,且是作者实验设置下的吞吐;不是「所有硬件、所有 batch 上都快 5 倍」。

2~8 倍(Mamba-2 / SSD)。 摘要写的是「核心层(core layer)比 Mamba 快 2~8 倍」。注意主语是核心层而不是端到端模型,也不是相对 Transformer——它衡量的是「同一层换一种求值算法」的收益。

60× 生成速度(S4,2021-10)。 摘要把这条与「91% 的 sequential CIFAR-10 准确率」「Long Range Arena 全项 SoTA(含长度 16k 的 Path-X)」并列,但三者是不同实验:60× 对应的是 CIFAR-10 与 WikiText-103 上的 pixel/token 自回归生成速度,不是 LRA 的成绩,也不代表通用语言建模的端到端加速。

把这三条放在一起,要先分清它们不在同一层级:Mamba 的 5× 是端到端生成吞吐的作者 benchmark;Mamba-2 的 2~8× 是核心层相对 Mamba 的加速;S4 的 60× 是特定基准上的生成速度。三者都不能互相代入,也都不是「换上这个架构就快 N 倍」。本文的 FLOP 表更是只算乘加次数,不含访存、并行度与 kernel 效率。

五个高频问答

问:既然三种写法等价,为什么还要分训练用卷积、推理用递推? 因为「等价」说的是计算结果相同,不是代价相同。训练时整段可见,卷积/矩阵形式能把 LL 个 token 的计算摊成并行;推理时每次只来一个 token,递推形式每步只做常数级工作,不必重算历史。选哪条路,取决于当前是「一次看整段」还是「一次看一个」。

问:Mamba-2 把状态矩阵约束成标量乘单位阵,是不是牺牲了表达能力? 是,而且这是有意的取舍。约束换来的是衰减可以提到矩阵外面,于是 MM 变成「普通矩阵乘 ∘ 逐元素权重」,能分块、能上 tensor core。论文报告的核心层 2~8 倍加速正是这笔交易的价格;表达能力是否够用,则由下游评测回答。

问:状态维 NN 是不是越大越好? 不是。它决定压缩后的「独立方向数」,也决定状态体积与每步计算。给定目标序列长度,L=NL=N 已经是两条复杂度曲线的交点;把 NN 取到远超序列长度,只会让每条 token 更贵。

问:SSM 的 decode 一定比注意力快吗? 只有当瓶颈在「读历史 KV」时成立。注意力的 decode 每步要读全部 KV,受带宽限制;SSM 只读固定状态。但如果 batch 很小、序列很短,固定状态那点计算量占比很低,差距会被 kernel 启动与并行度吃掉。别把架构优势当成无条件的性能承诺。

问:这套对偶和「线性注意力」是不是一回事? 骨架相同(固定状态、每步更新),但不是一回事。SSM 多了衰减矩阵与输入依赖的选择机制,且拥有卷积与半可分矩阵两条额外的求值路径;线性注意力一般只有「累加状态再乘」这一条。说「近亲」可以,说「等价」就过了。

同一件事的三种叫法:读代码时的对照

跨论文读代码最容易卡在术语上。下面这张表把常见的三种叫法对到一起,看到实现时可以直接对上号。

概念SSM 论文里的叫法实现/框架里的常见叫法注意力里的对应物
状态转移Aˉ\bar A、decayforget gate、decay rate无(KV 全部保留)
写入Bˉt\bar B_tinput projection、write gate新的 K/V 条目
读出CtC_toutput projection、read gatequery 与 KV 的内积
步长Δt\Delta_tdt、timescale无
状态xtx_trecurrent state、hidden state拼接后的 KV 缓存
分块chunk / blocktile、block size QQ无(注意力整段计算)

两个提醒。第一,「forget gate」在 SSM 里是乘性的连续衰减,不是 LSTM 那种带非线性激活的门;把它当 LSTM 读会得出错误结论。第二,「状态」在 SSM 里是固定大小、可微、可并行归约的线性量,而 KV 缓存是随长度增长、只读的存储——两者在系统层面的行为完全不同,只在「都是跨 token 传信息」这一点上相似。

把这张表记下来,再去读任何一份 SSM 实现(不管是并行扫描还是分块矩阵乘的版本),都能很快定位到「哪一段在做衰减、哪一段在做外积、哪一段在做遮罩」。

小结

把这篇的三句话带走:

  1. 递推、卷积、矩阵是同一个算子的三种求值顺序;卷积只在参数不随时间变时成立,选择性恰好打破了它。
  2. 整段前向可以写成一个下三角半可分矩阵乘输入;把状态转移约束成标量乘单位阵后,这个矩阵可以分块——块内是下三角遮罩的矩阵乘,块间只传一次状态。
  3. 省下来的是乘加次数和状态体积,不是全部成本:交叉点在序列长度等于状态维数,状态是固定容量的有损压缩,长上下文里「能挂多少会话」往往比 FLOP 更重要。

如果你正在做长上下文服务,最实际的一步不是立刻换架构,而是先把「每层的 KV 体积 × 并发会话数」算清楚——那张表决定了你的瓶颈是算力还是显存,也决定了 SSM 那 512 倍的账对你有没有意义。

补一句方法论上的话:本文的三个等价性结论都可以用几十行 numpy 复现,误差应当落在机器精度。如果你在自己的实现里看到误差到了 1e-3 量级,那不是浮点噪声,而是某处的「衰减提不出去」或「遮罩写错了一位」——这类错误不会让程序崩,只会让模型悄悄地学不到该学的东西。

最后,把「对偶」当成一个检查工具:任何声称「线性复杂度」的架构,都可以问它一句——你的整段前向能写成哪个矩阵?这个矩阵的子块秩是多少?答不上来,多半说明它只是「更省」,而不是「更清楚」。

如果你要动手验证,最小的一组参数就在验证脚本里:L=64L=64、d=3d=3、N=4N=4、Q=16Q=16、种子 20261121——它足够小到能在几秒内跑完,又足够大到能把三种写法之间的差异逼出来。

📋 来源与核验记录

以下五份材料均在 2026-11-21 本轮实际打开核对(标题与提交日期以 arXiv 摘要页为准):

  1. Mamba: Linear-Time Sequence Modeling with Selective State Spaces,arXiv:2312.00752,v1 提交 2023-12-01、v2 2024-05-31。本文引用的「选择性参数化」「硬件感知的递推并行算法」「5× 吞吐、序列线性扩展」「Mamba-3B 超过同尺寸、匹配两倍尺寸 Transformer」均出自其摘要原文。 链接:https://arxiv.org/abs/2312.00752
  2. Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality,arXiv:2405.21060,2024-05-31。半可分矩阵框架、SSD、Mamba-2 核心层「2~8× faster」出自其摘要原文。 链接:https://arxiv.org/abs/2405.21060
  3. Efficiently Modeling Long Sequences with Structured State Spaces(S4),arXiv:2111.00396,v1 提交 2021-10-31、v3 2022-08-05。连续时间 SSM 方程、低秩修正→稳定对角化→Cauchy 核、生成快 60×、91% 的 sequential CIFAR-10 准确率、Long Range Arena 全项 SoTA(含长度 16k 的 Path-X)出自其摘要原文。 链接:https://arxiv.org/abs/2111.00396
  4. Combining Recurrent, Convolutional, and Continuous-time Models with Linear State-Space Layers(LSSL),arXiv:2110.13985,2021-10-26。用于说明连续时间 SSM 与 RNN/卷积/神经常微分方程的关系。 链接:https://arxiv.org/abs/2110.13985
  5. On the Parameterization and Initialization of Diagonal State Space Models(S4D),arXiv:2206.11893,v2 2022-08-05。该文提出 S4D,说明在特定参数化与初始化下完全对角的状态矩阵即可匹配 S4;本文按此限定引用,不推广为「任意对角都行」。 链接:https://arxiv.org/abs/2206.11893

本文自行推导与实测(与上列官方数字分列,不可混用):

  • 交叉点 L=NL=N、FLOP 表、KV 与状态体积表:按 4L2d4L^2d、4LNd4LNd、2Ld2Ld 乘 2 字节、dNdN 乘 4 字节现算,取 d=2048d=2048、N=64N=64。
  • 三种算法等价性:(脚本位于项目根 MagicNetWorld/_ops/tech-daily-plan/article-drafts/,不进站点仓),种子 20261121,取 L=64L=64、d=3d=3、N=4N=4、Q=16Q=16;误差 1.67e-16 / 6.66e-16 / 5.55e-16。
  • 下三角矩阵非零占比 0.5078(L=64L=64)。

未做真机实测:本文不含任何吞吐、MFU、显存占用的实测数据,全部为解析计算与数值等价性验证。文中引用的 5×、2~8×、60× 等倍数均为对应论文报告值,不是本站实测。