某次训练日志,每 100 步打印一次 loss,连着四行是 2.31、2.28、2.30、2.29。曲线不降,还在 0.03 的范围内来回蹭。值班的同学第一反应是把学习率从 3e-4 调到 1e-4,理由是「抖说明步子太大」。改完重跑,日志变成 2.31、2.30、2.30、2.30,既不抖了,也不降了。

这个现场很常见,归因却经常错。loss 横跳不代表方向错了,loss 不动也不代表学习率还不够大。学习率只是乘在梯度前面的一个系数,梯度本身才决定往哪走、走多急。看不懂梯度给出的信息,调学习率基本等于蒙。

梯度就是导数在高维上的推广。这篇先把一维导数讲透:它在算什么、用定义怎么算、数值上怎么近似、符号和绝对值分别对应什么、哪些地方根本没有导数。这些搞清楚之后,再回头看那条 2.31 的曲线,才知道该查什么。

导数就是变化率

导数(derivative)的定义只有一句话:函数在某一点的变化率。要衡量「变化有多快」,最自然的办法是拿两个点比较:横着走一段距离 h,函数值变了 f(x+h)−f(x),两者相除就是平均变化率。

        f(x + h) − f(x)
f'(x) ≈ —————————————————
              h

这个比值叫差商(difference quotient)。几何上它是一段割线的斜率:在曲线上取 (x, f(x)) 和 (x+h, f(x+h)) 两点,连成一条直线,斜率就是差商。h 越大,两个点离得越远,这条割线越粗糙;h 越小,割线越贴近曲线在那一点的切线。切线斜率,就是导数。

单位这件事值得停一下。如果 f 是 loss、x 是一个参数,导数的单位就是「每改动一个单位的参数,loss 变化多少」。它回答的不是「loss 现在有多大」,而是「把 x 再挪一点点,loss 会往哪边动、动多快」。这也解释了为什么只盯着 loss 的绝对值调参没有意义,真正决定下一步的是这个比值。

拿 f(x)=x² 在 x=3 试一下。真实导数是 6,因为 2x 在 x=3 得 6。下面用越来越小的 h 算差商。

f = lambda x: x * x
for h in [1, 0.1, 0.01, 0.001]:
    print(h, (f(3 + h) - f(3)) / h)

在 Python 3.15 上跑,输出是:

1 7.0
0.1 6.100000000000012
0.01 6.009999999999849
0.001 6.000999999999479

h 从 1 降到 0.001,差商从 7 降到 6.001。规律很清楚:h 缩小十倍,差商和 6 的距离也缩小十倍。这不是巧合,把式子展开就能看出来:(9+6h+h²−9)/h 等于 6+h,所以差商永远比 6 多一个 h,h 趋近 0 时它自然收敛到 6。那个多出来的 h,正是下一篇要处理的余项。

顺带说一句,差商可以只用右边的点,也可以只用左边的点,还可以两边各取一半。取两边的那种叫中心差分,逼近得更快,第 3 节会用到它。

用定义算三个基本导数

定义摆在这里,真正动手算的时候只有一套动作:写出 f(x+h)−f(x),化简,约掉 h,再让 h 趋近 0。三个例子走完,这套动作就成型了。

第一个是平方。把 (x+h)² 展开,x² 与前面的 −x² 消掉,剩下的每一项都带 h,正好和分母约掉。

f(x) = x²

f(x + h) − f(x)   (x + h)² − x²
———————————————— = ———————————————
       h                h

                 x² + 2xh + h² − x²
               = ———————————————————
                          h

               = 2x + h

h 趋近 0 时,2x + h 趋近 2x

关键是第二步:约分之后式子里已经没有分母了,h 可以安全地取 0。这一步是整个定义法的核心,也是很多人学完仍然不会算的原因——公式背下来了,但「先约分再取极限」这个动作没记住。

第二个是倒数。两个分数没法直接相减,先通分,分子会出现 −h,再和分母的 h 约掉。

f(x) = 1/x

