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

反向传播

梯度怎样一层一层地流回网络?

Boss 关

为一个 2→6→1 的网络写出反向传播,并用梯度检验证明它是对的。然后在浏览器里训练这个网络,直到四个 XOR 点全部分对。

在第 2 关,你可以手写出梯度:一个公式,两个参数。一个网络有成千上万个参数, 分布在很多层里。反向传播(backpropagation)能一趟算出它们全部的梯度, 靠的是反复使用同一条规则。这条规则就是链式法则(数学页用数字演示了它)。

这是仍然算得上“有层”的最小网络:一个输入,一个神经元,一个损失。

z=w⋅x+b→a=sigmoid(z)→L=(a−y)2z = w \cdot x + b \quad\to\quad a = \text{sigmoid}(z) \quad\to\quad L = (a - y)^2

取 x=2x = 2,w=0.5w = 0.5,b=−1b = -1,y=1y = 1:z=0z = 0,所以 a=sigmoid(0)=0.5a = \text{sigmoid}(0) = 0.5,L=(0.5−1)2=0.25L = (0.5 - 1)^2 = 0.25。 我们想要 ∂L/∂w\partial L / \partial w。

1. 唯一的规则

每个方框只知道自己的局部梯度(local gradient):输入动一下,它的输出动多少。 sigmoid 知道 ∂a/∂z=a(1−a)\partial a / \partial z = a(1 - a)。平方知道 ∂L/∂a=2(a−y)\partial L / \partial a = 2(a - y)。 要从 LL 回到 ww,就把路径上的局部梯度乘起来。这就是链式法则。

按“往回一步”,一次走一步。每个新的梯度会先显示成“?”,直到你在下面的题目里把它算出来。

把梯度从 L 送回去,一次一环

按“往回一步”,梯度就再往回走一个方框。w、x、b 和目标值 y 里的数都可以改。

∂L/∂w ·
∂L/∂x ·
∂L/∂b ·
z = w·x + b 0 ∂L/∂z ·
a = σ(z) 0.5 ∂L/∂a ·
L = (a − y)² 0.25 ∂L/∂L ·
  1. 前向: z = 0.5·2 + -1 = 0, a = σ(0) = 0.5, L = (0.5 − 1)² = 0.25
第 0 / 4 步
前向传播完成。按“往回一步”,让梯度从 L 出发。
0.5 前向的值 ∂L/∂· 梯度,往回流 梯度现在所在的位置

用一个小改动检验 ∂L/∂w

把 w 往两个方向各改 ε,拿得到的斜率和链式法则的答案比较。移动 ε 来改变改动的大小。

(L(w + ε) − L(w − ε)) / 2ε = ?
链式法则 ∂L/∂w = ?
差距 = 1.89e-11
数字 a = 0.5,y = 1。局部梯度 ∂L/∂a = 2(a − y) 是多少?

下一步需要你来算。实验台停在一个问号上。

数字 一个神经元算 a = sigmoid(z),损失是 L = (a − y)²。往回走时,∂L/∂a = −1,∂a/∂z = a(1 − a) = 0.5 × 0.5 = 0.25。用链式法则:∂L/∂z 是多少?

再乘一次就到 ww 了。

数字 一个神经元算 z = w·x + b,其中 x = 2。往回走时,∂L/∂z = −0.25,局部梯度是 ∂z/∂w = x = 2。∂L/∂w 是多少?

注意 ∂L/∂z\partial L / \partial z 起的作用。有了它之后,ww 和 bb 各自只需要再乘一次。 往回走意味着每个梯度只算一次,然后被前面所有层复用。所以它快。

我卡在这里了 为什么要往回走?我不能从 w 出发往前走吗?

对一个参数来说可以。从 ww 出发,你把“w 每变一单位,z 变多少”一路往前带到 L。 但接下来对 bb,你又得从头开始,对每个别的权重也一样。一个有一百万个权重的网络, 就要做一百万次前向传播。

往回走时,你从所有人共有的那一个东西出发,也就是损失,然后每个方框把一个数传给 它前面的方框。一趟反向传播就得到所有梯度,花费大约只相当于一两次前向传播。

2. 怎么知道梯度算对了?

回到定义:把 ww 调高一点点 ε\varepsilon,再调低同样多,看损失变了多少。

∂L∂w≈L(w+ε)−L(w−ε)2ε\frac{\partial L}{\partial w} \approx \frac{L(w + \varepsilon) - L(w - \varepsilon)}{2\varepsilon}

这个数值梯度(numeric gradient)完全不需要微积分,只要两次前向传播。用它来训练太慢了 (每个权重要两次前向传播),但拿它来检查再好不过。如果它和你的反向传播一致,你的反向传播就是对的。 这叫作梯度检验(gradient check)。

