循环神经网络1—RNN

这周在看循环神经网络，发现一个博客，里面的推导过程极其详细，借此记录重点

详细推导

强烈介意手推一遍，虽然可能会花一点时间，但便于理清思路。

语言模型

RNN是在自然语言处理领域中最先被用起来的，比如，RNN可以作为语言模型来建模。

什么是语言模型？

语言模型：给定一个一句话前面的部分，预测接下来最有可能的一个词是什么。

语言模型可以用在语音转文本（STT）上，也可以用在图像到文本的识别中（OCR）。

使用RNN之前，语言模型主要采用N-Gram，即先对句子切词，再在语料库中搜索前n个词进行预测，这样想法没有实用性，因为根本没有用到有用的信息，并且该模型还会占用海量的存储空间。

所以，RNN出现，理论上RNN可以往前看（往后看）任意多个词。

循环神经网络

基本神经网络

如上图左，一个简单的循环神经网络由一个输入层、一个隐藏层和一个输出层组成。

其中，x$x$是一个向量，代表输入层的值；s$s$是一个向量，代表隐藏层的值；o$o$是一个向量，代表输出层的值。

U$U$是输入层到隐藏层的权重矩阵，V$V$是隐藏层到输出层的权重矩阵，权重矩阵W$W$是隐藏层上一次的值作为这一次的输入的权重。循环神经网络与普通的全连接神经网络不同的地方也就在于W$W$。

如上图右，可表示循环神经网络的计算方式：

otst=g(Vst)(式1)=f(Uxt+Wst−1)(式2)(1)(2)$$\begin{array}{}\text{(1)}& {\mathrm{o}}_t& =g(V{\mathrm{s}}_t)(式1)\text{(2)}& {\mathrm{s}}_t& =f(U{\mathrm{x}}_t+W{\mathrm{s}}_{t-1})(式2)\end{array}$$

其中，式1是输出层的计算公式，输出层是一个全连接层，即每一个节点都与隐藏层的每个节点相连，g代表**函数，V$V$是输出层的权重矩阵。

式2是隐藏层的计算公式，它是一个循环层，f是**函数，U$U$是输入x$x$的权重矩阵，W$W$是上次值st−1$s_{t-1}$作为这次输入的权重矩阵。

双向循环神经网络

对于语言模型来说，很多时候光看前面的词是不够的，还需要看后面的词。普通的基本循环神经网络对此无法建模，因此，我们需要双向循环神经网络。

从上图可知，双向循环神经网络的隐藏层要保存两个值，一个A$A$参与正向计算，另一个值A′$A^{{}^{\prime }}$参与反向计算。最后的输出值y2$y_2$取决于A2$A_2$和A′2$A_2^{{}^{\prime }}$。仿照式1和试2，双向循环神经网络的计算方法如下：

otsts′t=g(Vst+V′s′t)=f(Uxt+Wst−1)=f(U′xt+W′s′t+1)(3)(4)(5)$$\begin{array}{}\text{(3)}& {\mathrm{o}}_t& =g(V{\mathrm{s}}_t+V^{\prime }{\mathrm{s}}_t^{\prime })\text{(4)}& {\mathrm{s}}_t& =f(U{\mathrm{x}}_t+W{\mathrm{s}}_{t-1})\text{(5)}& {\mathrm{s}}_t^{\prime }& =f(U^{\prime }{\mathrm{x}}_t+W^{\prime }{\mathrm{s}}_{t+1}^{\prime })\end{array}$$

可以看出：正向计算时，隐藏层的值st$s_t$与st−1$s_{t-1}$有关；反向计算时，隐藏层的值s′t$s_t^{{}^{\prime }}$和s′t−1$s_{t-1}^{{}^{\prime }}$有关。正向计算和反向计算不共享权重，也就是说U$U$和U′$U^{{}^{\prime }}$、W$W$和W′$W^{{}^{\prime }}$、V$V$和V′$V^{{}^{\prime }}$都是不同的权重矩阵。

深度循环神经网络

之前介绍的RNN都是只有一个隐藏层，当堆叠两个以上隐藏层时，就得到了深度循环神经网络

