做遥感影像配准的同事遇到过一个怪现象:把一张两千万像素的卫星影像从墨卡托投影重采样到等经纬度网格,挑了四十个控制点,软件报告的配准残差是 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 就是这么来的;到了神经网络,线性层的雅可比就是权重矩阵,批量时变成块对角,但没有实现会真的把它建出来。

下一篇讲矩阵求导的布局约定与常用公式。雅可比回答的是「函数对输入怎么变」,而训练一个模型时,损失是标量,参数是一整张矩阵,需要把标量对矩阵的导数写成一个形状相同的矩阵。分子布局和分母布局会把同一个结果写成互为转置的两种形式,先把这个约定钉死,再把常用公式逐条验证一遍,后面推反向传播才不会在转置上翻车。

当天可以自己验证的练习:

  1. 手算 F(x, y) = (x² + y, x·y) 在 (1, 2) 处的 2×2 雅可比,再写六行中心差分代码核对四个元素。
  2. 把上面例子的 h 换成 0.5、0.05、0.005,记录误差,确认误差大约按 h 的平方缩小,并解释为什么第一个输出分量的误差始终为零。
  3. 给 G(u, v) = (u+v, u·v) 和 F(p, q) = (p+q, p−q) 分别算雅可比,验证 J_F·J_G 与数值差分的复合结果一致,再试一次反序相乘,看维度是否仍然合法。
  4. 推导柱坐标 (r, θ, z) 到 (x, y, z) 的 3×3 雅可比行列式,并用 r=3 的具体点做数值核对,说明结果为什么等于 r。
  5. 给一层 y = W·x + b 取 3 个输入、2 个输出,写出 W,再对两条样本的批量映射做数值差分,确认 4×4 矩阵是块对角的。