第 7 关 · 基础 · 在浏览器里运行
English

优化

在真实数据上,怎样让训练又快又稳?

你已经会训练一个网络了:算损失,算梯度,往下坡走一步。 真实的训练还要加上四个习惯,让它更快、更稳。每个习惯都解决一个用几个数就能看出来的问题:

  1. 小批量(mini-batch):不要每走一步之前都把所有数据看一遍。
  2. 更好的优化器:不要让某一个陡峭的方向决定所有方向的速度。
  3. 初始化:从合适的权重出发,让各个数保持合理的大小。
  4. 学习率调度:开头和结尾都走小步。

第 8 关讲的是训练好模型的另一半:模型在从没见过的数据上也要好用。

1. 小批量

用一条直线 y^=wx+b\hat y = w x + b 拟合四个点:(1, 3)、(2, 3)、(3, 7)、(4, 7)。它们大致落在 y = 2x 上,带一些噪声。 从 w = 0.5,b = 0 出发。

误差(预测值 − 真实值)是 −2.5、−2、−5.5、−5。w 的梯度是各点 2 · error · x 的平均。

数字 点 (1, 3)、(2, 3)、(3, 7)、(4, 7);w = 0.5,b = 0,所以误差是 −2.5、−2、−5.5、−5。用全部四个点,dL/dw = 2·error·x 的平均是多少?

这用到了全部四个点。小批量只用其中一部分。取一个只有一个点 (3, 7) 的批:

数字 直线 ŷ = w·x + b,w = 0.5,b = 0。用一个只有一个点 (3, 7) 的批。它的误差是 −5.5。这一批的 dL/dw = 2·error·x 是多少?

一个点拉得比平均值更猛:−33,而不是 −21.5。点 (1, 3) 单独只给出 −5。 每一批对“哪边是下坡”都有自己的看法。平均下来,这些看法和完整的梯度一致, 但每一步只听其中一个。

先猜一猜批大小 1,学习率 0.02,从 w = 0.5,b = 0 出发。每走一步之后,你都在全部四个点上测一次损失。它每一步都下降吗?

试一试。批大小 4 就是全部数据。批大小 1 每一步只用一个点。

小批量:每一步只看一部分数据

选一个批大小,然后走几步。批大小为 4 时径直下坡;批大小为 1 时走得歪歪扭扭。

0123-202wb
每个 (w, b) 处全部 4 个点上的损失:灰色越浅,损失越低。
0369x=1x=2x=3x=4
4 个数据点和你的直线。
最好能到 0.8走一步,就会画出损失损失步数 →
每一步之后全部 4 个点上的损失(已走 0 步)。现在: 16.375
批大小
起点:w = 0.5,b = 0。选一个批大小,走几步。每一轮都会重新打乱这 4 个点。
你走的步和你的直线 上一步用到的点 最好的直线,w = 1.6,b = 1

批大小为 4 时,路径很平滑。批大小为 1 时,它来回摆动,到了谷底附近也一直停不下来。 即使在最好的直线 w = 1.6、b = 1 处,每个点单独看仍然往自己的方向拉。

我卡在这里了 既然全批更平滑,为什么不总是用全部数据?

因为真实的数据集有几百万个样本。全批走一步就要把它们全读一遍,只为了挪动一次。 一个 32 个样本的批给出的方向有噪声但有用,代价却只是一小部分,所以在走一次全批的时间里,你能走几千步。

噪声也不只是代价。它能把权重带离平坦的地方和小坑,这常常有帮助。 至于最后那些来回的小摆动,一个常见的办法是随着训练推进降低学习率。

把全部训练数据一批接一批地过一遍,叫作一轮(epoch)。有 4 个点、每批 1 个时, 一轮是 4 步。训练通常要跑很多轮,每一轮都重新打乱顺序。

数字 一个训练集有 1,000 个样本,你用大小为 50 的小批量。一轮是多少步?
我卡在这里了 为什么每一轮开始时都要重新打乱数据?

不打乱的话,每一轮的批都一样,顺序也一样。权重每次都沿着同一串方向走。如果数据是排好序的 (先全是 3,再全是 4),一轮里的每一段都只看到一种样本。最后那个较小的批也总是同样那几个样本。 每一轮换一个新的随机顺序,就得到一组新的批,于是每次的噪声都不一样,这能帮权重走出平坦的地方。