把第i个隐藏层的值表示为s(i)t$s_t^{(i)}$、s′(i)t$s_t^{{}^{\prime }(i)}$，则深度循环神经网络的计算方式可以表示为：

ots(i)ts′(i)t...s(1)ts′(1)t=g(V(i)s(i)t+V′(i)s′(i)t)=f(U(i)s(i−1)t+W(i)st−1)=f(U′(i)s′(i−1)t+W′(i)s′t+1)=f(U(1)xt+W(1)st−1)=f(U′(1)xt+W′(1)s′t+1)(6)(7)(8)(9)(10)(11)$$\begin{array}{}\text{(6)}& {\mathrm{o}}_t& =g(V^{(i)}{\mathrm{s}}_t^{(i)}+V^{\prime (i)}{\mathrm{s}}_t^{\prime (i)})\text{(7)}& {\mathrm{s}}_t^{(i)}& =f(U^{(i)}{\mathrm{s}}_t^{(i-1)}+W^{(i)}{\mathrm{s}}_{t-1})\text{(8)}& {\mathrm{s}}_t^{\prime (i)}& =f(U^{\prime (i)}{\mathrm{s}}_t^{\prime (i-1)}+W^{\prime (i)}{\mathrm{s}}_{t+1}^{\prime })\text{(9)}& ...\text{(10)}& {\mathrm{s}}_t^{(1)}& =f(U^{(1)}{\mathrm{x}}_t+W^{(1)}{\mathrm{s}}_{t-1})\text{(11)}& {\mathrm{s}}_t^{\prime (1)}& =f(U^{\prime (1)}{\mathrm{x}}_t+W^{\prime (1)}{\mathrm{s}}_{t+1}^{\prime })\end{array}$$

循环神经网络的训练

循环神经网络的训练算法：BPTT

BPTT算法是针对循环层的训练算法，基本原理和BP算法一样，包含三个步骤：

1. 前向计算每个神经元的输出值；

2. 反向计算每个神经元的误差项δj${\delta }_j$值，它是误差函数E对神经元j的加权输入netj$ne{t}_j$的偏导数；

3. 计算每个权重的梯度。

最后再用随机梯度下降算法更新权重。

循环层如下图所示：

1. 前向计算

使用式2对循环层进行前向计算：

st=f(Uxt+Wst−1)$${\mathrm{s}}_t=f(U{\mathrm{x}}_t+W{\mathrm{s}}_{t-1})$$

上式中，st$s_t$、xt$x_t$、st−1$s_{t-1}$都是向量，U、V是矩阵，向量的下标表示时刻。

2. 误差项的计算

BTPP算法将第l$l$层的t时刻的误差项δlt${\delta }_t^l$值沿两个方向传播，一个方向是传递到上一层网络，得到δl−1t${\delta }_t^{l-1}$值，这部分只与U有关；另一方向是沿时间线传递到初始t1$t_1$时刻，得到δl1${\delta }_1^l$值，这部分只与W有关。

我们用向量nett$ne{t}_t$表示神经元在t时刻的加权输入，因为：

nettst−1=Uxt+Wst−1=f(nett−1)(12)(13)$$\begin{array}{}\text{(12)}& {\mathrm{n}\mathrm{e}\mathrm{t}}_t& =U{\mathrm{x}}_t+W{\mathrm{s}}_{t-1}\text{(13)}& {\mathrm{s}}_{t-1}& =f({\mathrm{n}\mathrm{e}\mathrm{t}}_{t-1})\end{array}$$

因此（详细推导此处略过，详情见链接）：

