真正参与过前沿大语言模型预训练的人并不多。对于大多数从事语言模型相关工作的人来说，最初的 Transformer (Vaswani et al., 2017) 和第一代 GPT (Radford et al., 2018) 所采用的基本 decoder-only 架构已经十分熟悉。然而，即使持续关注新模型的发布，没有大规模训练经验的人也未必会逐一研究它们内部架构的变化。领先的开源模型依然以 Transformer 为基础，本文只讨论 decoder-only 模型，但其中许多关键组件已经发生了显著演变。本文尝试收集并梳理几个领先开源模型的架构设计，说明现代 Transformer 改变了什么、不同组件如今如何组合，以及这些设计背后的直觉。

快速回顾：Decoder-Only Transformer

在进入这些改动之前，我们先沿着熟悉的 decoder-only Transformer 从输入走到输出。下图以第一代 GPT 作为简洁的历史基线，展示数据贯穿整个模型的一条连续路径。

The GPT-1 decoder-only Transformer forward pass Token and position embeddings are added to form the initial hidden states. Repeated decoder blocks apply causal self-attention, residual addition, LayerNorm, an MLP, another residual addition, and another LayerNorm. The language-model head produces one logits row per input position. A final split shows next-token training on the left and generation on the right. token IDs Looks up one learned vector for every token ID. The embedding matrix W_e has shape |V| × d, so a length-T sequence becomes a T × d matrix. token embedding + Looks up a learned vector for every absolute position using W_p, then adds it to the token embedding. GPT-1 learns these position vectors, while the original Transformer used fixed sinusoidal encodings. position embedding Combines token identity and position: h_0 is the token embedding plus the position embedding. The result has shape T × d and enters the first decoder block. initial states h0 decoder block × L For block l, the input is h_(l−1). Block 1 receives h_0, while every later block receives the preceding block's output. block input hl−1 At position t, causal self-attention can read positions 1 through t while future positions are masked. This is the sublayer that mixes information across sequence positions. causal self-attention + residual Normalizes each position's hidden vector after the attention update joins the residual stream. In this GPT-1 block, normalization follows the residual addition. LayerNorm Applies the same two-layer feed-forward network independently at every position. It transforms features within each token state and does not mix information across positions. MLP + residual Normalizes each position's hidden vector after the MLP update joins the residual stream. The result is h_l, the output passed to the next decoder block. LayerNorm Collects the output of decoder block L for all T input positions. The final representation h_L has shape T × d. final states hL Projects every final hidden state into vocabulary scores. GPT-1 ties this projection to the token embedding matrix, so the LM head uses W_e^T. LM head Contains one vocabulary-score row for every input position, with shape T × |V|. Rows 1 through T−1 train next-token prediction, while row T supplies the distribution used to generate the next token. logits rows 1 … T−1 row T TRAINING shifted targets [x2, …, xT] cross-entropy loss GENERATION softmax next-token distribution decoding selects one token
Figure 1. A GPT-1 decoder-only forward pass (Radford et al., 2018), from learned token and position embeddings through $L$ repeated blocks and a tied LM head. Training uses logits rows 1 through $T-1$ with shifted targets; generation uses row $T$. Hover a component for details.

从图的顶部开始。每个 token ID 查找一个 token embedding，它的位置则查找一个位置嵌入。这两个向量宽度相同，二者相加后形成 $h_0$，也就是由 $T$ 个隐藏向量组成的序列。GPT-1 在这里使用可学习的绝对位置嵌入，原始 Transformer 使用固定的正弦位置编码。$h_0$ 随后进入第一个 decoder block；后续每个 block 都接收前一层的输出，因此第 $l$ 个 block 将 $h_{l-1}$ 映射为 $h_l$。

在 GPT-1 的 block 中，causal self-attention 让位置 $t$ 的隐藏状态从不晚于 $t$ 的位置收集信息。其输出与 block 输入相加，再进行归一化。随后，同一个 MLP 独立作用于每个位置，它的参数在所有序列位置之间共享。第二次残差相加与 LayerNorm 得到 $h_l$。这就是早期的 post-norm 顺序：先计算 $n_l = \operatorname{LayerNorm}(h_{l-1} + \operatorname{Attention}(h_{l-1}))$，再计算 $h_l = \operatorname{LayerNorm}(n_l + \operatorname{MLP}(n_l))$。

经过 $L$ 个 block，模型得到最终隐藏状态 $h_L \in \mathbb{R}^{T \times d}$。GPT-1 复用 token embedding 矩阵作为输出投影。每个隐藏状态乘以 $W_e^\top$ 后，得到 $\mathbb{R}^{T \times \lvert V \rvert}$ 中的 logits 矩阵。第 $t$ 行包含词表中每个 token 的一个分数，代表它成为位置 $t$ 之后下一个 token 的候选程度。

同一组 logits 有两种用途。训练时，第 1 行与 $x_2$ 比较，第 2 行与 $x_3$ 比较，依此类推，第 $T-1$ 行与 $x_T$ 比较。也就是说，$x_t$ 之后的预测以 $x_{t+1}$ 为目标。自回归生成时，只需要最新的一行 logits。Softmax 将它转换为下一个 token 的概率分布，解码策略再从中选择 token，例如使用贪心解码或采样。

这条熟悉的路径为后文提供了参照。现代模型保留了它的整体轮廓，同时改变了位置信息如何进入模型、注意力如何路由和保存信息、前馈容量如何分配，以及残差块如何组织。

模型概览

有了这个历史基线，我们便可以具体看看现代 decoder-only Transformer 的样子。本文选择六个能力领先的开放模型作为锚点：Kimi K2.5 (Moonshot AI, 2026)、Qwen3.5 (Qwen Team, 2026)、DeepSeek V4-Pro (DeepSeek-AI, 2026)、MAI-Thinking-1 (Microsoft AI Team, 2026)、GLM-5.2 (Z.ai, 2026) 和 Inkling (Thinking Machines Lab, 2026)。下表汇总了每个模型采用的主要架构技术。

表格将改动分成五类。位置机制包括旋转位置编码（RoPE）、partial RoPE、YaRN 和相对位置偏置。Attention 包括 grouped-query attention（GQA）、multi-head latent attention（MLA）、Gated DeltaNet、Compressed Sparse Attention（CSA）、Heavily Compressed Attention（HCA）与 DeepSeek Sparse Attention（DSA）。MLP 一栏列出 SwiGLU 与 mixture of experts（MoE）设计；归一化一栏包括均方根归一化（RMSNorm）和 query-key normalization（QK-Norm）。最后一栏收录跨越单个组件的技术，包括 query-key clipping（QK-Clip）、multi-token prediction（MTP）、manifold-constrained Hyper-Connections（mHC）、attention sink、KVShare 和 short convolution。

模型 参数量 位置机制 Attention MLP / MoE 归一化 其它技术
Kimi K2.5 1T激活 32B partial RoPE, YaRN MLA SwiGLU, sparse MoE, shared expert RMSNorm QK-Clip
Qwen3.5 397B激活 17B partial RoPE Gated DeltaNet, gated GQA SwiGLU, sparse MoE, shared expert RMSNorm, QK-Norm MTP
DeepSeek V4-Pro 1.6T激活 49B partial RoPE, YaRN CSA, HCA, 局部 attention clipped SwiGLU, sparse MoE, Hash 路由, shared expert RMSNorm mHC, attention sink, MTP
MAI-Thinking-1 962B激活 34.7B RoPE GQA, 局部/全局 attention SwiGLU, LatentMoE RMSNorm, QK-Norm attention 输出零初始化
GLM-5.2 753B激活 40B partial RoPE MLA, DSA, IndexShare SwiGLU, sparse MoE, shared expert RMSNorm MTP, KVShare
Inkling 975B激活 41B 相对位置偏置 GQA, sliding-window/全局 attention SwiGLU, sparse MoE, shared experts RMSNorm, QK-Norm short convolution

后文将依次解释这些类别中的改动，说明每项技术做了什么，以及它在直觉上为什么能够工作。

位置信息

Token embedding 标识的是某个 token，而不是这个 token 在序列中的某一次出现。在进入任何上下文层之前，单词 “the” 无论出现在何处都会得到同一个向量。Query、key 和 value 投影也在所有位置共享参数，所以这些投影本身不会引入行号。对位置 $t$ 的 query，令 $\mathcal V(t)$ 表示 attention mask 允许它看到的来源位置集合，$d_h$ 表示一个 attention head 的宽度，则注意力聚合为

\[\operatorname{Attention}_t =\sum_{s\in\mathcal V(t)} \frac{\exp(q_t^\top k_s/\sqrt{d_h})} {\sum_{j\in\mathcal V(t)}\exp(q_t^\top k_j/\sqrt{d_h})}v_s.\]

如果交换两个可见的 $(k_s,v_s)$，求和中的对应项也只是互换位置，结果保持不变。只有当向量携带来源位置的线索时，attention 才能区分它们。Decoder 的 causal mask 的确提供了一部分顺序信息，因为 $\mathcal V(t)$ 只包含不晚于 $t$ 的位置。但在这个可见前缀内部，mask 并不会告诉模型某个 key 在“一个 token 之前”，另一个在“一千个 token 之前”。因此在第一层中，同一个 token 的两次出现会产生相同的 key 和 value，与它们到 query 的距离无关。

语言需要的信息远多于“是否位于当前前缀”。“Dog bites man”和“man bites dog”包含相同的 token，却表达不同的事件。相邻 token 往往构成局部语法，而姓名和后续代词之间可能隔着很长一段文本。位置机制为这些关系提供模型可以使用的坐标。核心架构问题在于这些坐标从哪里进入：可以加到输入上，可以折进 query-key 的几何关系，也可以直接加入 attention 分数。

原始 Transformer 和 GPT 采用第一种方式。位置向量只在第一个 Transformer block 之前进入一次。

位置嵌入

两种早期设计都会给每个下标 $t$ 分配一个与 token embedding 同宽的向量 $p_t$，并计算

\[h_t=e(x_t)+p_t.\]

为什么简单相加就足够？把 token embedding $e(x_t)$ 简写为 $e_t$。采用列向量记法，位置 $t$ 的 query 和位置 $s$ 的 key 为

\[q_t=W_Qh_t=W_Q(e_t+p_t), \qquad k_s=W_Kh_s=W_K(e_s+p_s).\]

令 $A=W_Q^\top W_K$ 表示 dot product 内部的两个学习到的投影，展开 attention 分数得到

\[\begin{aligned} q_t^\top k_s &=(e_t+p_t)^\top A(e_s+p_s) \\ &=e_t^\top A e_s +e_t^\top A p_s +p_t^\top A e_s +p_t^\top A p_s. \end{aligned}\]

第一项比较 token 内容。中间两项让内容与绝对位置发生交互。最后一项即使在两个 token embedding 相同时，也能比较它们的位置。加法之所以有效，是因为后续每个学习到的投影都会混合 token 与位置两部分。模型可以学到某个词在文档开头附近具有不同作用、某些 token 常常紧跟在附近的分隔符之后，或者某些绝对位置之间应当如何交互。