2. 优化器

下面是一个形状像窄山谷的损失:

f(w1,w2)=0.5 (w12+25 w22)f(w_1, w_2) = 0.5\,(w_1^2 + 25\,w_2^2)

它的梯度是 (w1, 25w2)(w_1,\ 25 w_2)。山谷横向(w2w_2)比纵向(w1w_1)陡 25 倍。 从 (−4, 1) 出发。那里的梯度是 (−4, 25)。

普通的梯度下降(SGD)做的是 w←w−lr⋅gw \leftarrow w - \text{lr} \cdot g,lr = 0.03。

数字 f(w1, w2) = 0.5·(w1² + 25·w2²),从 (−4, 1) 出发,梯度是 (−4, 25)。用 lr = 0.03 走一步 SGD:新的 w2 是多少?

w2 从 1 跳到了 0.25,移动了 0.75。w1 只移动了 0.12,从 −4 到 −3.88。 陡的方向走得快,缓的方向走得非常慢。你想给 w1 更大的学习率,那就把它调大:

选择损失是 f(w1, w2) = 0.5·(w1² + 25·w2²),梯度是 (w1, 25·w2)。从 (−4, 1) 出发。为了让 w1 走得快些,SGD 的 lr 从 0.03 换成 0.09。w2 会怎样?

所以用普通 SGD 时,最陡的方向给所有方向定了速度上限。有两种解决办法:

  • 动量(momentum)保留一个记住过去步子的速度 uu:u←βu+gu \leftarrow \beta u + g,然后 w←w−lr⋅uw \leftarrow w - \text{lr} \cdot u。 β(beta)通常是 0.9:每一步保留旧速度的 90%,再加上新的梯度。 方向一致的步子(顺着山谷)会累加起来。符号来回翻转的步子(横穿山谷)会互相抵消。

  • Adam 给每个权重各自的步长。它保留两个滑动平均,每次把最新的值混进旧的平均里, 比如 m←0.9 m+0.1 gm \leftarrow 0.9\,m + 0.1\,g:

    • mm,梯度的平均(beta1 = 0.9),
    • vv,梯度平方的平均(beta2 = 0.999)。

    它每步走 lr⋅m^/v^\text{lr} \cdot \hat m / \sqrt{\hat v}。除以 v^\sqrt{\hat v} 抵消了梯度的大小, 所以不管梯度是 4 还是 25,每个权重都大约移动 lr。

下面是 Adam 在 lr = 0.3 时的第一步。题目问的是 w1 移动了多远,不是它落在哪里。m^\hat m 和 v^\hat v 是 m 和 v 在最初几步做了一点修正后的值。在第 1 步,它们就是 m^=g\hat m = g 和 v^=g2\hat v = g^2。 平方根 √ 总是取正的那个根,所以 (−4)2=16=4\sqrt{(-4)^2} = \sqrt{16} = 4。

数字 Adam 用 lr = 0.3,从 (−4, 1) 出发,梯度是 (−4, 25)。在第 1 步,m̂ = g,v̂ = g²,所以这一步是 0.3·g/√(g²)。w1 变化了多少?(给出移动的大小,不是新位置。)

现在让三个优化器都从 (−4, 1) 出发,比一比。

三个优化器,一个山谷

三个都从 (−4, 1) 出发。一步步走,或者按“播放 60 步”,看哪个先到达最低点。

最低点 (0, 0)起点 (−4, 1)−4−2024−101w1w2

每个圈是一个损失等高线。这些圈被压扁了:山谷横向(w2)比纵向(w1)陡 25 倍。

w1w2损失到 (0, 0) 的距离
SGD-4120.54.123
上一次更新:—
动量-4120.54.123
上一次更新:—
Adam-4120.54.123
上一次更新:—
步数:0
梯度是 g = (w1, 25·w2):横穿山谷的方向比顺着山谷的方向陡 25 倍。
SGD 动量 Adam 最低点 起点
动手试试

把动量 β 设成 0,按“播放 60 步”。动量现在走的是哪条路径?再试试 β = 0.99。记住更多步的速度 什么时候有帮助,什么时候又会把权重带过谷底?

深入一点 为什么 Adam 要除以 1 − β^t

