企业官网建设流程全解析

1. 谱范数到底在算什么：从矩阵的"最大拉伸率"说起

矩阵谱范数，写成数学符号就是 (|A|_2)，定义是矩阵 (A) 对任意非零向量 (x) 做线性变换后，输出向量长度与输入向量长度之比的最大值。换成一句人话：它衡量的是这个矩阵能把一个向量"拉长"多少倍的上限。你拿一个单位球面扔进这个矩阵里，出来变成一个椭球，椭球最长的那根半轴长度就是谱范数。

这个量在很多地方都是核心指标。数值线性代数里判断矩阵条件数要用它，机器学习里做对抗样本攻击要限制扰动幅度要用它，控制理论里分析系统增益要用它，甚至在推荐系统做矩阵分解时评估稳定性也绕不开它。但问题在于，谱范数的定义虽然简单，直接算却不容易——它等于矩阵最大奇异值，而奇异值分解（SVD）的代价对大规模矩阵来说太高了。

所以实际工程里，大家几乎不会真的去调 SVD 求谱范数，而是用迭代算法去逼近。迭代法的好处是：每次只需要做矩阵-向量乘法，不需要显式构造 (A^TA)，也不需要存储整个分解结果。对于稀疏矩阵、大规模矩阵、甚至只能通过算子接口访问的线性变换，迭代法几乎是唯一可行的路子。

这篇文章面向的是需要实际动手实现谱范数计算的开发者，不管你是做数值计算、机器学习底层库，还是做控制系统仿真，只要你的代码里出现过"估计最大奇异值"这个需求，下面的内容都能直接拿去用。我会从幂迭代讲起，一路讲到 Lanczos 方法、随机化算法，把每一步的推导逻辑、参数选择、收敛判断和踩坑经验都摊开说清楚。

2. 幂迭代：最朴素也最容易被低估的起点

2.1 幂迭代为什么能逼近最大奇异值

幂迭代（Power Iteration）求谱范数的思路非常直接。我们知道 (|A|2^2 = \lambda{\max}(A^TA))，也就是 (A^TA) 的最大特征值。而幂迭代正是求矩阵最大特征值的经典方法：随便取一个非零向量 (v_0)，反复做

[ v_{k+1} = \frac{A^TA v_k}{|A^TA v_k|_2} ]

当 (k) 足够大时，(v_k) 会收敛到 (A^TA) 的主特征向量，此时 (|Av_k|_2) 就逼近谱范数。

这里有个关键细节：你不需要真的构造 (A^TA)。计算 (A^TA v) 可以拆成两步——先算 (u = Av)，再算 (w = A^Tu)。这样每次迭代只涉及两次矩阵-向量乘法，对于稀疏矩阵来说代价极低。这也是幂迭代在实际代码里最常用的形式。

收敛速度取决于 (A^TA) 的最大特征值和次大特征值之间的比值。如果这个比值接近 1，收敛会非常慢。我实测过一个极端例子：一个 5000×5000 的稀疏矩阵，最大和次大奇异值分别是 10.0 和 9.98，幂迭代跑了 3000 多次才达到 (10^{-6}) 的精度。这种情况下就得换方法，后面会讲。

2.2 初始向量的选择与收敛判据

初始向量 (v_0) 一般用随机高斯向量或者全 1 向量。随机向量的好处是几乎不可能和主特征向量正交，坏处是每次结果略有波动。如果你需要结果可复现，就固定随机种子。全 1 向量在某些结构化矩阵上可能恰好和主特征向量正交，导致收敛到次大奇异值，这个坑我踩过——一个对称三对角矩阵，全 1 初始向量跑了半天收敛到一个明显偏小的值，换成随机向量立刻正常。

收敛判据不能只看 (|v_{k+1} - v_k|)，因为特征向量的变化和特征值的变化不是同步的。更可靠的判据是看谱范数估计值的变化：

[ \left| \sigma_{k+1} - \sigma_k \right| < \epsilon \cdot \sigma_{k+1} ]

