奇异值分解与低秩近似：从矩阵压缩到 LoRA 微调

线性代数中，矩阵分解是一个反复出现的主题。特征值分解告诉我们方阵的内在振动模式，QR 分解揭示了正交性的力量，而奇异值分解（Singular Value Decomposition, SVD）则是所有分解中最深刻的一个——它对矩阵的形状没有任何要求，却能揭示矩阵最本质的几何结构。

这篇文章从 SVD 的几何直觉出发，推导 Eckart-Young 最优低秩近似定理，然后回答一个在深度学习实践中反复出现的问题：为什么一个秩远小于原矩阵维度的分解，仍然能够有效近似原矩阵？LoRA 微调正是这一原理的工程实例。

SVD 的几何直觉

任何一个 $m \times n$ 的实矩阵 $A$ 都可以分解为

A = U \Sigma V^T

其中 $U$ 是 $m \times m$ 正交矩阵， $V$ 是 $n \times n$ 正交矩阵， $\Sigma$ 是 $m \times n$ 对角矩阵，对角线上的元素 $\sigma_1 \geq \sigma_2 \geq \cdots \geq \sigma_r > 0$ 称为奇异值， $r = \text{rank}(A)$ 。

这个分解的几何含义非常清晰：一个线性变换可以分解为三步操作——旋转、拉伸、旋转。

具体来说，对于 $A \in \mathbb{R}^{m \times n}$ ，向量 $x$ 经过 $A$ 变换为 $Ax$ 的过程可以理解为：

$V^T$ 旋转： $V^T$ 是正交矩阵，它的作用是将 $x$ 旋转到一组新的坐标轴方向。正交变换不改变向量的长度和相对位置，只改变方向。
$\Sigma$ 拉伸： $\Sigma$ 是对角矩阵，它沿着每个坐标轴方向进行独立的缩放。第 $i$ 个方向上的缩放因子恰好是 $\sigma_i$ 。
$U$ 旋转：最后， $U$ 将拉伸后的结果旋转到输出空间的最终方向。

最经典的例子是单位圆的变换。二维空间中的单位圆经过 $V^T$ 旋转后仍然是单位圆（正交变换保距），经过 $\Sigma$ 拉伸后变成椭圆，半轴长度恰好等于 $\sigma_1$ 和 $\sigma_2$ ，再经过 $U$ 旋转后，椭圆的方向被旋转到了最终的朝向。

SVD 的几何直觉：旋转-拉伸-旋转

Loading visualization...

单位圆经过 V^T 旋转、Σ 拉伸、U 旋转后变为椭圆。拖动滑块切换截断秩 k，观察低秩近似如何影响变换结果。

const W = container.clientWidth, H = container.clientHeight;
const margin = {top: 30, right: 20, bottom: 40, left: 20};
const panelW = (W - margin.left - margin.right - 60) / 3;
const panelH = H - margin.top - margin.bottom;
const cx = panelW / 2, cy = panelH / 2;
const scale = 65;

// 示例矩阵 A = U * Sigma * V^T
const theta = Math.PI / 6;
const U_mat = [[Math.cos(theta), -Math.sin(theta)], [Math.sin(theta), Math.cos(theta)]];
const Sigma_mat = [[2.5, 0], [0, 0.8]];
const Vt_mat = [[Math.cos(Math.PI/5), Math.sin(Math.PI/5)], [-Math.sin(Math.PI/5), Math.cos(Math.PI/5)]];

function matMul(A, B) {
  return [
    [A[0][0]*B[0][0]+A[0][1]*B[1][0], A[0][0]*B[0][1]+A[0][1]*B[1][1]],
    [A[1][0]*B[0][0]+A[1][1]*B[1][0], A[1][0]*B[0][1]+A[1][1]*B[1][1]]
  ];
}

function transform(A, x, y) {
  return [A[0][0]*x + A[0][1]*y, A[1][0]*x + A[1][1]*y];
}

const svg = d3.select(container).append("svg")
  .attr("width", W).attr("height", H);

const g = svg.append("g").attr("transform", `translate(${margin.left},${margin.top})`);

// 控制区
const controlG = svg.append("g").attr("transform", `translate(${W/2 - 120}, ${H - 30})`);

let rankK = 2;

