L07b Vanilla RNN:同一组权重,一格一格往下读
从 tanh 讲起,手算一个一维 RNN 读三步,看隐状态怎么把前面的信息带下去;再数参数、看同一个单元的三种接法,最后说清梯度为什么会消失。
一句话版
RNN 每读一格,就把「上一步记下的东西」和「这一格的输入」合起来,算出新的记忆,再从记忆里读出这一步的输出。每一格用的都是同一组权重,所以序列多长都能读。
上一页讲了为什么固定维数的网络装不下序列,见 L07a。这一页从零讲 vanilla RNN 一个模型。
先认识这几个词
读之前最好记得 L05 的梯度消失:反向传播时梯度一层层连乘,越乘越小。
| 词 | 全称 / 读法 | 一句人话 |
|---|---|---|
| RNN | Recurrent Neural Network,循环神经网络 | 每一步都用同一组权重、把上一步结果带下去的网络 |
| vanilla | 原味的 | 最基础、没加改进的版本 |
| 隐状态 h_t | hidden state | 读到第 t 步为止,网络记在心里的内容 |
| tanh | 双曲正切,读 tan-h | 把任何数压到 −1 到 1 之间的函数 |
| W_hh、W_hx、W_yh | 三个权重矩阵 | 下标读作「从后者到前者」:W_hx 是从输入 x 到隐状态 h |
| 展开 | unroll | 把每个时间步画成一格,排成一排来看 |
一个类比:只有一张便签的速记员
想象一位速记员在听一段很长的口述。他手里只有一张便签。每听到一个词,就根据「便签上原来写的」和「刚听到的词」改写便签。
听完最后一个词,便签上的内容就是他对整段话的理解。RNN 的隐状态就是这张便签,每一步改写便签的规则都一样。
便签只有这么大。早先记下的东西,会被一次次改写冲淡。这就是 RNN 记不住很久以前内容的原因。
类比在哪里失效:
- 速记员改写便签靠理解。RNN 只是做两次矩阵乘法、加起来、过一个 tanh,规则是训练出来的。
- 速记员可以回头翻录音。RNN 读过的输入只能通过隐状态间接留下来,原文不会保存。
从零讲起
1. 先补一块:tanh(补充)
它解决什么问题
RNN 每一步都要把新算出的数存进隐状态,再带到下一步。如果不加限制,这个数可能一步比一步大,几十步以后就大得没法算。tanh 把每一步的结果都压回 −1 到 1 之间。
直觉
tanh 像一个有上下限的弹簧秤。轻轻拉,读数跟着变;拉得再狠,指针也只到头为止。
输入在 0 附近时,tanh 的输出和输入差不多。输入越往两边走,输出越贴近 1 或 −1,曲线越来越平。
一步一步看
目标:把几个输入代进 tanh,看它怎样把任何数压进 −1 到 1,正负号不变,越大越贴近 1。
-
画出 tanh 曲线:中间一段很陡,两头很平,被夹在 1 和 −1 两条线之间。
-
输入 0:tanh(0) = 0,正好在原点。
-
输入 1:tanh(1) ≈ 0.7616,比 1 小一点,被往回拉了。
-
输入 −0.8183:tanh(−0.8183) ≈ −0.6741,负数进去还是负数出来。
-
输入 3:tanh(3) ≈ 0.995,已经很贴近 1 了。
怎么算
tanh(z) = (e^z − e^(−z)) / (e^z + e^(−z))
意思是:分子是「e 的 z 次方」减「e 的负 z 次方」,分母是两者相加。分子的绝对值永远小于分母,所以结果一定落在 −1 和 1 之间。
z 很大时,e^(−z) 几乎为 0,分子分母都约等于 e^z,结果趋近 1。z 很小(很负)时同理趋近 −1。
考试不会让你手算 e 的幂。记住三件事就够:tanh(0) = 0;正数进正数出、负数进负数出;输出不超过 1 也不低于 −1。
常见误解
以为 tanh 和 sigmoid 是同一个东西
两者形状都是 S 形,取值范围不同。sigmoid 输出在 0 到 1 之间,tanh 输出在 −1 到 1 之间。下一页 LSTM 会同时用到两者:sigmoid 管「放行多少」,tanh 管「写入的内容」。
试一下
tanh(−1) 约等于多少?
tanh 是奇函数,tanh(−1) = −tanh(1) ≈ −0.7616。
2. RNN 怎么一步步算
它解决什么问题
上一页说过,要一种「同一套权重、每个位置重复用」的网络。RNN 就是这样一种网络。它还要做到一件事:后面的步骤能用上前面读到的信息。
从哪来(补充)
带「回路」的神经网络出现得很早。Michael I. Jordan 1986 年提出了 Jordan 网络,Jeffrey Elman 1990 年提出了 Elman 网络。后者的结构和今天说的 vanilla RNN 基本一致:隐藏层的输出在下一步再喂回自己。
出处:Wikipedia: Recurrent neural network
直觉
把网络画成一个格子:输入从下面进来,输出从上面出去,格子自己还有一根线连回自己。这根回线就是「把上一步的记忆带到这一步」。
把时间拉开,每一步画一格,就是一排一模一样的格子,相邻格子之间用 W_hh 连起来。
一步一步看
目标:用一维 RNN 读入 1、0、−1 算三步,看输入为 0 那一步的输出全靠隐状态从前面带来。
先看两种画法,再用一个一维的例子算三步。设 W_hh = 0.5,W_hx = 1,W_yh = 2,起始隐状态 h_0 = 0,输入依次是 1、0、−1。
-
折叠画法和展开画法是同一个网络。展开后每一格用的都是同一组 W_hh、W_hx、W_yh。
-
第 1 步,读入 x_1 = 1。上一步的记忆是 0,所以 0.5×0 + 1×1 = 1,h_1 = tanh(1) ≈ 0.7616,输出 y_1 = 2×0.7616 ≈ 1.5232。
-
第 2 步,读入 x_2 = 0。输入是 0,记忆还在:0.5×0.7616 + 1×0 = 0.3808,h_2 ≈ 0.3634,y_2 ≈ 0.7268。
-
第 3 步,读入 x_3 = −1:0.5×0.3634 + 1×(−1) = −0.8183,h_3 ≈ −0.6741,y_3 ≈ −1.3483。
-
回头看第 2 步:输入是 0,输出却是 0.7268。这个数全是从 h_1 带过来的,这就是「隐状态记住前面的信息」。
怎么算
课件给的两条式子:
h_t = tanh(W_hh h_{t−1} + W_hx x_t)
y_t = W_yh h_t
意思是:第 t 步的新记忆,由「上一步的记忆乘 W_hh」加「这一步的输入乘 W_hx」,再过一个 tanh 得到。这一步的输出,只看当前记忆,乘一个 W_yh 就行。
三个权重的下标都读作「从后者到前者」。W_hh 是从旧记忆到新记忆,W_hx 是从输入到记忆,W_yh 是从记忆到输出。
式子里没有写偏置项,这是课件的简写。真实网络里两条式子各加一个偏置。
常见误解
以为展开图画了很多格,就是很多层不同的网络
展开图的每一格是同一个单元在不同时刻的样子,权重一模一样。它和「堆了很多层的深度网络」形状像,但所有格子共用同一组参数。
以为某一步输入是 0,这一步的输出也是 0
输出只看当前隐状态,而隐状态里带着上一步的记忆。上面第 2 步输入是 0,输出约 0.7268。
试一下
同一个一维 RNN,把输入改成 2、0。h_1 和 h_2 各约多少?(tanh(2) ≈ 0.964,tanh(0.482) ≈ 0.448)
h_1 = tanh(0.5×0 + 1×2) = tanh(2) ≈ 0.964。h_2 = tanh(0.5×0.964 + 1×0) = tanh(0.482) ≈ 0.448。
3. 权重共享:参数量和三种接法
它解决什么问题
上一页说,固定维数的网络让每个位置配一套权重,句子再长就装不下。RNN 让所有时间步共用三个矩阵,这一点直接决定了两件事:参数有多少,以及同一个单元能接成哪些结构。
直觉
一把印章可以盖一百次,盖第一百次也不需要第二把印章。RNN 的三个矩阵就是这把印章,序列有多少步,就盖多少次。
既然每一格都一样,每一格要不要喂输入、要不要取输出,就可以按任务自由决定。
一步一步看
目标:数输入 3 维、隐状态 4 维、输出 2 维的 RNN 有多少权重,看序列多长都用同一组 36 个。
取输入 3 维、隐状态 4 维、输出 2 维,不计偏置。
-
W_hh 把 4 维旧记忆变成 4 维新记忆,是 4×4 = 16 个数。
-
W_hx 把 3 维输入变成 4 维,是 4×3 = 12 个数。
-
W_yh 把 4 维记忆变成 2 维输出,是 2×4 = 8 个数。
矩阵 从 → 到 形状 个数 W_hh 隐状态 → 隐状态 4×4 16 W_hx 输入 → 隐状态 4×3 12 W_yh 隐状态 → 输出 2×4 8 合计 36 -
序列长 5 步,用的是这 36 个;长 500 步,还是这 36 个。
-
同一个单元,按任务接成三种样子。
怎么算
参数量 = 隐×隐 + 隐×输入 + 输出×隐
意思是:每个矩阵的形状都是「去向维数 × 来源维数」。三个矩阵的个数加起来,就是整个 RNN 的参数,和序列长度没有关系。
代进去:4×4 + 4×3 + 2×4 = 16 + 12 + 8 = 36。
常见误解
以为序列越长,RNN 的参数越多
长序列只是让同一组权重多算几遍。参数量只看三个维数,不看序列长度。
以为 W_hx 是「输入维数 × 隐状态维数」
矩阵要乘在输入向量的左边,结果是隐状态,所以行数是隐状态维数,列数是输入维数。个数一样,形状写反了在写矩阵乘法时会对不上。
试一下
输入 2 维、隐状态 3 维、输出 1 维,不计偏置,参数共多少?
3×3 + 3×2 + 1×3 = 9 + 6 + 3 = 18 个。
4. 梯度消失、梯度爆炸和长依赖
它解决什么问题
RNN 能读任意长的序列,可是读得越远,前面的信息越淡。训练时也一样:要靠很早那一步的输入来纠正错误,梯度传不回去。这一节说清楚原因,也是下一页 LSTM 和后面 attention 要对付的问题。
从哪来(补充)
Sepp Hochreiter 1991 年在他的毕业论文里分析了梯度消失。Bengio、Simard、Frasconi 1994 年的论文《Learning long-term dependencies with gradient descent is difficult》也专门讨论了这件事。
RNN 按时间展开后,相当于一个很深的前馈网络,用「沿时间的反向传播」(BPTT)训练,所以和深层网络一样会遇到梯度消失。
出处:Wikipedia: Vanishing gradient problem
直觉
传话游戏。第一个人说的话,每传一个人都会走点样。传十个人以后,原话剩不下多少。
在 RNN 里,第 1 步的信息每过一步都要乘一次 W_hh、再过一次 tanh。W_hh 小于 1 时,影响一步比一步弱;大于 1 时,又可能一步比一步大,最后炸掉。
一步一步看
目标:让第 1 步的信息每过一步乘一次 W_hh,看 0.5 时十步后几乎不剩,换成 2 就爆掉,反向的梯度也一样。
还用上面的一维 RNN,W_hh = 0.5。只看第 1 步的信息在后面还剩多少,先不管 tanh 的压缩。
-
第 1 步:信息原样在,记作 1。
-
第 2 步:乘一次 0.5,剩 0.5。
-
第 3 步:再乘 0.5,剩 0.25。
-
第 11 步:一共乘了 10 次,剩 0.5 的 10 次方,约 0.001。
第几步 乘了几次 0.5 剩下多少 1 0 1 2 1 0.5 3 2 0.25 11 10 约 0.001 -
换成 W_hh = 2,十次以后是 2 的 10 次方,等于 1024,数值就爆了。
-
反向传播时梯度走的是同一条链,方向相反,所以同样会消失或爆炸。
怎么算
把第 1 步的影响传到第 T 步,要连乘 T − 1 个因子,每个因子是「W_hh 乘 tanh 的导数」。
意思是:连乘的因子小于 1,乘得越多越接近 0,这是梯度消失;因子大于 1,乘得越多越大,这是梯度爆炸。tanh 的导数最大只有 1,大多数时候小于 1,所以消失比爆炸更常见。
课件把这些归成 RNN 类模型的优缺点:
- 优点:能处理长度可变的序列;能学到序列内部的先后依赖。
- 缺点:梯度爆炸和消失;训练和推理耗时长;难以捕捉很长距离的依赖。
「训练和推理慢」的原因:第 t 步要用第 t−1 步的隐状态,必须等上一步算完,各步没法同时算。
常见误解
以为这些缺点只属于 LSTM,因为课件把这页放在 LSTM 一节
这几条是 vanilla RNN 和 LSTM 共有的。两者都要一步接一步算,所以都慢;LSTM 只是缓解了长依赖和梯度消失,没有根除。
以为算力足够强,RNN 就不慢了
慢的原因是依赖关系:第 t 步要等第 t−1 步。再多的计算单元,也只能排队等前一步。
试一下
W_hh = 0.9,不计 tanh,第 1 步的信息传到第 21 步还剩多少?
乘了 20 次 0.9,0.9 的 20 次方约 0.12。比 0.5 慢得多,但还是在衰减。
把它们串起来
RNN 是一个格子反复用。每一步把旧记忆乘 W_hh、新输入乘 W_hx,加起来过 tanh,得到新记忆;新记忆乘 W_yh 就是输出。tanh 保证记忆不会越滚越大。
因为三个矩阵在所有时间步共用,参数量只看维数,和序列长度无关。也因为每一格都一样,可以按任务决定哪些格子喂输入、哪些格子取输出,接成上一页的几种结构。
代价是记忆会被冲淡。第 1 步的信息每过一步都要乘一次 W_hh,梯度沿时间往回传也要连乘,于是会消失或爆炸。再加上每一步都要等上一步,训练和推理都慢。下一页的 LSTM 针对的是「冲淡」这一条。
课件里的坑
- [简写] p.13 的两条式子没写偏置项,是课件的简写。按课件口径算参数时不计偏置。
- [留白] p.13 右边列了 One-to-Many、Many-to-One、Many-to-Many 加一个大问号,课件没给答案,下面例 1 按 p.11 的例子补齐。
- [适用条件] p.18 的优缺点放在「04 LSTM」页眉下,但几条都是 vanilla RNN 和 LSTM 共有的。
- [读图提醒] p.13 左下角那段外文配了三个长短不同的框 X¹、X²、X³,意思是不同样本的长度可以不同,不是三个不同的输入维数。
课后 10 分钟:考点复习
这 10 分钟怎么用:先默写两条 RNN 式子,说出三个权重各连哪两样东西;再按完整例题把一维 RNN 手算三步;然后算一次参数量;最后说出三个缺点,各给一句原因。
必背
- vanilla RNN:h_t = tanh(W_hh h_{t−1} + W_hx x_t),y_t = W_yh h_t。
- 三个权重矩阵 W_hh、W_hx、W_yh 在所有时间步共用,参数量和序列长度无关。
- 隐状态记住、累积每个时间步的信息;某一步输入为 0,输出也不一定为 0。
- 参数量:W_hh 是隐×隐,W_hx 是隐×输入,W_yh 是输出×隐;输入 3、隐状态 4、输出 2 时共 36 个(不计偏置)。
- 同一个单元的接法:Many-to-One 只取最后一步的输出,One-to-Many 只在第一步给输入,Many-to-Many 每步都取输出。
- RNN/LSTM 的优点:处理长度可变的序列、学序列内部的依赖;缺点:梯度爆炸和消失、训练推理慢、难捕捉很长的依赖。
课件例题
本讲课件没有带数字的例题。课件留了两道思考题,考法多半是「说出 RNN 怎么接成各种结构」和「RNN 怎么工作」。
例 1(课件 p.13):同一个 RNN 单元怎么接成不同结构
题面:p.13 右侧列出 One-to-Many、Many-to-One、Many-to-Many,旁边画了一个大问号。用同一个 RNN 单元,三种结构分别怎么接?
提示
想想每一步要不要给输入、要不要取输出。
解答
- Many-to-One:每步都读输入,只取最后一步的输出,例如情感分类。
- One-to-Many:只在第一步给输入,后面每步把上一步的输出当输入,例如看图说话。
- Many-to-Many:每步都取输出(视频描述),或者先用编码器读完再用解码器生成(p.16 的 seq2seq)。
例 2(课件 p.27):vanilla RNN 怎么工作
题面:p.27 第 2 条问 vanilla RNN 怎么工作,课件答案只有一句:用隐状态记住、累积每个时间步的信息。把这句话展开。
提示
对照 p.13 的两条式子:新隐状态由哪两样东西算出?输出由什么算出?
解答
- 每一步把上一步的隐状态 h_{t−1} 乘 W_hh,把这一步的输入 x_t 乘 W_hx,两者相加后过 tanh,得到新的隐状态 h_t。
- 输出 y_t 由当前隐状态乘 W_yh 得到。
- 隐状态一步步往后传,前面所有输入的信息都累积在里面,这就是「记住、累积每个时间步的信息」。
- 三个权重在所有时间步共用,所以能处理任意长度的序列。
完整例题
自编情境。一维 vanilla RNN,W_hh 取 0.5,W_hx 取 1,W_yh 取 2,起始隐状态 0,输入序列依次是 1、0、−1。(a) 逐步算出隐状态和输出。(b) 输入 3 维、隐状态 4 维、输出 2 维时,参数量多少(不计偏置)?
- 第 1 步:0.5×0 + 1×1 = 1,h_1 = tanh(1) ≈ 0.7616,y_1 = 2×0.7616 ≈ 1.5232。
- 第 2 步:0.5×0.7616 + 1×0 = 0.3808,h_2 = tanh(0.3808) ≈ 0.3634,y_2 ≈ 0.7268。
- 第 3 步:0.5×0.3634 + 1×(−1) = −0.8183,h_3 = tanh(−0.8183) ≈ −0.6741,y_3 ≈ −1.3483。
- 参数量:W_hh 4×4 = 16,W_hx 4×3 = 12,W_yh 2×4 = 8,共 36。
答案:隐状态约 0.7616、0.3634、−0.6741;输出约 1.5232、0.7268、−1.3483;共 36 个参数。
要点:第 2 步的输入是 0,输出却不是 0,因为隐状态带着第 1 步的信息。第 1 步的影响每过一步要乘一次 0.5,越往后越弱。
答题格式:每一步写三行:先写 tanh 里面的加法,再写 h_t,再写 y_t。小数保留四位。
变式题(先自己做)
(1) 改编自课件 p.13:一个 vanilla RNN,输入 5 维、隐状态 8 维、输出 3 维,不计偏置,参数共多少?序列从 10 步变成 100 步,参数变不变? (2) 自编情境:一维 RNN,W_hh = 1,W_hx = 1,h_0 = 0,输入依次是 1、1。h_2 约多少?(tanh(1) ≈ 0.7616,tanh(1.7616) ≈ 0.942) (3) 自编情境:为什么 RNN 的训练没法像 CNN 那样把各位置同时算?
提示
(1) 三个矩阵各是「去向维数 × 来源维数」。(2) 第 2 步 tanh 里面是 1×h_1 + 1×1。(3) 第 t 步要用到什么?
判分点与答案(非官方评分标准)
判分点:① 三个矩阵的形状写对;② 说明参数和序列长度无关;③ 手算时上一步的隐状态代对;④ 慢的原因要落到「依赖上一步」。
- (1) 8×8 + 8×5 + 3×8 = 64 + 40 + 24 = 128;序列变长参数不变。
- (2) h_1 = tanh(1) ≈ 0.7616;h_2 = tanh(0.7616 + 1) = tanh(1.7616) ≈ 0.942。
- (3) 第 t 步的隐状态要用到第 t−1 步的隐状态,必须等上一步算完,所以只能一步一步顺序算。
闪卡自测
1. 写出 vanilla RNN 的两条式子。
h_t = tanh(W_hh h_{t−1} + W_hx x_t),y_t = W_yh h_t(p.13)。
2. 序列变长,RNN 的参数量会变吗?
不会,三个权重矩阵在所有时间步共用(p.13)。
3. 隐状态的作用是什么?
记住、累积每个时间步的信息(p.13、p.27)。
4. tanh 的取值范围?RNN 为什么要它?
−1 到 1。把每步的隐状态压回有限范围,避免一步比一步大。
5. W_hx 的形状是什么?
隐状态维数 × 输入维数。
6. Many-to-One 怎么用 RNN 单元接?
每步都读输入,只取最后一步的输出(p.13)。
7. 课件列的 RNN 类模型两个优点?
能处理长度可变的序列;能学序列内部的先后依赖(p.18)。
8. 课件列的 RNN 类模型三个缺点?
梯度爆炸和消失;训练和推理慢;难捕捉很长的依赖(p.18)。
9. 梯度为什么会消失?
沿时间往回传要连乘很多个因子,因子小于 1 就越乘越小。
下一讲
下一页 L07c 讲 LSTM:在隐状态之外多加一条只做乘和加的记忆线,再用三个门控制忘多少、写多少、读多少。先把本页「记忆每一步都被冲淡」这一条记清,LSTM 的每个零件都是冲着它去的。
个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。