可学习的绝对位置嵌入。 最直接的方法为上下文中的每个序列位置分配一个可训练向量。Token embedding 回答“这是哪个 token”，位置嵌入回答“这次出现位于哪个位置”。若同一个 token $x$ 出现在位置 7 和 23，则初始隐藏状态分别为

\[h_7=e(x)+p_7, \qquad h_{23}=e(x)+p_{23}.\]

两者的 token 部分相同，$p_7$ 与 $p_{23}$ 则区分了这两次出现。它们被称为绝对位置向量，因为每个向量属于特定下标；它们又是可学习的，因为梯度下降会像更新模型其它参数一样更新它们。GPT-1 在长度 512、隐藏维度 768 的序列上训练，因此学习了 512 个 768 维的位置向量。实现通常将它们存成查找表 $P\in\mathbb R^{512\times768}$，位置 $t$ 读取第 $P_t$ 行。

这种灵活性也解释了它的局限。$p_{100}$ 和 $p_{101}$ 一开始是互不相关的参数，模型必须从数据中学会它们表示相邻位置。位置 512 之外则没有训练过的对应向量。可学习的绝对位置嵌入在训练上下文内提供灵活坐标，却没有为相对位移或训练范围外的位置提供内置结构。

正弦位置编码。 原始 Transformer 使用一个确定性构造替换了可学习的查找表。它仍然为每个位置生成一个 $d$ 维向量，只是这些坐标沿平滑、周期性的曲线变化，而非相互独立地训练。假设 $d$ 为偶数，构造使用 $d/2$ 个频率。对频率下标 $i=0,\ldots,d/2-1$，一个余弦坐标与一个正弦坐标组成一对：

\[p_t^{(i)} = \begin{bmatrix} \cos(\omega_i t) \\ \sin(\omega_i t) \end{bmatrix}, \qquad \omega_i=10000^{-2i/d}.\]

频率 $\omega_i$ 表示位置前进一步时，这一对坐标旋转多少弧度。等价地，波长 $\lambda_i=2\pi/\omega_i$ 表示完成一整圈需要多少个 token step。以 $d=6$ 为例，三组频率并排组成

\[p_t= \begin{bmatrix} \cos(\omega_0t),& \sin(\omega_0t),& \cos(\omega_1t),& \sin(\omega_1t),& \cos(\omega_2t),& \sin(\omega_2t) \end{bmatrix}^{\top}.\]

整个 $d$ 维向量就是 $p_t$，因此仍按 $h_t=e(x_t)+p_t$ 加到 token embedding 上。原始 base Transformer 的宽度是 512，所以每个位置的向量由 256 对坐标组成。每对坐标采用不同频率，但最终仍通过一次加法共同进入模型。

为什么每个频率要同时使用 sine 和 cosine？位置平移会变成一个与起始位置无关的旋转。对任意位移 $\Delta$，

\[p_{t+\Delta}^{(i)} = \begin{bmatrix} \cos(\omega_i\Delta)&-\sin(\omega_i\Delta) \\ \sin(\omega_i\Delta)&\cos(\omega_i\Delta) \end{bmatrix} p_t^{(i)} =R_i(\Delta)p_t^{(i)}.\]

同一个矩阵 $R_i(\Delta)$ 可以从任意位置前进 $\Delta$。比较两个位置时，相对位移也会自然出现：

\[\begin{aligned} \left(p_t^{(i)}\right)^\top p_s^{(i)} &=\cos(\omega_i t)\cos(\omega_i s) +\sin(\omega_i t)\sin(\omega_i s) \\ &=\cos(\omega_i t-\omega_i s) \\ &=\cos\!\left(\omega_i(t-s)\right). \end{aligned}\]

第二行来自 cosine subtraction identity，所以结果只依赖 $t-s$。若两个位置同时向前移动相同距离，比较结果不会改变。Cosine 对位移符号是对称的，但两坐标还能提供 cross term

\[\sin(\omega_i t)\cos(\omega_i s) -\cos(\omega_i t)\sin(\omega_i s) =\sin\!\left(\omega_i(t-s)\right).\]

当两个位置的先后次序反转时，这个量会改变符号。学习到的 query 与 key 投影可以组合这些坐标乘积，因此正弦和余弦坐标对同时包含相对位移的大小与方向信息。

一组正弦和余弦坐标最终会绕圆一周并重复。频率同时决定每个 token 的相位变化量和完成一圈所需的距离。完整位置编码会组合一系列不同频率。图 2 使用原始的 10,000 频率基数，展示 $d=16$、长度 512 时的频率谱。每一行追踪某个坐标随 $t$ 的变化，每一列则是完整的 $p_t$。

Sinusoidal position embeddings across positions and coordinates The horizontal axis contains 512 token positions and the vertical axis contains 16 embedding coordinates. Each pair of rows is one sine-cosine frequency pair. Fast-changing coordinates appear near the top and slow-changing coordinates near the bottom. One selected position is outlined and enlarged as a vertical vector on the right. SINUSOIDAL POSITION ENCODING each column is one position vector SELECTED COLUMN position 128 the complete vector p128 position embedding coordinate high frequency fast change low frequency slow change coordinate value −1 0 +1
Figure 2. Sinusoidal position embeddings across 512 positions, using $d=16$ and a frequency base of 10,000. Each column is the complete position vector $p_t$, and each adjacent pair of rows is one sine-cosine frequency. The high-frequency pairs near the top change rapidly across positions, while the low-frequency pairs near the bottom change slowly, showing how the encoding combines fine local variation with phase information that evolves over longer distances.

靠上的窄条纹来自短波长，靠下的宽条纹来自长波长。从 $t$ 移到 $t+\Delta$ 时，第 $i$ 对坐标前进角度 $\omega_i\Delta$，其 Euclidean change 为

\[\left\lVert p_{t+\Delta}^{(i)}-p_t^{(i)}\right\rVert =2\left\lvert\sin\!\left(\frac{\omega_i\Delta}{2}\right)\right\rvert \approx \omega_i\lvert\Delta\rvert \qquad \text{when }\lvert\omega_i\Delta\rvert\text{ is small}.\]

对同一个较小的 $\Delta$，频率越高，坐标变化越大。图中最快的一对使用 $\omega=1$，每个 token 旋转一弧度，约为 $57^\circ$，完成一圈只需约 6.3 个 token。最慢的一对使用 $\omega\approx0.000316$，每个 token 只旋转约 $0.018^\circ$，完整一圈需要约 20,000 个 token。上方的高频坐标可以区分邻近位移，但会快速循环；下方的低频坐标在相邻位置间变化很小，单独使用时无法区分这些位置，却能在更长距离上提供缓慢变化的参照。

这种组合类似同时观察钟表的快针和慢针。快针在一个短周期内分辨细小步长，慢针则把这个周期放进更大的范围。完整位置向量同样兼顾局部敏感性与长距离相位，只有所有坐标对同时对齐时，两个位置才会重合。Base Transformer 使用 256 个波长约从 6 到 60,000 token step 的坐标对。对位移 $\Delta$，所有频率上的 $\cos(\omega_i\Delta)$ 和 $\sin(\omega_i\Delta)$ 共同形成多尺度的相对位置特征，学习到的投影可以进一步组合它们。更远的 token 并不必然对应更大的位置-vector distance，因为这种编码具有周期性，而非单调性。

正弦 embedding 依然属于绝对位置编码，因为 $p_t$ 由绝对下标生成并在输入处相加。完整 attention 分数仍然包含前面展开的内容-位置交互项。它提供的保证更窄：平移具有共享的几何结构，相对位移可以从该结构中恢复。常数 10,000 决定波长范围，它是一个设计选择，并没有数学上的唯一性。

正弦构造为位置提供了有用的几何关系，但这套几何只在输入形成时进入一次。RoPE 将相同的旋转思想直接带进 attention，使相对位置直接影响 query 选择哪个 key。

现代 Transformer 如何使用位置

RoPE。 Rotary Position Embedding 将旋转结构放进 query-key 比较本身 (Su et al., 2021)。图 2 中的频率安排会再次出现。正弦位置编码将正弦和余弦值组成 $p_t$ 并加到 token embedding；RoPE 则用这些值定义作用于 query 和 key 坐标对的旋转。

RoPE 从一个简单目标出发。若 $f(q_t,t)$ 把位置 $t$ 施加到 query，$f(k_s,s)$ 把位置 $s$ 施加到 key，那么它们的 dot product 应保留内容 comparison，同时让位置只通过位移 $s-t$ 进入：

\[f(q_t,t)^\top f(k_s,s) =g(q_t,k_s,s-t).\]

这个要求保留两个内容向量，并把两个绝对位置下标化为相对位移。旋转恰好满足这样的组合规则。RoPE 将 query 与 key 的坐标两两分组，每一对按当前位置决定的角度旋转。对一个频率，位置 $t$ 的旋转为

\[R_t^{(i)} = \begin{bmatrix} \cos(\omega_i t) & -\sin(\omega_i t) \\ \sin(\omega_i t) & \cos(\omega_i t) \end{bmatrix}.\]

每对坐标使用自己的频率，与正弦 embedding 相同。将这些二维 rotation 放到一个大矩阵的 diagonal block 中，记作 $R_t$，便可让所有坐标对独立旋转。RoPE 计算

\[\widetilde q_t = R_t q_t, \qquad \widetilde k_s = R_s k_s.\]

在频率 $i$ 上，位置 $t$ 的 query 旋转 $\omega_i t$，位置 $s$ 的 key 旋转 $\omega_i s$。Attention 随后通过 dot product 比较完整的旋转向量。Rotation 的 transpose 会反转角度，因此 $R_t^\top=R_{-t}$；连续应用 rotation 会相加角度，因此 $R_aR_b=R_{a+b}$。两个绝对旋转最终组合成

\[\widetilde q_t^{\top}\widetilde k_s = q_t^{\top}R_t^{\top}R_s k_s = q_t^{\top}R_{s-t}k_s.\]

最终 rotation 只依赖 $s-t$。这就是 RoPE 的相对位置性质：位置 5 的 query 读取位置 2 的 key，与位置 103 的 query 读取位置 100 的 key，都会得到同一个位置变换，因为二者的 $s-t$ 都是 $-3$。它们的内容 vector 仍然可以产生不同分数，$q_t$ 和 $k_s$ 依然保留在表达式中。RoPE 为位移提供一致的几何结构，同时让模型继续学习内容 comparison。若用正方向位移 $\Delta=t-s$，同一 rotation 写作 $R_{-\Delta}$。

这种放置方式有两个直接结果。位置改变 query 或 key 的方向，却保持其 norm；相对位置几何直接参与选择来源 token 的分数。Value 通常不做旋转，因为它携带的是选择完成之后要取回的信息。公式可以在任意整数位置计算，但 checkpoint 只学会了训练上下文中出现过的 phase pattern。显著更长的上下文可能使部分频率进入模型未见过的相位区域。