const sliderG = controlG.append("g");
sliderG.append("text").attr("x", 0).attr("y", -5).text("截断秩 k:").style("font-size", "13px").style("fill", "#555");
const slider = sliderG.append("foreignObject").attr("width", 80).attr("height", 25).attr("x", 75).attr("y", -18)
  .append("xhtml:input")
  .attr("type", "range").attr("min", 1).attr("max", 2).attr("step", 1).attr("value", 2)
  .style("width", "80px")
  .on("input", function() { rankK = +this.value; draw(); });

const rankLabel = sliderG.append("text").attr("x", 165).attr("y", -5).text("2").style("font-size", "13px").style("font-weight", "bold");

function drawPanel(g, title, transformFn, color, approxTransformFn) {
  g.append("rect").attr("width", panelW).attr("height", panelH)
    .attr("fill", "#fafafa").attr("stroke", "#ddd").attr("rx", 4);
  g.append("text").attr("x", panelW/2).attr("y", 18)
    .text(title).style("text-anchor", "middle").style("font-size", "13px").style("font-weight", "bold").style("fill", "#333");

// 坐标轴
  const axG = g.append("g").attr("transform", `translate(${cx},${cy})`);
  axG.append("line").attr("x1", -cx+10).attr("x2", cx-10).attr("y1",0).attr("y2",0).attr("stroke","#ccc").attr("stroke-dasharray","3,3");
  axG.append("line").attr("x1",0).attr("x2",0).attr("y1",-cy+25).attr("y2",cy-10).attr("stroke","#ccc").attr("stroke-dasharray","3,3");

// 画变换后的形状
  const n = 120;
  const points = [];
  for (let i = 0; i <= n; i++) {
    const t = 2 * Math.PI * i / n;
    const [x, y] = transformFn(Math.cos(t), Math.sin(t));
    points.push([cx + x * scale, cy - y * scale]);
  }

// 如果有近似变换，先画原始（淡色）
  if (approxTransformFn) {
    const approxPoints = [];
    for (let i = 0; i <= n; i++) {
      const t = 2 * Math.PI * i / n;
      const [x, y] = transformFn(Math.cos(t), Math.sin(t));
      approxPoints.push([cx + x * scale, cy - y * scale]);
    }
    g.append("path")
      .datum(approxPoints)
      .attr("d", d3.line().x(d=>d[0]).y(d=>d[1]))
      .attr("fill", "none").attr("stroke", "#ddd").attr("stroke-width", 1.5).attr("stroke-dasharray", "4,3");

// 近似形状
    const kPoints = [];
    for (let i = 0; i <= n; i++) {
      const t = 2 * Math.PI * i / n;
      const [x, y] = approxTransformFn(Math.cos(t), Math.sin(t));
      kPoints.push([cx + x * scale, cy - y * scale]);
    }
    g.append("path")
      .datum(kPoints)
      .attr("d", d3.line().x(d=>d[0]).y(d=>d[1]))
      .attr("fill", color).attr("fill-opacity", 0.15).attr("stroke", color).attr("stroke-width", 2);
  } else {
    g.append("path")
      .datum(points)
      .attr("d", d3.line().x(d=>d[0]).y(d=>d[1]))
      .attr("fill", color).attr("fill-opacity", 0.15).attr("stroke", color).attr("stroke-width", 2);
  }
}

function draw() {
  g.selectAll("*").remove();
  rankLabel.text(rankK);

// 构建截断 Sigma
  const SigmaK = [[rankK >= 1 ? Sigma_mat[0][0] : 0, 0], [0, rankK >= 2 ? Sigma_mat[1][1] : 0]];
  const AK = matMul(U_mat, matMul(SigmaK, Vt_mat));
  const A_full = matMul(U_mat, matMul(Sigma_mat, Vt_mat));

// Panel 1: 单位圆 (输入空间)
  const g1 = g.append("g").attr("transform", `translate(0,0)`);
  drawPanel(g1, "输入空间：单位圆", (x,y) => [x, y], "#4a90d9", null);

// Panel 2: 经过 V^T 旋转和 Σ 拉伸
  const g2 = g.append("g").attr("transform", `translate(${panelW + 30},0)`);
  const sigmaTransform = (x, y) => transform(Sigma_mat, ...transform(Vt_mat, x, y));
  const sigmaKTransform = (x, y) => transform(SigmaK, ...transform(Vt_mat, x, y));
  drawPanel(g2, "V^T 旋转 + Σ 拉伸", sigmaTransform, "#e07b39", rankK < 2 ? sigmaKTransform : null);

// Panel 3: 最终结果 A = U Σ V^T
  const g3 = g.append("g").attr("transform", `translate(${2*(panelW + 30)},0)`);
  const fullTransform = (x, y) => transform(A_full, x, y);
  const approxTransform = (x, y) => transform(AK, x, y);
  drawPanel(g3, "最终变换 A = UΣV^T", fullTransform, "#50a050", rankK < 2 ? approxTransform : null);

// 箭头
  [[panelW + 8, cy], [2*panelW + 38, cy]].forEach(([ax, ay]) => {
    g.append("path").attr("d", `M${ax},${ay} L${ax+14},${ay}`)
      .attr("stroke", "#999").attr("stroke-width", 1.5)
      .attr("marker-end", "url(#arrowhead)");
  });

// 定义箭头
  g.append("defs").append("marker")
    .attr("id", "arrowhead").attr("markerWidth", 8).attr("markerHeight", 6)
    .attr("refX", 7).attr("refY", 3).attr("orient", "auto")
    .append("path").attr("d", "M0,0 L8,3 L0,6 Z").attr("fill", "#999");
}