实验台用计算机的方式写很小的数:1e−5 表示 1×10−5=0.000011 \times 10^{-5} = 0.00001,2e−11 表示 2×10−112 \times 10^{-11}。这里的“e”和第 3 关的 e≈2.72e \approx 2.72 毫无关系。

数字 在一个简单的函数上检验:L(w) = w²。在 w = 3、ε = 0.1 时,(L(w + ε) − L(w − ε)) / (2ε) 是多少?
先猜一猜在梯度检验里,把 ε 滑到 1e−12。和 ε = 1e−5 相比,它和链式法则答案的差距会……

3. 从数到矩阵

真正的一层对很多神经元、很多样本同时做同样的事。每个单独的数都变成了矩阵。 在这一关余下的部分,dz 表示 ∂L/∂z\partial L/\partial z:损失在某一层激活函数之前的输出上的梯度, 每个样本、每个神经元一个数。一般来说,它不是第 2 关的误差(预测值 − 真实值): 在隐藏层,链式法则算出什么它就是什么。只有在输出层、用 sigmoid 配交叉熵时,它才 正好是 (p−y)/n(p - y)/n(下面的“深入一点”方框会讲为什么)。 有三条规则让它流动起来:

  1. 一层权重的梯度:dW = X.T @ dz,其中 X 是这一层的输入,X.T 是它的转置(第 1 关)。 “这一层的输入”指的是进入这一层的东西:对隐藏层来说是数据 X,但对输出层来说, 是隐藏层的输出(下面的 Boss 关叫它 a1),而不是 X。
  2. 一层偏置的梯度:db = dz.sum(axis=0),每个神经元一个数。偏置就像一个输入 永远是 1 的权重,所以它的梯度就是 dz 对样本的简单求和。(.sum(axis=0) 沿着行往下加, 和第 1 关第 7 节一样。)
  3. 往回一层:dz_prev = (dz @ W.T) * f'(z_prev)。@ 把梯度经过权重送回去。 * 是逐元素的:它把每个数乘上激活函数在那一点的斜率。

下面把同样的规则用在一个小网络上:2 个输入,3 个隐藏神经元,1 个输出。它用 sigmoid 和平方 损失,和第 1 节一样。隐藏神经元 1 就是第 1 节的那个神经元:x1=2x_1 = 2,w=0.5w = 0.5,b=−1b = -1。输出也正好落在 z=0z = 0,所以反向传播的起点也是同样的 −1-1 和 −0.25-0.25。先往前走,然后继续按“下一步”往回走。

先带着数往前走,再让梯度沿着同样的线流回来

按“下一步”往前走。选一层,查看它的数。

xhaLW1W2(a − y)²
按“下一步”,用 x = [2, 1] 做前向传播。 · 一共 13 个参数
层(4)

往回走时,看看进入 h 的那些线:每条都变成了 ∂L/∂w,线的粗细现在表示梯度,而不是权重。

正的权重或值负的权重或值 圆盘的填充色就是它的值:颜色越深,离 0 越远。 前向(这一步) 反向:梯度 “∂ −0.5” = 梯度 ∂L/∂(那个值)。 线越粗 = |w| 越大。选一层,查看它的数。

X.T @ dz 是从哪来的?先看一个样本。对一行输入 xx 和一个输出梯度, 权重的梯度是 x⋅dzx \cdot dz,和第 1 节完全一样(∂L/∂w=x⋅∂L/∂z\partial L/\partial w = x \cdot \partial L/\partial z)。 有好几个样本时,损失是对它们求和,所以梯度也加起来。两个样本,两个输入,一个输出:

样本输入 xdzx × dz(每个输入乘以 dz)
0[1, 2]0.5[0.5, 1.0]
1[3, 1]−1?

dW 是最后一列在两个样本上的和。X.T @ dz 用一次乘法就正好算出这个和。

数字 两个样本:X = [[1, 2], [3, 1]],dz = [[0.5], [−1]]。X.T @ dz 的第一个元素 dW[0][0] 是多少?
数字 两个样本的 dz = [[0.5], [−1]]。这一层有一个输出神经元,一个偏置。db = dz.sum(axis=0) 是多少?

我们用来学 XOR 的网络是 XX (4, 2) → W1W_1 (2, 6) → tanh → W2W_2 (6, 1) → sigmoid。

形状 X 是 (4, 2)。隐藏层的梯度 dz1 是 (4, 6)。dW1 = X.T @ dz1 是什么形状?

规则 3 把梯度往回送一层。先在 XOR 网络上试试,再手算两个数。

形状 XOR 网络上的规则 3:dz2 是 (4, 1),每个样本一个数,W2 是 (6, 1)。dz2 @ W2.T 是什么形状?
数字 一个样本,一个有 2 个 tanh 神经元的隐藏层,一个输出。dz2 = [[0.5]],W2 = [[2], [−1]](所以 W2.T = [[2, −1]]),隐藏层输出是 a1 = [[0.5, 0]]。tanh 在一个神经元处的斜率是 1 − a²,其中 a 是那个神经元的输出。用第 3 节的规则 3。dz1 的第一个数是多少?
我卡在这里了 为什么 dW = Xᵀ @ dz 里有一个转置?

