旋转约束下的压缩：从 RoPE 到 DeepSeek MLA

Transformer 推理的一个核心瓶颈是 KV Cache：每个 token 的 Key 和 Value 向量需要缓存以供后续 token 的注意力计算使用，其存储量随序列长度线性增长。当上下文窗口扩展到 128K 甚至 1M token 时，KV Cache 的显存占用成为部署的硬约束。低秩压缩是最自然的思路——将高维的 KV 向量投影到低维空间存储——但 RoPE 的旋转操作让这件事变得远比想象中复杂。

本文聚焦于一个看似简单的数学问题：为什么不能先对 KV 做低秩压缩再施加 RoPE？答案涉及旋转矩阵与低秩投影的深层不兼容性，而理解这个不兼容性，就是理解 DeepSeek MLA 的解耦 RoPE 设计的全部动机。

MLA 的完整架构和实验分析见 Multi-Head Latent Attention，本文聚焦解耦设计的数学动机。

KV Cache 的瓶颈

标准的 Multi-Head Attention（MHA）中，每个注意力头独立维护 Key 和 Value 向量。对于序列长度 $L$ 、隐藏维度 $d$ 、头数 $h$ ，KV Cache 的存储量为：

\text{KV Cache} = 2 \times L \times h \times d_h

其中 $d_h = d/h$ 是每头维度。以 LLaMA-2-70B 为例： $L = 4096$ ， $h = 64$ ， $d_h = 128$ ，KV Cache 占用 $2 \times 4096 \times 64 \times 128 \times 2 = 128\text{MB}$ （FP16）。当 $L$ 扩展到 128K 时，这个数字飙升至 4GB。

三个主流的 KV Cache 压缩方案是：

Multi-Query Attention (MQA)：所有头共享一组 KV，将 KV Cache 缩减为 $2 \times L \times d_h$ ，但牺牲了多头间的表达能力
Grouped-Query Attention (GQA)：将头分为 $g$ 组，每组共享 KV，是 MQA 和 MHA 的折中
Multi-Head Latent Attention (MLA)：将 KV 投影到低维潜在空间，通过低秩压缩实现与 GQA 相当的压缩率，同时保持更强的表达能力

MLA 的压缩策略最为优雅，但也面临一个其他方案没有的数学障碍：RoPE 的旋转操作与低秩投影不兼容。

低秩压缩的直觉

低秩压缩的核心假设是：KV 向量虽然生活在 $d$ 维空间中，但其有效信息实际上集中在一个更低维的子空间中。

形式化地说，假设存在投影矩阵 $\mathbf{W}^{down} \in \mathbb{R}^{r \times d}$ （ $r \ll d$ ）和重构矩阵 $\mathbf{W}^{up} \in \mathbb{R}^{d \times r}$ ，使得：

\mathbf{k} \approx \mathbf{W}^{up} \mathbf{W}^{down} \mathbf{k} = \mathbf{W}^{up} \mathbf{c}_k

其中 $\mathbf{c}_k = \mathbf{W}^{down} \mathbf{k} \in \mathbb{R}^r$ 是压缩后的潜在向量。存储时只需保存 $\mathbf{c}_k$ （ $r$ 维而非 $d$ 维），使用时通过 $\mathbf{W}^{up}$ 重构。

这种压缩在信息论上是合理的。Transformer 的 Key 向量是由线性投影 $\mathbf{k} = \mathbf{W}_K \mathbf{x}$ 生成的，其中 $\mathbf{W}_K \in \mathbb{R}^{d_h \times d}$ 。当 $d_h < d$ 时， $\mathbf{W}_K$ 本身就是低秩的（秩最多为 $d_h$ ），Key 向量自然位于 $\mathbf{W}_K$ 的列空间中。MLA 的思路是：既然 Key 向量本来就存在于低维子空间中，为什么不在缓存时利用这一点？

RoPE 与低秩压缩的不兼容性

问题出现在 RoPE 的旋转操作上。在标准 MHA + RoPE 中，注意力分数的计算流程是：

\text{score}(m, n) = (\mathbf{R}_m \mathbf{q}_m)^T (\mathbf{R}_n \mathbf{k}_n)

其中 $\mathbf{R}_m$ 和 $\mathbf{R}_n$ 是 RoPE 的旋转矩阵。如果对 Key 做低秩压缩，理想的工作流是：

