离得更远。它的梯度沿着 传过来,每经过一个节点就乘上一个局部因子: 在加法那里乘 1,在乘积 那里乘 。
把 改成 10,按 全部运行。 变了,但每个梯度都没变,因为 从头到尾只被加进去。 现在改一下 。哪些梯度变了?为什么 不依赖于 本身?
独立做出这 4 道题。 全部答对,这一关就算三星通关。看过答案的不算。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
开始前快速复习一下。可选,不会锁住这一关。
在第 6 关,你手写了反向传播。在 PyTorch 里(第 9 关),一行 loss.backward() 就全做完了。
这一关让你看看这一行在里面做了什么。学完这一关,你会自己写出同样的东西,大约 50 行 Python。
它用到两个想法:
取 ,,,,。给中间结果起名字: ,。按主按钮(它一开始是 计算 e = a·b),一次算一个节点。算完 之后,同一个按钮 会运行反向传播。
反向传播从设定 开始。它只是说“如果 L 增加一点点,L 就增加同样的一点点”。 这是起始的数;其他每个梯度都是从它开始的乘积。 然后反向传播从末尾往开头访问各个节点。 访问一个节点只意味着一件事:用这个节点自己的规则,把它的梯度推给它的输入。
按主按钮,一次算一个节点地做前向计算,然后把梯度传回去。改一个输入,试试别的数。
离得更远。它的梯度沿着 传过来,每经过一个节点就乘上一个局部因子: 在加法那里乘 1,在乘积 那里乘 。
把 改成 10,按 全部运行。 变了,但每个梯度都没变,因为 从头到尾只被加进去。 现在改一下 。哪些梯度变了?为什么 不依赖于 本身?
这是一个自动求导引擎的核心。一个 Value 存着一个数(data)、它的梯度(grad)、
算出它的那些值(_children),以及一个知道局部规则的小函数 _backward。
加法已经写好了。乘法交给你:规则就是实验台里的那条。
有三处 Python 写法你可能没见过:
Value 写 a + b 时,会运行 def __add__(self, other);写 a * b 时运行 __mul__。
self 是左边那个,other 是右边那个。lambda: None 是一个什么都不做的小函数。不是由运算得到的值,它的 _backward 就是这个。_backward 定义在 __mul__ 里面,所以之后反向传播调用它时,它仍然能用 self、other 和 out。
out._backward = _backward 这一行把这个函数存到结果上,留着以后用。Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
_backward 运行时,out 已经从它后面的节点那里拿到了自己的梯度。
这正是从末尾开始访问所保证的。out.grad 是“out 每变一个单位,L 变多少”。
局部规则把它变成“self 每变一个单位,L 变多少”。这一次乘法就是链式法则。
在真实的网络里,一个权重会流向很多地方。最简单的情况:。这里 同时是 同一个乘法的两个输入。微积分告诉我们 。
在 x * x 里,self 和 other 是同一个对象:两个名字都指向 x。
所以 _backward 里的两行,各自把梯度的一部分送到同一个 x:self.grad 得到 ,
other.grad 又得到一个 。只有把两部分加起来,才得到 。
一个流向好几处的值,会通过所有这些地方影响 。它的总梯度是每条路径传回来的部分之和。
+= 把它们收集起来。用 = 的话,每条路径都会覆盖前一条,只有最后一条路径算数。
这也是为什么 PyTorch 里的 loss.backward() 会往 .grad 里累加,以及为什么你每一步之前都要调用
opt.zero_grad()(第 9 关)。在一次反向传播里,累加是对的。跨越不同的步时,旧的和必须清掉。
现在你自己给 Value 加一种新运算:减法,out = self - other。前向部分已经写好了。反向规则是:
self 增加一点,out 增加同样多。局部因子是 1,和加法一样。other 增加一点,out 减少同样多。局部因子是 −1。所以 self 得到 1 × out.grad,other 得到 −1 × out.grad。两行都要写,而且仍然往 .grad 里累加:
other.grad -= out.grad 是 other.grad = other.grad - out.grad 的简写,和加上 −1 × out.grad 一样。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
一个节点只有在所有用到它的节点都被访问过之后,才能被访问。否则它的梯度还不完整。
把节点排成一个列表,让每个节点都排在它的输入之后,这叫拓扑序(topological order)。
对实验台里的计算图,一个这样的列表是 [a, b, e, c, f, d, L]:每个节点都出现在算出它的那些节点之后。
代码用一个小的递归函数 build 来构造这个列表:加入一个节点之前,先构造它的每个子节点
(深度优先遍历),所以子节点总是排在列表更前面。然后反向传播从末尾开始访问这个列表,从 L 开始。
还有一处 Python:reversed(xs) 从最后一项到第一项走一遍列表。
比如 list(reversed([1, 2, 3])) 是 [3, 2, 1]。
写出 backward 在 build(self) 之后的结尾部分:给 L 它的起始梯度(第 1 节),然后按正确的顺序访问每个节点,
调用它的 _backward。tanh 方法也已经写好了,所以最后一个测试是一个真正的神经元。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
PyTorch 的做法一样,只有三点不同,而且都只是规模上的:
@、exp、softmax、layer_norm……;访问的顺序、+=、起始梯度 :全都一样。
tanh 展示了任何一种新运算的套路。前向算出 ,反向加上 out.grad。
一种运算只要有了这两部分,引擎就能在任何地方用它。
通关后,这里会显示关键公式和常见错误。
_backward 函数,往 .grad 里累加。out.grad。乘法:每个输入得到另一个输入的 data × out.grad.grad 里永远用 +=:一个用在好几处的值,得到的是所有部分的和_backward+= 写成 =,于是一个用了两次的值只留下了最后一部分。按 ? 查看快捷键