∂nett∂nett−1=∂nett∂st−1∂st−1∂nett−1=Wdiag[f′(nett−1)]=⎡⎣⎢⎢⎢⎢⎢⎢w11f′(nett−11)w21f′(nett−11)wn1f′(nett−11)w12f′(nett−12)w22f′(nett−12)..wn2f′(nett−12).........w1nf(nett−1n)w2nf(nett−1n)wnnf′(nett−1n)⎤⎦⎥⎥⎥⎥⎥⎥(14)(15)(16)$$\begin{array}{}\text{(14)}& \frac{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_t}{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_{t-1}}& =\frac{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_t}{\mathrm{\partial }{\mathrm{s}}_{t-1}}\frac{\mathrm{\partial }{\mathrm{s}}_{t-1}}{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_{t-1}}\text{(15)}& & =Wdiag[f^{\prime }({\mathrm{n}\mathrm{e}\mathrm{t}}_{t-1})]\text{(16)}& & =\left[\begin{array}{cccc}{w}_{11}{f}^{\prime }(ne{t}_1^{t-1})& w_{12}{f}^{\prime }(ne{t}_2^{t-1})& ...& w_{1n}f(ne{t}_n^{t-1})\\ w_{21}{f}^{\prime }(ne{t}_1^{t-1})& w_{22}{f}^{\prime }(ne{t}_2^{t-1})& ...& w_{2n}f(ne{t}_n^{t-1})\\ & .\\ & .\\ w_{n1}{f}^{\prime }(ne{t}_1^{t-1})& w_{n2}{f}^{\prime }(ne{t}_2^{t-1})& ...& w_{nn}{f}^{\prime }(ne{t}_n^{t-1})\end{array}\right]\end{array}$$

上式描述了将δ沿时间往前传递一个时刻的规律，根据这个规律，可以求得任意时刻k的误差项δk${\delta }_k$：

δTk=====∂E∂netk∂E∂nett∂nett∂netk∂E∂nett∂nett∂nett−1∂nett−1∂nett−2...∂netk+1∂netkWdiag[f′(nett−1)]Wdiag[f′(nett−2)]...Wdiag[f′(netk)]δltδTt∏i=kt−1Wdiag[f′(neti)](式3)(17)(18)(19)(20)(21)$$\begin{array}{}\text{(17)}& {\delta }_k^T=& \frac{\mathrm{\partial }E}{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_k}\text{(18)}& =& \frac{\mathrm{\partial }E}{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_t}\frac{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_t}{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_k}\text{(19)}& =& \frac{\mathrm{\partial }E}{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_t}\frac{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_t}{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_{t-1}}\frac{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_{t-1}}{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_{t-2}}...\frac{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_{k+1}}{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_k}\text{(20)}& =& Wdiag[f^{\prime }({\mathrm{n}\mathrm{e}\mathrm{t}}_{t-1})]Wdiag[f^{\prime }({\mathrm{n}\mathrm{e}\mathrm{t}}_{t-2})]...Wdiag[f^{\prime }({\mathrm{n}\mathrm{e}\mathrm{t}}_k)]{\delta }_t^l\text{(21)}& =& {\delta }_t^T\prod _{i=k}^{t-1}Wdiag[f^{\prime }({\mathrm{n}\mathrm{e}\mathrm{t}}_i)](式3)\end{array}$$

式3是将误差项沿时间反向传播的算法。

循环层将误差项反向传递到上一层网络，与普通的全连接层完全一样。

(δl−1t)T===∂E∂netl−1t∂E∂netlt∂netlt∂netl−1t(δlt)TUdiag[f′l−1(netl−1t)](式4)(22)(23)(24)$$\begin{array}{}\text{(22)}& ({\delta }_t^{l-1}{)}^T=& \frac{\mathrm{\partial }E}{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_t^{l-1}}\text{(23)}& =& \frac{\mathrm{\partial }E}{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_t^l}\frac{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_t^l}{\mathrm{\partial }{\mathrm{n}\mathrm{e}\mathrm{t}}_t^{l-1}}\text{(24)}& =& ({\delta }_t^l{)}^{T}Udiag[f^{\prime l-1}({\mathrm{n}\mathrm{e}\mathrm{t}}_t^{l-1})](式4)\end{array}$$

式4就是将误差项传递到上一层的算法。

3. 权重梯度的计算

首先，我们计算误差函数E对权重矩阵W的梯度∂E∂W$\frac{\mathrm{\partial }E}{\mathrm{\partial }W}$.

上图展示了前两步已经计算得到的值，包括每个时刻t循环层的输出值st$s_t$以及误差项δt${\delta }_t$。