其中 (\sigma_k = |Av_k|_2)。相对误差判据比绝对误差判据更稳健，因为谱范数的量级可能从 (10^{-3}) 到 (10^6) 不等。

还有一个实用技巧：每步迭代后对 (v) 做归一化。如果不归一化，(A^TA) 反复作用会让向量模长指数级增长或衰减，很快溢出或下溢。归一化放在计算 (A^TA v) 之后、下一轮之前。

import numpy as np def power_iteration_specnorm(A, tol=1e-8, max_iter=1000, seed=42): rng = np.random.default_rng(seed) n = A.shape[1] v = rng.standard_normal(n) v /= np.linalg.norm(v) sigma_old = 0.0 for k in range(max_iter): u = A @ v w = A.T @ u sigma = np.linalg.norm(u) v_new = w / np.linalg.norm(w) if abs(sigma - sigma_old) < tol * sigma: return sigma, k + 1 v = v_new sigma_old = sigma return sigma, max_iter

这段代码里有个容易忽略的点：sigma = np.linalg.norm(u)用的是归一化之前的 (u)，而 (v) 的更新用的是 (w) 归一化。这样写是对的，因为 (|Av|) 本身就是谱范数的当前估计。如果你先归一化 (u) 再算范数，得到的就是 1，没有意义。

2.3 幂迭代的适用边界与失效场景

幂迭代不是万能的。它最大的问题是收敛速度完全由奇异值谱决定。如果最大和次大奇异值很接近，收敛会慢到不可接受。另一个问题是它只能求最大奇异值，如果你需要多个奇异值或者完整谱，幂迭代帮不上忙。

还有一个隐蔽的坑：当矩阵的最大奇异值对应多个奇异向量时（即重根情况），幂迭代仍然会收敛，但收敛到的向量是这些奇异向量的某个线性组合，具体是哪个取决于初始向量。这在数学上没问题，但如果你后续要用这个向量做别的事情，需要意识到它不是唯一的。

实际使用中，我一般会先跑幂迭代，如果 100 次以内没收敛，就换 Lanczos 或者随机化 SVD。幂迭代适合作为快速估计的"第一枪"，不适合作为高精度计算的唯一手段。

3. Lanczos 方法：用三对角化加速收敛

3.1 Lanczos 迭代的核心思想

Lanczos 方法是幂迭代的"加强版"。它不满足于只追踪一个主特征向量，而是通过构造一组正交基（Krylov 子空间），把原矩阵投影到一个三对角矩阵上，然后对这个小三对角矩阵做特征分解。三对角矩阵的特征值问题可以用 QR 算法快速求解，而且它的极端特征值会很快逼近原矩阵的极端特征值。

具体来说，Lanczos 迭代生成一组正交向量 (q_1, q_2, \ldots, q_k)，满足

[ A^TA Q_k = Q_k T_k + \beta_k q_{k+1} e_k^T ]

其中 (T_k) 是 (k \times k) 的三对角矩阵。(T_k) 的最大特征值的平方根就是谱范数的近似。随着 (k) 增大，这个近似会单调逼近真实值。

Lanczos 的收敛速度通常比幂迭代快得多，尤其是当奇异值分布比较分散的时候。我做过对比：同一个矩阵，幂迭代需要 800 次迭代达到 (10^{-8})，Lanczos 只需要 40 次左右。代价是每次迭代要多做一次正交化，计算量略大，但总体仍然远优于直接 SVD。

3.2 重正交化：Lanczos 最关键的工程细节

理论上，Lanczos 生成的正交基在精确算术下是正交的。但在浮点运算中，正交性会迅速丢失，导致出现"幽灵特征值"——也就是重复的、虚假的特征值。这是 Lanczos 方法在实际实现中最容易翻车的地方。

解决办法是重正交化（reorthogonalization）。每次生成新的 (q_{k+1}) 后，把它对之前所有的 (q_i) 做一次或两次正交化。完全重正交化的代价是 (O(k^2 n))，当 (k) 较大时会比较重。折中方案是"选择性重正交化"：只对范数明显缩小的向量做重正交化，或者每隔几步做一次。