Partial RoPE。 一个 query 或 key head 有许多坐标，无需让每个坐标都携带显式 rotary phase。多个现代模型只让 head 的一部分维度负责位置-sensitive comparison，剩余部分保留为普通内容特征。用上标 $(r)$ 与 $(u)$ 分别表示旋转和未旋转部分，则

\[\widetilde q_t = \begin{bmatrix} R_t q_t^{(r)} \\ q_t^{(u)} \end{bmatrix}, \qquad \widetilde k_s = \begin{bmatrix} R_s k_s^{(r)} \\ k_s^{(u)} \end{bmatrix}.\]

其 dot product 分解为

\[\widetilde q_t^\top\widetilde k_s = \left(q_t^{(r)}\right)^\top R_{s-t}k_s^{(r)} + \left(q_t^{(u)}\right)^\top k_s^{(u)}.\]

第一项通过相对 rotation $R_{s-t}$ 比较内容，第二项比较两个未旋转的特征 vector。同一个分数可以同时利用这两种信号。较小的位置切片仍能告诉模型两个 token 的相对位移，其余维度则为内容特征保留更多空间。切片大小成为架构选择：增大它会增加位置-sensitive interaction 的容量，减小它则让更多 head dimension 不受 rotary phase 影响。

这个拆分对 multi-head latent attention 尤其重要。MLA 需要一条较大的、与位置无关的内容路径，以便从 compressed cache 中读取；较小的 rotary 路径则显式保留。Attention 章节会推导为什么位置-dependent rotation 会阻碍相关的权重 absorption。其代价仍然需要通过实验判断：更小的 rotary slice 降低显式位置状态，同时也减少了分数中用于位置-sensitive interaction 的维度。

YaRN。 RoPE 可以在任意整数位置计算 rotation，但 checkpoint 只从训练序列中学过有限范围的 phase pattern。YaRN 会调整这些 rotation，使模型适应更长上下文 (Peng et al., 2023)。假设训练长度 $L_{\text{train}}=4096$，目标长度 $L_{\text{target}}=32{,}768$，目标包含八倍的位置，因此上下文-length ratio 为

\[\rho=\frac{L_{\text{target}}}{L_{\text{train}}} =\frac{32768}{4096}=8.\]

在 $t/\rho$ 处计算 RoPE，可以把更长的坐标范围映射回训练时见过的范围：位置 32,768 得到的角度大致等于原先位置 4,096 的角度。这个操作称为位置 interpolation，等价于将每个频率除以 $\rho$。但它也会压缩所有局部位移。$\rho=8$ 时，相隔八个 token 的角度差只相当于训练时的一个 token。波长为 64 的短波坐标在 4,096 token 内已经重复很多次，再缩小频率会损失熟悉的局部分辨率；波长为 16,384 的长波坐标在训练中只走过四分之一圈，若保持不变并延伸到 32,768，则会进入远超训练范围的 phase。

YaRN 因此对不同频段采用不同处理：短波长坐标尽量保留原频率，长波长坐标向 $\omega_i/\rho$ 缩放，中间频段进行插值：

\[\omega_i^{\text{YaRN}} = \gamma_i\omega_i + (1-\gamma_i)\frac{\omega_i}{\rho}.\]

$\gamma_i$ 取决于该频率在训练期间完成了多少圈，即 $L_{\text{train}}/\lambda_i$。接近 1 时保留原频率，接近 0 时采用完整 interpolation。YaRN 还会在 softmax 之前用一个依赖长度的经验系数缩放 attention logits，以补偿 key 数量大幅增加时 attention concentration 的变化。

这些改动不改变模型维度，所以已有 RoPE checkpoint 可以在推理时使用 YaRN，continuation 训练则让模型进一步适应新几何。Static YaRN 对所有请求固定目标 ratio，例如 $\rho=8$。此时在长度 1,024 上，一个完全插值的坐标只走到原来约位置 128 的角度。Dynamic YaRN 在 4,096-token 训练范围内保持原频率，只有请求增长时才增大 $\rho$，到 32,768 时达到 8。直接在 32,768 上使用原频率则属于 raw RoPE extrapolation。

论文同时测量了推理-only extension 和 continuation 训练。在 8k 实验中，推理-only YaRN 的 sliding-window perplexity 为 3.49，uniform interpolation 为 3.65。经过 400 个 continuation-训练 step 后，YaRN 达到 3.35；uniform interpolation 经过 1,000 step 后达到 3.34。结果与机制相符：尽量保留熟悉的局部 phase change，缩放会离开训练范围的慢速 rotation，并用更少的额外训练完成适应。

相对位置偏置。 RoPE 通过旋转 query 和 key 让距离影响 attention。另一种方法保持它们的几何不变，直接给 attention 分数加上学习到的距离偏好。例如，一个 head 可以学到紧邻的前一个 token 通常应获得小幅加分，而数百个位置之前的 token 不应享受这类默认偏好；内容点积仍然可以覆盖这个先验：

\[\operatorname{score}_{t,s,h} =\alpha q_{t,h}^\top k_{s,h} +b_h(\Delta), \qquad \Delta=t-s,\]

其中 $\alpha=1/\sqrt{d_h}$ 是通常的 attention 缩放因子，$b_h(\Delta)$ 是 head $h$ 对相对距离 $\Delta$ 学到的修正。若两个 token 同时前移，$\Delta$ 不变，因此这个偏好会跟随 token pair，而不属于某个绝对位置。

直接使用查找表也会遇到长上下文问题。表示两倍数量的精确距离需要两倍条目。对前沿模型来说，参数量也许仍可接受，但学习这些条目并在训练分布外使用它们更困难。每个远距离 bucket 只能从足够长的训练样本中获得更新，距离 900,000 的值与 900,001 的值之间也没有共享结构。训练后扩大表格只会产生没有训练过的新条目。因此实际设计需要共享、分桶、插值或有意设置截断距离。

Inkling 同时使用 sharing 与 cutoff，并让 distance preference 依赖当前 query。每一层学习 16 个可复用的 backward-distance profile。对每个 query 位置，每个 attention head 根据当前隐藏状态生成 16 个 mixing 权重：

\[r_{t,h}=W_R^{(h)}h_t\in\mathbb R^{16}.\]

这些 profile 组成 $B\in\mathbb R^{16\times D}$，其中 $D$ 是表示的 backward distance 数量。列 $B_{:,\Delta}$ 包含距离 $\Delta$ 上的 16 个 profile value，它们的加权组合给出 query-specific bias：

\[b_{t,h}(\Delta)=r_{t,h}^\top B_{:,\Delta}, \qquad \Delta=t-s.\]

$B$ 的每一行是一种随距离变化的学习模式，$r_{t,h}$ 则为当前 query 选择如何组合这些模式。因此同一个 head 可以对某个 token 偏好附近来源，对另一个 token 偏好更远的来源，距离仍作为一项加性修正进入内容分数。

表示范围被有意限制。Inkling 的 sliding-window 层覆盖窗口内全部 512 个位置，全局层的 relative bias 只学习距离 0 到 1,023。超过截断距离后，这个位置项贡献为零。距离 2,000 与 200,000 的 key 不会通过精确距离直接区分，但它们仍可通过 $q_t^\top k_s$ 以及较低的 causal 层和 short convolution 累积的上下文信息得到不同分数。精确距离成为学习到的局部先验，远程检索则主要依赖内容。缩小表格也带来明确边界：需要区分 20,000 与 200,000 token 精确距离的任务，必须通过其它计算恢复该信息。

YaRN 与 Inkling 采用不同的 long-上下文选择。YaRN 在整个扩展范围内维持 rotary coordinate，Inkling 只在有限邻域内提供精确 relative distance。Thinking Machines 报告称完整 Inkling 设计在其实验中比 RoPE 具有更好的效果和 extrapolation，但发布材料没有提供专门的位置机制 ablation。因此这一结果支持的是包括 bounded bias、内容 attention 和 short convolution 在内的整体架构。

综合六个模型可以看到，位置机制会跟随 token mixer 及其记忆 layout。Kimi、DeepSeek 和 GLM 将 partial RoPE 与压缩或共享 cached 内容的 attention 结合；Kimi 与 DeepSeek 还通过 YaRN 延伸 rotary 路径。Qwen 只在 full-attention 层使用 partial RoPE，recurrent Gated DeltaNet 层则通过 causal 状态 update 与 short convolution 获得顺序。MAI 先在局部 attention 中加入 RoPE，再把隐藏状态交给全局层。Inkling 使用 bounded relative bias，把更远距离的 retrieval 交给内容。位置选择决定了 attention 可以比较什么、哪些信息必须留在记忆中，也因此自然引向下一节的 attention 与 caching。

注意力与记忆

位置信息告诉模型 token 来自哪里，attention 则决定当前位置应该读取哪些 token，以及从中取回什么。令 $x_t\in\mathbb R^{d_{\text{model}}}$ 表示位置 $t$ 的隐藏状态，$X\in\mathbb R^{T\times d_{\text{model}}}$ 堆叠进入某一 attention 层的全部 $T$ 个隐藏状态。一个 attention head 先进行三次学习到的投影：

\[Q=XW_Q, \qquad K=XW_K, \qquad V=XW_V.\]

三种投影给 token 分配三种角色。Query $q_t$ 表示当前位置在寻找什么，key $k_s$ 表示来源位置 $s$ 可以通过什么特征被匹配，value $v_s$ 则携带匹配成功后要返回的信息。对 causal decoder 中的位置 $t$，

\[\ell_{t,s}=\frac{q_t^\top k_s}{\sqrt{d_h}}, \qquad s\le t,\] \[a_{t,s} =\frac{\exp(\ell_{t,s})}{\sum_{j=1}^{t}\exp(\ell_{t,j})}, \qquad o_t=\sum_{s=1}^{t}a_{t,s}v_s.\]

Dot product 越大，query 与 key 的方向越接近，相应 value 对输出的影响越大。除以 $\sqrt{d_h}$ 可以抵消 head 宽度增长带来的分数 variance，使 softmax 不会仅因为 head 变宽就变得过于尖锐。写成矩阵形式就是

\[\operatorname{Attention}(Q,K,V) =\operatorname{softmax}\!\left( \frac{QK^\top}{\sqrt{d_h}}+M \right)V.\]

$QK^\top$ 的形状为 $T\times T$。Causal mask 保留其中 $T(T+1)/2$ 个 query-key pair，因此 full prompt attention 的算术量为 $O(T^2)$。FlashAttention 通过在片上高速内存中分块访问 Q、K、V，并逐块维护 softmax 所需的最大值和归一化因子，避免完整分数 matrix 的反复读写 (Dao et al., 2022)。它返回完全相同的 attention 结果，$O(T^2)$ 的 pairwise arithmetic 仍然存在。

KV Cache

生成分为 prefill 和逐 token decoding。Prefill 一次处理完整 prompt，并在每一层为全部位置计算 Q、K、V。生成位置 $t$ 时，第 $l$ 层的新隐藏状态产生