m 和 v 从 0 开始。走一步之后,m = 0.1·g:只有梯度的十分之一,仅仅因为它从 0 开始。 除以 1 − 0.9¹ = 0.1 正好抵消这一点,于是 m^=g\hat m = g。走了很多步之后,0.9t0.9^t 几乎是 0,这个修正就小到可以忽略了。 v 和 beta2 = 0.999 也一样。

关键是比值 m^/v^\hat m / \sqrt{\hat v}。如果一个权重的梯度符号一直不变,这个比值接近 ±1,权重每步大约移动 lr。 如果符号不停地翻转,m^\hat m 平均下来趋向 0,而 v^\sqrt{\hat v} 仍然很大,所以步子变小。正是这一点止住了横穿山谷的来回摆动。

自己写出动量的一步,分两行:先算新的速度,再移动。

代码写出动量的一步:先用新的梯度 g 更新速度 u,再把 w 移动 lr 乘以 u。两个都返回。

Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行

现在写出 Adam 的更新。NumPy 里的平方根是 np.sqrt,比如 np.sqrt(16.0) 是 4.0。 真实的代码会在分数的下面(分母)加一个很小的数 eps(1e-8),即 v^+eps\sqrt{\hat v} + \text{eps},这样永远不会 除以 0。函数通过参数 eps 收到它。

代码写出 Adam 的更新。mₕₐₜ 和 vₕₐₜ 已经算好了。

Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行

3. 初始化

训练开始之前,每个权重都需要一个值。通常的做法是随机取。但取多大?

要谈“多大”,我们需要一个词。标准差(standard deviation,std)说的是一组数通常离它们的均值有多远。 [1, −1, 1, −1] 的标准差是 1。[10, −10, 10, −10] 的标准差是 10。(第 10 关给出准确的公式。 数学页也有一个简短的例子。)

一层的每个输出都是对它的输入求和:z=x1w1+x2w2+⋯+xnwnz = x_1 w_1 + x_2 w_2 + \dots + x_n w_n。如果输入的标准差是 1, 权重的标准差是 s,那么这个和的标准差大约是 √n · s。要让它保持为 1,就取 s = 1/√n,其中 n 是这一层的输入个数(它的“扇入”)。

我卡在这里了 为什么和的标准差按 √n 增长,而不是按 n?

因为正负起伏会部分抵消。真正精确相加的是方差(标准差的平方):n 个独立项的和, 每项方差为 s²,和的方差就是 n·s²。开平方回到标准差:√n · s。 例子:100 个标准差各为 0.1 的项,方差是 100 × 0.01 = 1,所以标准差是 1。

数字 一层有 100 个输入(扇入 n = 100)。按规则 s = 1/√n,它的权重应该取多大的标准差?

现在叠上 10 层,而且把大小取错。每一层都把标准差乘以 √n · s:

数字 输入的标准差是 1。它们穿过 10 层,没有激活函数,宽度 100,权重标准差 0.2。每一层把标准差乘以 √100 · 0.2。10 层之后标准差是多少?

激活函数解决不了这个问题。试试 tanh:

选择一个网络有 10 层,宽度 100,每层之后都接 tanh。权重的标准差是 0.01,输入的标准差是 1。没有 tanh 的话,每层会把标准差乘以 √100 · 0.01。10 层之后,输出……

让 40 个随机输入穿过 10 层宽度为 100 的网络。改变权重的大小和激活函数。

十层深:各层的输出能保持大小吗?

选一个激活函数和一个权重标准差。每一层的输出应该保持在标准差 1 附近。

1e-121e-81e-411e4输入12345678910合适:约为 1

每一层输出的标准差(第 0 层是输入,标准差为 1),对数刻度,从 10⁻¹² 到 10⁴。

第 1 层 0.495
第 2 层 0.245
第 3 层 0.125
第 4 层 0.062
第 5 层 0.031
第 6 层 0.016
第 7 层 8.0e-3
第 8 层 3.8e-3
第 9 层 1.9e-3
第 10 层 9.3e-4
激活函数
各层的输出几乎消失了:最后一层的输出几乎全是 0。 没有激活函数时,每一层把标准差乘以大约 √100 × 0.05 = 0.50.
一层输出的标准差 每根条上标准差 = 1 的位置 消失了或变得非常大 每一层数值的分布形状,按它自己的标准差缩放
深入一点 为什么 ReLU 要用 √(2/n),而不是 1/√n

