一位同事把 ∂(xᵀAx)/∂x 抄进了代码。他记得结论是「A 乘 x」,于是写下 grad = A @ x。用对称矩阵做单元测试,梯度方向是对的,损失也能下降,只是每一步都像踩了刹车;换成非对称的 A,训练直接发散。回头逐项核对才发现,正确答案是 (A + Aᵀ)x,对称时退化成 2Ax,他写的恰好只有一半。

另一类事故更隐蔽。按论文里的公式实现,结果和预期差一个转置,可 numpy 不报错:广播机制把列向量和行向量凑成一个方阵,代码继续跑,loss 慢慢变成 nan。等定位到那一行,两天已经过去了。最麻烦的是,单看每个符号都对,错的是它们的排列方式。

矩阵求导的公式本身并不复杂,难的是布局约定和形状。同一个标量对向量的导数,换一种书写习惯就会得到互为转置的两个结果,两边都没算错。这篇先把约定钉死,再给一套只看形状的自检流程,然后把常用公式逐条推导、逐条用数值差分核对,最后用迹技巧重推二次型。

布局约定:先定形状,再谈公式

设 y 是标量,x 是 n 维列向量,A 是 m×n 矩阵。所谓布局(layout),指的是把求导结果里的维度按什么顺序摆。主流的两套是分子布局和分母布局:分子布局把输出那一侧的维度放在前面,分母布局把输入那一侧的维度放在前面。对同一个导数,两套写法整体差一个转置,数值完全相同。

本文采用的是一套工程代码里更常见的混合约定:标量对向量、标量对矩阵按分母布局,结果与输入同形,也就是梯度是列向量、矩阵导数是同形状矩阵;向量对向量按分子布局,结果是 m 行 n 列的雅可比,行对应输出,和上一篇一致。这套约定不是纯理论分类,但它和自动微分框架里梯度与参数同形的行为对得上,也避免了每推一步就要转一次。

求导类型本文采用(工程混合)纯分子布局纯分母布局
标量 y 对 n 维向量 xn×1 列向量1×n 行向量n×1 列向量
标量 y 对 m×n 矩阵 Am×n,与 A 同形n×m,转置m×n,与 A 同形
m 维向量 y 对 n 维向量 xm×n 雅可比m×n 雅可比n×m,转置

这张表最重要的用法不是背,而是遇到分歧时先问一句「你用的是哪套」。网上大量「矩阵求导公式大全」把两套混着列,同一个公式在不同条目里形状相反,抄错一次就会在代码里多一个转置。真正的争论往往不是数学错误,而是双方默认的布局不同。

名字记不住没关系,形状必须写出来。每次推导前在草稿上标一行:输入是什么形状,输出是什么形状,结果应该是什么形状。三行写完,大部分错误会自己暴露。

维度检查:先写形状,再算数值

矩阵求导的自检可以固定成四步,顺序不要变。

确认函数类型:标量、向量还是矩阵
写出输入的形状,以及每个中间量的形状
按约定写出结果的形状
逐项检查相乘的内维与加法项的形状

第一步决定用哪条规则。标量对向量,结果和向量同形;标量对矩阵,结果和矩阵同形;向量对向量,结果是雅可比,行数等于输出维数、列数等于输入维数。第二步是真正容易出错的地方,因为很多表达式里有多个矩阵和向量,必须先标清楚谁乘谁得到什么。

举个具体的:A 是 m×n,x 是 n 维,b 是 m 维。那么 Ax 是 m 维,Ax − b 也是 m 维,‖Ax − b‖² 是标量。标量对 n 维的 x 求导,结果必须是 n 维。候选公式 2Aᵀ(Ax − b) 里,Aᵀ 是 n×m,乘 m 维括号,得到 n 维,接上了;而 2A(Ax − b) 得到 m 维,只有在 m=n 时才不报错,这就是方阵掩盖错误的原因。