draw();

当我们将某个奇异值设为零时，对应的"拉伸方向"被完全舍弃，椭圆退化为一条线段（rank-1 近似）或一个点（rank-0）。这就是低秩近似的几何本质：丢弃小奇异值对应的方向，只保留大奇异值对应的主要形变。

SVD 的代数定义

更形式化地，设 $A \in \mathbb{R}^{m \times n}$ ，其奇异值分解为

A = U \Sigma V^T = \sum_{i=1}^{r} \sigma_i u_i v_i^T

其中 $u_i \in \mathbb{R}^m$ 是 $U$ 的第 $i$ 列（左奇异向量）， $v_i \in \mathbb{R}^n$ 是 $V$ 的第 $i$ 列（右奇异向量）， $\sigma_i$ 是奇异值。

这个展开形式揭示了一个重要事实：矩阵 $A$ 可以表示为 $r$ 个秩为 1 的矩阵之和，每个秩 1 矩阵 $u_i v_i^T$ 捕捉了 $A$ 的一个"成分"，其重要性由 $\sigma_i$ 衡量。

奇异值与特征值的关系也值得注意： $A^T A$ 的特征值恰好是 $\sigma_i^2$ ，对应的特征向量就是 $v_i$ 。类似地， $AA^T$ 的特征值也是 $\sigma_i^2$ ，特征向量是 $u_i$ 。这意味着 SVD 可以通过求解 $A^T A$ 或 $AA^T$ 的特征值分解来获得。

Moore-Penrose 伪逆

在推导 Eckart-Young 定理之前，我们需要引入一个关键工具——Moore-Penrose 伪逆。它不仅给出了奇异值分解的"逆运算"，还为低秩近似提供了统一的优化视角。

设 $A \in \mathbb{R}^{m \times n}$ 的 SVD 为 $A = U\Sigma V^T$ ，其伪逆定义为

A^+ = V \Sigma^+ U^T

其中 $\Sigma^+$ 是将 $\Sigma$ 中非零奇异值取倒数后转置得到的矩阵：若 $\Sigma$ 的对角线为 $(\sigma_1, \ldots, \sigma_r, 0, \ldots, 0)$ ，则 $\Sigma^+$ 的对角线为 $(1/\sigma_1, \ldots, 1/\sigma_r, 0, \ldots, 0)$ 。

当 $A$ 是可逆方阵时， $A^+ = A^{-1}$ ；当 $A$ 列满秩时， $A^+ = (A^T A)^{-1} A^T$ ；当 $A$ 行满秩时， $A^+ = A^T (AA^T)^{-1}$ 。伪逆是逆矩阵概念在任意形状、任意秩矩阵上的推广。

伪逆的优化视角

伪逆不仅是一个代数定义，它还可以从优化问题中自然地导出。考虑

A^+ = \arg\min_B \|AB - I_m\|_F^2

其中 $I_m$ 是 $m \times m$ 单位矩阵。这个优化问题的含义是：在所有 $B$ 中，找到使得 $AB$ 最接近单位矩阵的那个。对目标函数求导并令其为零，可以得到最优解恰好是 $A^+$ 。类似地， $A^+$ 也是 $\arg\min_C \|CA - I_n\|_F^2$ 的最优解。

这个优化视角揭示了一个重要事实：伪逆是"最小二乘意义下最接近逆矩阵的矩阵"。

伪逆桥接低秩近似

伪逆的关键作用在于，它将低秩近似问题分解为两个更简单的子问题。考虑