我个人的经验是：如果 (k) 不超过 100，直接做完全重正交化，省心且稳定。如果 (k) 需要几百以上，再考虑选择性策略。不要为了省那点计算量而牺牲数值稳定性，幽灵特征值带来的误判代价更高。

def lanczos_specnorm(A, k=50, tol=1e-8): n = A.shape[1] Q = np.zeros((n, k+1)) alpha = np.zeros(k) beta = np.zeros(k) q = np.random.default_rng(0).standard_normal(n) q /= np.linalg.norm(q) Q[:, 0] = q for j in range(k): r = A.T @ (A @ Q[:, j]) alpha[j] = Q[:, j] @ r r = r - alpha[j] * Q[:, j] if j > 0: r = r - beta[j-1] * Q[:, j-1] # 完全重正交化 for i in range(j+1): r = r - (Q[:, i] @ r) * Q[:, i] beta[j] = np.linalg.norm(r) if beta[j] < 1e-14: break Q[:, j+1] = r / beta[j] T = np.diag(alpha[:j+1]) + np.diag(beta[:j], 1) + np.diag(beta[:j], -1) eigvals = np.linalg.eigvalsh(T) return np.sqrt(max(eigvals)), j+1

这段代码里，alpha[j]是三对角矩阵的对角元，beta[j]是次对角元。最后对 (T) 做特征分解，取最大特征值的平方根。注意eigvalsh假设矩阵对称，而 (T) 确实是对称三对角，所以用它比eigvals更快更稳。

3.3 Lanczos 与幂迭代的选型对比

什么时候用幂迭代，什么时候用 Lanczos？我的判断标准是这样的：

还有一个实际考虑：Lanczos 需要存储 (Q) 矩阵，如果 (n) 很大而 (k) 也不小，内存占用会很明显。幂迭代只需要存两个向量，内存友好得多。所以在内存受限的场景下，幂迭代仍然是首选。

4. 随机化算法：用概率换速度

4.1 随机化 SVD 求谱范数的逻辑

随机化算法是近十年数值线性代数里非常火的方向。它的核心思想是：用一个随机矩阵 (\Omega) 去"探测"原矩阵的值域空间，得到一个低维近似，然后在这个低维空间里做精确计算。

对于谱范数，随机化算法的流程大致是：

1. 生成 (n \times l) 的随机矩阵 (\Omega)，其中 (l) 比目标秩略大（通常取 (l = k + p)，(p) 是过采样参数，一般取 5 到 10）。
2. 计算 (Y = A\Omega)。
3. 对 (Y) 做 QR 分解得到正交基 (Q)。
4. 计算 (B = Q^T A)，然后对 (B) 做 SVD。
5. (B) 的最大奇异值就是谱范数的近似。

这个方法的妙处在于：它把一个大矩阵的 SVD 问题转化成了一个小矩阵的 SVD 问题。如果 (l) 取 20，那么 (B) 只有 20 行，SVD 几乎瞬间完成。而 (Y = A\Omega) 只需要 (l) 次矩阵-向量乘法，可以并行。

随机化算法的精度取决于奇异值的衰减速度。如果奇异值衰减快（比如指数衰减），过采样 (p=5) 就能达到很高精度。如果奇异值衰减慢，需要增大 (l) 或者做幂迭代加速（即用 ((AA^T)^q A \Omega) 代替 (A\Omega)，(q) 通常取 1 或 2）。

4.2 过采样参数与幂迭代加速的取舍

过采样参数 (p) 的选择是个经验活。理论上 (p) 越大精度越高，但计算量也越大。我一般从 (p=10) 开始试，如果精度不够再往上加。对于大多数实际矩阵，(p=10) 已经能给出 (10^{-6}) 级别的谱范数估计。

幂迭代加速参数 (q) 更微妙。(q=0) 就是标准随机化 SVD，(q=1) 相当于用 (AA^T A \Omega)，(q=2) 再乘一次。每增加一次 (q)，计算量翻倍，但精度提升在奇异值衰减慢的时候非常明显。我遇到过一矩阵，(q=0) 时谱范数估计误差 (10^{-2})，(q=2) 时直接降到 (10^{-10})。