第三步要特别小心「同形」和「同维」的区别。标量对 m×n 矩阵求导,结果是 m×n,不是 n×m;但如果这个矩阵恰好是方阵,两种写法都合法,只有数值能区分。所以单元测试不要只用方阵,也不要用对称矩阵,应该专门挑 2×3、3×2 和非对称的方阵,让转置错误无处可藏。

第四步是乘法检查。矩阵乘法要求左矩阵的列数等于右矩阵的行数,这个条件不满足时应该直接报错,而不是靠广播兜底。写完公式后把每个乘法的内维标出来,比如 (n×m)·(m×1) 的内维是 m,结果是 n×1,一眼就能看出对不对。加法两边的形状必须完全相同,广播在这里只会帮倒忙。

常用公式:六条,逐条推一遍

下面六条覆盖了线性模型、最小二乘、二次型、行列式和迹这几类最常见的形式。每一条都给出推导的落脚点,而不是只给结论。所有公式都按上一节的约定书写:标量对向量得到列向量,标量对矩阵得到同形矩阵。

第一条,∂(aᵀx)/∂x = a。把内积展开成 Σᵢ aᵢxᵢ,对 xₖ 求偏导时,求和里只有 i=k 那一项留下,结果是 aₖ。把所有 k 排成一列,就是向量 a。这条没有转置,因为 a 和 x 同维。

aᵀx = Σᵢ aᵢ·xᵢ
∂(aᵀx)/∂xₖ = aₖ
所以 ∂(aᵀx)/∂x = a

第二条,∂(xᵀx)/∂x = 2x。这是上一条取 a=x 的特例,但更直接:xᵀx = Σᵢ xᵢ²,对 xₖ 求导得 2xₖ。注意这里不能写成 x,平方项求导会掉下来一个 2,这是最常见的「结果少一半」来源之一。

xᵀx = Σᵢ xᵢ²
∂(xᵀx)/∂xₖ = 2·xₖ
所以 ∂(xᵀx)/∂x = 2x

第三条,∂(xᵀAx)/∂x = (A + Aᵀ)x。把二次型写成双重求和 ΣᵢΣⱼ Aᵢⱼxᵢxⱼ,对 xₖ 求导,会得到两类项:一类是 i=k 时留下的 Σⱼ Aₖⱼxⱼ,即 Ax 的第 k 个分量;另一类是 j=k 时留下的 Σᵢ Aᵢₖxᵢ,即 Aᵀx 的第 k 个分量。两类合并,就是 (A + Aᵀ)x。A 对称时两项相同,退化成 2Ax;A 非对称时,只写 Ax 就漏掉了一半贡献。

xᵀAx = Σᵢ Σⱼ Aᵢⱼ·xᵢ·xⱼ
∂/∂xₖ = Σⱼ Aₖⱼ·xⱼ + Σᵢ Aᵢₖ·xᵢ
      = (Ax)ₖ + (Aᵀx)ₖ
所以 ∂(xᵀAx)/∂x = (A + Aᵀ)x

第四条,∂‖Ax − b‖²/∂x = 2Aᵀ(Ax − b)。令残差 r = Ax − b,先对 r 求导得 2r,再乘上 r 对 x 的雅可比。r 对 x 的映射是线性的,雅可比就是 A,形状 m×n。按照上一篇的链式法则,梯度是 Aᵀ(2r),顺序和形状都必须如此。写成 2A(Ax − b) 是最典型的漏转置。

r = Ax − b
∂(rᵀr)/∂r = 2r
∂r/∂x = A        (m×n)
链式:∂/∂x = Aᵀ·(2r) = 2Aᵀ(Ax − b)

第五条,∂log det A/∂A = (A⁻¹)ᵀ,前提是 A 可逆。推导用行列式的局部展开:给 A 加一个小扰动 E,有 det(A + E) ≈ det(A)·(1 + tr(A⁻¹E)),于是 log det(A + E) − log det A ≈ tr(A⁻¹E)。把迹展开成 ΣᵢΣⱼ (A⁻¹)ᵢⱼ·Eⱼᵢ,对 Eᵢⱼ 的偏导就是 (A⁻¹)ⱼᵢ。按位置 (i,j) 排成矩阵,正好是 (A⁻¹)ᵀ,不是 A⁻¹。A 对称时两者相同,又是一个会被对称测试放过的错误。

