做遥感影像配准的同事遇到过一个怪现象:把一张两千万像素的卫星影像从墨卡托投影重采样到等经纬度网格,挑了四十个控制点,软件报告的配准残差是 0.3 像素,肉眼看也对得上。可是把结果拿去统计海岸线长度和海域面积,和基准数据比,边缘区域错开了七八个像素,面积大了将近百分之三。
控制点没错,错的是变换模型。代码里用了一个全局固定的 2×2 仿射矩阵,相当于假设「整张图上每一点的局部缩放和旋转都一样」。墨卡托到经纬度的映射不满足这个假设:同样的经度差,在赤道附近和在高纬度对应的地面距离完全不同。固定矩阵只在标定中心附近准确,离中心越远,偏差越大,而且偏差不是均匀的,是按距离的平方在长。
要描述「每一点各自的线性近似」,数学上用的就是雅可比矩阵(Jacobian matrix):一个多元函数在某一点附近,可以用一个矩阵来近似,这个矩阵就是它所有偏导数按固定顺序排成的一张表。这篇要讲清三件事:这张表为什么是 m 行 n 列,怎么用数值差分把它核出来,以及它在坐标变换、链式法则和神经网络里分别扮演什么角色。
一张表:行是输出,列是输入
先固定记号。一个多元函数 F: Rⁿ 到 Rᵐ,意思是它吃进 n 个实数,吐出 m 个实数。写成向量形式,输入是 x = (x₁, x₂, …, xₙ),输出是 F(x) = (F₁(x), F₂(x), …, Fₘ(x))。每个输出分量 Fᵢ 都是一个标量函数,都可以对每一个输入分量 xⱼ 求偏导。
把这些偏导排成矩阵,就是雅可比:第 i 行第 j 列的元素是 ∂Fᵢ/∂xⱼ。行号跟着输出走,列号跟着输入走。形状是 m×n,不是 n×m。这个约定不是审美选择,而是为了让矩阵乘法写得顺:输入方向的变化量是一个 n 维列向量,雅可比左乘它,得到 m 维的输出变化量。
[ ∂F1/∂x1 ∂F1/∂x2 ... ∂F1/∂xn ]
[ ∂F2/∂x1 ∂F2/∂x2 ... ∂F2/∂xn ]
J = [ ... ... ... ... ]
[ ∂Fm/∂x1 ∂Fm/∂x2 ... ∂Fm/∂xn ]
J · Δx 的维度: (m×n) · (n×1) = (m×1)
维数这一条是自检的第一道关。如果写出一个 n×m 的矩阵,乘 n 维列向量根本乘不了,除非你把它转置。很多人不是不懂偏导,而是把「第 i 行对应第 i 个输入」记反了。判断方法很直接:看这个矩阵乘在输入变化量的左边还是右边,乘完能不能得到输出那一侧的维数。乘不通,就是排错了。
顺带把雅可比和梯度的关系说清。梯度通常只定义在标量函数上,也就是 m=1 的情况。这时雅可比只有一行,是 1×n 的行向量;而梯度习惯写成 n×1 的列向量。两者数值一样,形状差一个转置。所以「梯度是雅可比的特例」这句话成立,但要注意布局约定,否则会在公式里差一个转置,这正是下一篇要处理的事。
∂Fᵢ/∂xⱼ 是一个数,不是向量。整张表才是矩阵。看到「对 x 求导得到 (1, y)」这种写法时,要问清楚这个括号里的两个数分别对应哪个输出,否则很容易把列写成行。手算一个 2×2 的例子
取一个足够小、又能看出结构的函数:F(x, y) = (x + y, x·y)。输入两维,输出两维,所以雅可比是 2×2。按照「列是输入」的规则,先固定输入分量,看两个输出各自怎么变。
对 x 求偏导,把 y 当常数:第一个输出 x + y 的导数是 1,第二个输出 x·y 的导数是 y。这一列是 (1, y),写在第一列。对 y 求偏导,把 x 当常数:第一个输出对 y 的导数是 1,第二个输出对 y 的导数是 x。这一列是 (1, x),写在第二列。
[ ∂F1/∂x ∂F1/∂y ] [ 1 1 ]
J(x,y)=[ ] = [ ]
[ ∂F2/∂x ∂F2/∂y ] [ y x ]
在点 (1, 2) 处代入,得到 J = [[1, 1], [2, 1]]。注意左下角的 2 是 y 的值,右下角的 1 是 x 的值。这里很容易写反,因为直觉上「x 那一列应该出现 x」,但第二行第二列恰好是 x 对第二个输出的贡献,跟 x 本身的数值一样只是巧合。
用中心差分把这四个数逐个核一遍。中心差分的做法是:对某个输入分量加一个很小的 h,再减一个 h,用两次输出的差除以 2h。它比单侧差分准,误差是 h 的平方量级。取 h 等于十的负五次方,在双精度浮点上比较稳。
def F(x, y):
return [x + y, x * y]
def jac(fn, p, h=1e-5):
rows = len(fn(*p))
J = [[0.0] * len(p) for _ in range(rows)]
for j in range(len(p)):
a, b = list(p), list(p)
a[j] += h
b[j] -= h
fa, fb = fn(*a), fn(*b)
for i in range(rows):
J[i][j] = (fa[i] - fb[i]) / (2 * h)
return J
for row in jac(F, (1, 2)):
print(["%.6f" % v for v in row])
本机 Python 3.15 跑出来的结果:
['1.000000', '1.000000']
['2.000000', '1.000000']
四舍五入到六位小数,和手算完全一致。数值差分不会「证明」公式,但它能抓住排错:如果把行和列弄反,输出会变成 [[1, 2], [1, 1]],拿它和手算结果一比立刻就能发现。工程里更常见的做法不是手算,而是写一个数值梯度检查器,把解析实现的雅可比和差分结果逐项比,相对误差超过千分之一就报错。
局部线性化:只在一点附近成立
雅可比的核心用途,是把一个不好算的非线性函数,在某一点附近换成一个好算的线性函数。严格的说法是:如果 F 在点 x 处可微,那么
F(x + Δ) = F(x) + J(x)·Δ + o(‖Δ‖)
移项后: F(x + Δ) − F(x) − J(x)·Δ 的模长,比 ‖Δ‖ 更快趋于 0
用上面那个例子验证。取 x=(1,2),Δ=(h, h),其中 h 依次取 0.1、0.01、0.001。真实值是 F(1+h, 2+h) = (3+2h, 2+3h+h²),线性近似值是 (3+2h, 2+3h)。第一个分量本来就线性,误差为零;第二个分量差一个 h²,所以最大误差正好是 h 的平方。
p = (1.0, 2.0)
Fp = F(*p)
J = [[1, 1], [2, 1]]
for h in (0.1, 0.01, 0.001):
truth = F(p[0] + h, p[1] + h)
approx = [Fp[i] + J[i][0] * h + J[i][1] * h for i in range(2)]
err = max(abs(truth[i] - approx[i]) for i in range(2))
print("h=%.3f true=(%.6f, %.6f) approx=(%.6f, %.6f) err=%.1e"
% (h, truth[0], truth[1], approx[0], approx[1], err))
h=0.100 true=(3.200000, 2.310000) approx=(3.200000, 2.300000) err=1.0e-02
h=0.010 true=(3.020000, 2.030100) approx=(3.020000, 2.030000) err=1.0e-04
h=0.001 true=(3.002000, 2.003001) approx=(3.002000, 2.003000) err=1.0e-06
h 缩小十倍,误差缩小一百倍。这就是「一阶近似」的实际含义:误差不是变小一点,而是按步长的平方变小。反过来看,如果步长扩大十倍,误差扩大一百倍,所以拿一个点的雅可比去推很远处的函数值,误差会迅速失控。开头那个配准问题就是如此:用中心点的矩阵去推边缘像素,距离一大,二次项就把结果带偏了。
这也解释了数值微分的步长为什么不能随便选。h 太大,截断误差是 h² 量级;h 太小,两个几乎相等的浮点数相减会发生有效位抵消,舍入误差按 1/h 放大。双精度下常用的折中是十的负五到十的负六次方。对特别敏感的函数,可以用复数步长或自动微分,不必在差分上死磕。
链式法则:矩阵乘法,顺序不能反
复合函数的导数还是链式法则,只是每个环节的导数变成了矩阵,矩阵相乘代替了数相乘。若 G: R² 到 R³,F: R³ 到 R²,复合映射 F∘G 把二维送到二维,它的雅可比是 2×2。公式写成:
J(F∘G)(u) = J_F(G(u)) · J_G(u)
维度: (2×3) · (3×2) = (2×2)
内层维数 3 必须接上
内层维数接不上,乘法就没有定义,这是最硬的一道检查。但要注意,维度检查只能排除一部分错误:在这个例子里,J_G·J_F 是 (3×2)·(2×3),得到 3×3,也完全合法,可它描述的是另一个复合映射 G∘F,不是我们要的那个。所以除了看维数,还得确认哪个函数在里层、哪个在外层。
取具体映射:G(u, v) = (u+v, u·v, u−v),F(p, q, r) = (p+q, p·r)。在 (u,v)=(1,2) 处,G 的输出是 (3, 2, −1),正好作为 F 的输入。
def G(u, v):
return [u + v, u * v, u - v]
def F(p, q, r):
return [p + q, p * r]
def jac(fn, p, h=1e-5):
rows = len(fn(*p))
J = [[0.0] * len(p) for _ in range(rows)]
for j in range(len(p)):
a, b = list(p), list(p)
a[j] += h
b[j] -= h
fa, fb = fn(*a), fn(*b)
for i in range(rows):
J[i][j] = (fa[i] - fb[i]) / (2 * h)
return J
def compose(u, v):
return F(*G(u, v))
JG = jac(G, (1, 2))
JF = jac(F, (3, 2, -1))
prod = [[sum(JF[i][k] * JG[k][j] for k in range(3)) for j in range(2)]
for i in range(2)]
print("J_F * J_G:")
for row in prod:
print(["%.6f" % v for v in row])
print("numeric:")
for row in jac(compose, (1, 2)):
print(["%.6f" % v for v in row])
手算的中间结果:J_G 是 [[1,1], [2,1], [1,−1]],J_F 是 [[1,1,0], [−1,0,3]]。相乘得到 [[3,2], [2,−4]]。直接对复合函数做数值差分,结果一模一样。
J_F * J_G:
['3.000000', '2.000000']
['2.000000', '-4.000000']
numeric:
['3.000000', '2.000000']
['2.000000', '-4.000000']
拿第一行第一列核对一下乘法:1·1 + 1·2 + 0·1 = 3。这三个加数分别来自 F 的第一个输出对三个中间变量的敏感度,乘上 G 的三个输出对 u 的敏感度。这正是链式法则的展开式,矩阵乘法只是把「对每个中间变量求和」这件事打包了。数值差分和解析乘法在第七位小数上一致,说明中间没有漏项。
雅可比行列式:面积被放大了多少
当输入输出维数相同,雅可比是方阵,可以取行列式。行列式在这里有一个非常具体的解释:它是一小块面积或体积被映射后的缩放倍数。二维情况下,输入平面上一个很小的矩形,经过映射后变成一个很小的平行四边形,后者面积约等于前者面积乘上 |det J|。符号则记录方向有没有被翻转。
最经典的例子是极坐标。映射 (r, θ) 到直角坐标:x = r·cosθ,y = r·sinθ。对 r 求偏导得一列 (cosθ, sinθ),对 θ 求偏导得一列 (−r·sinθ, r·cosθ)。行列式是 r·cos²θ + r·sin²θ = r,用到了恒等式 cos²θ + sin²θ = 1。
[ cosθ −r·sinθ ]
J(r,θ)=[ ]
[ sinθ r·cosθ ]
det J = cosθ·r·cosθ − (−r·sinθ)·sinθ = r
这就是换元积分里那个多出来的 r 的来源。在直角坐标下算面积,微元是 dx·dy;换到极坐标,同一块小区域对应的微元是 r·dr·dθ。不是公式里凭空塞了一个 r,而是坐标网格本身被拉伸了:越往 r 大的地方,同样的角度增量 dθ 划过的弧长越长,面积自然按 r 倍增长。
在 r=2.5、θ=0.7 处做数值核对:
import math
def polar(r, t):
return [r * math.cos(t), r * math.sin(t)]
def jac(fn, p, h=1e-5):
rows = len(fn(*p))
J = [[0.0] * len(p) for _ in range(rows)]
for j in range(len(p)):
a, b = list(p), list(p)
a[j] += h
b[j] -= h
fa, fb = fn(*a), fn(*b)
for i in range(rows):
J[i][j] = (fa[i] - fb[i]) / (2 * h)
return J
J = jac(polar, (2.5, 0.7))
for row in J:
print(["%.6f" % v for v in row])
print("det = %.6f" % (J[0][0] * J[1][1] - J[0][1] * J[1][0]))
['0.764842', '-1.610544']
['0.644218', '1.912105']
det = 2.500000
结果正好是 r 的值 2.5。可以顺手验算:cos0.7 = 0.764842,sin0.7 = 0.644218,−2.5·sin0.7 = −1.610544,2.5·cos0.7 = 1.912105。行列式是 0.764842×1.912105 − (−1.610544)×0.644218。第一项约为 1.462458,第二项里的 1.610544×0.644218 约为 1.037541,减去负数等于加上正数,合计约 2.500000。这不是巧合,而是 cos²θ + sin²θ = 1 在数值上的体现。
行列式为负表示定向翻转,比如把 (x, y) 映射成 (y, x),雅可比是 [[0,1],[1,0]],行列式等于 −1。面积用的是绝对值,所以缩放倍数仍然是 1,但手性变了。做图像变换时如果只取 det 不取绝对值,负号会让面积变成负数,后续统计全错。行列式为零则是另一种情况:映射把一块有面积的区域压成一条线或一个点,信息不可逆,这种变换不能用来做坐标还原。
神经网络里的一层:雅可比就是权重矩阵
把视角换到最常见的线性层。y = W·x + b,其中 W 是 m×n 矩阵,x 是 n 维列向量,y 是 m 维。这个函数对 x 的雅可比是什么?对每个输出分量 yᵢ = Σⱼ Wᵢⱼ·xⱼ + bᵢ,对 xⱼ 的偏导就是 Wᵢⱼ,而且与 x 无关。所以整张雅可比就是 W 本身,形状 m×n。偏置 b 只平移输出,不影响导数,求导时直接消失。
真实训练不会一条一条样本算。把 B 条样本的输入拼成一个 B×n 的矩阵 X,输出拼成 B×m 的矩阵 Y。如果硬要把所有输入拉直成一个长度 B·n 的列向量,把所有输出也拉直成长度 B·m 的列向量,那么整个批量映射的雅可比是一个 (B·m)×(B·n) 的矩阵。它的结构是块对角:每条样本只影响自己的输出,块与块之间没有交叉,每个对角块都是同一个 W。
W = [[1.0, 2.0], [-1.0, 0.5]]
b = [0.3, -0.2]
def layer(x1, x2):
x = [x1, x2]
return [W[i][0] * x[0] + W[i][1] * x[1] + b[i] for i in range(2)]
def batch(x1, x2, x3, x4):
return layer(x1, x2) + layer(x3, x4)
# 中心差分整个批量映射,输入 4 维,输出 4 维
for row in jac(batch, (1.0, 2.0, -0.5, 0.3)):
print(["%.3f" % v for v in row])
['1.000', '2.000', '0.000', '0.000']
['-1.000', '0.500', '0.000', '0.000']
['0.000', '0.000', '1.000', '2.000']
['0.000', '0.000', '-1.000', '0.500']
输出是 4×4,左上和右下两个 2×2 块都等于 W,其余位置为零。这验证了「块对角」这个结构。但没有任何框架会真的把这个矩阵建出来:一层 4096 维到 4096 维、批量 1024,显式雅可比有大约 (1024×4096)² 个元素,数量级是十的十三次方,按 float64 存要上百 TB。真正需要的往往不是 J,而是它和某个向量的乘积。反向传播算的是 vᵀ·J,对线性层就是 vᵀ·W,实现时写成 Wᵀ·v,代价和一次普通矩阵乘法一样。
一张现象对照表
下面这些现象都来自真实调试,表面看各不相同,追下去多半落在雅可比的形状、取值或适用范围上。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 梯度和参数维度对不上 | 把 m 行 n 列写成了 n 行 m 列,或把列向量当成了行向量 | 先写出输入输出各几维,确认 J 是 m×n 且左乘 n 维列向量 |
| 坐标变换后面积偏大或偏小 | 换元时漏了雅可比行列式,或只用了中心点的固定矩阵 | 在每个采样点算 det J 并取绝对值,检查是否逐点变化 |
| 线性近似只在很小范围准 | 雅可比只是局部一阶信息,二次项随距离平方增长 | 把步长减半,看误差是否降到约四分之一 |
| 链式相乘时维度报错 | 内外层函数顺序弄反,中间维数没接上 | 标出每个雅可比的形状,确认相邻两个的内维相等 |
| 变换后的面积出现负值 | 雅可比行列式为负,映射翻转了定向 | 检查是否对 det 取了绝对值,以及坐标轴顺序是否被交换 |
| 批量数据的雅可比形状乱掉 | 把样本维和特征维混在一起,或忘了块对角结构 | 确认总输入维是 B·n、总输出维是 B·m,块数等于 B |
| 数值梯度和解析梯度对不上 | 函数在该点不可导,或差分步长落在折点两侧 | 换几个步长重测,检查 ReLU、绝对值、最大值这类折点 |
边界与代价
第一,雅可比可能非常大。它的元素个数是 m×n,输入输出各一千维就是一百万个元素,各四千维就是一千六百万个,按双精度存超过一百兆字节。这还只是一层、一个样本。所以「先构造雅可比再使用」在这类场景里是不现实的,必须走矩阵与向量相乘的路径。
第二,它只在一点附近有效。雅可比是线性近似,不是函数本身。距离越远,高阶项越重要;如果函数曲率很大,哪怕很近,近似也可能不准。判断近似是否够用,要看具体任务能容忍多大误差,而不是看公式写没写对。
第三,不可导点上没有雅可比。ReLU 在零点、绝对值在零点、最大值函数在多个输入相等处,导数都不存在。工程上通常取一个次梯度(比如 ReLU 在零点取 0 或 0.5),能跑通,但那不是数学意义上的导数。数值差分在这些点附近会来回跳,不能拿它当唯一裁判。
第四,行列式为零不等于「全局不可逆」。它只说明在当前点附近,映射把某个方向压扁了,局部不能还原。一个映射可能在某些点行列式为零,在别处仍然可逆;也可能处处行列式非零,却因为绕了一圈仍然不是全局一一对应。做坐标反解时,除了看行列式,还要看映射本身的结构。
第五,数值差分有精度上限。截断误差和舍入误差一个随步长增大、一个随步长缩小,二者折中出一个最好的步长,通常在十的负五到十的负六次方。再往下压步长,误差反而上升。需要高精度时应当用自动微分或解析公式,而不是把 h 调到十的负十二次方。
小结与练习
把这篇压成几句话:雅可比是多元函数在一点处的线性近似,形状 m×n,行对应输出、列对应输入;它可以用中心差分逐项核对;复合函数的雅可比是各段雅可比的矩阵乘积,内维必须接上,顺序不能反;方阵情形下,行列式给出局部面积或体积的缩放倍数,换元积分里的 r 就是这么来的;到了神经网络,线性层的雅可比就是权重矩阵,批量时变成块对角,但没有实现会真的把它建出来。
下一篇讲矩阵求导的布局约定与常用公式。雅可比回答的是「函数对输入怎么变」,而训练一个模型时,损失是标量,参数是一整张矩阵,需要把标量对矩阵的导数写成一个形状相同的矩阵。分子布局和分母布局会把同一个结果写成互为转置的两种形式,先把这个约定钉死,再把常用公式逐条验证一遍,后面推反向传播才不会在转置上翻车。
当天可以自己验证的练习:
- 手算
F(x, y) = (x² + y, x·y)在(1, 2)处的 2×2 雅可比,再写六行中心差分代码核对四个元素。 - 把上面例子的 h 换成 0.5、0.05、0.005,记录误差,确认误差大约按 h 的平方缩小,并解释为什么第一个输出分量的误差始终为零。
- 给
G(u, v) = (u+v, u·v)和F(p, q) = (p+q, p−q)分别算雅可比,验证J_F·J_G与数值差分的复合结果一致,再试一次反序相乘,看维度是否仍然合法。 - 推导柱坐标
(r, θ, z)到(x, y, z)的 3×3 雅可比行列式,并用 r=3 的具体点做数值核对,说明结果为什么等于 r。 - 给一层
y = W·x + b取 3 个输入、2 个输出,写出 W,再对两条样本的批量映射做数值差分,确认 4×4 矩阵是块对角的。