← COMP5541 全部讲次
L07b · 第 9 周

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 记不住很久以前内容的原因。

类比在哪里失效:

  1. 速记员改写便签靠理解。RNN 只是做两次矩阵乘法、加起来、过一个 tanh,规则是训练出来的。
  2. 速记员可以回头翻录音。RNN 读过的输入只能通过隐状态间接留下来,原文不会保存。

从零讲起

1. 先补一块:tanh(补充)

它解决什么问题

RNN 每一步都要把新算出的数存进隐状态,再带到下一步。如果不加限制,这个数可能一步比一步大,几十步以后就大得没法算。tanh 把每一步的结果都压回 −1 到 1 之间。

直觉

tanh 像一个有上下限的弹簧秤。轻轻拉,读数跟着变;拉得再狠,指针也只到头为止。

输入在 0 附近时,tanh 的输出和输入差不多。输入越往两边走,输出越贴近 1 或 −1,曲线越来越平。

一步一步看

目标:把几个输入代进 tanh,看它怎样把任何数压进 −1 到 1,正负号不变,越大越贴近 1。

  1. 画出 tanh 曲线:中间一段很陡,两头很平,被夹在 1 和 −1 两条线之间。

    横轴从 −3 到 3 的 tanh 曲线,纵轴被夹在 −1 和 1 两条虚线之间,两头越来越平。曲线上标了三个点:tanh(1) 约 0.7616 描成青绿,tanh(0.3808) 约 0.3634,tanh(−0.8183) 约 −0.6741

  2. 输入 0:tanh(0) = 0,正好在原点。

  3. 输入 1:tanh(1) ≈ 0.7616,比 1 小一点,被往回拉了。

  4. 输入 −0.8183:tanh(−0.8183) ≈ −0.6741,负数进去还是负数出来。

  5. 输入 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。

  1. 折叠画法和展开画法是同一个网络。展开后每一格用的都是同一组 W_hh、W_hx、W_yh。

    左边折叠画法:输入 X 经 W_hx 到隐藏层 H,H 经 W_yh 到输出 Y,H 还有一条经 W_hh 回到自己的环。右边沿时间展开成 t−1、t、t+1 三格,每格都是 x 到 h 到 y,相邻两格的 h 之间用 W_hh 连接,W_hh 描成青绿

  2. 第 1 步,读入 x_1 = 1。上一步的记忆是 0,所以 0.5×0 + 1×1 = 1,h_1 = tanh(1) ≈ 0.7616,输出 y_1 = 2×0.7616 ≈ 1.5232。

    一维 RNN 第 1 步:h_0 = 0 经乘 0.5 传入,读入 x_1 = 1,算出 h_1 约 0.7616、y_1 约 1.5232,这一格描成青绿,后两格是问号

  3. 第 2 步,读入 x_2 = 0。输入是 0,记忆还在:0.5×0.7616 + 1×0 = 0.3808,h_2 ≈ 0.3634,y_2 ≈ 0.7268。

    一维 RNN 第 2 步:h_1 = 0.7616 乘 0.5 传入,读入 x_2 = 0,算出 h_2 约 0.3634、y_2 约 0.7268,这一格描成青绿,第 1 格灰底显示已算出的值

  4. 第 3 步,读入 x_3 = −1:0.5×0.3634 + 1×(−1) = −0.8183,h_3 ≈ −0.6741,y_3 ≈ −1.3483。

    一维 RNN 第 3 步:h_2 = 0.3634 乘 0.5 传入,读入 x_3 = −1,算出 h_3 约 −0.6741、y_3 约 −1.3483,这一格描成青绿,前两格灰底

  5. 回头看第 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 维,不计偏置。

  1. W_hh 把 4 维旧记忆变成 4 维新记忆,是 4×4 = 16 个数。

  2. W_hx 把 3 维输入变成 4 维,是 4×3 = 12 个数。

  3. W_yh 把 4 维记忆变成 2 维输出,是 2×4 = 8 个数。

    矩阵 从 → 到 形状 个数
    W_hh 隐状态 → 隐状态 4×4 16
    W_hx 输入 → 隐状态 4×3 12
    W_yh 隐状态 → 输出 2×4 8
    合计 36
  4. 序列长 5 步,用的是这 36 个;长 500 步,还是这 36 个。

  5. 同一个单元,按任务接成三种样子。

    三张小图,每张都是四个相连的隐藏层格子。Many-to-One 每步都有输入,只在最后一格取输出;One-to-Many 只在第一格给输入,四格都取输出;Many-to-Many 每格都有输入也都取输出。要取的输出格描成青绿

怎么算

参数量 = 隐×隐 + 隐×输入 + 输出×隐