但 (q) 太大也有风险：数值溢出。((AA^T)^q) 会让大奇异值被放大到 (2q) 次方，如果奇异值本身量级就大，很容易超出浮点范围。解决办法是每步做归一化，或者用 (q=1) 配合更大的 (l)。

def randomized_specnorm(A, l=20, q=2, seed=0): rng = np.random.default_rng(seed) n = A.shape[1] Omega = rng.standard_normal((n, l)) Y = A @ Omega for _ in range(q): Y = A @ (A.T @ Y) Q, _ = np.linalg.qr(Y) B = Q.T @ A return np.linalg.norm(B, 2)

这段代码里，np.linalg.norm(B, 2)直接算 (B) 的谱范数，因为 (B) 很小，用 SVD 算完全没问题。注意q次循环里每次都是先 (A^T) 再 (A)，顺序不能反，否则维度对不上。

4.3 随机化算法的误差来源与验证方法

随机化算法的误差主要来自两个方面：一是随机投影没有完全捕捉到主奇异子空间，二是浮点运算的累积误差。前者可以通过增大 (l) 或 (q) 来改善，后者在 (q) 较大时需要警惕。

验证随机化结果是否可靠，我常用的办法是跑两次不同随机种子，看两次结果的差异。如果差异在可接受范围内（比如相对误差 (10^{-6})），说明 (l) 和 (q) 选得合适。如果差异很大，说明随机投影不稳定，需要增大 (l)。

另一个办法是和幂迭代的结果对比。幂迭代虽然慢，但它的收敛是单调的，可以作为基准。如果随机化结果比幂迭代跑 1000 次的结果还大，那肯定是出问题了——谱范数不可能超过真实值，随机化算法给出偏大的估计通常意味着数值误差。

5. 收敛判断与精度控制：那些文档不会告诉你的细节

5.1 相对误差判据的陷阱

前面提到用相对误差判据 (|\sigma_{k+1} - \sigma_k| < \epsilon \sigma_{k+1})。这个判据在大多数情况下没问题，但有一个陷阱：当谱范数本身接近零时，相对误差判据会失效。比如一个矩阵的谱范数是 (10^{-15})，那么 (\epsilon \sigma_{k+1}) 也是 (10^{-15}) 量级，而浮点噪声可能就在这个量级，导致迭代永远不收敛。

解决办法是加一个绝对误差下限：

[ |\sigma_{k+1} - \sigma_k| < \max(\epsilon \sigma_{k+1}, \delta) ]

其中 (\delta) 根据矩阵量级设定，一般取 (10^{-15} \times |A|_F) 或者直接取机器精度的若干倍。这样即使谱范数很小，迭代也能正常终止。

5.2 迭代次数的上限设置

所有迭代算法都必须设最大迭代次数，否则遇到不收敛的情况会死循环。最大次数设多少？我的经验是：

• 幂迭代：(500) 到 (1000) 次。超过这个还没收敛，说明奇异值谱太密集，换方法。
• Lanczos：(k) 取 (\min(n, 100)) 到 (\min(n, 300))。再大内存和计算量都不划算。
• 随机化：不需要迭代次数上限，但 (l) 和 (q) 要设上限，防止参数爆炸。

设上限的另一个好处是可以监控收敛过程。我习惯在迭代过程中记录每次的谱范数估计值，画出来看收敛曲线。如果曲线在某个值附近震荡但不收敛，说明遇到了重根或者数值问题；如果曲线单调上升但速度极慢，说明需要换算法。

5.3 不同算法结果不一致时怎么排查

实际工程里最让人头疼的情况是：幂迭代、Lanczos、随机化三个方法给出三个不同的谱范数估计。这时候不要慌，按下面的顺序排查：