\[q_t^{(l)}=h_t^{(l-1)}W_Q^{(l)}, \qquad k_t^{(l)}=h_t^{(l-1)}W_K^{(l)}, \qquad v_t^{(l)}=h_t^{(l-1)}W_V^{(l)}.\]

当前 query 要读取此前所有 key 与 value：

\[o_t^{(l)} =\operatorname{softmax}\!\left( \frac{q_t^{(l)}(K_{\le t}^{(l)})^\top}{\sqrt{d_h}} \right)V_{\le t}^{(l)}.\]

过去的 query 已经完成自己的输出，不会再次出现；过去的 key 和 value 却可能被每个未来 query 读取。若不保存 K/V，模型每生成一个 token 都要重新经过前面的各层，再重复历史位置上的 K/V 投影。推理系统因此将这些已经计算好的张量保留下来，这就是 KV cache。

KV caching across prefill and one decode step During prefill, full query, key, and value matrices are computed for T prompt positions. Keys and values flow into the layer cache, while queries stop after producing the prefill outputs. During decoding, one new query row attends to cached keys plus one new key, and the resulting weights mix cached values plus one new value. The new key and value are then appended to the cache. KV CACHE, ONE DECODER LAYER prefill creates the history; each decode step restores it and appends one slice PREFILL T prompt positions are processed together Q [T, dh] × Kᵀ [dh, T] → attention weights [T, T] × V [T, dh] → outputs [T, dh] Q is not cached KV CACHE AFTER PREFILL K1:T T retained key rows V1:T T retained value rows ONE DECODE STEP qT+1 [1, dh] used once × Kᵀ≤T+1 [dh, T+1] new k → weights [1, T+1] × V≤T+1 [T+1, dh] new v → oT+1 [1, dh] restored from cache computed for position T+1 append the new k/v slice after this step
Figure 3. For one decoder layer, prefill creates the retained K/V history. Each decode step reads that history with one new query, then adds one new key-value slice. Adapted from NVIDIA's KV-caching illustration (Verma & Vaidya, 2023).

图 3 将 prefill 和一次 decode step 画在同一个 tensor layout 中。Prefill 生成 $T$ 行 Q、K、V。Q 在产生本位置输出后结束，K 和 V 则进入 cache。Decode 时，新的 $q_{T+1}$ 乘以恢复出的 key matrix，得到一行 attention 权重，再用它混合 value matrix。新的 $k_{T+1}$ 与 $v_{T+1}$ 随后加入 cache，供下一步使用。

普通 multi-head attention 的 cache 近似占用

\[M_{\mathrm{KV}}=2BTLn_hd_hb,\]

其中 $B$ 是批大小，$T$ 是保留长度，$L$ 是层数，$n_h$ 是 head 数，$d_h$ 是 head 宽度，$b$ 是每个数的字节数，系数 2 来自 K 和 V。若 $B=1$、$T=32{,}768$、$L=32$、$n_h=32$、$d_h=128$，并使用每个数 2 字节的 BF16，单条序列就需要 16 GiB KV cache。上下文越长，cache 的驻留容量和每个新 token 读取 K/V 的带宽都线性增加。PagedAttention 则把固定大小的逻辑 cache block 映射到不连续的物理显存，使不同长度请求的增长和共享前缀复用更容易管理 (Kwon et al., 2023)。

压缩每个 Token 的 Cache

第一类现代改动保留 $T$ 个可独立寻址的 token 条目，只缩小每个条目保存的内容。MQA 与 GQA 在多个 query head 之间共享 K/V；MLA 更进一步，用一个 compact latent 表示替代完整的 per-head K/V tensor。

共享 K/V Head

普通 multi-head attention（MHA）中，Q、K、V 都产生 $H_q$ 个 head。每个来源 token 因此向 cache 增加 $H_q$ 个 key 和 $H_q$ 个 value。Multi-query attention（MQA）保留 $H_q$ 个 query head，却只生成一个 K head 和一个 V head (Shazeer, 2019)。不同 query head 仍然会对共享 key 产生不同权重，只是它们读取同一个来源表示。

Grouped-query attention（GQA）位于两者之间 (Ainslie et al., 2023)：

\[Q\in\mathbb R^{B\times H_q\times T_q\times d_h}, \qquad K,V\in\mathbb R^{B\times H_{kv}\times T_k\times d_h},\]

其中 $1<H_{kv}<H_q$，每个 K/V stream 服务 $H_q/H_{kv}$ 个 query head。MHA 对应 $H_{kv}=H_q$，MQA 对应 $H_{kv}=1$。

MHA, GQA, and MQA head layouts All three layouts contain eight query heads. Multi-head attention uses eight key and value heads, grouped-query attention uses two shared key and value heads, and multi-query attention uses one shared key and value head. Values Keys Queries MHA 8 query heads · 8 K/V heads 8 independent K/V streams GQA 8 query heads · 2 K/V heads 2 shared K/V streams · ¼ cache width MQA 8 query heads · 1 K/V head 1 shared K/V stream · ⅛ cache width Every source token remains; only its cached K/V head axis shrinks.
Figure 4. K/V heads stored for each source token. MHA assigns a K/V pair to every query head, GQA shares each pair within a group, and MQA shares one pair across all query heads. The token positions remain individually addressable in all three layouts. Adapted from Figure 2 of the GQA paper (Ainslie et al., 2023).

图 4 固定相同的序列 length 和 query head 数，只改变每个 token 保存多少 K/V head。因此 cache 公式变为

\[M_{\mathrm{KV}}=2BTLH_{kv}d_hb.\]

从 $H_q$ 个 cached head 减少到 $H_{kv}$，cache 容量和 decode 时的 K/V 读取量按 $H_q/H_{kv}$ 缩小。所有 $H_q$ 个 query 仍会与每个可见位置比较，所以 full-attention pair count 基本不变。这个设计的直觉是：模型对历史提出许多不同问题的能力，比为每个问题都保存一份独立来源表示更重要。Inkling 与 MAI 的传统 attention 层使用 GQA，Qwen3.5 则在周期性的 full-attention 层中使用 gated GQA。

用 MLA 压缩 K/V

Multi-head latent attention（MLA）(DeepSeek-AI, 2024) 沿用了 LoRA 中“先降维、再升维”的低秩思路 (Hu et al., 2022)。LoRA 用这种结构表示权重更新，MLA 则把它用于生成 key 和 value 的路径：先把来源隐藏状态压缩成共享 latent，再从 latent 生成每个 head 的内容 key 和 value。

\[c_s^{KV}=W^{DKV}h_s\in\mathbb R^{d_c},\] \[k_{s,h}^{C}=W_h^{UK}c_s^{KV}, \qquad v_{s,h}=W_h^{UV}c_s^{KV}.\]

这相当于将原来的投影 factorize 为

\[W_h^K=W_h^{UK}W^{DKV}, \qquad W_h^V=W_h^{UV}W^{DKV}.\]

Serving 时真正值得保留的是中间的 $c_s^{KV}$，也就是 KV latent。问题在于，若每次 decode 都把全部历史 latent 重新展开成 per-head K/V，计算量会随上下文增长；若缓存展开结果，又会恢复原来的大 cache。MLA 依靠线性运算的结合律改变计算顺序。Key 路径可以将 up-投影移到当前 query 一侧：

\[q_{t,h}^\top W_h^{UK}c_s^{KV} =\left((W_h^{UK})^\top q_{t,h}\right)^\top c_s^{KV}.\]

模型只需变换一次当前 query，就能直接与所有 cached latent 比较。Value 路径同样可以先在 latent space 中完成 weighted sum，再做 up-投影：

\[\sum_s a_{t,s,h}W_h^{UV}c_s^{KV} =W_h^{UV}\left(\sum_s a_{t,s,h}c_s^{KV}\right).\]

这就是权重 absorption。扩展后的历史 K/V 无需真正 materialize。

完整 RoPE 会破坏这种吸收，因为来源旋转 $R_s$ 随历史位置变化。MLA 因此把分数分成较大的内容通路和较小的 rotary 通路。内容 key 从 latent 生成并保持可吸收；额外的共享 rotary key $k_s^R$ 显式缓存：

\[q_{t,h}=[q_{t,h}^{C};q_{t,h}^{R}], \qquad k_{s,h}=[k_{s,h}^{C};k_s^R].\]

最终每个来源 token 只需保留

\[\operatorname{Cache}(s)=[c_s^{KV},k_s^R].\]
Multi-head latent attention architecture Reading upward, an input hidden state produces a query latent, one shared rotary key, and a shared key-value latent. The query latent expands into per-head content and rotary queries. The key-value latent expands through the key and value up-projections into per-head content keys and values, while the shared rotary key supplies the positional part of every key. Content and rotary slices are concatenated before attention, and multi-head attention produces one output per head before the final hidden state. A moving highlight marks the key-value latent and rotated shared key that are cached for each source token. MULTI-HEAD LATENT ATTENTION cached during inference per token: cKV + kR output hidden ut {ot,i} Multi-Head Attention queries { [qC; qR] }h keys { [kC; kR] }h values {vC}h concat {qC}h {qR}h concat k R t shared across heads {kC}h W UQ i apply RoPE query latent c Q t W UK i W UV i KV latent c KV t down-project down-project apply RoPE input hidden ht
Figure 5. MLA in MHA mode, read from bottom to top. The KV latent expands through $W_i^{UK}$ and $W_i^{UV}$ into each head's content key and value. The moving gradient identifies $c^{KV}$ and $k^R$, the tensors retained in the cache for each source token. Adapted from Figure 2 of the DeepSeek-V2 technical report (DeepSeek-AI, 2024).

图 5 展示投影 view：query side 的中间量只服务当前 token，来源 side 的 $c_s^{KV}$ 与 $k_s^R$ 则需要留给未来 query。高效 decode 会采用吸收后的等价顺序，直接读取这两个 compact tensor。通用 Transformers 实现有时会重新展开并缓存 K/V，这能验证函数，却会失去 MLA 的 cache 优势。真正的收益依赖 latent-aware serving kernel。

Kimi K2 还遇到了 attention logit 在 Muon 训练中增长到极大值的问题 (Kimi Team, 2025)。通常的 $1/\sqrt{d_h}$ 只补偿 head 宽度，无法阻止学习到的 Q/K norm 在训练中增长。QK-Norm 会直接归一化 projected query 和 key，但吸收后的 MLA 并不显式 materialize完整 key。Kimi 因此使用 QK-Clip，在 optimizer step 后约束相关投影的 scale。这属于训练稳定性机制，不改变 MLA 的主要记忆表示。

决定读取哪些 Token

减少每个 token 的 cache 宽度之后，还可以减少 query 实际读取的位置数。Full attention、sliding window、periodic 全局 attention、attention sink 与学习到的 sparse selection 都作用在这个维度上。