\min_{\text{rank}(B) \leq r} \|A - B\|_F^2

我们可以将 $B$ 参数化为 $B = XY$ （其中 $X \in \mathbb{R}^{m \times r}$ ， $Y \in \mathbb{R}^{r \times n}$ ），从而将问题改写为

\min_{X, Y} \|A - XY\|_F^2

这是一个交替最小化的标准形式。关键观察是：给定 $X$ 时， $Y$ 的最优解为

Y^* = X^+ A

这是因为伪逆给出了 $\min_Y \|A - XY\|_F^2$ 的解析最优解——正是伪逆的优化视角的直接推论。将 $Y^*$ 代回后，问题化简为对 $X$ 的搜索，而 $X$ 的最优解对应于 $A$ 的前 $r$ 个左奇异向量，从而回收到截断 SVD 的结果。

苏剑林在《低秩近似之路》系列中正是用伪逆桥接了整个推理链：从伪逆的定义出发，通过优化视角推导出低秩近似的结构，再由此得到 SVD 截断的最优性。这种处理方式使得伪逆、SVD 和 CR 近似三篇文章形成了统一的逻辑体系——伪逆是"最优近似"的语言，SVD 给出了这个语言的具体答案，而 CR 近似则是在附加结构约束下的最优近似。

Eckart-Young 定理

SVD 最深刻的性质之一是它给出了最优低秩近似。这就是 Eckart-Young-Mirsky 定理：

定理（Eckart-Young, 1936）：设 $A$ 的 SVD 为 $A = U\Sigma V^T$ ，截断 SVD 定义为
$A_k = \sum_{i=1}^{k} \sigma_i u_i v_i^T$
则对于任意秩不超过 $k$ 的矩阵 $B$ ，有
$\|A - A_k\|_F \leq \|A - B\|_F$
即 $A_k$ 是 $A$ 在所有秩不超过 $k$ 的矩阵中 Frobenius 范数意义下的最优近似。

这个定理的证明思路非常优雅。首先，注意到

\|A - A_k\|_F^2 = \sum_{i=k+1}^{r} \sigma_i^2

也就是说，截断 SVD 的近似误差恰好是被舍弃的奇异值的平方和。

证明的关键在于利用矩阵的秩的可加性约束。对于任意秩不超过 $k$ 的矩阵 $B$ ， $A - B$ 的秩不超过 $r + k$ （但更精确的分析利用了秩与奇异值的关系）。通过 Weyl 不等式， $A - B$ 的第 $i$ 大奇异值至少是 $\sigma_{i+k}(A)$ ，因此

\|A - B\|_F^2 = \sum_{i=1}^{\min(m,n)} \sigma_i^2(A - B) \geq \sum_{i=k+1}^{r} \sigma_i^2(A) = \|A - A_k\|_F^2

这就完成了证明。定理对谱范数（2-范数）同样成立： $\|A - A_k\|_2 = \sigma_{k+1}$ ，且这是所有秩不超过 $k$ 的近似中的最小值。

借助伪逆的语言，Eckart-Young 定理也可以这样理解：将低秩近似问题参数化为 $\min_{X,Y} \|A - XY\|_F^2$ （其中 $X$ 有 $r$ 列），给定 $X$ 后 $Y$ 的最优解是 $Y = X^+ A$ ，而 $X$ 的最优选择正是 $A$ 的前 $k$ 个左奇异向量构成的矩阵。截断 SVD 的最优性，就是伪逆在这个嵌套优化问题中提供的解析最优解。

Eckart-Young 定理告诉我们：截断 SVD 是有理论保证的最优解，而非启发式方法。在所有秩不超过 $k$ 的矩阵中，你找不到比 $A_k$ 更好的近似。

谱衰减假设：为什么现实矩阵通常是低秩的？

Eckart-Young 定理保证了截断 SVD 是最优的，但它没有告诉我们近似误差有多大。这取决于奇异值的衰减速度。

如果奇异值快速衰减——前几个奇异值占据了大部分能量——那么即使 $k \ll r$ ， $A_k$ 也能很好地近似 $A$ 。反之，如果奇异值缓慢衰减，低秩近似就会丢失大量信息。

定义矩阵的"累积能量占比"为

\rho(k) = \frac{\sum_{i=1}^{k} \sigma_i^2}{\sum_{i=1}^{r} \sigma_i^2}

当 $\rho(k) \approx 1$ 而 $k \ll r$ 时，我们说这个矩阵是"低秩友好"的。