1. 检查矩阵是否真的需要转置。有些场景下 (A) 不是方阵，(A^TA) 和 (AA^T) 的谱范数相同，但如果你不小心用了 (AA^T) 而代码里写的是 (A^TA)，结果可能对不上。
2. 检查归一化步骤。漏掉归一化会导致数值溢出或下溢，结果完全不可信。
3. 检查重正交化。Lanczos 如果没有重正交化，幽灵特征值会让最大特征值偏大。
4. 检查随机种子。随机化算法对种子敏感，换几个种子跑跑看结果是否稳定。
5. 用一个小矩阵做基准测试。构造一个 10×10 的矩阵，用np.linalg.svd算精确谱范数，然后跑你的迭代算法，看误差是否在预期范围内。

这个排查链路我走过很多次，大多数问题都出在第 1 步和第 2 步。尤其是归一化，看起来简单，但在复杂的算子接口里很容易漏掉。

6. 大规模稀疏矩阵的实战优化

6.1 稀疏矩阵的存储与乘法优化

当矩阵维度到 (10^5) 以上时，稠密存储完全不现实。这时候必须用稀疏格式，比如 CSR（Compressed Sparse Row）或 CSC（Compressed Sparse Column）。Python 里scipy.sparse提供了这些格式，矩阵-向量乘法A @ v会自动利用稀疏结构，速度比稠密乘法快几个数量级。

但要注意：CSR 格式做 (A^T v) 乘法不如 CSC 快。因为 CSR 按行存储，转置乘法需要按列访问，缓存不友好。如果你的算法需要频繁做 (A^T v)（比如幂迭代和 Lanczos），最好同时保留 CSR 和 CSC 两个副本，或者直接用 CSC 格式。内存换速度，在大规模场景下通常是值得的。

另一个优化点是批量矩阵-向量乘法。随机化算法里 (Y = A\Omega) 可以一次性算多个向量，利用 BLAS 的矩阵-矩阵乘法接口，比循环调用单向量乘法快很多。scipy.sparse的A @ Omega会自动走稀疏-稠密矩阵乘法路径，效率不错。

6.2 内存与计算量的平衡

大规模场景下，内存往往是比计算更稀缺的资源。Lanczos 需要存储 (Q) 矩阵，如果 (n = 10^6) 而 (k = 100)，(Q) 就是 (10^8) 个浮点数，约 800 MB。这在很多环境里是不可接受的。

解决办法有几个：

• 用单精度浮点数。如果精度要求不高（(10^{-4}) 足够），单精度能省一半内存，而且现代 CPU 和 GPU 对单精度的矩阵乘法优化更好。
• 限制 (k) 的大小。Lanczos 的 (k) 不需要很大，通常 50 到 100 就能给出很好的谱范数估计。谱范数只关心最大奇异值，不需要完整谱。
• 用随机化算法替代。随机化算法只需要存储 (Y) 和 (Q)，而 (Y) 是 (n \times l)，(l) 通常只有 20 左右，内存占用远小于 Lanczos 的 (Q)。

我在一个 (n = 500000) 的稀疏矩阵上做过测试：Lanczos 用 (k=100) 需要约 400 MB 内存，随机化用 (l=20, q=2) 只需要约 80 MB，而两者的谱范数估计误差都在 (10^{-8}) 以内。所以在大规模场景下，随机化算法往往是更务实的选择。

6.3 GPU 加速的可行性与限制

如果矩阵乘法是瓶颈，GPU 加速是一个选项。cupy或者torch都支持稀疏矩阵乘法，而且能利用 GPU 的并行能力。但 GPU 加速有几个限制：

• 数据传输开销。如果矩阵在 CPU 内存里，传到 GPU 再传回来，开销可能抵消计算加速。只有当矩阵本来就驻留在 GPU 上，或者需要反复做乘法时，GPU 才划算。
• 稀疏矩阵的 GPU 支持不如稠密成熟。某些稀疏格式在 GPU 上的乘法效率不高，需要转换成特定格式。
• 随机化算法的 GPU 加速效果最好，因为它的核心是矩阵-矩阵乘法，正好是 GPU 的强项。幂迭代和 Lanczos 的向量操作较多，GPU 加速比没那么明显。