\text{score}(m, n) = (\mathbf{R}_m \mathbf{q}_m)^T (\mathbf{R}_n \mathbf{W}^{up} \mathbf{c}_k)

但这里有一个微妙的问题。在推理阶段， $\mathbf{c}_k$ 从 KV Cache 中取出后，需要先重构 $\mathbf{k} = \mathbf{W}^{up} \mathbf{c}_k$ ，再施加旋转 $\mathbf{R}_n \mathbf{k}$ 。这意味着每个新 token 在注意力计算时都需要执行：

\mathbf{R}_n \mathbf{W}^{up} \mathbf{c}_k

而 $\mathbf{R}_n \mathbf{W}^{up}$ 是一个 $d \times r$ 的矩阵，随位置 $n$ 变化。这与低秩压缩的初衷——缓存一个固定低维向量、用固定的上投影矩阵重构——相矛盾：如果 $\mathbf{R}_n \mathbf{W}^{up}$ 随位置变化，那么预计算 $\mathbf{W}^{up} \mathbf{c}_k$ 并缓存就失去了意义，因为旋转必须在重构之后才能施加。

更深层的问题是：旋转矩阵 $\mathbf{R}_n$ 会破坏低秩结构。设 $\mathbf{k}$ 位于 $\mathbf{W}^{up}$ 的列空间中，即 $\mathbf{k} = \mathbf{W}^{up} \mathbf{c}$ 。施加旋转后：

\mathbf{R}_n \mathbf{k} = \mathbf{R}_n \mathbf{W}^{up} \mathbf{c}

问题是： $\mathbf{R}_n \mathbf{W}^{up}$ 的列空间是否仍然可以由某个 $r$ 维子空间表示？

答案是：一般情况下不可以。

数学证明

旋转矩阵 $\mathbf{R}_n$ 是正交矩阵， $\mathbf{W}^{up} \in \mathbb{R}^{d \times r}$ （ $r < d$ ）。 $\mathbf{W}^{up}$ 的列空间 $\mathcal{S} = \text{col}(\mathbf{W}^{up})$ 是 $\mathbb{R}^d$ 中的一个 $r$ 维子空间。

旋转矩阵 $\mathbf{R}_n$ 作用在 $\mathcal{S}$ 上得到 $\mathbf{R}_n \mathcal{S} = \{\mathbf{R}_n \mathbf{v} : \mathbf{v} \in \mathcal{S}\}$ ，这也是一个 $r$ 维子空间。关键问题是：不同的位置 $n$ 对应不同的旋转，产生的子空间 $\mathbf{R}_n \mathcal{S}$ 也不相同。

考虑注意力计算中 Query 和 Key 的交互。Query 一侧计算 $\mathbf{R}_m \mathbf{q}_m$ ，Key 一侧需要计算 $(\mathbf{R}_n \mathbf{W}^{up} \mathbf{c}_k)$ 。在自回归推理时，对于已经缓存的 Key，我们需要对所有历史位置 $n = 1, 2, \ldots, L$ 计算这个值。

如果我们想用低秩表示来避免重构 $d$ 维向量，需要找到一个投影矩阵 $\mathbf{P}$ 使得：

\mathbf{q}_m^T \mathbf{R}_m^T \mathbf{R}_n \mathbf{W}^{up} \mathbf{c}_k = (\mathbf{P} \mathbf{R}_m \mathbf{q}_m)^T (\mathbf{P} \mathbf{R}_n \mathbf{W}^{up} \mathbf{c}_k)

但这要求 $\mathbf{R}_m^T \mathbf{R}_n \mathbf{W}^{up}$ 的列空间对所有 $m, n$ 都能被同一个低秩投影 $\mathbf{P}$ 捕捉，而这对于一般的旋转矩阵是不成立的。

更具体地，考虑 RoPE 的分块对角旋转矩阵。对于 $d = 4$ （两个维度对），旋转矩阵为：

\mathbf{R}_n = \begin{pmatrix} \cos n\theta_1 & -\sin n\theta_1 & 0 & 0 \\ \sin n\theta_1 & \cos n\theta_1 & 0 & 0 \\ 0 & 0 & \cos n\theta_2 & -\sin n\theta_2 \\ 0 & 0 & \sin n\theta_2 & \cos n\theta_2 \end{pmatrix}