1/(x + h) − 1/x   x − (x + h)          −h
———————————————— = ——————————————— = ———————————————
       h            h·x·(x + h)      h·x·(x + h)

                 = −1 / (x·(x + h))

h 趋近 0 时,结果趋近 −1/x²

约完之后剩下的式子在 h=0 处有定义,直接代入得 −1/x²。要留意 x 不能取 0,函数本身在 0 处就没有定义,谈不上导数。

第三个是根号。√x 没法通分,用的是分子有理化:上下同乘 √(x+h)+√x,分子变成 (x+h)−x,只剩一个 h,再和分母约掉。

f(x) = √x

√(x + h) − √x   (√(x + h) − √x)(√(x + h) + √x)
—————————————— = —————————————————————————————
      h                h·(√(x + h) + √x)

                (x + h) − x               h
              = ——————————————— = ———————————————
                h·(√(x + h) + √x)   h·(√(x + h) + √x)

                    1
              = ——————————————
                √(x + h) + √x

h 趋近 0 时,结果趋近 1/(2√x)

三个例子走完,会发现同一个模式反复出现:先想办法造出一个含 h 的因子,把它约掉,剩下的部分才允许 h 取 0。结果整理起来就是最常用的三条:x² 的导数是 2x,1/x 的导数是 −1/x²,√x 的导数是 1/(2√x)。它们都能从定义推出来,不需要另背。真正需要带走的是那个约分动作,以及最后一步「h 趋近 0」到底在做什么。这件事现在只是含糊地说了过去,下一篇会把它写成极限。

数值微分:用两次函数值换一个导数

手算只在教学里可行。工程里要检查梯度写得对不对,靠的是数值微分(numerical differentiation):不推导公式,直接用函数值相减。最朴素的是前向差分,也就是差商本身,误差和 h 同阶,记作 O(h)。换成中心差分,精度立刻提升一档。

              f(x + h) − f(x − h)
f'(x) ≈ —————————————————————————
                     2h

为什么中心差分更准?把 f(x+h) 和 f(x−h) 各做一次泰勒展开再相减,含 h 的一次项正好抵消,剩下的是 h² 那一项,所以误差是 O(h²)。h 缩小十倍,误差缩小一百倍。这是它便宜又好用的原因:多算一次函数值,换来两个数量级的精度。

拿 sin 在 x=1 实测。解析导数是 cos(1),大约 0.5403023058681398。

import math
x = 1.0
exact = math.cos(x)
for h in [1e-2, 1e-3, 1e-4, 1e-5, 1e-6, 1e-7, 1e-8]:
    approx = (math.sin(x + h) - math.sin(x - h)) / (2 * h)
    print("%.0e  %.12f  %.3e" % (h, approx, abs(approx - exact)))
1e-02  0.540293300875  9.005e-06
1e-03  0.540302215818  9.005e-08
1e-04  0.540302304968  9.004e-10
1e-05  0.540302305857  1.114e-11
1e-06  0.540302305896  2.772e-11
1e-07  0.540302305674  1.943e-10
1e-08  0.540302308449  2.581e-09

前四行完全符合 O(h²):h 每降十倍,误差降一百倍,从 9e-6 一路降到 1e-11。但从 1e-6 开始,误差不再下降,反而回升,h=1e-8 时已经涨到 2.6e-9。

原因不在公式,在浮点数。双精度浮点只有大约 16 位十进制有效数字,sin(1+h) 和 sin(1−h) 的值又非常接近,相减时高位互相抵消,剩下的有效位被舍入噪声占满。h 越小,两个值越接近,抵消越严重,最后连正负号都不再可信。所以数值微分存在一个最优步长,通常落在 1e-5 附近,再小就没有意义。

顺带比较一下代价。前向差分一次只算一个函数值,中心差分要算两个,高维下就是两倍的函数调用。参数到百万级时,没人会对每一维都做数值检查,通常是抽几个维度,或者在整批数据上做一个方向投影来对比。精度也和数据类型有关:float32 只有大约 7 位有效数字,同样的公式放到 GPU 上算,最优步长会比双精度大得多,大约在 1e-3 附近,照搬 1e-5 只会得到噪声。