关键观察是：现实世界中的许多矩阵确实是低秩友好的。这不是巧合，而有深层的原因：

平滑性：自然图像的像素矩阵通常具有高度的空间相关性，相邻像素值变化缓慢。这种平滑性意味着矩阵的大部分信息集中在少数几个奇异向量上。JPEG 压缩的核心——离散余弦变换（DCT）——就是在利用这一性质。
有限生成机制：在神经网络中，权重矩阵的更新往往沿着低维子空间进行。经验研究表明，SGD 训练过程中的梯度方向高度集中，少数几个方向贡献了大部分方差。这意味着训练好的权重矩阵可以用低秩矩阵很好地近似。
统计结构：推荐系统中的用户-物品交互矩阵、语言模型中的词共现矩阵，其背后都有少量隐因子驱动。这些低维隐因子结构使得矩阵天然是低秩的。

谱值衰减与低秩近似

Loading visualization...

左：快速衰减 vs 缓慢衰减的奇异值分布。右：拖动截断位置滑块，实时查看累积能量占比和近似误差。

const W = container.clientWidth, H = container.clientHeight;
const margin = {top: 35, right: 25, bottom: 55, left: 55};
const plotW = (W - margin.left - margin.right - 80) / 2;
const plotH = H - margin.top - margin.bottom;

const svg = d3.select(container).append("svg").attr("width", W).attr("height", H);
const g = svg.append("g").attr("transform", `translate(${margin.left},${margin.top})`);

// 生成两类谱
const n = 30;
const fastDecay = [], slowDecay = [];
for (let i = 0; i < n; i++) {
  fastDecay.push(10 * Math.exp(-0.3 * i));
  slowDecay.push(10 / (1 + 0.5 * i));
}
const totalFast = fastDecay.reduce((s,v) => s + v*v, 0);
const totalSlow = slowDecay.reduce((s,v) => s + v*v, 0);

let truncIdx = 5;
let mode = "fast"; // "fast" or "slow"

// 模式切换按钮
const btnG = svg.append("g").attr("transform", `translate(${W/2}, ${H - 15})`);
const fastBtn = btnG.append("g").style("cursor", "pointer").on("click", () => { mode = "fast"; draw(); });
fastBtn.append("rect").attr("x", -155).attr("y", -13).attr("width", 70).attr("height", 22).attr("rx", 4)
  .attr("fill", () => mode === "fast" ? "#4a90d9" : "#eee").attr("stroke", "#aaa");
fastBtn.append("text").attr("x", -120).attr("y", 3).text("快速衰减").style("font-size", "12px")
  .style("fill", mode === "fast" ? "#fff" : "#333").style("text-anchor", "middle");

const slowBtn = btnG.append("g").style("cursor", "pointer").on("click", () => { mode = "slow"; draw(); });
slowBtn.append("rect").attr("x", -75).attr("y", -13).attr("width", 70).attr("height", 22).attr("rx", 4)
  .attr("fill", () => mode === "slow" ? "#e07b39" : "#eee").attr("stroke", "#aaa");
slowBtn.append("text").attr("x", -40).attr("y", 3).text("缓慢衰减").style("font-size", "12px")
  .style("fill", mode === "slow" ? "#fff" : "#333").style("text-anchor", "middle");

// 截断滑块
const sliderG = svg.append("g").attr("transform", `translate(${margin.left + plotW + 100}, ${H - 15})`);
sliderG.append("text").attr("x", -10).attr("y", 4).text("截断位置 k:").style("font-size", "12px").style("fill", "#555");
const slider = sliderG.append("foreignObject").attr("width", 100).attr("height", 22).attr("x", 60).attr("y", -10)
  .append("xhtml:input")
  .attr("type", "range").attr("min", 1).attr("max", n).attr("step", 1).attr("value", truncIdx)
  .style("width", "100px")
  .on("input", function() { truncIdx = +this.value; draw(); });
const sliderLabel = sliderG.append("text").attr("x", 170).attr("y", 4).style("font-size", "12px").style("font-weight", "bold");