假设 $\mathbf{W}^{up}$ 的两列为 $\mathbf{u}_1, \mathbf{u}_2 \in \mathbb{R}^4$ 。 $\mathbf{R}_n \mathbf{u}_1$ 和 $\mathbf{R}_n \mathbf{u}_2$ 的方向随 $n$ 变化而旋转。不同位置 $n$ 对应的 $\mathbf{R}_n \mathbf{u}_1$ 在 $\mathbb{R}^4$ 中形成不同的方向——当 $n$ 取遍 $1$ 到 $L$ 时，这些方向的集合会"填满"比 $r = 2$ 更高维的子空间。

只有在极其特殊的情况下（比如 $\mathbf{W}^{up}$ 的列恰好是旋转的公共特征向量）， $\mathbf{R}_n \mathcal{S} = \mathcal{S}$ 对所有 $n$ 成立。但 RoPE 的旋转矩阵没有实数特征向量（它是真正的旋转，不是反射），所以这种情况不可能发生。

权重吸收：从工程视角看不兼容性

上述"向量旋出子空间"的论证从几何角度解释了不兼容性，但还可以从更工程化的"权重吸收"视角来理解这个问题。

不加 RoPE 时，注意力分数的计算为：

\text{score}(m, n) = \mathbf{q}_m^T \mathbf{k}_n = \mathbf{h}_m^T \mathbf{W}_Q^T \mathbf{W}_K \mathbf{h}_n

其中 $\mathbf{W}_Q^T \mathbf{W}_K$ 是一个固定的 $d \times d$ 矩阵，可以预计算。在 MLA 的框架下， $\mathbf{h}_n$ 被压缩为低维潜在向量 $\mathbf{c}_n = \mathbf{W}^{down} \mathbf{h}_n$ ，注意力计算变为：

\text{score}(m, n) = (\mathbf{W}^{Q_c} \mathbf{c}_m)^T (\mathbf{W}^{KV_c} \mathbf{c}_n)

关键在于 $\mathbf{W}^{Q_c}$ 和 $\mathbf{W}^{KV_c}$ 都是固定矩阵， $\mathbf{c}_n$ 可以预计算并缓存——这就是"权重吸收"，推理时只需存储低维的 $\mathbf{c}_n$ 而非高维的 $\mathbf{k}_n$ 。

加 RoPE 后，中间插入了位置相关的旋转矩阵 $\mathbf{R}_{m-n}$ ：

\text{score}(m, n) = \mathbf{h}_m^T \mathbf{W}_Q^T \mathbf{R}_{m-n} \mathbf{W}_K \mathbf{h}_n

$\mathbf{R}_{m-n}$ 随位置差 $m - n$ 变化，无法与 $\mathbf{W}_Q^T$ 或 $\mathbf{W}_K$ 合并为固定矩阵——权重吸收失效。在低秩压缩框架下，这意味着无法将旋转操作"吸收"到上投影矩阵中，必须先重构高维向量再施加旋转，低秩缓存的效率优势荡然无存。

这条论证路径比"向量旋出子空间"更精确也更工程化：它直接指向了解耦设计的动机——恢复权重吸收能力。解耦设计将旋转操作从低秩压缩路径中移除，使得内容部分的投影矩阵可以预计算和合并，从而在推理时实现真正的低秩缓存。

RoPE 与低秩压缩的冲突

Loading visualization...

左：低秩投影后的 KV 向量（2D 子空间）；中：施加 RoPE 后向量旋出子空间；右：解耦设计——内容在低维子空间，位置独立编码

// ========================================
// RoPE 与低秩压缩冲突可视化
// ========================================

const W = container.clientWidth;
const H = container.clientHeight;

const cs = getComputedStyle(document.documentElement);
const colors = {
  accent: cs.getPropertyValue('--viz-accent').trim() || '#3b82f6',
  text: cs.getPropertyValue('--viz-text').trim() || '#1f2937',
  muted: cs.getPropertyValue('--viz-text-muted').trim() || '#6b7280',
  grid: cs.getPropertyValue('--viz-grid').trim() || '#e5e7eb',
};

// --- 控制面板 ---
const controls = d3.select(container).append('div').attr('class', 'd3-viz-controls');
controls.append('label').text('位置 n:');
const posSlider = controls.append('input')
  .attr('type', 'range').attr('min', 0).attr('max', 64).attr('value', 0).attr('step', 1);
const posValue = controls.append('span').attr('class', 'd3-viz-value').text('0');