检查梯度时不要一味把 h 调小。正确做法是取几个不同量级的 h,看误差是否先降后升。如果解析梯度写错了,误差在各个 h 上都会稳定地大,不会呈现这种先降后升的形状。

导数告诉你的两件事:方向和陡峭程度

导数给出两件事,缺一不可。第一是符号,它说方向:值为正说明 x 增大时 f 增大,想让 f 变小就得往负方向走;值为负说明反过来。第二是绝对值,它说陡峭程度:绝对值大,说明脚下很斜,同样的位移会带来很大的函数值变化;绝对值小,说明接近平台,走同样的距离几乎不改变结果。

梯度下降(gradient descent)就是照着这两条信息走路:算出导数,取反方向,乘一个步长。写成一行是 x = x − lr·f'(x),其中 lr 是学习率,决定把导数给出的方向放大多少倍。

这里有个常被忽略的点:学习率不是「走多远」,而是「按梯度的大小放大多少倍」。梯度绝对值大时,同样的 lr 迈得更远;梯度接近 0 时,再大的 lr 也几乎不动。所以「loss 不降」既可能是 lr 太小,也可能是梯度本身已经贴到零,这两种情况要调的东西完全不同。

用一个最简单的一维函数 f(x)=x² 试。它的导数是 2x,最小值在 0。从 x=2 出发,分别用 0.1、0.5、1.05 三个学习率各走十步。

for lr in [0.1, 0.5, 1.05]:
    x = 2.0
    print("lr =", lr)
    for i in range(10):
        g = 2 * x
        x = x - lr * g
        print("  step %2d  x = %10.4f  f(x) = %10.4f" % (i + 1, x, x * x))
lr = 0.1
  step  1  x =     1.6000  f(x) =     2.5600
  step  2  x =     1.2800  f(x) =     1.6384
  step  3  x =     1.0240  f(x) =     1.0486
  step  4  x =     0.8192  f(x) =     0.6711
  step  5  x =     0.6554  f(x) =     0.4295
  step  6  x =     0.5243  f(x) =     0.2749
  step  7  x =     0.4194  f(x) =     0.1759
  step  8  x =     0.3355  f(x) =     0.1126
  step  9  x =     0.2684  f(x) =     0.0721
  step 10  x =     0.2147  f(x) =     0.0461
lr = 0.5
  step  1  x =     0.0000  f(x) =     0.0000
  step  2  x =     0.0000  f(x) =     0.0000
  step  3  x =     0.0000  f(x) =     0.0000
  step  4  x =     0.0000  f(x) =     0.0000
  step  5  x =     0.0000  f(x) =     0.0000
  step  6  x =     0.0000  f(x) =     0.0000
  step  7  x =     0.0000  f(x) =     0.0000
  step  8  x =     0.0000  f(x) =     0.0000
  step  9  x =     0.0000  f(x) =     0.0000
  step 10  x =     0.0000  f(x) =     0.0000
lr = 1.05
  step  1  x =    -2.2000  f(x) =     4.8400
  step  2  x =     2.4200  f(x) =     5.8564
  step  3  x =    -2.6620  f(x) =     7.0862
  step  4  x =     2.9282  f(x) =     8.5744
  step  5  x =    -3.2210  f(x) =    10.3750
  step  6  x =     3.5431  f(x) =    12.5537
  step  7  x =    -3.8974  f(x) =    15.1900
  step  8  x =     4.2872  f(x) =    18.3799
  step  9  x =    -4.7159  f(x) =    22.2397
  step 10  x =     5.1875  f(x) =    26.9100

三组结果说明三件事。lr=0.1 时每一步把距离乘以 0.8,十步后 x 从 2 降到 0.21,loss 从 4 降到 0.046,稳定但慢。lr=0.5 时一步就落到 0,因为 2 减去 0.5 乘 4 正好是 0;这是临界情况,再多一点就过头。lr=1.05 时每一步把 x 变成原来的 −1.1 倍,符号来回翻,绝对值越来越大,loss 从 4.84 涨到 26.9。