Attention visibility patterns and local information flow across layers The top row compares four single-layer attention masks. The lower left panel uses the same matrix form to show a sliding-window receptive field widening across layers. The lower right panel reads from the input upward and shows the corresponding growth in information coverage. DIRECT VISIBILITY WITHIN ONE LAYER Global every earlier key key position → query position → Sliding Window the latest W keys the same local band in every row Window + Sink initial keys remain visible sink column + recent window Sparse Top-k query-dependent keys a different sparse row per query LAYER-WISE RECEPTIVE FIELD Layer 1 W = 3 Layer 2 2W − 1 = 5 Layer 3 3W − 2 = 7 … Layer L 1 + L(W − 1) direct in this layer reachable through lower layers INFORMATION COVERAGE ACROSS DEPTH higher layer Layer L 1 + L(W − 1) ⋮ Layer 3 3W − 2 = 7 Layer 2 2W − 1 = 5 Layer 1 W = 3 Input 1 earlier positions t
Figure 6. Top: four single-layer attention masks, where every filled cell is a query-key pair computed by the main attention operation. Lower left: attention-style matrices show the effective receptive field after Layer 1, 2, 3, and $L$; dark cells are read directly in the current layer, while lighter cells are reachable through lower layers. Lower right: reading upward from the input, the same width-3 window expands the information available to state $t$. Adapted from the layer-wise receptive-field analysis in PowerAttention (Chen et al., 2025).

Sliding-window attention。 位置 $t$ 只直接读取最近 $W$ 个 key：

\[\mathcal S_t^{\mathrm{局部}} =\{\max(1,t-W+1),\ldots,t\}.\]

单层可见范围有限，但多层可以通过中间隐藏状态逐步传递更远信息。若每层 window 宽度为 $W$，经过 $L$ 层后，一个输出最多可受

\[R_L=1+L(W-1)\]

个连续输入位置影响。不过最终 query 仍只对上一层的 $W$ 个状态直接分配 attention 权重，更早信息已经被压进中间表示。Prompt attention 从 $O(T^2)$ 下降到约 $O(TW)$；只有运行时真正丢弃未来不再需要的条目时，cache 容量才会有相应下降。

周期性全局 attention。 Inkling 与 MAI 都采用五层 512-token 局部 attention 后接一层全局 attention 的周期。局部层以固定成本处理附近信息，全局层定期恢复对完整前缀的直接比较，使远程细节无需永远依赖多跳传播。

Attention sink。 Softmax 要把总概率质量分配为 1。当没有可见 token 值得读取时，一些模型会把多余概率放到最前面的稳定 token 上。StreamingLLM 因而在 rolling cache 中同时保留少量初始 token 与最近窗口 (Xiao et al., 2023)。DeepSeek V4 则为每个 head 学习一个没有对应 value 的 sink logit，分配给 sink 的概率在 value mixing 前直接消失。

DeepSeek Sparse Attention（DSA）。 固定窗口按距离决定可见范围，DSA 则让每个 query 根据内容选择远程位置。直接先运行完整 MLA 再取 top-$k$ 已经产生全部成本，因此 DSA 使用一个更便宜的 Lightning Indexer 先扫描历史，再让 core MLA 只读取候选位置 (DeepSeek-AI, 2025)。

DeepSeek Sparse Attention under MLA The neutral path follows MLA in multi-query attention mode. A query latent produces the main query heads, while a key-value latent and a shared rotary key form each complete cache entry. The accented path sends smaller index queries, cached index keys through the current token, and query-dependent head weights into the Lightning Indexer. Its scores drive a top-k selector, which gathers both the selected MLA keys and their latent values for core attention. DEEPSEEK SPARSE ATTENTION UNDER MLA output hidden ut { o C t,i } {ot,i} W UV i Multi-Query Attention (Core Attention) {[ q A t,i ; q R t,i ]} Top-k Selector concat { q A t,i } { q R t,i } { q C t,i } W UK i c Q t apply RoPE complete MLA cache entry c KV t k R t concat k R t apply RoPE c KV t Lightning Indexer { q I t,j } partial RoPE { k I s } s≤t partial RoPE { w I t,j } input hidden ht
Figure 7. DeepSeek Sparse Attention instantiated under MLA. The accented path shows the Lightning Indexer ranking source tokens and the Top-k Selector gathering the selected MLA keys and latent values for core attention. Adapted from Figure 1 of the DeepSeek-V3.2-Exp report.

Indexer 为每个来源 token 保存一个窄 key $k_s^I$。当前 token 生成多个 index query 与 query-dependent head 权重，组合成每个来源的一个 ranking 分数：

\[I_{t,s} =\sum_{j=1}^{H_I}w_{t,j}^I \operatorname{ReLU}\!\left((q_{t,j}^I)^\top k_s^I\right).\]

多个 query head 允许小型 scorer 从不同方向搜索，ReLU 把每个 head 变成 positive-match detector，$w_{t,j}^I$ 决定当前 query 重视哪些方向。Top-$k$ 只返回位置下标；core MLA 随后从这些位置收集完整 cache 条目，并重新计算自己的 attention logits、softmax 和 value mixture。Indexer 的分数不会直接成为 core attention 权重。

Indexer 通过模仿稠密 attention 的分布学习候选位置，之后模型再适应 sparse top-$k$ 路径。Attention 主计算从 $O(T^2)$ 下降到 $O(Tk)$，indexer 对所有历史位置的扫描仍然存在，只是每次比较更窄、更便宜。GLM-5.2 使用相同的两阶段机制，也会选择 2,048 个位置 (GLM-5 Team, 2026)。它还进一步使用 IndexShare：四层一组，第一层计算 top-$k$ 位置，后三层复用这些地址。每层仍使用自己的 MLA 投影、attention 权重和 value，只省去重复的全历史索引扫描。相邻层的相关位置常常高度重合，但复用也意味着后三层无法补回第一层漏掉的位置 (Bai et al., 2026)。

将 Token 历史压缩成更少的条目

DSA 让 attention 主计算读取更少位置，但它搜索的历史仍然每个 token 增加一个条目。DeepSeek V4 更进一步，先把远程历史本身压成更短的序列 (DeepSeek-AI, 2026)。

V4 使用 Shared K=V MQA。每个 query head 用一个共享来源 vector $c_s$ 同时作为 key 与 value：

\[\alpha_{t,i,s} =\operatorname{Softmax}_s\!\left( \frac{q_{t,i}^{\mathsf T}c_s}{\sqrt{d_h}} \right), \qquad o_{t,i}=\sum_s\alpha_{t,i,s}c_s.\]

不同 query head 仍会提出不同问题并产生不同权重，来源 side 却只保留一个表示。V4 随后把一组 token 压缩成一个学习到的记忆。每个隐藏状态产生 candidate $C_s$ 与 compression logits $Z_s$，每个特征 coordinate 都在 block 内独立做 softmax：

\[C_s=h_sW^{KV}, \qquad Z_s=h_sW^Z,\] \[A_{s,r}=\operatorname{Softmax}_{s\in\mathcal B}(Z_{s,r}+B_{s,r}), \qquad C_r^{\mathrm{comp}}=\sum_{s\in\mathcal B}A_{s,r}C_{s,r}.\]

不同 coordinate 可以从 block 中不同 token 提取信息，因此比简单平均或一个共享 scalar 权重更灵活。

CSA 采用 4:1 overlapping compression。每个条目同时读取当前 4-token chunk 和前一个 chunk，并通过两个独立的 $a/b$ 分支进行特征-wise pooling。它还用另一套相同结构生成更窄的 compressed index key。Indexer 扫描这些 key，选择最多 1,024 个 compressed 条目交给 core attention。

HCA 同时改变三个选择：它采用 128:1 的无重叠压缩和单一 compressor 分支，并让 query 稠密读取全部压缩条目。二者的核心差异如下。

  CSA HCA
压缩比例 4:1 128:1
Block overlap 相邻 4-token chunk 重叠 不重叠的 128-token block
Compressor 两个分支（$a/b$） 单分支
远程记忆粒度 每 4 个新 token 一个条目 每 128 个 token 一个条目
检索方式 Indexer top-$k$ 稠密读取全部条目

HCA 将 32,768-token 历史压成 256 个远程条目，因此稠密扫描已经足够便宜；代价是远程记忆粒度更粗。CSA 保留更细的摘要，并为依赖 query 的检索支付 indexer 成本。两者都保留一个精确的 128-token 局部窗口，用于近期 token 和尚未完成的压缩分块。

DeepSeek-V4 compressed attention from source tokens to attention output Source hidden states feed two aligned feature-wise pooling modules and an exact sliding-window branch. One module forms compressed Shared Key-Value entries; the other forms narrower index keys. The Lightning Indexer uses those keys to select remote entries, while HCA reads a more heavily compressed sequence densely. The remote and local entries join query heads in Shared Key-Value Multi-Query Attention, followed by a grouped output projection. A moving highlight marks exact, compressed, and index-key entries retained in the cache. Output hidden state ⋯ concatenate WOB ⋯ ⋯ ⋯ group 1 group 2 group g ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ W₁ᴼᴬ W₂ᴼᴬ Wgᴼᴬ Shared K=V Multi-Query Attention inverse partial RoPE concatenate partial RoPE exact recent entries ⋯ selected compressed entries ⋯ core query heads partial RoPE Top-k selector compressed K=V entries CiComp HCA dense read main compressor CiComp weighted pooling ∑ Sᵇ ⊙ Cᵇ + ∑ Sᵃ ⊙ Cᵃ ⋯ ⋯ Cb Ca ⋯ ⋯ Sb Sa ⋯ ⋯ Zb+Bb Za+Ba softmax over tokens ⋯ nearest tokens (sliding window) previous chunk (b) current chunk (a) WbKV WaKV WbZ WaZ Compressed Lightning Indexer index scores Lightning Indexer kiIComp qIt,j wIt,j index-key compressor query hidden state latent cQ
Figure 8. DeepSeek-V4 compressed attention. The $b$ path reads the preceding source chunk and the $a$ path reads the current one. Each compact stack represents the source-token rows in one chunk. Learned $W^{aKV}$ and $W^{bKV}$ projections produce the candidate stacks. Separate $W^{aZ}$ and $W^{bZ}$ projections, together with learned within-chunk biases $B^a$ and $B^b$, produce one combined score stack. A single softmax across all source positions gives $S^a$ and $S^b$, whose two weighted contributions are added in the pooling module. The compact index-key compressor repeats this structure with independent parameters and a narrower feature width; the superscript $I$ marks its indexer-side keys, query heads, and head weights. The moving highlight marks exact recent entries, compressed remote entries, and compressed index keys retained during decoding. At the top, each head group passes through its own $W_g^{OA}$ projection before concatenation, then $W^{OB}$ returns the result to the residual-stream width.

V4-Pro 的 61 个主层先使用两层 HCA，之后 CSA 与 HCA 交替，共 31 层 HCA、30 层 CSA。模型在深度方向反复切换较粗粒度的稠密覆盖与更细粒度的稀疏检索，每层都保留精确的局部窗口。Partial RoPE 为压缩条目和局部条目提供 query 到来源的相对位置，compressor 内学习到的 slot bias 则标识 token 在 block 中的位置。不同层需要保存局部状态、尚未完成的分块、压缩条目，以及 CSA 特有的压缩索引 key 与重叠缓冲区，因此 cache 本身也成为一种异构状态。