ReLU 把每个负数都变成 0。大约一半的值是负的,所以 ReLU 在每一层大约去掉一半的方差。 要纠正这一点,就把权重的方差加倍:s² = 2/n,所以 s = √(2/n)。n = 100 时大约是 0.14。 在实验台里用 ReLU 试试。用 0.1 时,数值越来越小,10 层之后大约是 0.02。用 0.14 时,它们保持在 0.5 附近。

tanh 在 0 附近接近一条直线,所以它的表现和线性的情况差不多:1/√n 让数值不至于消失, 不过它们仍然会变小,10 层之后大约是 0.2。

4. 学习率调度

大模型很少整个训练过程都用同一个学习率。有两个常见的习惯:

  1. 预热(warmup):从一个很小的 lr 开始,在最初几百步里把它调高。
  2. 衰减(decay):随着训练推进,降低 lr。
深入一点 为什么要预热,为什么要衰减?

开始时,m^\hat m 和 v^\hat v 只是很少几个梯度的平均,权重又是随机的,所以早期的大步子 可能把权重朝坏的方向推出很远。预热让最初的这些步子保持很小。

接近结束时,有噪声的小批量步子会在谷底附近来回摆动(就是你在第 1 节看到的那些来回的小摆动)。 更小的 lr 让这些摆动更小,于是权重最后停得离谷底更近。

最简单的调度是两条直线。选一个最高学习率 peak、预热步数 warmup, 以及整个训练的步数 total。在第 tt 步(从 0 开始数):

lr(t)={peak⋅t / warmupif t<warmuppeak⋅(total−t) / (total−warmup)otherwise\text{lr}(t) = \begin{cases} \text{peak} \cdot t \,/\, \text{warmup} & \text{if } t < \text{warmup} \\ \text{peak} \cdot (\text{total} - t) \,/\, (\text{total} - \text{warmup}) & \text{otherwise} \end{cases}

那个大括号的意思是“这两行用其中一行”。把它读成两条规则:tt 小于 warmup 时用上面一行, 之后用下面一行。预热期间学习率从 0 升到 peak,然后沿直线下降,在最后一步降到 0。

数字 一个调度:peak = 0.004,warmup = 100,total = 1000。第 25 步还在预热期,所以 lr = peak · t / warmup。第 25 步的 lr 是多少?

预热之后,用第二行。

数字 一个调度:peak = 0.004,warmup = 100,total = 1000。第 550 步已过预热期,所以 lr = peak · (total − t) / (total − warmup)。第 550 步的 lr 是多少?

很多模型把下降的那条直线换成一条平滑的曲线(半个余弦波),但模式是一样的: 先快速升上去,再慢慢降下来。

你在第 21 关写的 GPT 就用了这些习惯:它用 Adam 在大小为 64 的小批量上训练。

现在把这一关的各个部分放进一次小小的训练里。损失是 (w−3)2(w - 3)^2,在 w=3w = 3 处最低, 调度已经写成了 lr_at。写出循环体:每一步取梯度,从调度里拿到这一步的学习率, 再用动量(第 2 节)移动 w。

代码为损失 (w − 3)² 写出训练循环的循环体,带动量和学习率调度:每一步都从 lr_at 拿到自己的学习率。要写好几行。

Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行

小结

通关后的总结

通关后,这里会显示关键公式和常见错误。

你现在会了

  • 在一个有两个权重的损失上,手算 SGD、动量或 Adam 的一步。
  • 根据一层的扇入选出权重的标准差,并说出选错时 10 层会造成什么后果。
  • 算出先预热再衰减的学习率在任意一步的值。

要记住

  • 一轮 = (样本数 / 批大小)步
  • 动量:,然后
  • Adam 每步走 :每个权重大约移动 lr
  • 初始化:, = 扇入(ReLU:)
  • 每一层把标准差乘以 ,所以 10 层把它乘以

常见错误

  • 把 SGD 的移动量 lr · g 套到 Adam 上:Adam 要除以 ,所以移动量大约是 lr。
  • 把每层的倍数加起来,而不是乘起来:3 层每层都让标准差翻倍,结果是 ,不是 6。

按 ? 查看快捷键

阅读模式 · 实验台数值全部显示,不计星