注意第三组的每一步,导数的符号都是对的:x 为正时梯度为正,就往负方向走;x 为负时梯度为负,就往正方向走。方向一次都没错过,它还是发散了。符号正确只保证这一步是在下坡,不保证能走到谷底。学习率乘得太大,一步跨过谷底还冲上对面的坡,下一次梯度又把你推回来,越推越远。对一维二次函数来说,稳定的步长上限是 2/f'',也就是曲率倒数的两倍;这里 f''=2,所以 lr 必须小于 1,1.05 刚好越界。

不可导的地方:尖角、ReLU 与二阶信息

导数存在的前提,是那个差商有唯一的极限。如果从左边靠近和从右边靠近得到两个不同的数,导数就不存在。最典型的例子是绝对值 |x| 在 0 点。

从左边看,x 为负时 |x|=−x,斜率是 −1;从右边看,x 为正时 |x|=x,斜率是 1。用采样验证:

g = lambda t: abs(t)
for h in [0.1, 0.01, 0.001]:
    print("h=%.3f right=%.6f left=%.6f" % (
        h, (g(0 + h) - g(0)) / h, (g(0 - h) - g(0)) / -h))
h=0.100 right=1.000000 left=-1.000000
h=0.010 right=1.000000 left=-1.000000
h=0.001 right=1.000000 left=-1.000000

不管 h 取多小,右差商恒为 1,左差商恒为 −1。它们不会靠拢,所以极限不存在,|x| 在 0 处不可导。图像上就是一个尖角,尖角处没有唯一的切线。

ReLU 是同一个形状:max(0, x)。x 小于 0 时导数为 0,大于 0 时导数为 1,0 点两边对不上。深度学习框架不会因此报错,它直接规定 0 点的梯度为 0(有的实现取 1),这个约定叫次梯度(subgradient)。它不是数学意义上的导数,是工程上的一个选择。所以同一份代码在不同框架下,ReLU 在 0 点的梯度可能不一样。一般不影响训练,但如果你的数据大量落在 0 点,就得知道这个约定存在。

类似的位置还有 max 池化和排序。max 在两个输入相等时,梯度该给谁没有定论,框架通常只回传给其中一个;排序和 argmax 更是把输入当成离散下标看待,局部扰动不改变输出,导数恒为 0。这些操作夹在模型中间时,反向传播照样能跑,但流过去的梯度已经不包含那一小段的选择信息了。

再说二阶导数。把导数再求一次导,得到 f''(x),它描述斜率本身变化的快慢,也就是曲线的弯曲方向。f'' 大于 0 叫凸,开口向上;小于 0 叫凹。这个符号决定了很多算法的行为:梯度下降在凸区间稳定,牛顿法则直接使用二阶信息。

牛顿法的一步更新是 x = x − f'(x)/f''(x)。它把导数除以曲率,曲率大就少走一点,曲率小就多走一点,所以通常比固定步长快。拿 f(x)=x²−2 求 √2,从 1 出发:

x = 1.0
for i in range(4):
    x = x - (x * x - 2) / (2 * x)
    print("iter", i + 1, repr(x))
iter 1 1.5
iter 2 1.4166666666666667
iter 3 1.4142156862745099
iter 4 1.4142135623746899

四步就到 1.4142135623746899,有效数字大约每步翻倍。代价是每一步都要算二阶导数,高维下还要解一个矩阵方程,参数量一大就负担不起。所以深度学习的优化器基本只用一阶信息,二阶方法更多出现在小规模或特殊结构的问题上。

一张现象对照表

下面这些现象在训练日志里都很常见,表面看差别很大,但都能回到「导数在说什么」这一层。