controls.append('label').text('动画:');
const playBtn = controls.append('button')
  .text('▶ 播放')
  .style('font-size', '0.8em')
  .style('padding', '2px 8px')
  .style('border-radius', '4px')
  .style('cursor', 'pointer')
  .style('border', '1px solid ' + (colors.grid || '#ccc'))
  .style('background', 'transparent');

controls.append('div').attr('class', 'd3-viz-hint')
  .text('观察旋转如何将向量带出低维子空间，而解耦设计将内容与位置分离');

// --- 三列布局 ---
const colW = Math.floor((W - 40) / 3);
const svgHeight = H - 55;
const panelR = Math.min(colW, svgHeight) * 0.32;

const panels = [
  {title: '低秩投影', subtitle: 'KV 在低维子空间中', color: '#3b82f6'},
  {title: '施加 RoPE', subtitle: '向量旋出子空间', color: '#ef4444'},
  {title: '解耦设计', subtitle: '内容低秩 + 位置独立', color: '#10b981'}
];

const panelGs = panels.map((p, i) => {
  const svg = d3.select(container).append('svg')
    .attr('width', colW).attr('height', svgHeight)
    .style('display', 'inline-block')
    .style('position', i > 0 ? 'absolute' : 'relative')
    .style('left', i > 0 ? (20 + i * colW) + 'px' : '0')
    .style('top', '55px');

svg.append('text').attr('x', colW/2).attr('y', 18)
    .attr('text-anchor','middle').attr('font-size','0.85em').attr('font-weight','600')
    .attr('fill', p.color).text(p.title);
  svg.append('text').attr('x', colW/2).attr('y', 33)
    .attr('text-anchor','middle').attr('font-size','0.65em').attr('fill', colors.muted).text(p.subtitle);

const cx = colW / 2;
  const cy = svgHeight / 2 + 10;

const g = svg.append('g').attr('transform', `translate(${cx},${cy})`);

// 坐标轴
  g.append('line').attr('x1',-panelR-15).attr('x2',panelR+15).attr('y1',0).attr('y2',0)
    .attr('stroke', colors.grid).attr('stroke-width',0.5);
  g.append('line').attr('x1',0).attr('x2',0).attr('y1',-panelR-15).attr('y2',panelR+15)
    .attr('stroke', colors.grid).attr('stroke-width',0.5);
  g.append('text').attr('x',panelR+20).attr('y',4).attr('fill', colors.muted).attr('font-size','0.6em').text('d₁');
  g.append('text').attr('x',4).attr('y',-panelR-10).attr('fill', colors.muted).attr('font-size','0.6em').text('d₂');

return g;
});

// --- 定义低秩子空间 ---
// 假设 d=4，低秩投影到 2 维子空间
// W_up 的列向量（在 4D 中取前 2 个坐标投影到 2D 显示）
const numVecs = 6;
const subspVectors = [];
for (let i = 0; i < numVecs; i++) {
  const angle = (i / numVecs) * Math.PI;
  subspVectors.push({
    x: Math.cos(angle) * 0.8,
    y: Math.sin(angle) * 0.7
  });
}

// 子空间边界（椭圆）
const subspEllipse = [];
for (let a = 0; a <= 2 * Math.PI + 0.1; a += 0.1) {
  subspEllipse.push({
    x: 0.85 * Math.cos(a),
    y: 0.75 * Math.sin(a)
  });
}

// RoPE 旋转角度
const theta1 = 1.0;
const theta2 = 0.3;

// --- 面板1：低秩投影 ---
// 画子空间边界
const ellipse1 = panelGs[0].append('path')
  .attr('fill', 'rgba(59,130,246,0.08)')
  .attr('stroke', '#3b82f6').attr('stroke-width', 1.5).attr('stroke-dasharray','4,3');

const vecs1 = subspVectors.map(() => panelGs[0].append('line')
  .attr('stroke','#3b82f6').attr('stroke-width',2).attr('stroke-linecap','round'));
const dots1 = subspVectors.map(() => panelGs[0].append('circle').attr('r',3.5).attr('fill','#3b82f6'));

const label1 = panelGs[0].append('text').attr('x', 0).attr('y', panelR + 25)
  .attr('text-anchor','middle').attr('font-size','0.7em').attr('fill', colors.muted);