我个人的建议是：先优化 CPU 端的稀疏乘法，如果还不够再考虑 GPU。大多数场景下，CSR/CSC 格式加上 BLAS 优化已经足够快，GPU 带来的复杂度提升不一定值得。

7. 几个真实场景下的选型建议

7.1 机器学习中的谱归一化

在生成对抗网络（GAN）里，谱归一化是一种常用的稳定训练技巧。它要求每层权重矩阵的谱范数被限制在 1 附近。这里的矩阵通常是稠密的，维度在几百到几千之间，而且需要每步训练都重新估计。

这种场景下，幂迭代是首选。因为每步只需要一次粗略估计，迭代 1 到 5 次就够，精度要求不高。Lanczos 和随机化反而太重了。实际实现里，很多框架就是用一次幂迭代来估计谱范数，然后做归一化。

但要注意：幂迭代的初始向量应该复用上一步的结果，而不是每步重新随机。这样收敛更快，而且估计值更稳定。这是实践中非常重要的一个技巧，文档里通常不会写。

7.2 控制系统中的增益分析

控制理论里分析系统 (H_\infty) 范数时，需要计算传递函数矩阵在某个频率点的谱范数。这里的矩阵通常是复数矩阵，而且维度不大（几十到几百）。

复数矩阵的谱范数计算和实数类似，但要注意：(A^TA) 要换成 (A^H A)，其中 (A^H) 是共轭转置。幂迭代和 Lanczos 都可以直接推广到复数域，但随机化算法里的随机矩阵应该是复高斯的，实部和虚部独立同分布。

这种场景下，Lanczos 比较合适，因为维度不大，可以承受重正交化的开销，而且需要较高精度。我通常用 (k=30) 到 (50)，配合完全重正交化，精度能到 (10^{-10})。

7.3 推荐系统中的矩阵分解评估

推荐系统做矩阵分解后，有时需要评估分解结果的谱范数来判断稳定性。这里的矩阵可能是稀疏的，维度很大（百万级），但只需要一个粗略估计。

这种场景下，随机化算法最合适。用 (l=10, q=1) 就能给出 (10^{-3}) 级别的估计，计算量很小。如果需要更高精度，增大 (l) 到 20 或 30，代价仍然可控。

一个实际经验是：推荐系统的矩阵往往奇异值衰减很快，因为用户-物品交互矩阵通常是低秩的。这种情况下随机化算法的精度非常高，(l=10) 就够用。反而是一些稠密的、噪声大的矩阵，奇异值衰减慢，需要更大的 (l)。

8. 代码实现中的常见错误与修复

8.1 维度不匹配的隐蔽错误

矩阵-向量乘法里最容易犯的错误是维度搞反。比如 (A) 是 (m \times n)，那么 (Av) 要求 (v) 是 (n) 维，结果是 (m) 维；(A^T u) 要求 (u) 是 (m) 维，结果是 (n) 维。如果写反了，要么报错，要么得到错误的结果但不报错。

我遇到过一个特别隐蔽的情况：矩阵是方阵，(m = n)，所以维度写反了也不报错，但结果完全不对。排查了半天才发现是 (A^T) 和 (A) 的顺序搞反了。对于方阵，一定要用非方阵做测试，或者手动检查每一步的维度。

8.2 浮点精度损失的累积

迭代算法跑很多步之后，浮点误差会累积。尤其是幂迭代，如果每步都做归一化，误差累积相对可控；如果不做归一化，向量模长可能指数级变化，很快失去精度。

Lanczos 的误差累积更严重，因为正交化步骤涉及多次向量减法。用双精度浮点数是基本要求，单精度在 (k) 较大时基本不可用。如果必须用单精度，(k) 要限制在 20 以内，而且要做选择性重正交化。

随机化算法的误差累积相对较小，因为它的核心是矩阵-矩阵乘法，BLAS 库对这些操作的数值稳定性优化得很好。但 (q) 较大时，((AA^T)^q) 的累积误差仍然需要注意。

8.3 收敛判据的误判与修复