梯度计算算法：只要知道了任意一个时刻的误差项δt${\delta }_t$，以及上一个时刻循环层的输出值st−1$s_{t-1}$，就可以按照下面的公式求出权重矩阵在t时刻的梯度∇WtE${\nabla }_{Wt}E$:

∇WtE=⎡⎣⎢⎢⎢⎢⎢⎢δt1st−11δt2st−11..δtnst−11δt1st−12δt2st−12δtnst−12.........δt1st−1nδt2st−1nδtnst−1n⎤⎦⎥⎥⎥⎥⎥⎥(式5)$${\mathrm{\nabla }}_{W_t}E=\left[\begin{array}{cccc}{\delta }_1^t{s}_1^{t-1}& {\delta }_1^t{s}_2^{t-1}& ...& {\delta }_1^t{s}_n^{t-1}\\ {\delta }_2^t{s}_1^{t-1}& {\delta }_2^t{s}_2^{t-1}& ...& {\delta }_2^t{s}_n^{t-1}\\ .\\ .\\ {\delta }_n^t{s}_1^{t-1}& {\delta }_n^t{s}_2^{t-1}& ...& {\delta }_n^t{s}_n^{t-1}\end{array}\right](式5)$$

我们求得了权重矩阵W在t时刻的梯度∇WtE${\nabla }_{Wt}E$，最终的梯度∇WE${\nabla }_{W}E$是各个时刻的梯度之和（至于为什么是“和”，详细推导见链接）：

∇WE==∑i=1t∇WiE⎡⎣⎢⎢⎢⎢⎢⎢δt1st−11δt2st−11..δtnst−11δt1st−12δt2st−12δtnst−12.........δt1st−1nδt2st−1nδtnst−1n⎤⎦⎥⎥⎥⎥⎥⎥+...+⎡⎣⎢⎢⎢⎢⎢⎢δ11s01δ12s01..δ1ns01δ11s02δ12s02δ1ns02.........δ11s0nδ12s0nδ1ns0n⎤⎦⎥⎥⎥⎥⎥⎥(式6)(25)(26)$$\begin{array}{}\text{(25)}& {\mathrm{\nabla }}_{W}E=& \sum _{i=1}^t{\mathrm{\nabla }}_{W_i}E\text{(26)}& =& \left[\begin{array}{cccc}{\delta }_1^t{s}_1^{t-1}& {\delta }_1^t{s}_2^{t-1}& ...& {\delta }_1^t{s}_n^{t-1}\\ {\delta }_2^t{s}_1^{t-1}& {\delta }_2^t{s}_2^{t-1}& ...& {\delta }_2^t{s}_n^{t-1}\\ .\\ .\\ {\delta }_n^t{s}_1^{t-1}& {\delta }_n^t{s}_2^{t-1}& ...& {\delta }_n^t{s}_n^{t-1}\end{array}\right]+...+\left[\begin{array}{cccc}{\delta }_1^1{s}_1^0& {\delta }_1^1{s}_2^0& ...& {\delta }_1^1{s}_n^0\\ {\delta }_2^1{s}_1^0& {\delta }_2^1{s}_2^0& ...& {\delta }_2^1{s}_n^0\\ .\\ .\\ {\delta }_n^1{s}_1^0& {\delta }_n^1{s}_2^0& ...& {\delta }_n^1{s}_n^0\end{array}\right](式6)\end{array}$$

式6就是计算循环层权重矩阵W的梯度的公式。

RNN的梯度爆炸和消失问题

不幸的是，前面提到的几种RNNs都不能很好的处理较长的序列。原因是RNN在训练中很容易发生梯度爆炸和梯度消失，这导致训练梯度不能在较长序列中一直传递下去，从而使RNN无法捕捉到长距离的影响。（具体原因见链接）

处理梯度爆炸：设置一个梯度阈值，当梯度超过这个阈值时可以直接截取。

处理梯度消失：

1. 合理的初始化权重值。初始化权重，使每个神经元尽可能不要取极大值或极小值，以躲开梯度消失的区域。

2. 使用ReLU代替Sigmoid和tanh作为**函数。

3. 使用其他结构的RNNs，如长短时记忆网络（LTSM）和Gated Recurrent Unit（GRU）。