function draw() {
  g.selectAll("*").remove();

// 更新按钮颜色
  fastBtn.select("rect").attr("fill", mode === "fast" ? "#4a90d9" : "#eee");
  fastBtn.select("text").style("fill", mode === "fast" ? "#fff" : "#333");
  slowBtn.select("rect").attr("fill", mode === "slow" ? "#e07b39" : "#eee");
  slowBtn.select("text").style("fill", mode === "slow" ? "#fff" : "#333");

const data = mode === "fast" ? fastDecay : slowDecay;
  const total = mode === "fast" ? totalFast : totalSlow;
  const color = mode === "fast" ? "#4a90d9" : "#e07b39";
  sliderLabel.text(truncIdx);

// === 左图：奇异值谱 ===
  const xScale = d3.scaleBand().domain(d3.range(n).map(i => i+1)).range([0, plotW]).padding(0.15);
  const maxSigma = data[0];
  const yScale = d3.scaleLog().domain([0.01, maxSigma * 1.2]).range([plotH, 0]);

const leftG = g.append("g");

// y轴
  leftG.append("g").call(d3.axisLeft(yScale).ticks(5, ".1f")).attr("font-size", "10px");
  leftG.append("text").attr("x", -plotH/2).attr("y", -42).text("奇异值 σ (log)")
    .style("text-anchor", "middle").style("font-size", "11px").attr("transform", "rotate(-90)");

// x轴
  leftG.append("g").attr("transform", `translate(0,${plotH})`)
    .call(d3.axisBottom(xScale).tickValues([1,5,10,15,20,25,30])).attr("font-size", "10px");
  leftG.append("text").attr("x", plotW/2).attr("y", plotH + 35).text("奇异值索引")
    .style("text-anchor", "middle").style("font-size", "11px");

// 柱子
  leftG.selectAll(".bar").data(data).join("rect")
    .attr("x", (d,i) => xScale(i+1)).attr("width", xScale.bandwidth())
    .attr("y", d => yScale(Math.max(0.01, d)))
    .attr("height", d => plotH - yScale(Math.max(0.01, d)))
    .attr("fill", (d,i) => i < truncIdx ? color : "#ccc").attr("opacity", 0.8);

// 截断线
  leftG.append("line")
    .attr("x1", xScale(truncIdx) + xScale.bandwidth()/2)
    .attr("x2", xScale(truncIdx) + xScale.bandwidth()/2)
    .attr("y1", 0).attr("y2", plotH)
    .attr("stroke", "red").attr("stroke-dasharray", "4,3").attr("stroke-width", 1.5);

leftG.append("text").attr("x", plotW/2).attr("y", -10).text("奇异值谱")
    .style("text-anchor", "middle").style("font-size", "13px").style("font-weight", "bold");

// === 右图：累积能量 ===
  const rightG = g.append("g").attr("transform", `translate(${plotW + 80}, 0)`);
  const xScale2 = d3.scaleLinear().domain([1, n]).range([0, plotW]);
  const yScale2 = d3.scaleLinear().domain([0, 1.05]).range([plotH, 0]);

rightG.append("g").call(d3.axisLeft(yScale2).ticks(5)).attr("font-size", "10px");
  rightG.append("text").attr("x", -plotH/2).attr("y", -42).text("累积能量占比")
    .style("text-anchor", "middle").style("font-size", "11px").attr("transform", "rotate(-90)");

rightG.append("g").attr("transform", `translate(0,${plotH})`)
    .call(d3.axisBottom(xScale2).ticks(6)).attr("font-size", "10px");
  rightG.append("text").attr("x", plotW/2).attr("y", plotH + 35).text("奇异值索引")
    .style("text-anchor", "middle").style("font-size", "11px");

// 计算累积能量
  const cumEnergy = [];
  let cumSum = 0;
  for (let i = 0; i < n; i++) {
    cumSum += data[i] * data[i];
    cumEnergy.push(cumSum / total);
  }

// 面积
  const area = d3.area()
    .x((d,i) => xScale2(i+1))
    .y0(plotH)
    .y1((d) => yScale2(d));
  rightG.append("path").datum(cumEnergy)
    .attr("d", area).attr("fill", color).attr("opacity", 0.15);

// 曲线
  const line = d3.line().x((d,i) => xScale2(i+1)).y(d => yScale2(d));
  rightG.append("path").datum(cumEnergy)
    .attr("d", line).attr("fill", "none").attr("stroke", color).attr("stroke-width", 2);

rightG.append("text").attr("x", plotW/2).attr("y", -10).text("累积能量占比")
    .style("text-anchor", "middle").style("font-size", "13px").style("font-weight", "bold");

// 截断标记
  rightG.append("circle")
    .attr("cx", xScale2(truncIdx)).attr("cy", yScale2(cumEnergy[truncIdx-1]))
    .attr("r", 5).attr("fill", "red");

// 数值标签
  const energy = (cumEnergy[truncIdx-1] * 100).toFixed(1);
  const error = ((1 - cumEnergy[truncIdx-1]) * 100).toFixed(1);
  rightG.append("text").attr("x", plotW/2).attr("y", plotH + 50)
    .text(`k=${truncIdx}: 能量 ${energy}%, 误差 ${error}%`)
    .style("text-anchor", "middle").style("font-size", "12px").style("fill", "#333");
}