// --- 面板2：施加 RoPE ---
const ellipse2 = panelGs[1].append('path')
  .attr('fill', 'rgba(59,130,246,0.05)')
  .attr('stroke', '#3b82f6').attr('stroke-width', 1).attr('stroke-dasharray','4,3').attr('opacity', 0.4);

const vecs2 = subspVectors.map(() => panelGs[1].append('line')
  .attr('stroke','#ef4444').attr('stroke-width',2).attr('stroke-linecap','round'));
const dots2 = subspVectors.map(() => panelGs[1].append('circle').attr('r',3.5).attr('fill','#ef4444'));

// 子空间边界（虚线，原来的）
const ellipse2orig = panelGs[1].append('path')
  .attr('fill','none')
  .attr('stroke','#3b82f6').attr('stroke-width',1).attr('stroke-dasharray','3,3').attr('opacity',0.3);

const label2 = panelGs[1].append('text').attr('x', 0).attr('y', panelR + 25)
  .attr('text-anchor','middle').attr('font-size','0.7em').attr('fill', colors.muted);

// --- 面板3：解耦设计 ---
// 内容子空间（稳定，不旋转）
const ellipse3 = panelGs[2].append('path')
  .attr('fill', 'rgba(59,130,246,0.08)')
  .attr('stroke', '#3b82f6').attr('stroke-width', 1.5).attr('stroke-dasharray','4,3');

const vecs3 = subspVectors.map(() => panelGs[2].append('line')
  .attr('stroke','#3b82f6').attr('stroke-width',2).attr('stroke-linecap','round'));
const dots3 = subspVectors.map(() => panelGs[2].append('circle').attr('r',3.5).attr('fill','#3b82f6'));

// 位置编码（独立旋转箭头，在子空间外）
const posVecs = [];
for (let i = 0; i < 3; i++) {
  posVecs.push(panelGs[2].append('line')
    .attr('stroke','#10b981').attr('stroke-width',2).attr('stroke-linecap','round').attr('stroke-dasharray','5,3'));
  posVecs.push(panelGs[2].append('circle').attr('r',3).attr('fill','#10b981'));
}

const label3 = panelGs[2].append('text').attr('x', 0).attr('y', panelR + 25)
  .attr('text-anchor','middle').attr('font-size','0.7em').attr('fill', colors.muted);

// 图例
const legend3 = panelGs[2].append('g').attr('transform', `translate(${-colW/2+15}, ${-svgHeight/2+50})`);
legend3.append('line').attr('x1',0).attr('x2',12).attr('y1',0).attr('y2',0)
  .attr('stroke','#3b82f6').attr('stroke-width',2);
legend3.append('text').attr('x',16).attr('y',3.5).attr('font-size','0.6em').attr('fill', colors.muted).text('内容（低秩）');
legend3.append('line').attr('x1',0).attr('x2',12).attr('y1',14).attr('y2',14)
  .attr('stroke','#10b981').attr('stroke-width',2).attr('stroke-dasharray','5,3');
legend3.append('text').attr('x',16).attr('y',17.5).attr('font-size','0.6em').attr('fill', colors.muted).text('位置（独立）');

// --- 更新函数 ---
let animating = false;
let animFrame = null;