将 Token 历史压缩成固定大小的状态

CSA 与 HCA 的远程序列仍会随着 block 数增长。Linear attention 把整个历史折进形状固定的 recurrent 状态。Qwen3.5 在大多数层中使用 Gated DeltaNet，再定期回到全局 softmax attention。

普通 causal attention 在位置 $t$ 需要 $t$ 次 query-key comparison，处理长度 $T$ 的序列共需要

\[1+2+\cdots+T=\frac{T(T+1)}{2}=O(T^2).\]

若暂时以 dot product 作为分数并省略 normalization，乘法可以重新组合：

\[\begin{aligned} o_t &=\sum_{i\le t}v_i(k_i^\top q_t) \\ &=\left(\sum_{i\le t}v_ik_i^\top\right)q_t \\ &=S_tq_t, \end{aligned}\] \[S_t=S_{t-1}+v_tk_t^\top.\]

每个 K/V pair 都写入同一个 matrix $S_t$，未来 query 直接读取这个 matrix，无需重访独立 key。固定 $d_k,d_v$ 后，$S_t$ 的形状与历史长度无关，所以处理 $T$ 个 recurrent step 的成本为 $O(T)$。

New-token computation in softmax and linear attention Standard attention compares the new query with cached keys, applies softmax to the score row, then uses the resulting weights to mix cached values. The linear-attention side shows its fixed-shape numerator state; normalized variants retain an additional vector state. Repeating the steps across T positions gives quadratic and linear work in sequence length. SOFTMAX ATTENTION growing K/V cache O(T) past K/V cache new K/V V K qₜ softmax(qₜKᵀ) aₜ × oₜ 1 + 2 + ··· + T O(T²) LINEAR ATTENTION fixed-size recurrent state O(1) St = St−1 + vtktT St qₜ × oₜ 1 + 1 + ··· + 1 O(T)
Figure 9. One softmax query forms a length-$t$ score row, normalizes it, and uses the resulting weights to mix $V$. The linear-attention side shows the fixed-shape numerator state $S_t$; normalized kernel variants keep a vector state $z_t$ in parallel. The bottom line in each column accumulates the per-position work.

更一般地，可以用有限维特征 map 定义 factorized similarity：

\[\kappa(q,k)=\phi(q)^\top\phi(k), \qquad S_t=\sum_{i\le t}v_i\phi(k_i)^\top, \qquad o_t=S_t\phi(q_t).\]

$\phi$ 的 $r$ 个 coordinate 可以理解为 $r$ 个 shared 记忆 channel。所有历史 token 只能通过这些固定 channel 影响未来 query。若希望保持 weighted average 的归一化形式，还需保存

\[z_t=\sum_{i\le t}\phi(k_i), \qquad o_t=\frac{S_t\phi(q_t)}{z_t^\top\phi(q_t)}.\]

Softmax 使用 $\exp(q^\top k)$。在一维中，Taylor expansion 为

\[\exp(qk) =1+qk+\frac{q^2k^2}{2!}+\frac{q^3k^3}{3!}+\cdots,\]

对应的精确 $\phi$ 含有所有多项式阶数，因此是无限维。实际的 linear attention 可以使用有限特征近似，例如 Performer 的正值随机特征 (Choromanski et al., 2021)；也可以选择另一个可分解的正值 kernel，并从头训练模型适应这种相似度。原始 Linear Transformer 使用 $\phi(x)=\operatorname{ELU}(x)+1$ (Katharopoulos et al., 2020)。后来的循环式 mixer 也常常省略显式 $z_t$，改用 Q/K normalization、状态衰减、输出归一化与学习到的 gate 控制尺度。例如 2024 年的并行 DeltaNet 会先对 Q 和 K 应用 SiLU，再进行 $\ell_2$ 归一化 (Yang et al., 2024)。

DeltaNet。 $S_t$ 可以理解为一张 key-to-value 的 linear map。一个 outer product 满足

\[(v_ik_i^\top)q=v_i(k_i^\top q),\]

也就是先比较 query 与 key，再按匹配强度返回 value。将所有 outer product 相加会把关联叠在同一个 matrix 中。相似 key 会写进重叠方向，相同 key 再次写入则会把新 value 累加到旧 value 上。

DeltaNet 先读取当前位置已经保存的内容，再只写入 prediction error (Schlag et al., 2021)：

\[\widehat v_t=S_{t-1}k_t, \qquad S_t=S_{t-1}+\beta_t(v_t-\widehat v_t)k_t^\top.\]

$\beta_t=\sigma(W_\beta x_t)$ 是输入-dependent write gate。若 unit-norm key 地址原来读出 10、新目标为 3，delta update 写入 $3-10=-7$，而普通 additive update 会得到 13。这个 rule 等价于对局部记忆 objective $\frac12\lVert Sk_t-v_t\rVert_2^2$ 做一次 online gradient step。

Gated DeltaNet。 Delta update 只修正当前 key 方向，其他 stale 内容仍可能留在状态中。Gated DeltaNet 先用 $\alpha_t$ 衰减整个旧状态，再用 $\beta_t$ 进行 targeted correction (Yang et al., 2025)：

\[\widetilde S_t=\alpha_tS_{t-1}, \qquad \widehat v_t=\widetilde S_tk_t,\] \[S_t=\widetilde S_t+\beta_t(v_t-\widehat v_t)k_t^\top, \qquad o_t=S_tq_t.\]

$\alpha_t$ 管理整张记忆的遗忘，$\beta_t$ 控制当前关联被改写的强度。完整 Gated DeltaNet block 在 recurrent rule 之前还加入 kernel 宽度 4 的 causal depthwise short convolution：

\[\widetilde U^q_{t,c} =\sum_{r=0}^{K-1}C^q_{r,c}U^q_{t-r,c}.\]

每个 channel 有自己沿时间维的 $K$ 个学习到的权重，shape 保持 $T\times d_q$。Short convolution 让当前位置生成 Q/K/V 前先看最近几个 token，可以学习 previous-token shift、局部 difference、短语边界等局部 pattern。它提供显式局部路径，recurrent matrix 则携带长期状态。Block 还生成输出 gate $g_t$：

\[y_t=W_O\!\left[\operatorname{Norm}(o_t)\odot\operatorname{SiLU}(g_t)\right].\]
Four projected token vectors entering ShortConv and the Gated DeltaNet block The left shows four separate projected token vectors beside one compact learned four-by-d query convolution matrix. Short arrows connect both operands to one elementwise multiplication, whose output is summed across time. One column is highlighted to trace a single channel. A dashed leader connects this expansion to the query Conv node in the Gated DeltaNet block. Query and key paths use Linear, Conv, SiLU, and L2 Norm; value uses Linear, Conv, and SiLU; alpha and beta enter the gated delta rule; the separate output gate runs around the right side of the rule. SHORT CONVOLUTION · K = 4 projected token learned kernel Cq ⊙ token t−3 token t−2 token t−1 token t Σ after ShortConv GATED DELTANET BLOCK yt Linear × Norm Gated Delta Rule qt L2 Norm SiLU Conv Linear kt L2 Norm SiLU Conv Linear vt SiLU Conv Linear αt Linear βt Linear SiLU Linear gt ht
Figure 10. Gated DeltaNet's token mixer. Each row on the left is a separate token after the Q projection. The compact learned matrix $C^q\in\mathbb R^{4\times d_q}$ supplies four temporal weights for every channel; the highlighted column traces one channel. The dashed leader identifies the Q-path Conv expanded on the left. The K and V paths use their own learned kernels. The block follows Figure 1 of the Gated Delta Networks paper.

生成时，层 cache 只需固定大小的 $S_t$ 与 short convolution 最近几个 projected channel。Qwen3.5 以三层 Gated DeltaNet 加一层 gated 全局 GQA 的比例重复。Recurrent 层以固定状态承担大多数序列 mixing，周期性 full attention 则重新提供对独立历史 token 的 query-dependent direct access。Qwen 报告该 3:1 hybrid 优于其测试的纯 linear-attention 与纯 standard-attention stack (Qwen Team, 2025)。

这一整章的机制作用在不同轴上。MQA、GQA 与 MLA 改变每个 token 保存多少信息；局部 attention、DSA 与 IndexShare 改变 query 读取哪些位置以及如何找到它们；CSA 与 HCA 减少远程记忆条目数；linear attention 与 DeltaNet 在使用它们的层中直接移除不断增长的 token 轴。QK-Norm、QK-Clip、attention sink 与输出 gate 则控制分数尺度、归一化行为和写入残差流的强度。存储宽度、条目数量、可读位置、状态表示与 attention 动力学可以独立选择，所以现代模型能够组合这些技术。

MLP 与 MoE

Attention 决定当前位置从序列中收集什么，MLP 决定如何处理已经写入当前隐藏状态的信息。它在每个位置独立运行，并在所有 token 之间共享参数。原始 Transformer 的 FFN 为

\[\operatorname{FFN}(h)=W_{\mathrm{down}}\,\sigma(W_{\mathrm{up}}h).\]

若 $w_j$ 是 $W_{\mathrm{up}}$ 的第 $j$ 行，$d_j$ 是 $W_{\mathrm{down}}$ 的第 $j$ 列，则

\[\operatorname{FFN}(h) =\sum_{j=1}^{d_{\mathrm{ff}}}\sigma(w_j^\top h)d_j.\]

每个 $w_j$ 检测隐藏状态中一种学习到的模式，激活值决定对应更新方向 $d_j$ 写回多少。更宽的中间层提供更多“检测并更新”的组合；非线性让不同输入激活不同组合。

Gated MLP

SwiGLU 为中间层的每个坐标生成两个学习到的视图，一个表示候选内容，另一个调节它在当前上下文中的重要程度：

\[\operatorname{SwiGLU}(h) =W_{\mathrm{down}} \left[ \operatorname{SiLU}(W_{\mathrm{gate}}h) \odot W_{\mathrm{up}}h \right].\]

乘法使每个特征响应都依赖上下文。由于 $h$ 已包含 attention 收集的信息，gate 可以抑制、反转或放大候选特征。这里的 gate 并非概率，SiLU 可以为负，也没有 1 的上界。SwiGLU 多出一条投影，因此在相近参数预算下通常使用比普通 FFN 更窄的中间维度。受控实验发现这种门控形式优于 ReLU 与 GELU FFN (Shazeer, 2020)，本文六个模型都在稠密 MLP、expert 或两者中使用它。

DeepSeek V4 还为训练稳定性加入 clamping。令 $u=W_{\mathrm{up}}h$、$g=W_{\mathrm{gate}}h$，则

\[\widetilde u=\operatorname{clip}(u,-10,10), \qquad \widetilde g=\min(g,10), \qquad m=\operatorname{SiLU}(\widetilde g)\odot\widetilde u.\]