draw();

观察上图可以发现，对于快速衰减的谱，仅保留前 5-10 个奇异值就能捕获超过 99% 的能量；而对于缓慢衰减的谱，则需要保留更多的分量。这也解释了为什么同一套低秩近似方法在不同场景下效果差异巨大——它取决于数据本身的谱结构。

LoRA：低秩分解的工程实例

LoRA（Low-Rank Adaptation）是低秩近似理论在深度学习中最成功的应用之一。其核心思想极为简洁：

对于一个预训练好的权重矩阵 $W_0 \in \mathbb{R}^{d \times d}$ ，LoRA 将微调时的增量参数化为

\Delta W = A B

其中 $A \in \mathbb{R}^{d \times r}$ ， $B \in \mathbb{R}^{r \times d}$ ， $r \ll d$ 。微调后的权重为

W = W_0 + \Delta W = W_0 + AB

参数量从 $d^2$ 降低到 $2dr$ 。当 $r = 4$ 、 $d = 4096$ 时，参数量仅为原来的 $0.2\%$ 。

LoRA 有效的关键假设是：微调过程中的权重增量 $\Delta W$ 具有低秩结构。这不是一个先验假设——它由 SVD 的语言可以精确表达：如果 $\Delta W$ 的奇异值快速衰减，那么存在一个低秩矩阵 $AB$ 能够很好地近似它。Hu et al. (2022) 的实验证实了这一点——他们发现 LoRA 学到的 $\Delta W$ 的有效秩（即奇异值显著不为零的维度）通常非常低。

从 Eckart-Young 定理的角度看， $AB$ 是 $\Delta W$ 的最优秩 $r$ 近似（当 $A$ 和 $B$ 无约束时）。当然，实际训练中 $AB$ 是通过梯度下降直接优化的，而非对 $\Delta W$ 做 SVD 截断——但两者在数学上是等价的：SGD 在低秩约束下的最优解必然收敛到截断 SVD 的结果。

为什么微调增量天然低秩？一种直觉是：预训练已经将权重带到了一个"好"的邻域，微调只需要在这个邻域内做小幅调整。而高维空间中的局部调整，其自由度远小于整个参数空间——类似于泰勒展开中低阶项主导了局部行为。另一种视角来自流形假设：自然数据的参数空间本身可能就嵌在低维流形上，微调只是沿着这个流形移动。

MLA 中的低秩联合投影

低秩近似在大型语言模型中的另一个关键应用是 DeepSeek 的 Multi-head Latent Attention（MLA）。其核心思想是：将 Key 和 Value 的投影矩阵联合压缩到一个低秩隐空间。

标准 Multi-Head Attention 中，每个 token 需要缓存的 KV 对维度为 $2 \times n_h \times d_h$ （ $n_h$ 为头数， $d_h$ 为头维度）。MLA 的做法是引入一个下投影矩阵 $W^{DKV} \in \mathbb{R}^{d \times d_r}$ （ $d_r \ll d$ ），将输入投影到低秩隐空间

c_t = W^{DKV} x_t

再由上投影矩阵恢复 Key 和 Value：

k_t = W^{UK} c_t, \quad v_t = W^{UV} c_t

缓存的对象从完整的 KV 向量变为了压缩后的 $c_t$ ，长度从 $2 \times n_h \times d_h$ 降低到 $d_r$ 。在 DeepSeek-V2 中， $d_r = 512$ ，而原始 KV 维度为 $2 \times 128 \times 128 = 32768$ ，压缩比超过 $60\times$ 。

这其实就是 SVD 低秩近似的工程实现：联合 KV 投影矩阵 $[W^K; W^V]$ 被 $W^{UK} W^{DKV}$ 和 $W^{UV} W^{DKV}$ 近似，其秩被 $d_r$ 限制。由于注意力权重矩阵的谱通常快速衰减（长序列中的注意力高度集中），这种低秩压缩在几乎不损失性能的前提下极大地降低了推理开销。

关于 MLA 的更详细分析，可以参考本站的 DeepSeek MLA 详解。

CR 近似：有结构约束的低秩近似