function update(n) {
  const rotAngle1 = n * theta1;
  const rotAngle2 = n * theta2;

// 面板1：低秩投影（不变）
  const ellipsePath = d3.line()
    .x(d => d.x * panelR).y(d => -d.y * panelR)
    .curve(d3.curveCardinalClosed.tension(0.5));
  ellipse1.attr('d', ellipsePath(subspEllipse));
  ellipse2orig.attr('d', ellipsePath(subspEllipse));
  ellipse3.attr('d', ellipsePath(subspEllipse));

subspVectors.forEach((v, i) => {
    const px = v.x * panelR;
    const py = -v.y * panelR;
    vecs1[i].attr('x1',0).attr('y1',0).attr('x2',px).attr('y2',py);
    dots1[i].attr('cx',px).attr('cy',py);
    vecs3[i].attr('x1',0).attr('y1',0).attr('x2',px).attr('y2',py);
    dots3[i].attr('cx',px).attr('cy',py);
  });

// 面板2：施加 RoPE（旋转）
  const rotEllipse = subspEllipse.map(d => {
    const cos1 = Math.cos(rotAngle1), sin1 = Math.sin(rotAngle1);
    const cos2 = Math.cos(rotAngle2), sin2 = Math.sin(rotAngle2);
    // 在 4D 中旋转后投影到 2D（取前两维）
    return {
      x: d.x * cos1 - 0.3 * d.y * sin2,
      y: d.x * sin1 + 0.3 * d.y * cos2
    };
  });
  ellipse2.attr('d', ellipsePath(rotEllipse));

subspVectors.forEach((v, i) => {
    const cos1 = Math.cos(rotAngle1), sin1 = Math.sin(rotAngle1);
    const cos2 = Math.cos(rotAngle2), sin2 = Math.sin(rotAngle2);
    const rx = v.x * cos1 - 0.3 * v.y * sin2;
    const ry = v.x * sin1 + 0.3 * v.y * cos2;
    const px = rx * panelR;
    const py = -ry * panelR;
    vecs2[i].attr('x1',0).attr('y1',0).attr('x2',px).attr('y2',py);
    dots2[i].attr('cx',px).attr('cy',py);
  });

// 面板3：解耦设计 — 位置向量独立旋转
  const posAngles = [rotAngle1, rotAngle1 * 0.6, rotAngle2];
  for (let i = 0; i < 3; i++) {
    const pr = panelR * 0.6;
    const px = pr * Math.cos(posAngles[i]);
    const py = -pr * Math.sin(posAngles[i]);
    posVecs[i*2].attr('x1',0).attr('y1',0).attr('x2',px).attr('y2',py);
    posVecs[i*2+1].attr('cx',px).attr('cy',py);
  }

// 标签
  label1.text(`所有向量在低维子空间中（秩 r）`);
  label2.text(`旋转后离开子空间：需要 d 维存储`);
  label3.text(`内容低秩缓存 + 位置独立编码`);

posValue.text(n);
}

update(0);

posSlider.on('input', function() { update(+this.value); });

// 动画
playBtn.on('click', function() {
  if (animating) {
    animating = false;
    if (animFrame) cancelAnimationFrame(animFrame);
    playBtn.text('▶ 播放');
    return;
  }
  animating = true;
  playBtn.text('⏸ 暂停');
  let pos = +posSlider.node().value;
  function step() {
    if (!animating) return;
    pos = (pos + 0.5) % 65;
    posSlider.node().value = pos;
    update(pos);
    animFrame = requestAnimationFrame(step);
  }
  step();
});

从可视化中可以清晰看到三种状态的区别。左侧面板中，所有 KV 向量整齐地排列在低维子空间内，只需存储 $r$ 维坐标。中间面板施加 RoPE 后，向量被旋转到子空间之外，要完整表示它们必须回到 $d$ 维——低秩压缩的优势荡然无存。右侧面板的解耦设计则巧妙地回避了这个问题：内容始终在低维子空间中，位置信息通过独立的旋转编码附加。

解耦 RoPE 设计的数学动机

既然旋转矩阵会破坏低秩结构，最直接的解决方案就是：不要旋转低秩压缩后的向量。

这就是 DeepSeek MLA 的解耦 RoPE 设计。其核心思想是将注意力计算分成两个独立的部分：

\text{score}(m, n) = \underbrace{(\mathbf{W}^{Q_c} \mathbf{c}_q)^T (\mathbf{W}^{KV_c} \mathbf{c}_k)}_{\text{内容注意力}} + \underbrace{(\mathbf{R}_m \mathbf{q}^{rope})^T (\mathbf{R}_n \mathbf{k}^{rope})}_{\text{位置注意力}}

其中：

$\mathbf{c}_q = \mathbf{W}^{QD} \mathbf{h}$ 是 Query 的低秩压缩， $\mathbf{c}_k = \mathbf{W}^{KVD} \mathbf{h}$ 是 Key-Value 的联合低秩压缩
$\mathbf{W}^{Q_c}$ 和 $\mathbf{W}^{KV_c}$ 是上投影矩阵，将低维潜在向量重构为高维
$\mathbf{q}^{rope}$ 和 $\mathbf{k}^{rope}$ 是专门的 RoPE Query 和 Key，维度远小于 $d$ ，不经过低秩压缩

这种设计的数学保证是：

内容注意力部分不涉及旋转， $\mathbf{W}^{KV_c} \mathbf{c}_k$ 可以预计算并缓存， $\mathbf{c}_k$ 只需 $r$ 维存储
位置注意力部分涉及旋转，但 $\mathbf{k}^{rope}$ 维度很小（通常 $d^{rope} \ll d$ ），其 KV Cache 开销可以忽略