现象真实原因第一步查什么
loss 完全不降梯度接近 0,或学习率太小,参数几乎没有位移打印梯度范数,和参数范数比一下量级
loss 在小区间来回震荡学习率超过 2/曲率,一步跨过谷底又跨回来固定其它条件,把学习率减半再跑两百步
loss 变成 NaN梯度爆炸溢出,或计算里出现 log(0)、除以 0逐层打印梯度范数,定位第一次出现 inf 或 nan 的层
loss 先降后升已经越过最优点,或学习率贴着临界值看 loss 拐点对应的步数,与梯度范数的变化对照
训练 loss 降、验证 loss 不降过拟合,不是优化问题,梯度没有问题对比两条曲线,再看数据量与正则强度
数值梯度和手算差一截用了前向差分,误差是 O(h),或 h 取得过小换中心差分,取几个 h 量级看误差是否先降后升
某个参数梯度恒为 0激活进入饱和区,或这条路径在计算图上被切断检查该层激活值分布,确认计算图连上了

边界与代价

第一,导数只是局部信息。它描述的是某一点附近的行为,不能告诉你远处的形状。损失函数有几个谷底、当前这个谷底是不是全局最小,导数本身回答不了。学习率能走多远,本质上要靠局部曲率来约束,而曲率也只在足够小的邻域内可信。

第二,数值微分有精度上限。浮点相减会抵消,步长存在一个最优值,再小反而更差。高维下更贵:每个参数维度至少要算两次函数值,一百万参数就是两百万次前向,这个代价没人愿意付,所以工程上只把它当作校验手段,抽样查几个维度就够。

第三,不可导点到处都是。ReLU、绝对值、max 池化、排序、argmax、量化,这些操作在某些点上没有导数。框架用次梯度或直接规定 0 糊过去,训练通常能跑,但这些点的梯度信息是丢掉的,不能让它们承担关键的解释责任。

第四,高维下一次梯度要遍历全部参数。所谓反向传播,就是把链式法则的中间结果复用起来,避免每个参数单独算一遍。即便这样,一次梯度仍然要存下每一层的中间激活,显存开销和参数量成正比,分布式训练还要再加一层通信成本。

第五,定义要求函数在该点的邻域内有定义。区间端点只能谈单侧导数,图像断开的地方连差商都写不出来。所以讨论导数之前,先确认函数在那一点附近是「连成一片」的,这件事正是下一篇的主题。

小结与练习

这篇可以压成三句。导数是差商在 h 趋近 0 时的结果,几何上就是切线斜率;它同时给出方向和陡峭程度,方向决定往哪走,陡峭程度决定能走多远;它只在一点附近有效,遇到尖角就不存在。开头那条 2.31 的曲线,现在至少能拆成两个问题:梯度是不是真的接近 0,学习率是不是已经越过曲率允许的上限。

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

  1. 对 f(x)=x² 在 x=3 手算 h=1、0.5、0.1、0.01 的差商,列成一张表,验证每一行都等于 6+h,并说明为什么 h 不能直接取 0。
  2. 对 f(x)=x³ 在 x=2 用中心差分算 h 从 1e-2 到 1e-8 的近似值,和解析值 12 比较,打印每个 h 的误差,找出误差最小的那个 h。
  3. 在 0 附近对 |x| 采样,取 h=0.1、0.01、0.001 分别算左右差商,确认它们恒为 1 和 −1;再在 x=1 处算一次,确认得到 1。
  4. 用中心差分算 sin 在 x=0 和 x=π/2 的导数,和 cos 的对应值比较。解释为什么后者的相对误差更大:cos(π/2) 约等于 0,绝对误差不变时相对误差会被放大。
  5. 写一维梯度下降,对 f(x)=(x−3)² 从 0 出发,学习率取 0.1、0.5、1.0、1.05 各跑十步,找出开始震荡的临界值,并和 2/f''=1 对照。

下一篇:那个 h 到底怎么趋近 0

回头看,这篇里有一个动作一直没有被认真对待:h 趋近 0。我们只是含糊地说「越来越接近」,然后就把 h 当成 0 代进去了。凭什么可以这样做?如果分子分母同时变成 0,那个比值为什么还有答案?

下一篇讲极限与连续。它会解释 0/0 不是「没有答案」,而是「答案取决于你怎么靠近」,也会说明连续与可导之间那条单向关系到底卡在哪一步。只有把极限的语言补上,导数的定义才算真正完整。