det(A + E) ≈ det(A)·(1 + tr(A⁻¹E))
log det(A + E) − log det A ≈ tr(A⁻¹E)
tr(A⁻¹E) = Σᵢ Σⱼ (A⁻¹)ᵢⱼ·Eⱼᵢ
∂/∂Eᵢⱼ = (A⁻¹)ⱼᵢ
所以 ∂log det A/∂A = (A⁻¹)ᵀ

第六条,∂tr(AB)/∂A = Bᵀ,其中 A 是 m×n,B 是 n×m,乘积是方阵,迹才有定义。把迹展开:tr(AB) = ΣᵢΣⱼ AᵢⱼBⱼᵢ。对 Aᵢⱼ 求偏导,只有 Bⱼᵢ 这一项留下。按 (i,j) 排成 m×n 矩阵,就是 Bᵀ,形状也正好和 A 相同。这条公式里 B 不能直接写成 B,除非 B 恰好对称。

tr(AB) = Σᵢ Σⱼ Aᵢⱼ·Bⱼᵢ
∂tr(AB)/∂Aᵢⱼ = Bⱼᵢ
所以 ∂tr(AB)/∂A = Bᵀ

六条公式有一个共同点:推导都落在「展开成求和,只留一个下标」这个动作上。记住这一点,比背六条结论更耐用,因为遇到稍微变形的表达式时还能自己推。下面用数值差分把六条全部核一遍。

数值核对:让公式自己说话

核对方法是逐元素中心差分:对输入向量的每个分量、或输入矩阵的每个元素,加上和减去一个小步长 h,用函数值之差除以 2h,得到数值导数。再把解析公式算出的矩阵逐项相减,取最大绝对误差,除以解析结果的最大绝对值,得到相对误差。取 h 等于十的负五次方,双精度下相对误差通常在十的负十一量级。

下面的脚本只用标准库,矩阵乘法、行列式和求逆都是手写的,没有 numpy。被测函数覆盖上面六条公式,最后打印每一行的相对误差。

import math

def T(A): return [list(r) for r in zip(*A)]
def mv(A, x): return [sum(A[i][j] * x[j] for j in range(len(x))) for i in range(len(A))]
def mm(A, B):
    return [[sum(A[i][t] * B[t][j] for t in range(len(B))) for j in range(len(B[0]))]
            for i in range(len(A))]

def grad(f, x, h=1e-5):
    g = []
    for j in range(len(x)):
        a, b = x[:], x[:]
        a[j] += h; b[j] -= h
        g.append((f(a) - f(b)) / (2 * h))
    return g

def gradm(f, A, h=1e-5):
    G = [[0.0] * len(A[0]) for _ in A]
    for i in range(len(A)):
        for j in range(len(A[0])):
            a = [r[:] for r in A]; b = [r[:] for r in A]
            a[i][j] += h; b[i][j] -= h
            G[i][j] = (f(a) - f(b)) / (2 * h)
    return G

def det(A):
    M = [r[:] for r in A]; n = len(M); d = 1.0
    for i in range(n):
        p = max(range(i, n), key=lambda r: abs(M[r][i]))
        M[i], M[p] = M[p], M[i]
        if p != i: d = -d
        d *= M[i][i]
        for r in range(i + 1, n):
            f = M[r][i] / M[i][i]
            for c in range(i, n):
                M[r][c] -= f * M[i][c]
    return d

def inv(A):
    n = len(A)
    M = [A[i][:] + [1.0 if i == j else 0.0 for j in range(n)] for i in range(n)]
    for i in range(n):
        p = max(range(i, n), key=lambda r: abs(M[r][i]))
        M[i], M[p] = M[p], M[i]
        pv = M[i][i]
        M[i] = [v / pv for v in M[i]]
        for r in range(n):
            if r != i:
                f = M[r][i]
                M[r] = [M[r][c] - f * M[i][c] for c in range(2 * n)]
    return [r[n:] for r in M]