关键发现是：低秩压缩和旋转编码作用于不同的子空间。内容信息在低秩子空间中被压缩和缓存，位置信息在独立的子空间中被旋转编码。两个子空间互不干扰，各自的数学性质得以保持。

从投影的角度看，解耦设计相当于将原始的注意力计算空间分解为：

\mathbb{R}^d = \mathcal{S}_{\text{content}} \oplus \mathcal{S}_{\text{position}}

内容子空间 $\mathcal{S}_{\text{content}}$ 是 $\mathbf{W}^{KV_c}$ 的列空间，支持低秩压缩；位置子空间 $\mathcal{S}_{\text{position}}$ 是 RoPE 向量所在的空间，支持旋转编码。

Partial RoPE：解耦设计的意外优势

解耦设计最初是为了绕过"旋转破坏低秩结构"这一数学障碍而提出的，但苏剑林在《MLA好在哪里（下）》中论证了一个更强的结论：Partial RoPE（只对小部分维度加 RoPE，其余保持 NoPE）的效果不逊色于甚至可能优于完全体的 RoPE。

这意味着 MLA 的解耦设计不是"无奈的妥协"，而可能是"意外的优势"。

Partial RoPE 的直觉是：在标准 RoPE 中，所有维度都承载位置信息，这意味着位置编码与内容语义在所有维度上耦合。但理想的设计应该是大部分维度专注于内容语义（NoPE），小部分维度编码位置信息——这更符合"位置编码不应该与内容压缩耦合"的设计原则。MLA 的解耦结构天然实现了这一点： $d^{rope}$ 维的 RoPE 路径只占总维度的一小部分，大部分信息通过 NoPE 的低秩压缩路径传递。

从信息论的角度，Partial RoPE 相当于将位置信息"集中"到少数维度上，而非"分散"到所有维度。这种集中化使得内容信息可以在剩余维度中被更有效地压缩，因为压缩算法不需要同时保留内容语义和位置语义的纠缠。

MHA-MQA 切换机制

MLA 的解耦设计不仅解决了 RoPE 与低秩压缩的冲突，还带来了一个有趣的副产物：训练阶段表现为 MHA，推理阶段表现为 MQA。

在训练阶段，MLA 为每个注意力头维护独立的 Query 上投影 $\mathbf{W}^{Q_c}_h$ ，每头的 Key-Value 由共享的低秩压缩 $\mathbf{c}_k$ 经不同的上投影 $\mathbf{W}^{KV_c}_h$ 重构。这等价于多头注意力（MHA），每头有不同的 KV 表达，模型有充分的训练容量。

在推理阶段，NoPE 部分的投影矩阵可以合并。具体地，内容注意力的计算为：

(\mathbf{W}^{Q_c} \mathbf{c}_q)^T (\mathbf{W}^{KV_c} \mathbf{c}_k) = \mathbf{c}_q^T (\mathbf{W}^{Q_c})^T \mathbf{W}^{KV_c} \mathbf{c}_k

$(\mathbf{W}^{Q_c})^T \mathbf{W}^{KV_c}$ 可以预计算为一个固定矩阵——这就是权重吸收。吸收后，推理时只需缓存低维的 $\mathbf{c}_k$ （与 KV-Shared 等价），所有头共享同一组潜在向量，行为类似于 MQA。RoPE 路径的 $\mathbf{k}^{rope}$ 维度很小，可以视为 MQA 中额外的一小部分 KV Cache。

这种 MHA-to-MQA 的切换通过 NoPE 部分的吸收性质实现：推理时 NoPE 部分的投影矩阵可以合并为单个矩阵乘法，无需为每个头单独计算。

以 DeepSeek-V2 的具体配置来看这一切换的维度变化。MLA 的压缩维度 $d_c = 512$ （KV 压缩投影维度），RoPE 维度 $d_{hR} = 64$ （每头的位置编码维度）。训练时，每头的 qk_head_dims = $(128 + 64)$ ，即 128 维内容注意力加上 64 维位置注意力，等价于标准的 MHA。推理时， $(\mathbf{W}^{Q_c})^T \mathbf{W}^{KV_c}$ 可预计算合并，等价于 head_dims = $(512 + 64)$ 的 MQA——head_dims 从 128 跃升到 512，4 倍的增长使得推理时每头拥有远超训练时的有效维度，这是 MLA 效果提升的最大贡献者。