意思是:每个矩阵的形状都是「去向维数 × 来源维数」。三个矩阵的个数加起来,就是整个 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 步:信息原样在,记作 1。

  2. 第 2 步:乘一次 0.5,剩 0.5。

  3. 第 3 步:再乘 0.5,剩 0.25。

  4. 第 11 步:一共乘了 10 次,剩 0.5 的 10 次方,约 0.001。

    第几步 乘了几次 0.5 剩下多少
    1 0 1
    2 1 0.5
    3 2 0.25
    11 10 约 0.001
  5. 换成 W_hh = 2,十次以后是 2 的 10 次方,等于 1024,数值就爆了。

  6. 反向传播时梯度走的是同一条链,方向相反,所以同样会消失或爆炸。

怎么算

把第 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 手算三步;然后算一次参数量;最后说出三个缺点,各给一句原因。

必背

  1. vanilla RNN:h_t = tanh(W_hh h_{t−1} + W_hx x_t),y_t = W_yh h_t。
  2. 三个权重矩阵 W_hh、W_hx、W_yh 在所有时间步共用,参数量和序列长度无关。
  3. 隐状态记住、累积每个时间步的信息;某一步输入为 0,输出也不一定为 0。
  4. 参数量:W_hh 是隐×隐,W_hx 是隐×输入,W_yh 是输出×隐;输入 3、隐状态 4、输出 2 时共 36 个(不计偏置)。
  5. 同一个单元的接法:Many-to-One 只取最后一步的输出,One-to-Many 只在第一步给输入,Many-to-Many 每步都取输出。
  6. RNN/LSTM 的优点:处理长度可变的序列、学序列内部的依赖;缺点:梯度爆炸和消失、训练推理慢、难捕捉很长的依赖。

课件例题

本讲课件没有带数字的例题。课件留了两道思考题,考法多半是「说出 RNN 怎么接成各种结构」和「RNN 怎么工作」。

例 1(课件 p.13):同一个 RNN 单元怎么接成不同结构

题面:p.13 右侧列出 One-to-Many、Many-to-One、Many-to-Many,旁边画了一个大问号。用同一个 RNN 单元,三种结构分别怎么接?

提示

想想每一步要不要给输入、要不要取输出。

解答
  1. Many-to-One:每步都读输入,只取最后一步的输出,例如情感分类。
  2. One-to-Many:只在第一步给输入,后面每步把上一步的输出当输入,例如看图说话。
  3. Many-to-Many:每步都取输出(视频描述),或者先用编码器读完再用解码器生成(p.16 的 seq2seq)。

例 2(课件 p.27):vanilla RNN 怎么工作

题面:p.27 第 2 条问 vanilla RNN 怎么工作,课件答案只有一句:用隐状态记住、累积每个时间步的信息。把这句话展开。

提示

对照 p.13 的两条式子:新隐状态由哪两样东西算出?输出由什么算出?

解答
  1. 每一步把上一步的隐状态 h_{t−1} 乘 W_hh,把这一步的输入 x_t 乘 W_hx,两者相加后过 tanh,得到新的隐状态 h_t。
  2. 输出 y_t 由当前隐状态乘 W_yh 得到。
  3. 隐状态一步步往后传,前面所有输入的信息都累积在里面,这就是「记住、累积每个时间步的信息」。
  4. 三个权重在所有时间步共用,所以能处理任意长度的序列。

完整例题

自编情境。一维 vanilla RNN,W_hh 取 0.5,W_hx 取 1,W_yh 取 2,起始隐状态 0,输入序列依次是 1、0、−1。(a) 逐步算出隐状态和输出。(b) 输入 3 维、隐状态 4 维、输出 2 维时,参数量多少(不计偏置)?

  1. 第 1 步:0.5×0 + 1×1 = 1,h_1 = tanh(1) ≈ 0.7616,y_1 = 2×0.7616 ≈ 1.5232。
  2. 第 2 步:0.5×0.7616 + 1×0 = 0.3808,h_2 = tanh(0.3808) ≈ 0.3634,y_2 ≈ 0.7268。
  3. 第 3 步:0.5×0.3634 + 1×(−1) = −0.8183,h_3 = tanh(−0.8183) ≈ −0.6741,y_3 ≈ −1.3483。
  4. 参数量: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. (1) 8×8 + 8×5 + 3×8 = 64 + 40 + 24 = 128;序列变长参数不变。
  2. (2) h_1 = tanh(1) ≈ 0.7616;h_2 = tanh(0.7616 + 1) = tanh(1.7616) ≈ 0.942。
  3. (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 的每个零件都是冲着它去的。

下一讲 →
L07c L07c LSTM:一条记忆线,加三个门

个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。