内容分支受到双侧限制，gate 的激活前数值只截断过大的正值，从而限制极端乘积，同时保留 SwiGLU 的基本结构。

Sparse Mixture of Experts

Gated MLP 可以按输入选择特征，但每个 token 仍经过同一组投影。代码、中文与算术关系可能需要不同的非线性变换。单纯增宽共享 MLP 会增加容量，却让所有 token 都支付完整计算。MoE 提供多个独立 MLP 和一个学习到的 router。Router 对归一化后的输入 $x$ 产生分数与概率：

\[s(x)=W_rx, \qquad p(x)=\operatorname{softmax}(s(x)).\]

Dense MoE 会评估全部 expert 并混合结果：

\[m_{\mathrm{dense}}(x)=\sum_{e=1}^{E}p_e(x)\operatorname{MLP}_e(x).\]

可以把它理解成一个小型 function committee。相似隐藏状态若反复偏好同一 expert，该 expert 会在相应输入区域得到更多训练并逐渐 specialization。部分研究确实观察到 domain 或 language preference (Do et al., 2026)，但 expert 的作用也可能没有简洁的人类标签。

Sparse MoE 只保留分数最大的 $k$ 条 route：

\[\mathcal A(x)=\operatorname{TopK}(s(x),k),\] \[m_{\mathrm{sparse}}(x) =\sum_{e\in\mathcal A(x)}\widetilde p_e(x)\operatorname{MLP}_e(x).\]

模型仍存储全部 $E$ 个 expert，每个 token 只执行其中 $k$ 个。与包含相同 expert 的 dense MoE 相比，参数量不变，expert 计算量大幅减少；与每个 token 计算量相近的 dense MLP 相比，则可以存储远多得多的参数 (Shazeer et al., 2017)。

Dense and sparse mixture-of-experts routing Both pre-norm sublayers store four expert MLPs. Dense routing evaluates all four experts. Sparse top-two routing evaluates only expert MLPs one and three. Each mixed output is added to the residual stream. DENSE MoE 4 stored · 4 evaluated h′ₜ + Σ 0.41 0.19 0.32 0.08 MLP₁ MLP₂ MLP₃ MLP₄ router .41 .19 .32 .08 RMSNorm residual hₜ SPARSE MoE 4 stored · 2 evaluated h′ₜ + Σ 0.56 0 0.44 0 MLP₁ MLP₂ MLP₃ MLP₄ router .41 .19 .32 .08 RMSNorm residual hₜ
Figure 11. One pre-norm MLP sublayer with four stored expert MLPs. Dense routing evaluates all four and mixes them with weights $(0.41,0.19,0.32,0.08)$. Sparse top-2 routing evaluates $\operatorname{MLP}_1$ and $\operatorname{MLP}_3$ only; this example renormalizes their weights to $(0.56,0.44)$. The resulting mixture follows the same residual addition on both sides.

图 11 展示一个 pre-norm MLP 子层。Dense MoE 将 token 送入全部四个 expert，sparse top-2 路由只选择概率最高的 MLP 1 和 MLP 3，再对选中权重归一化、混合并通过残差连接加回 $h_t$。

TopK 中不可导的是从连续分数到离散 expert 索引集合的跳变。选定集合之后，被选中的权重、expert 输出及其参数仍可正常反向传播。若两个分数从 $(0.60,0.59)$ 变为 $(0.60,0.601)$，活跃分支会突然切换，普通导数无法在这个边界上给出连续斜率。未选 expert 没有为该 token 计算输出，也就没有“如果选择它会怎样”的反事实梯度。热门 expert 因此可能得到更多训练并越来越强，冷门 expert 则进一步缺少数据。

稀疏激活还会引入系统成本。Expert 通常分布在不同 GPU 上，token 必须分发到选中的设备，再把输出传回。良好的 MoE 设计需要同时平衡存储容量、实际计算量、路由负载与 all-to-all 通信。

Fine-Grained 与 Shared Expert

现代模型倾向于使用很多较窄的 expert。假设一种设计激活一个中间宽度为 8,192 的 expert，另一种激活八个宽度为 1,024 的 expert。两者每个 token 执行的总中间宽度相同，后者却能独立选择八个较小变换，组合方式更多。这就是 fine-grained expert segmentation 的直觉 (Dai et al., 2024)。

某些变换对几乎所有 token 都有用。Shared expert 通常在 routed TopK 之外始终执行，提供一条公共 MLP 路径。DeepSeek 风格的实现会混合 routed expert 的输出，再直接加上一个 shared SwiGLU。若多个始终活跃的 SwiGLU 只是相加，它们可以等价地拼成一个更宽的 shared 分支，因此“几个 shared expert”主要描述这条常驻 MLP 路径的宽度。

不同模型的组合并不一致。DeepSeek V4-Pro 从 384 个 routed expert 中选 6 个并加一个 shared expert；Kimi K2.5 从 384 个中选 8 个；Qwen3.5 从 512 个中选 10 个，并给 shared 路径单独的 sigmoid gate；Inkling 则让两个 shared expert 带输入-dependent 权重，并与 routed expert 一起归一化。更细的粒度带来更多组合，也意味着更多 router logits、更碎的 dispatch 和更小的 matrix multiplication。

保持 Router 平衡

Specialization 无需让每个 expert 接收完全相同的 token 数，但长期严重失衡会造成训练反馈循环和硬件等待。Switch Transformer 的经典方法在 language-model loss 之外加入 balancing loss (Fedus et al., 2022)：

\[\mathcal L_{\mathrm{balance}} =\alpha E\sum_{i=1}^{E}f_iP_i,\]

其中 $f_i$ 是实际送往 expert $i$ 的 token fraction，$P_i$ 是平均 router probability。过载且长期高概率的 expert 会增大 loss，gradient 通过 $P_i$ 调低这种偏好。

Loss-Free Balancing 使用更直接的 feedback controller。TopK 之前给 expert $i$ 加 correction bias $b_i$，每个 batch 后根据实际 load 更新：

\[\mathcal A(x_t)=\operatorname{TopK}_i(s_{i,t}+b_i,k),\] \[b_i\leftarrow b_i+u\,\operatorname{sign}(\bar c-c_i).\]

负载低于平均值的 expert 得到正向修正，过载 expert 得到负向修正。Bias 只影响选择过程，原始 router 分数仍决定被选输出如何混合，因此无需把平衡项加入语言模型的梯度 (Wang et al., 2024)。DeepSeek V4-Pro、Kimi K2.5、GLM-5.2 和 Inkling 都使用这种 correction bias。

用 LatentMoE 压缩 Expert 通信

在大模型中，expert 常常通过 expert parallelism 分布在多个 GPU。标准 MoE 会把宽度为 $d$ 的隐藏状态复制并发送给每个被选 expert，再收回宽度为 $d$ 的结果，因此两个方向各传输约 $kd$ 个数。LatentMoE 在来源 GPU 上先进行共享的 down-projection：

\[z_t=W_{\downarrow}h_t, \qquad z_t\in\mathbb R^\ell, \qquad \ell<d.\]

Dispatcher 发送 $z_t$，远程 expert 也返回 $\ell$ 维输出。结果在 latent space 中合并，最后通过 shared up-投影回到 model 宽度：

\[m(h_t)=W_{\uparrow} \left[ \sum_{i\in\mathcal A(h_t)}p_i(h_t)E_i(W_{\downarrow}h_t) \right].\]

Router 仍读取原始 $h_t$，所以决定 token 去哪里时保留完整表示；只有 routed expert 分支被压缩。All-to-all 通信量从 $kd$ 变成 $k\ell$。

Standard MoE and LatentMoE architectures A standard MoE sublayer with four experts and Top-2 routing is compared with an iso-budget LatentMoE example with eight narrower experts and Top-4 routing. Both include the hidden-state residual path, shared expert, router, all-to-all dispatch, weighted selected experts, and all-to-all combine. LatentMoE adds a down-projection before dispatch and an up-projection after combine. STANDARD MOE 4 experts · Top-2 · routed width d h′ₜ width d + All-to-all combine × × SE E1 E2 E3 E4 All-to-all dispatch Router hₜ width d LATENTMOE 8 experts · Top-4 · routed width ℓ = d/2 h′ₜ width d + UP ℓ → d All-to-all combine × × × × SE E1 E2 E3 E4 E5 E6 E7 E8 All-to-all dispatch DOWN d → ℓ Router hₜ width d
Figure 12. An iso-budget illustration. The standard layer has four experts with routed width $d$ and activates two. With $\ell=d/2$, LatentMoE halves each expert's routed input and output width, allowing eight experts and Top-4 at approximately the same routed-parameter and active-compute cost. Communication per selected expert is halved; the larger TopK uses that saving, leaving total per-token all-to-all traffic roughly comparable. Hatched boxes are selected experts, the × nodes apply router weights, and SE is the shared expert. Adapted from the original LatentMoE comparison (Elango et al., 2026).

图 12 复现论文在相同预算下的比较。若 $\ell=d/2$，expert 池可从四个增加到八个，TopK 从二增加到四。每个被选 expert 只传一半数据，双倍 TopK 后总通信量仍约等于标准 MoE。若保持 TopK 不变，则可以直接减少通信。MAI-Base-1 把 6,656 维隐藏状态路由到 512 个 expert 中的 8 个，在分发前压缩到 3,072 维，expert 计算完成后再恢复宽度。较窄的 latent 可能丢失 expert 所需信息，额外投影也会增加计算；收益在于把节省的通信量和参数带宽投入更多 expert 或更大的 TopK。

归一化与残差连接

在深度 $l$，decoder 用矩阵 $H_l\in\mathbb R^{T\times d}$ 表示全部 token。$H_0$ 来自输入 embedding，$H_L$ 最终映射为 vocabulary logits。序列

\[H_0\longrightarrow H_1\longrightarrow\cdots\longrightarrow H_L\]

就是 residual stream。它并非额外模块，只是隐藏状态沿模型深度持续传递的主干。Attention 从中读取并写入跨 token 的更新，MLP 则在每个位置写入非线性更新：

\[U_l=H_l+\Delta_l^{\mathrm{attn}}, \qquad H_{l+1}=U_l+\Delta_l^{\mathrm{mlp}}.\]

旧表示可以直接通过，每个子层只需学习应增加的修正。Residual stream 的不断相加也会使整体尺度随深度和训练变化。若隐藏状态放大 $c$ 倍，不带 bias 的 Q 和 K 都近似放大 $c$ 倍，其点积会放大 $c^2$；MLP 激活与 SwiGLU 的 gate-content 乘积也会改变。归一化为学习到的分支提供更稳定的输入尺度，使它可以专注于各坐标的模式，而无需同时适应不断漂移的整体幅度。

Pre-Norm 与 RMSNorm

Post-norm 的一般子层写作

\[H_{l+1}=\operatorname{Norm}(H_l+F_l(H_l)).\]

即使 $F_l$ 很小，残差路径仍要经过归一化。现代 decoder 更常使用 pre-norm：

\[H_{l+1}=H_l+F_l(\operatorname{Norm}(H_l)).\]