苏剑林的消融实验进一步揭示了各设计因素的优先级：增大 head_dims（loss 差 0.003~0.004）> Partial RoPE > KV-Shared。这意味着 MLA 性能提升的最大来源是更大的每头维度（更多表达力），其次才是 Partial RoPE 和 KV-Shared 带来的压缩效率。

与 GQA/MQA 的信息论对比

GQA 和 MQA 通过减少 KV 的头数来压缩 KV Cache，其实就是一种"粗粒度"的压缩：多个 Query 头被迫共享同一组 KV，信息在头间被平均化。

MLA 的低秩压缩则是一种"细粒度"的压缩：每个头仍然有自己的 KV 表达，但它们存在于低维潜在空间中。重构矩阵 $\mathbf{W}^{KV_c}$ 在推理时将潜在向量映射回高维空间，不同头可以通过不同的投影来恢复各自的特殊性。

从信息论的角度，设 KV Cache 的总存储量为 $B$ bits：

MQA： $B = 2 \times L \times d_h$ （1 组 KV），信息瓶颈最严重
GQA（ $g$ 组）： $B = 2 \times L \times g \times d_h$ ，信息量随组数线性增长
MLA： $B = L \times (r + d^{rope})$ ，其中 $r$ 是压缩维度， $d^{rope}$ 是位置编码维度

当 $r \approx g \times d_h$ 时，MLA 和 GQA 的 KV Cache 大小相当。但 MLA 的表达力更强：GQA 中 $g$ 组 KV 是离散的 $g$ 个点，MLA 中 $r$ 维潜在向量可以连续地表示整个低维子空间中的任意点。这种连续性使得 MLA 在相同压缩率下保留了更多信息。

当然，MLA 也有代价：上投影矩阵 $\mathbf{W}^{KV_c}$ 的计算量在推理时需要为每个新 token 执行，而 GQA 的重构是简单的复制。这是压缩率与计算量之间的另一个 trade-off。

小结

RoPE 与低秩压缩的不兼容性，根源在于旋转矩阵会破坏低维子空间的结构。这个看似技术性的数学事实，直接导致了 DeepSeek MLA 的核心设计决策：将内容子空间与位置子空间解耦。

解耦设计的精妙之处在于，既然旋转和压缩在数学上不可兼容，它转而重新组织计算流程，使得两者各自在独立的子空间中运作，互不干扰。而 Partial RoPE 的分析进一步揭示，这种解耦是优势而非妥协——只对小部分维度施加 RoPE 的效果不逊于甚至优于完全体的 RoPE。权重吸收的论证则从工程视角解释了不兼容性的本质：RoPE 插入的位置相关旋转矩阵使得投影矩阵无法预计算，而解耦设计恢复了这种预计算能力。MLA 的 MHA-MQA 切换机制使得训练时有充分的表达力，推理时有极致的缓存效率。这种"分而治之"的思路，是深度学习架构设计中反复出现的模式：当两个操作在数学上不兼容时，不要强行统一，而是为它们各自创造合适的空间。

从更广的视角看，MLA 的解耦设计揭示了一个通用的设计原则：位置编码不应该与内容压缩耦合。这个原则不仅适用于 RoPE + 低秩压缩的场景，也适用于其他任何位置编码与 KV Cache 压缩的组合。理解了这个原则，就能理解为什么 MLA 在工程实现上比单纯的低秩压缩复杂得多——它需要为位置信息单独维护一套注意力计算路径——但这种复杂性的回报是：在相同压缩率下远超 GQA 的表达能力。

参考文献

Su, J. (2025). Transformer升级之路：MLA好在哪里？（上）. https://kexue.fm/archives/10907
Su, J. (2025). Transformer升级之路：MLA好在哪里？（下）. https://kexue.fm/archives/11111
DeepSeek-AI (2024). DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model. arXiv:2405.04434.

KV Cache 的瓶颈#

低秩压缩的直觉#

RoPE 与低秩压缩的不兼容性#

数学证明#

权重吸收：从工程视角看不兼容性#

解耦 RoPE 设计的数学动机#

Partial RoPE：解耦设计的意外优势#

MHA-MQA 切换机制#

与 GQA/MQA 的信息论对比#

小结#

相关概念#

参考文献#

相关文章