def rel(u, v):
    if not isinstance(u[0], list): u, v = [u], [v]
    d = max(abs(u[i][j] - v[i][j]) for i in range(len(v)) for j in range(len(v[0])))
    s = max(abs(x) for r in v for x in r) or 1.0
    return d / s

a = [1.5, -2.0, 0.5]; x = [0.7, -1.2, 2.0]
print("a^T x       rel=%.2e" % rel(grad(lambda v: sum(p * q for p, q in zip(a, v)), x), a))
print("x^T x       rel=%.2e" % rel(grad(lambda v: sum(p * p for p in v), x), [2 * v for v in x]))

A = [[2.0, 1.0, 0.0], [0.0, 3.0, 1.0], [1.0, 0.0, 2.5]]
print("x^T A x     rel=%.2e" % rel(
    grad(lambda v: sum(p * q for p, q in zip(v, mv(A, v))), x),
    mv([[A[i][j] + A[j][i] for j in range(3)] for i in range(3)], x)))

M = [[1.0, 2.0], [0.0, 1.0], [1.0, 0.0]]; b = [1.0, 2.0, 0.5]; xs = [0.5, -1.0]
print("||Ax-b||^2  rel=%.2e" % rel(
    grad(lambda v: sum((mv(M, v)[i] - b[i]) ** 2 for i in range(3)), xs),
    [2 * q for q in mv(T(M), [mv(M, xs)[i] - b[i] for i in range(3)])]))

S = [[2.0, 1.0, 0.5], [0.3, 1.5, -0.2], [0.1, 0.4, 1.2]]
g5 = gradm(lambda B: math.log(det(B)), S)
a5 = T(inv(S))
print("log det A   rel=%.2e" % rel(g5, a5))

P = [[1.0, 2.0, 3.0], [0.5, -1.0, 0.0]]
Q = [[1.0, 0.5], [2.0, -1.0], [0.0, 3.0]]
print("tr(AB)      rel=%.2e" % rel(
    gradm(lambda B: sum(B[i][j] * Q[j][i] for i in range(2) for j in range(3)), P), T(Q)))

本机 Python 3.15 的真实输出:

a^T x       rel=1.27e-11
x^T x       rel=6.55e-12
x^T A x     rel=3.13e-12
||Ax-b||^2  rel=6.55e-12
log det A   rel=3.67e-11
tr(AB)      rel=1.26e-11

六行的相对误差都在十的负十一次方量级,比常见的千分之一阈值低了八个数量级。这说明解析公式和数值导数逐项一致,没有漏项、没有转置、也没有系数错误。误差没有更小,是因为中心差分本身有截断误差和舍入误差,h 取十的负五次方时,双精度大概只能到十的负十一。想再往下压,应该换自动微分,而不是继续减小 h。

迹技巧:把求和藏进一个符号里

迹(trace)是方阵对角线元素之和,记作 tr(A)。它把双重求和压成一个标量,在矩阵求导里非常好用。四条性质先摆出来:标量等于它自己的迹;tr(AB) = tr(BA),前提是乘积合法,这条叫循环性质;tr(A) = tr(Aᵀ);内积可以写成迹,aᵀb = tr(aᵀb) = tr(baᵀ)。

这些性质的价值在于换顺序。矩阵乘法不可交换,AB 和 BA 一般不相等,但它们的迹相等。所以在只关心标量的时候,可以随意把因子轮换到方便的位置,把「对谁求导」的那一项挪到微分符号旁边。这是迹技巧的全部秘密,不需要额外记公式。