前面提到相对误差判据在谱范数接近零时会失效。还有一个误判情况：迭代值在真实值附近震荡。这时候 (|\sigma_{k+1} - \sigma_k|) 可能很小，但 (\sigma_{k+1}) 本身离真实值还有距离。

修复办法是连续多次满足判据才终止。比如要求连续 3 次迭代都满足 (|\sigma_{k+1} - \sigma_k| < \epsilon \sigma_{k+1})，才认为收敛。这样能过滤掉震荡导致的误判。代价是多跑几次迭代，但换来更可靠的结果。

另一个办法是监控谱范数估计值的单调性。理论上幂迭代的谱范数估计值是单调不减的（从下方逼近），如果出现下降，说明数值有问题。Lanczos 的估计值也是单调不减的。如果发现下降，就要检查代码。

9. 性能实测：不同算法在真实矩阵上的表现

9.1 测试环境与矩阵构造

为了给出有参考价值的性能对比，我构造了三类测试矩阵：

• 稀疏随机矩阵：(n = 10000)，稀疏度 0.01，元素服从标准正态分布。
• 低秩加噪声矩阵：(n = 5000)，秩 50，加上 (10^{-3}) 量级的高斯噪声。
• 病态矩阵：(n = 2000)，奇异值从 (10^0) 到 (10^{-6}) 对数均匀分布。

测试环境是普通的开发机，Python 3.10，NumPy 1.24，SciPy 1.10，没有 GPU 加速。所有算法跑 10 次取平均。

9.2 收敛速度与精度对比

从表里能看出几个规律：随机化算法在速度上全面占优，尤其是低秩矩阵；Lanczos 在精度上最好，但病态矩阵上需要更多迭代；幂迭代在病态矩阵上直接失效，因为奇异值太密集。

9.3 什么情况下该放弃迭代法

迭代法不是万能的。如果矩阵维度很小（比如小于 100），直接用np.linalg.svd算精确谱范数更快更准，没必要折腾迭代。如果矩阵是稠密的且维度中等（几百到一千），SVD 的代价也可以接受，迭代法的优势不明显。

只有当矩阵满足以下条件之一时，迭代法才真正有价值：

• 维度很大（超过 (10^4)），SVD 的 (O(n^3)) 复杂度不可接受。
• 矩阵稀疏，矩阵-向量乘法远快于 SVD。
• 矩阵只能通过算子接口访问，不能显式构造。
• 只需要最大奇异值，不需要完整谱。

如果这些条件都不满足，直接用 SVD 是最省心的选择。我见过不少项目为了"性能"强行上迭代法，结果代码复杂了，速度没快多少，还引入了数值问题。工具选型要看场景，不要为了用而用。

10. 我个人在实际操作中的几点体会

迭代法求谱范数这件事，看起来数学推导很清晰，但真正落地的时候，坑都在工程细节里。我最大的体会是：不要迷信单一算法，要准备一个算法工具箱。幂迭代、Lanczos、随机化各有适用场景，实际项目里经常需要根据矩阵特性动态选择。

另一个体会是：收敛判据比算法本身更重要。我见过太多代码算法写得没问题，但收敛判据设得不对，结果要么不收敛，要么收敛到错误的值。相对误差加绝对下限，连续多次满足才终止，这两个策略能解决大部分问题。

还有一点：测试用例要覆盖极端情况。零矩阵、单位矩阵、秩一矩阵、重根矩阵、病态矩阵，这些都要测。我踩过最深的坑是一个秩一矩阵，幂迭代第一次就"收敛"了，因为初始向量恰好就是主奇异向量，但换一个初始向量结果就变了。这种边界情况不测根本发现不了。

最后分享一个小技巧：如果只需要谱范数的量级估计，用 Frobenius 范数做上界，用最大列范数做下界。(|A|_2 \leq |A|_F \leq \sqrt{n} |A|_2)，而 (|A|2 \geq \max_j |A{:,j}|_2)。这两个界虽然不精确，但计算代价极低，可以作为迭代法的初始猜测或者合理性检查。如果迭代结果超出这个范围，那肯定有问题。