让形状来决定。XX 是 (4, 2):4 个样本,2 个输入。隐藏层的梯度 dz1 是 (4, 6)。 梯度的形状必须和 W1W_1 一样,也就是 (2, 6)。 把一个 (4, 2) 和一个 (4, 6) 乘成 (2, 6),唯一的办法是 XTX^T (2, 4) @ dz1 (4, 6)。

消掉的那个 4 就是样本:转置把每个权重在全部 4 个样本上的梯度加了起来。 形状对不上时,把形状写下来,找出唯一能对上的那种摆法。

深入一点 为什么输出层的梯度就是 p − y

输出用 sigmoid,损失是第 3 关的交叉熵:L=−[yln⁡p+(1−y)ln⁡(1−p)]L = -[y \ln p + (1-y)\ln(1-p)]。 把两个局部梯度串起来:

∂L∂p=p−yp(1−p)∂p∂z=p(1−p)\frac{\partial L}{\partial p} = \frac{p - y}{p(1-p)} \qquad \frac{\partial p}{\partial z} = p(1-p)

两者相乘,p(1−p)p(1-p) 约掉了:∂L/∂z=p−y\partial L / \partial z = p - y。这就是为什么下面代码里输出层的梯度 只是 p - y(再除以 4,因为损失是 4 个样本的平均)。这也是为什么 sigmoid 和 交叉熵几乎总是一起用。

4. Boss:写出反向传播

前向传播已经写好了。整个反向传播由你来写:从输出层的 dz2 = (p − y) / n 开始 (上面的“深入一点”方框讲了为什么),然后用三条规则求出全部四个梯度。tanh 的局部梯度 是 1−tanh⁡(z)21 - \tanh(z)^2,而你已经有 tanh⁡(z)\tanh(z) 了:它就是 a1。在 Python 里,平方写作 a1 ** 2(** 是乘方,和第 2 关一样;^ 不是)。隐藏的测试会对你的 backward 返回的每个 梯度做梯度检验,取 ε=10−5\varepsilon = 10^{-5}(写作 1e-5)。

代码写出整个反向传播:训练一步需要的每个梯度,从输出层的 dz2 一直到 dW1 和 db1。好几行。

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

你的梯度和数值梯度一致。现在来训练这个网络。每一步都把每个权重逆着它的梯度挪一下, 和第 2 关完全一样。为了不在这个单元里露出 Boss 的答案,它不调用你的 backward:它用慢办法 得到梯度,把每个数改一点点(第 2 节的检验方法)。你的梯度检验已经证明, 那些就是你的 backward 给出的同样的数,只是算起来慢得多。

代码写出更新这一步,然后在 XOR 上跑 1000 步梯度下降。

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

下面的实验台跑的是同一个网络,只是用 JavaScript 而不是 NumPy 写的。按“训练”,看它学习。

一个 2 → 6 → 1 的网络学习 XOR

按“训练”,看背景怎样绕着四个点弯曲。然后关掉激活函数,再试一次。

0110x1 →x2 ↑
损失0步数 →训练后会画出损失
训练中的损失(最近 200 条记录)
输入目标值输出
[0, 0]00.000
[0, 1]10.000
[1, 0]10.000
[1, 1]00.000
步数 0 · 损失(交叉熵) — · ✗ 还没学会
背景:网络有多确定是 1 目标值 1 目标值 0 答错的点
动手试试

在最上面的反向传播实验台里,把目标值设成 y = 0,再往回走一遍。哪些梯度变了符号? 然后设 w = 5。为什么 ∂L/∂w 几乎消失了?看看 a 接近 1 时的 a(1 − a)。

可选的支线:支线 U3 写一个小程序,像 PyTorch 那样替你做这次 反向传播,大约 50 行 Python。第 7 关继续主线。

小结

通关后的总结

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

你现在会了

  • 在一个小网络里手动沿链式法则往回走,把局部梯度乘起来。
  • 用数值估计 检验任何一个梯度。
  • 用 NumPy 写出两层网络的反向传播,并在 XOR 上训练它。

要记住

  • 链式法则:
  • dW = X.T @ dz,形状和 W 一样
  • db = dz.sum(axis=0):每个神经元一个数,对样本求和
  • dz_prev = (dz @ W.T) * f'(z_prev);对 tanh,
  • sigmoid 配交叉熵:输出层的 dz = (p - y) / n

常见错误

  • 写成 db = dz,没有对样本求和,于是形状不对。
  • 在形状需要转置的地方用了 W @ dz 或 dz @ W:先把形状写下来。
这一关之后可以去的支线可选;下一关用不到它们。

按 ? 查看快捷键

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