学习分支读取归一化后的副本，原始 $H_l$ 直接进入加法。若 $F_l=0$，则 $H_{l+1}=H_l$。其 Jacobian 为

\[\frac{\partial H_{l+1}}{\partial H_l} =I+\frac{\partial F_l(\operatorname{Norm}(H_l))}{\partial H_l}.\]

$I$ 来自对 $H_l$ 的直接复制，为前向信息和反向梯度提供一条无需连续穿过学习变换的路径。它不能保证训练永远稳定，但能显著减轻深层网络对一串 Jacobian 乘积的依赖 (Xiong et al., 2020)。

LayerNorm 同时减去均值并除以标准差 (Ba et al., 2016)：

\[\operatorname{LayerNorm}(x) =g\odot\frac{x-\mu(x)}{\sqrt{\sigma^2(x)+\epsilon}}+b.\]

RMSNorm 只控制尺度，不进行重新居中 (Zhang & Sennrich, 2019)：

\[\operatorname{RMSNorm}(x) =g\odot\frac{x}{\sqrt{\frac1d\sum_i x_i^2+\epsilon}}.\]

忽略 $\epsilon$ 时，$\operatorname{RMSNorm}(cx)\approx\operatorname{RMSNorm}(x)$，因此同一种坐标模式即使整体放大，分支看到的输入仍近似相同。它省去均值计算、中心化减法和 bias，并在现代 decoder-only 模型中表现出足够的稳定性。本文六个模型都使用 RMSNorm，这代表一种经验上有效的工程默认选择，并不意味着它在所有场景都优于 LayerNorm。

Pre-norm 只归一化分支读取的副本，residual stream 自身仍不断累加。最后通常还需

\[Z=\operatorname{RMSNorm}(H_L)W_{\mathrm{vocab}},\]

使词表输出层读取到尺度可控的最终表示。

Manifold-Constrained Hyper-Connections

普通残差子层始终执行 $x_{l+1}=x_l+F_l(x_l)$。这条恒等路径很稳定，但所有层都读取并修改同一个显式的跨层状态。Hyper-Connections（HC）将一条 residual stream 扩展为 $n$ 条完整宽度的 stream (Zhu et al., 2025)：

\[X_l\in\mathbb R^{n\times d}.\]

每个子层用三个小映射完成读取、混合和写回：

\[h_l^{\mathrm{in}}=A_lX_l, \qquad h_l^{\mathrm{out}}=F_l(h_l^{\mathrm{in}}), \qquad X_{l+1}=B_lX_l+C_lh_l^{\mathrm{out}},\]

其中

\[A_l\in\mathbb R^{1\times n}, \qquad B_l\in\mathbb R^{n\times n}, \qquad C_l\in\mathbb R^{n\times1}.\]

$A_l$ 从多个 stream 读取一个子层输入，$B_l$ 让旧 stream 彼此混合并向前传递，$C_l$ 将一个子层输出分配回多个 stream。Attention 或 MLP 仍只运行一次，所以昂贵子层不会执行 $n$ 份；持久残差状态则扩大为 $n$ 倍。多条 stream 让一部分信息长期保留，另一部分持续加工，并允许模型学习短路径、长路径和部分并行的跨层路线。

自由的 $B_l$ 会在深度上重复相乘：

\[B_{L-1}B_{L-2}\cdots B_lX_l.\]

每层只放大 $1.02$，100 层后也会变成约 $7.2$；每层缩小到 $0.98$，100 层后则只剩约 $0.13$。HC 获得灵活路由的同时，也引入了连续矩阵乘积造成的不稳定性。

Manifold-Constrained Hyper-Connections（mHC）保留多 stream 拓扑，并把 $B_l$ 约束到由非负双随机矩阵构成的 Birkhoff polytope (Xie et al., 2026)：

\[\mathcal B_n =\left\{B\in\mathbb R^{n\times n}\ \middle|\ B\mathbf1=\mathbf1, \ \mathbf1^\top B=\mathbf1^\top, \ B_{ij}\ge0\right\}.\]

每行和为 1，使输出 stream 成为输入 stream 的凸组合；每列和为 1，保持每个输入的总影响。双随机矩阵的谱范数不超过 1，而且它们的乘积仍然是双随机矩阵，因此 residual mixer 不会在深度上放大欧几里得范数。模型先对未约束的 logits 取指数，再通过 Sinkhorn-Knopp 迭代交替进行列归一化与行归一化：

\[M^{(0)}=\exp(\widetilde B_l), \qquad M^{(r)}=\operatorname{RowNorm}(\operatorname{ColNorm}(M^{(r-1)})).\]

读取和写回系数也被限制为有界的非负值：

\[A_l=\sigma(\widetilde A_l), \qquad C_l=2\sigma(\widetilde C_l).\]
Residual connection paradigms A narrow standard residual panel is followed by wider Hyper-Connection and manifold-constrained Hyper-Connection panels. The multi-stream panels show four residual streams, a one-by-four reader matrix, a four-by-four residual mixer, a four-by-one writer matrix, and one ordinary layer evaluation. RESIDUAL one stream · fixed route xl+1 + Fl xl HYPER-CONNECTIONS four streams · learned routing Xl+1 + BlXl Bl Cl hout Layer Fl hin Al Xl 4 streams × d MANIFOLD-CONSTRAINED HC four streams · constrained routing Xl+1 + BlXl Bl Sinkhorn Cl 2·sigmoid hout Layer Fl hin Al sigmoid Xl 4 streams × d
Figure 13. One-token view of the residual path, adapted from Figure 1 of the mHC paper. The cell grids make the stream-axis shapes explicit: $A_l\in\mathbb R^{1\times4}$ reads four streams into one $h_{\mathrm{in}}$, $B_l\in\mathbb R^{4\times4}$ mixes the persistent streams, and $C_l\in\mathbb R^{4\times1}$ writes one $h_{\mathrm{out}}$ back to four streams. The ordinary layer $F_l$ still runs once. mHC keeps the same topology and constrains the three routing maps.

DeepSeek V4-Pro 使用 $n=4$，在每个 block 的 attention 和 MoE 周围各放一个 mHC 模块。残差状态的形状为 $[B,T,4,7168]$，$A_l$ 先把四条 stream 合成一个普通宽度的子层输入，$C_l$ 再把输出写回经过 $B_l$ 混合的四条 stream。最后，一个学习到的 hyper-connection head 在最终 RMSNorm 与词表输出层之前将四条 stream 合并。融合 kernel、选择性重计算和流水线重叠将官方报告的训练耗时增幅降到 6.7%。

直觉上，普通 residual 像单车道，所有信息沿同一条路前进，每一层继续向其中加入更新。HC 开出多条车道，并让学习到的匝道决定从哪里读取、如何换道、把新信息写到哪里。自由的匝道可能在许多层后把流量不断集中或稀释。mHC 给换道矩阵加入守恒约束，让旧信息可以重新分配，同时避免路由本身产生指数级增益。

现代 Transformer 的设计逻辑

理解现代 Transformer 最有效的方式，是把它看作一套由不同成本、信息保真度和访问方式组成的分层信息路径。逐 token 保存的精确记忆与稠密计算都很昂贵，因此现代架构会分别安排这两类预算：重要信息继续走高保真路径，其余信息则进入压缩、稀疏、循环或条件路径。由此节省的显存、带宽、计算量和通信量，又可以支持更大的参数容量与更灵活的路由。精确路径和数值约束负责保护近似机制最容易损伤的能力。

从这个角度看，各个 Transformer 组件的变化属于同一套系统。Attention 已经成为记忆系统的设计：它决定保留哪些历史、以什么形式保留，以及哪些信息仍可被直接寻址。位置机制则要以适合该记忆表示的方式附着位置信息。MLP 已经成为条件计算：MoE 保存大量变换，每个 token 只激活其中一小部分。残差连接决定信息如何沿深度传播，归一化、门控与路由约束则让这些路径保持可控。熟悉的 decoder block 仍保留着原来的外形，内部的资源分配已经发生了明显变化。

本文介绍的几类 attention 正好展示了这条连续谱。MLA 仍为每个 token 保留一条记录，同时缩小记录的特征宽度；局部和稀疏 attention 保留逐 token 的记忆，同时限制 query 可以读取的位置；CSA 与 HCA 把部分远程序列压成学习到的摘要；Gated DeltaNet 则把历史折进固定大小的循环状态。它们削减的成本各不相同，保留的能力也不同。Latent cache 保留逐 token 寻址，稀疏检索保留对少量远程 token 的直接访问，分块压缩减少长期驻留的记忆条目，循环状态则移除不断增长的 token 轴，也因此无法再单独访问已经折入状态的历史记录。

MoE 把同一原则应用到模型容量。稀疏路由让总参数量与每个 token 的计算量在一定程度上分离，细粒度 expert 为 router 提供更多可组合的更新。LatentMoE 又把通信纳入预算，通过缩小跨设备传输的激活来降低成本。省下来的资源通常会在架构的其它位置重新投入。DeepSeek V4 例如降低远程记忆与活跃 expert 的成本，同时保留更大的参数池和四条残差流。因此，架构效率更适合被理解为预算再分配：先让一种资源变得便宜，再把节省的预算投入更有价值的容量。

混合架构是其中反复出现的设计原则。激进的近似机制通常会配一条更窄、保真度更高的路径。Qwen 在循环层之间周期性插入完整 attention，DeepSeek 则在压缩的远程记忆旁始终保留精确的局部窗口。局部 attention 堆栈会通过全局层重新连接，路由 expert 也可以与稠密或共享计算共存。这些路径补回压缩和条件路由容易损失的信息访问能力。约束机制处理另一类风险：QK normalization 控制 attention 分数增长，router balancing 控制 expert 流量，mHC 约束残差混合在深度上的连续组合。精确路径保护访问能力，约束机制维持系统可控。

这些节省最终还要由实际实现兑现。运行时需要继续保存 latent，MLA 才能降低 cache；不可达条目需要真正被移出 cache，局部 attention 才能减少容量；kernel 需要直接消费选中的索引，稀疏 attention 才能减少计算。Gated DeltaNet 依赖能够直接处理固定状态的循环 kernel，LatentMoE 也需要让激活跨越设备边界时保持窄维。在这个规模上，架构同时规定了方程、张量的存放位置和移动方式。

综合这些模型，近期细节通常保留显式的局部路径，远程历史则可以存成 latent、按需选择、压成学习到的摘要，或折进循环状态。广泛有用的变换在需要一致性的地方保持稠密，额外容量则转为条件激活。最常被削减的资源包括 KV-cache 容量、内存带宽、attention 计算量、每个 token 实际执行的 expert 计算和通信流量；这些节省又支持更大的 expert 池、更丰富的路由、额外的残差流，以及周期性的精确访问。现代 Transformer 的设计，就是构造一套受预算约束的信息层级：在错误代价高的地方保留精确路径，压缩或路由其余工作，再把节省的资源投入每个 token 可以按需使用的容量。