标量:        y = tr(y)
循环:        tr(AB) = tr(BA)          (乘积合法时)
转置不变:    tr(A) = tr(Aᵀ)
内积写成迹:  aᵀb = tr(aᵀb) = tr(b·aᵀ)
Frobenius:   tr(AᵀB) = Σᵢ Σⱼ Aᵢⱼ·Bᵢⱼ

用迹重推一次 ∂(xᵀAx)/∂x。先把标量写成迹:f = xᵀAx = tr(xᵀAx)。利用循环性质把 xᵀ 挪到最后,得到 tr(Axxᵀ)。对两边取微分,df = tr(A·d(xxᵀ)),而 d(xxᵀ) = dx·xᵀ + x·dxᵀ。代进去拆成两项,再用循环性质和转置不变把每一项整理成 tr((某个向量)ᵀ·dx) 的形式,系数加起来就是梯度。

f = tr(xᵀAx) = tr(Axxᵀ)
df = tr(A·d(xxᵀ))
   = tr(A·dx·xᵀ) + tr(A·x·dxᵀ)
   = tr(xᵀA·dx) + tr(dxᵀ·A·x)
   = tr((Aᵀx)ᵀ·dx) + tr((Ax)ᵀ·dx)
   = tr(((A + Aᵀ)x)ᵀ·dx)
所以 ∂f/∂x = (A + Aᵀ)x

这套写法比逐项拆下标省事,也不容易漏掉 Aᵀx 那一项。关键在于最后一步:把 tr(Gᵀ·dx) 里的 G 读出来,它就是梯度。只要能把微分整理成这个标准形式,系数矩阵按约定摆好就是答案。矩阵求导的很多「高级技巧」,本质都是把表达式往这个形式凑。

三个最常见的错误

公式背错只是表面,真正反复出现的是下面三类结构性错误。每一类都给出错误写法、正确写法和为什么错。

漏转置

把 ∂‖Ax − b‖²/∂x 写成 2A(Ax − b)。当 A 是 2×3 时,括号是 2 维,乘出来还是 2 维,而梯度必须是 3 维,形状直接不匹配;当 A 是方阵时形状碰巧对,数值却全错。正确写法是 2Aᵀ(Ax − b),转置的作用是把 m 维的残差映回 n 维的输入空间。

布局混用

从一份用分子布局的资料里抄来 ∂(xᵀAx)/∂x = xᵀ(A + Aᵀ),这是一条 1×n 的行向量。代码里把它和 n×1 的 x 相加,广播不会报错,而是生成一个 n×n 矩阵,下一步再乘就彻底变形。正确写法是按本文约定写成列向量 (A + Aᵀ)x,或者在入口处统一转置一次。

把矩阵当标量约掉

看到 tr(AB),把 A 和 B 当成普通数,约掉 A 得到 B。但矩阵乘法不可交换,迹也不是普通乘积,正确结果是 Bᵀ。同类错误还有把 (Ax)ᵀ(Ax) 里的 A 直接「提出来约掉」,得到 xᵀx;实际是 xᵀAᵀAx,A 根本约不掉。

三类错误有一个共同的防线:先用非方阵、非对称矩阵做形状检查和数值检查。方阵和对称矩阵会同时掩盖转置错误和漏项错误,是最差的测试用例。真正有效的单元测试,是拿一个 2×3 的 A、一个 3 维的 x,把解析梯度和中心差分逐项比,误差超过千分之一就失败。

一张现象对照表

下面这些现象在推导、实现和调参时都出现过,原因基本都能归到布局、形状或公式适用条件上。

现象真实原因第一步查什么
梯度和参数维度差一个转置用了另一套布局,或抄公式时漏了转置打印梯度和参数的真实形状,按本文三条规则对照
二次型的梯度只有一半只写了 Ax,漏掉 Aᵀx 那一项用非对称 A 检查结果是否等于 (A + Aᵀ)x
对称矩阵测试全过,换非对称就错对称时 A = Aᵀ,把错误恰好掩盖了固定用非对称矩阵和非方阵做回归测试
log det 的导数和差分差一个转置对 Aᵢⱼ 求导得到的是 (A⁻¹)ⱼᵢ把解析矩阵转置后再和数值矩阵比较
迹公式套错,结果多一项或少一项循环性质用在了不合法的维度上,或把迹当普通乘积先确认每个乘积的内维合法,再检查轮换顺序
数值梯度对得上,训练还是不收敛梯度符号、缩放或更新方向有误,不是求导本身做一步小步长下降,确认损失确实变小
复合函数的梯度整体转置链式相乘时内外层顺序反了标出每个雅可比的形状,确认内维相接且顺序正确