SVD 截断给出的是无约束的最优低秩近似——近似矩阵的每个元素都可以取任意值。但在许多实际场景中，我们希望近似矩阵保留原始数据的某些结构。CR（Column-Row）近似正是这样一类有结构约束的低秩近似。

CR 近似的基本形式为

A \approx C A_R

其中 $C$ 是从 $A$ 中选出的 $m \times k$ 列子矩阵， $A_R$ 是选出的 $k \times n$ 行子矩阵， $k$ 为目标秩。与 SVD 截断不同，CR 近似的因子直接来自原始矩阵的行列，而非抽象的奇异向量。

这带来了几个重要的区别：

可解释性：SVD 的奇异向量通常是所有原始行/列的线性组合，缺乏直接的物理含义；而 CR 近似选出的行列就是原始数据的一部分，保留了解释性。在特征选择场景中，这意味着我们可以直接识别"哪些特征最重要"，而不仅仅是"哪些组合最重要"。
兼容非线性运算：许多数据管道在矩阵运算之外还涉及非线性操作（如逐元素激活函数）。SVD 截断后的矩阵不再具有原始数据的结构，难以与这些非线性操作交互；而 CR 近似保留的行列可以直接穿过非线性层。
计算效率：CR 近似不需要计算完整的 SVD，只需选择重要的行和列，计算量显著更低。这在随机化线性代数（randomized linear algebra）中被广泛利用。

CR 近似与 SVD 截断的精度差距取决于原始矩阵的结构。当 $A$ 的主要信息集中在少数行列上时（例如稀疏矩阵或局部化矩阵），CR 近似可以非常接近 SVD 截断的效果；当信息均匀分散时，CR 近似的误差会更大，因为它无法像 SVD 那样通过线性组合来"浓缩"信息。

在深度学习中，CR 近似的思想出现在结构化低秩近似的研究中——例如，对神经网络的权重矩阵做低秩近似时，如果要求近似矩阵的某些行或列与原矩阵相同（以保持与特定神经元连接的兼容性），就自然地引出了 CR 近似的问题。

苏剑林在《低秩近似之路（三）：CR 近似》中详细讨论了 CR 近似的最优选择策略，以及它与 SVD 截断之间的精度关系。从伪逆的统一视角看，SVD 截断是"无约束最优"，CR 近似是"行列约束下的最优"——两者共享同一个优化框架，只是约束条件不同。

小结

奇异值分解揭示了矩阵最本质的结构——它将任意线性变换分解为旋转和拉伸的组合，而奇异值量化了每个方向上"拉伸"的强度。伪逆给出了 SVD 的"逆运算"，为低秩近似提供了统一的优化语言：将 $\min \|A - XY\|_F^2$ 中内层优化的解析解表达为伪逆，使得截断 SVD 的最优性可以从嵌套优化的结构中自然推出。Eckart-Young 定理保证了截断 SVD 是无约束下的最优低秩近似，而 CR 近似则表明，即使在附加行列选择的结构约束下，低秩近似的框架依然适用——只是约束不同，最优解的形式不同。

LoRA 和 MLA 都是无约束低秩近似的成功实践。它们的有效性建立在同一个经验事实之上：深度学习中的许多矩阵——无论是微调增量还是注意力投影——其奇异值谱都呈现快速衰减的特征。低秩近似是在"去噪"而非"丢失信息"——小奇异值对应的成分往往是不重要的或者甚至是噪声。

参考文献

苏剑林. 低秩近似之路（一）：伪逆. https://kexue.fm/archives/10366
苏剑林. 低秩近似之路（二）：SVD. https://kexue.fm/archives/10407
苏剑林. 低秩近似之路（三）：CR近似. https://kexue.fm/archives/10427
Eckart, C., & Young, G. (1936). The approximation of one matrix by another of lower rank. Psychometrika, 1(3), 211-218.
Hu, E. J., et al. (2022). LoRA: Low-Rank Adaptation of Large Language Models. ICLR 2022.
DeepSeek-AI. (2024). DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model.

SVD 的几何直觉#

SVD 的代数定义#

Moore-Penrose 伪逆#

伪逆的优化视角#

伪逆桥接低秩近似#

Eckart-Young 定理#

谱衰减假设：为什么现实矩阵通常是低秩的？#

LoRA：低秩分解的工程实例#

MLA 中的低秩联合投影#

CR 近似：有结构约束的低秩近似#

小结#

相关概念#

参考文献#

相关文章