边界与代价

第一,布局没有唯一标准。论文、教材、框架文档各自默认一套,甚至同一份资料前后不一致。这不是数学缺陷,而是记号层面的历史包袱。能做的只有两件事:自己写清楚约定,读别人的公式时先确认约定,不要拿两套的结果直接比较。

第二,公式多,容易记混。上面六条已经是精简后的结果,实际还会遇到含矩阵逆、伪逆、行列式绝对值、带约束的版本,每一条都有适用条件。死记硬背的失败率很高,可靠的办法是记住推导路径:展开求和、看单项、或者用微分加迹。推导慢一点,但错了能自己发现。

第三,矩阵求导的公式库只覆盖常见形式。线性项、二次型、范数平方、行列式、迹,这几类有干净的闭式解;一旦遇到逐元素非线性、归一化、softmax、注意力里的 softmax 交叉项,手推很快会失控。这类函数应该交给自动微分,人只需要理解形状和链式结构。

第四,高阶导数更复杂。标量对向量的导数是向量,再对向量求导得到矩阵,再求一次就是三阶张量,维度迅速膨胀。实际训练里很少显式构造 Hessian,通常只用到 Hessian 与向量的乘积,或者用有限差分估计曲率。把高阶导数写成普通矩阵求导的重复应用,形式上可行,计算上很快变得不现实。

第五,矩阵乘法不可交换,这条会渗透到每一个推导细节。能够轮换的只有迹里面的循环顺序,以及标量之间的乘法;矩阵本身、矩阵与向量的乘积都不能随意换位。把矩阵当标量约分,是这类错误里最不容易被形状检查发现的一种,因为约掉之后维度有时仍然合法。

小结与练习

这篇的主线可以压成四句:布局约定决定结果要不要转置,公式本身往往没有错;形状检查是最便宜的自检,先写输入输出再写结果;六条常用公式都能从「展开求和、只留一个下标」推出来,其中二次型和最小二乘最容易漏掉转置项;迹技巧把标量写成迹,再利用循环性质换顺序,可以大幅减少下标运算。

下一篇讲反向传播。前面拿到的雅可比描述「函数对输入怎么变」,而训练时损失是标量、参数是矩阵,需要把标量对参数的导数写成同形矩阵,再让每一层的转置把上游梯度映回输入维度。矩阵求导的公式一旦嵌进多层网络,就会以链式相乘的形式反复出现;布局错一次,整条链上的形状都会跟着错。

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

  1. 手推 ∂(aᵀx)/∂x 和 ∂(xᵀx)/∂x,再用一个 3 维的具体向量做中心差分,确认结果分别等于 a 和 2x。
  2. 手推 ∂(xᵀAx)/∂x,取一个非对称的 2×2 矩阵,先用 (A + Aᵀ)x 算,再用数值差分核对,最后试一次只写 Ax,看差多少。
  3. 给 ‖Ax − b‖² 取 2×3 的 A 和 3 维的 x,分别计算 2Aᵀ(Ax − b) 与 2A(Ax − b) 的形状,解释哪一个才可能正确。
  4. 用迹技巧重推 ∂(xᵀAx)/∂x,把每一步的 tr 展开写清楚,特别检查 Aᵀx 那一项是从哪里来的。
  5. 故意把 ∂tr(AB)/∂A 写成 B 而不是 Bᵀ,选一个非对称的 B,比较解析结果和数值差分的差,记录相对误差的量级。