邱锡鹏《神经网络与深度学习》学习笔记。

1.循环神经网络

前馈神经网络的输出只依赖当前的输入，但在很多现实任务（如视频、语音、文本）中，网络的输出不仅和当前时刻的输入相关，也和其过去一段时间的输出相关。此外时序数据的长度一般是不固定的，而前馈神经网络要求输入和输出的维数都是固定的。因此处理这类时序数据相关的问题时，就需要一种能力更强的模型。

循环神经网络(recurrent neural network,RNN)是一种具有短期记忆能力的神经网络。在 RNN 中，神经元不但可以接受其他神经元的信息，也可以接受自身的信息，形成具有环路的网络结构。

RNN 的参数可以通过随时间反向传播算法来学习。将误差信息按照时间逆序一步一步的往前传递。当输入序列比较长时，会存在梯度爆炸和梯度消失问题，也称为长程依赖问题。解决这个问题最有效的方法是门控机制（Gating Mechanism）。

RNN 已被广泛应用于语音识别、语言模型以及自然语言生成等任务上。

1.1 简单循环神经网络

1.1.1 循环神经网络：给网络增加记忆能力

循环神经网络通过使用带自反馈的神经元，使网络具有短期记忆能力。因此，能够处理任意长度的时序数据。

给定一个输入序列${\mathbf{x}}_{1:T}=\left({\mathbf{x}}_1,{\mathbf{x}}_2,\dots ,{\mathbf{x}}_t,\dots ,{\mathbf{x}}_T\right)$，循环神经网络通过下面的公式更新带反馈边的隐藏层的活性值${\mathbf{h}}_t$:
$${\mathbf{h}}_t=f({\mathbf{h}}_{t-1},{\mathbf{x}}_t)$$ 其中，${\mathbf{h}}_0=0$,$f(\cdot )$为一个非线性函数，可以是一个前馈网络。

从数学上讲，上式可以看成一个动力系统。因此隐藏层的活性值${\mathbf{h}}_t$也称为状态（state）或隐状态（Hidden State）。

动力系统（Dynamical System）是一个数学上的概念，指系统状态按照一定的规律随时间变化的系统。

下图给出了循环神经网络的示例，其‘延时器’是一个虚拟单元，记录神经元的最近一次（或几次）活性值。

理论上，前馈神经网络可以模拟任何连续函数，循环神经网络可以模拟任何程序。

1.1.2 简单循环网络

简单循环网络（Simple Recurrent Network，SRN，1990）是一个非常简单的循环神经网络，在只有一个隐藏层的前馈神经网络中增加了从隐藏层到隐藏层的反馈连接。

令向量${\mathbf{x}}_t\in {\mathbb{R}}^M$表示在时刻$t$时网络的输入，${\mathbf{h}}_t\in {\mathbb{R}}^D$表示$t$时刻的隐藏层状态（即隐藏层神经元活性值），$boldsymbol{y}_{t} $表示输出。则一个完全连接的简单循环神经网络定义为：

$$\begin{array}{l}{\mathbf{z}}_t=\mathbf{U}{\mathbf{h}}_{t-1}+\mathbf{W}{\mathbf{x}}_t+\mathbf{b}\\ {\mathbf{h}}_t=f\left({\mathbf{z}}_t\right)\\ {\mathbf{y}}_t=\mathbf{V}{\mathbf{h}}_t\end{array}$$

${\mathbf{z}}_t$为隐藏层的净输入，$\mathbf{U}\in {\mathbb{R}}^{D\times D}$为状态-状态权重矩阵，$\mathbf{W}\in {\mathbb{R}}^{D\times M}$为状态-输入权重矩阵。$\mathbf{b}\in {\mathbb{R}}^D$为偏置向量，$f(\cdot )$为非线性激活函数，通常为 Logistic 函数或 Tanh 函数。$\mathbf{V}$为状态-输出权重矩阵。$\mathbf{U}$、$\mathbf{W}$、$\mathbf{b}$ 和 $\mathbf{V}$ 都是网络参数。

如果我们把每个时刻的状态都看做前馈神经网络的一层，循环神经网络可以看做时间维度上权值共享的神经网络。下图给出了按时间展开的循环神经网络。

循环神经网络的拟合能力也十分强大。一个完全连接的循环神经网络是任何非线性动力系统的近似器，可以近似解决所有的可计算问题。

1.2 RNN 应用于机器学习的三种任务模式

RNN可以应用到很多不同类型的机器学习任务。根据这些任务的特点可以分为以下几种模式：序列到类别模式、同步的序列到序列模式、异步的序列到序列模式。

1.2.1 序列到类别模式

输入为序列，输出为类别。主要用于序列数据的分类问题。

假设输入样本为一个长度为$T$的序列${\mathbf{x}}_{1:T}=\left({\mathbf{x}}_1,\cdots ,{\mathbf{x}}_T\right)$，输出为一个类别 y ∈ { 1 , . . . , C } yin{1,...,C} y∈{1,...,C}.将样本按不同时刻输入到循环神经网络中，得到不同时刻的隐藏状态${\mathbf{h}}_1,\cdots ,{\mathbf{h}}_T$,我们可以将${\mathbf{h}}_T$看作整个序列的最终状态（或特征），并输入给分类器$g(\cdot )$进行分类，即
$$\hat{y}=g\left({\mathbf{h}}_T\right)$$
其中$g(\cdot )$可以是简单的线性分类器（如 Logistic回归）或复杂的分类器（如多层全连接网络）。

也可以对整个序列的所有状态进行平均，并用这个平均状态来作为整个序列的表示，即
$$\hat{y}=g\left(\frac{1}{T}\sum _{t=1}^T{\mathbf{h}}_t\right)$$

1.2.2 同步的序列到序列模式

每一时刻都有输入和输出，输入序列和输出序列长度相同。主要用于序列标注（Sequence Labeling）任务。

这种模式的输出序列为 $y_{1:T}=\left(y_1,\cdots ,y_T\right)$.每个时刻的隐状态${\mathbf{h}}_t$代表了当前时刻和历史的信息，输入给分类器，得到当前时刻的标签${\hat{y}}_t$,即
$${\hat{y}}_t=g\left({\mathbf{h}}_t\right),\forall t\in [1,T]$$

同步的序列到序列模式图示如下

1.2.3 异步的序列到序列模式

异步的序列到序列模式也称为编码器-解码器（Encoder-Decoder）模型。输入序列和输出序列不需要严格的对应关系，也不需要保持相同的长度。比如在机器翻译中，输入为源语言的单词序列，输出为目标语言的单词序列。

异步的序列到序列模式一般通过先编码后解码的方式来实现。现将样本按不同时刻输入到一个循环神经网络（编码器）中，并得到其编码${\mathbf{h}}_T$，然后再使用另一个循环神经网络（解码器）得到输出序列${\hat{y}}_{1:M}$。
令$f_1(\cdot )$和$f_2(\cdot )$分别用作编码器和解码器的循环神经网络，则编码器-解码器模型可以写为
$$\begin{array}{rl}{\mathbf{h}}_t& =f_1\left({\mathbf{h}}_{t-1},{\mathbf{x}}_t\right)\\ {\mathbf{h}}_{T+t}& =f_2\left({\mathbf{h}}_{T+t-1},{\hat{\mathbf{y}}}_{t-1}\right)\\ {\hat{y}}_t& =g\left({\mathbf{h}}_{T+t}\right)\end{array}$$

下图给出了异步的序列到序列模式示例，其中$<EOS>$表示输入序列的结束。

1.3 参数学习

1.3.1 梯度下降

RNN 的参数可以通过梯度下降法来进行学习。

以随机梯度下降为例，给定一个训练样本$(\mathbf{x},\mathbf{y})$，其中${\mathbf{x}}_{1:T}=({\mathbf{x}}_1,...,{\mathbf{x}}_T)$为长度为$T$的输入序列， $y_{1:T}=\left(y_1,\cdots ,y_T\right)$是长度为$T$的标签序列。即在每个时刻$t$都有一个监督信息$y_t$，我们定义时刻$t$的损失函数为
$${\mathcal{L}}_t=\mathcal{L}\left(y_t,g\left({\mathbf{h}}_t\right)\right)$$
其中$g\left({\mathbf{h}}_t\right)$为第$t$时刻的输出，$\mathcal{L}$w为可微分的损失函数，比如交叉熵。那么整个序列的损失函数为
$$\mathcal{L}=\sum _{t=1}^T{\mathcal{L}}_t$$

整个序列的损失函数$\mathcal{L}$关于参数$\mathbf{U}$的梯度为
$$\frac{\partial \mathcal{L}}{\partial \mathbf{U}}=\sum _{t=1}^T\frac{\partial {\mathcal{L}}_t}{\partial \mathbf{U}}$$
即每个时刻损失${\mathcal{L}}_t$对参数$\mathbf{U}$的偏导数之和。

循环神经网络中存在一个递归调用的函数$f(\cdot )$，因此其计算梯度的方式和前馈神经网络不同一样。RNN 主要有两种计算梯度的方式：随时间反向传播（BPTT）算法和实时循环学习（RTRL）算法。

1.3.2 随时间反向传播算法

BackPropagation Through Time，BPTT 算法的主要思想是通过类似前馈神经网络的误差反向传播算法来计算梯度。

BPTT算法将循环神经网络看做展开的多层前馈神经网络，其中“每一层”对应循环神经网络中的“每个时刻”。这样，循环神经网络就可以按照前馈网络中的反向传播算法计算参数梯度。在“展开”的前馈网络中，所有层的参数是共享的，因此参数的真实梯度是所有“展开层”的参数梯度之和。

计算偏导数$\frac{\partial {\mathcal{L}}_t}{\partial \mathbf{U}}$

因为参数$\mathbf{U}$和隐藏层在每个时刻$k$的净输入${\mathbf{z}}_k=\mathbf{U}{\mathbf{h}}_{k-1}+\mathbf{W}{\mathbf{x}}_k+\mathbf{b}$有关，因此第$t$时刻的损失函数${\mathcal{L}}_t$关于参数$u_{ij}$的梯度为：
$$\frac{\partial {\mathcal{L}}_t}{\partial u_{ij}}=\sum _{k=1}^t\frac{{\partial }^{+}{\mathbf{z}}_k}{\partial u_{ij}}\frac{\partial {\mathcal{L}}_t}{\partial {\mathbf{z}}_k}$$
其中$\frac{{\partial }^{+}{\mathbf{z}}_k}{\partial u_{ij}}$表示“直接”偏导数，即公式${\mathbf{z}}_k=\mathbf{U}{\mathbf{h}}_{k-1}+\mathbf{W}{\mathbf{x}}_k+\mathbf{b}$中保持${\mathbf{h}}_{k-1}$不变，对$u_{ij}$进行求偏导数，得到

其中${\left[{\mathbf{h}}_{k-1}\right]}_j$为第 $k-1$ 时刻隐状态的第$j$维；${\mathbb{I}}_i(x)$除了第$i$行值为$x$外，其余都为 0 的行向量。

定义误差项${\delta }_{t,k}=\frac{\partial {\mathcal{L}}_t}{\partial {\mathbf{z}}_k}$为第$t$时刻的损失对第$t$时刻隐藏神经层的净输入${\mathbf{z}}_k$的导数，则当$1\le k<t$时：
$$\begin{array}{rl}{\delta }_{t,k}& =\frac{\partial {\mathcal{L}}_t}{\partial {\mathbf{z}}_k}\\ & =\frac{\partial {\mathbf{h}}_k}{\partial {\mathbf{z}}_k}\frac{\partial {\mathbf{z}}_{k+1}}{\partial {\mathbf{h}}_k}\frac{\partial {\mathcal{L}}_t}{\partial {\mathbf{z}}_{k+1}}\\ & =\mathrm{diag}\left(f^{\prime }\left({\mathbf{z}}_k\right)\right){\mathbf{U}}^{\top }{\delta }_{t,k+1}\end{array}$$

综合上述两式可得
$$\frac{\partial {\mathcal{L}}_t}{\partial u_{ij}}=\sum _{k=1}^t{\left[{\delta }_{t,k}\right]}_i{\left[{\mathbf{h}}_{k-1}\right]}_j$$
写成矩阵形式为
$$\frac{\partial {\mathcal{L}}_t}{\partial \mathbf{U}}=\sum _{k=1}^t{\delta }_{t,k}{\mathbf{h}}_{k-1}^{\top }$$
同理可得
$$\begin{array}{rl}\frac{\partial \mathcal{L}}{\partial \mathbf{W}}& =\sum _{t=1}^T\sum _{k=1}^t{\delta }_{t,k}{\mathbf{x}}_k^{\top }\\ \frac{\partial \mathcal{L}}{\partial \mathbf{b}}& =\sum _{t=1}^T\sum _{k=1}^t{\delta }_{t,k}\end{array}$$
下图为误差项随时间进行反向传播的示例：

1.3.3 实时循环学习算法

Real-Time Tecurrent Learning,RTRL，通过前向传播方式来计算梯度。

假设循环神经网络中第$t+1$时刻状态
$${\mathbf{h}}_{t+1}=f\left({\mathbf{z}}_{t+1}\right)=f\left(\mathbf{U}{\mathbf{h}}_t+\mathbf{W}{\mathbf{x}}_{t+1}+\mathbf{b}\right)$$
其关于参数$u_{ij}$的偏导数为
$$\begin{array}{rl}\frac{\partial {\mathbf{h}}_{t+1}}{\partial u_{ij}}& =\left(\frac{{\partial }^{+}{\mathbf{z}}_{t+1}}{\partial u_{ij}}+\frac{\partial {\mathbf{h}}_t}{\partial u_{ij}}{\mathbf{U}}^{\top }\right)\frac{\partial {\mathbf{h}}_{t+1}}{\partial {\mathbf{z}}_{t+1}}\\ & =\left({\mathbb{I}}_i\left({\left[{\mathbf{h}}_t\right]}_j\right)+\frac{\partial {\mathbf{h}}_t}{\partial u_{ij}}{\mathbf{U}}^{\top }\right)\mathrm{diag}\left(f^{\prime }\left({\mathbf{z}}_{t+1}\right)\right)\\ & =\left({\mathbb{I}}_i\left({\left[{\mathbf{h}}_t\right]}_j\right)+\frac{\partial {\mathbf{h}}_t}{\partial u_{ij}}{\mathbf{U}}^{\top }\right)\odot {\left(f^{\prime }\left({\mathbf{z}}_{t+1}\right)\right)}^{\top }\end{array}$$
其中${\mathbb{I}}_i(x)$是除了第$i$行值为$x$外，其余都为 0 的行向量。

RTRL 算法从第 1 个时刻开始，除了计算循环神经网络的隐状态之外，还利用上式依次前向计算偏导数$\frac{\partial {\mathbf{h}}_1}{\partial u_{ij}},\frac{\partial {\mathbf{h}}_2}{\partial u_{ij}},\frac{\partial {\mathbf{h}}_3}{\partial u_{ij}},\cdots$。
这样，假设第$t$个时刻存在一个监督信息，其损失函数为${\mathcal{L}}_t$，就可以同时计算损失函数对$u_{ij}$的偏导数$$\frac{\partial {\mathcal{L}}_t}{\partial u_{ij}}=\frac{\partial {\mathbf{h}}_t}{\partial u_{ij}}\frac{\partial {\mathcal{L}}_t}{\partial {\mathbf{h}}_t}$$
这样在$t$时刻，可以实时计算损失${\mathcal{L}}_t$关于参数$\mathbf{U}$的梯度，并更新参数。参数$\mathbf{W}$和$\mathbf{b}$的梯度也可以统一按上述方法实时计算。

两种算法比较
RTRL 和 BPTT 都是基于梯度下降的算法，分别通过前向模式和反向模式嘤嘤链式法则来计算梯度。在 RNN中，一般网络输出维度远低于输入维度，因此 BPTT 算法的计算量会更小，但 BPTT 算法需要保存所有时刻的中间梯度，空间复杂度较高。RTRL 算法不需要梯度回传，因此非常适合熊需要在线学习或无线序列的任务中。

1.4 基于门控的循环神经网络

1.4.1 长程依赖问题

RNN 在学习过程中的主要问题是由于梯度消失或爆炸问题，很难建模长时间间隔（Long Range）的状态之间的依赖关系。称为长程依赖问题（Long-Term Dependencies Problem）

在 BPTT 算法中，${\delta }_{t,k}$展开得到
$${\delta }_{t,k}=\prod _{\tau =k}^{t-1}\left(\mathrm{diag}\left(f^{\prime }\left(z_{\tau }\right)\right)U^{\top }\right){\delta }_{t,t}$$
如果定义$\gamma \cong \Vert \mathrm{diag}\left(f^{\prime }\left({\mathbf{z}}_{\tau }\right)\right){\mathbf{U}}^{\top }\Vert$，则
$${\delta }_{t,k}\cong {\gamma }^{t-k}{\delta }_{t,t}$$

若$\gamma >1$,当$t-k\to \infty$ 时 ${\gamma }^{t-k}\to \infty$,当间隔$t-k$比较大时，梯度也变得比较大，会造成系统不稳定，称为梯度爆炸问题（gradient exploding problem）。

相反若$\gamma <1$,当$t-k\to \infty$ 时 ${\gamma }^{t-k}\to 0$,当间隔$t-k$比较大时,梯度也变得非常小，会出现和深层前馈神经网络类似的梯度消失问题（vanishing gradient problem）。

要注意的是RNN 中的梯度消失不是说$\frac{\partial {\mathcal{L}}_t}{\partial \mathbf{U}}$的梯度消失了，而是$\frac{\partial {\mathcal{L}}_t}{\partial {\mathbf{h}}_k}$的梯度消失了（当$t-k$间隔比较大时）。也就是说，参数$\mathbf{U}$的更新注意靠当前时刻$t$的几个相邻状态${\mathbf{h}}_k$来更新，长距离的状态对参数$\mathbf{U}$没有影响。

由于 RNN 经常使用 Logistic 或 Tanh 作为激活函数，其导数都小于 1，并且权重矩阵$\Vert \mathbf{U}\Vert$也不会太大，因此如果时间间隔$t-k$过大，${\delta }_{t,k}$会趋向于 0，因而经常会出现梯度消失现象。

一般而言，RNN 的梯度爆炸问题比较容易解决，一般通过权重衰减或梯度截断来避免。

而解决梯度消失问题除了需要一些优化技巧外，还需要改变模型。比如让$\mathbf{U}=\mathbf{I}$,同时为了不丢失${\mathbf{h}}_t$和${\mathbf{h}}_{t-1}$之间的非线性激活性质（否则会降低模型的表现力），可以将模型改为
$${\mathbf{h}}_t={\mathbf{h}}_{t-1}+g\left({\mathbf{x}}_t,{\mathbf{h}}_{t-1};\theta \right)$$
，其中$g(\cdot )$是一个非线性函数，$\theta$为参数。这样${\mathbf{h}}_t$和${\mathbf{h}}_{t-1}$之间既有线性关系，也有非线性关系，并且可以缓解梯度消失问题。但这种改进依然存在两个问题：

1. 梯度爆炸问题：令${\mathbf{z}}_k=\mathbf{U}{\mathbf{h}}_{k-1}+\mathbf{W}{\mathbf{x}}_k+\mathbf{b}$为第$k$时刻函数$g(\cdot )$的输入，计算误差项${\delta }_{t,k}=\frac{\partial {\mathcal{L}}_t}{\partial z_k}$项时，梯度可能会过大，从而导致梯度爆炸问题。
2. 记忆容量问题：随着${\mathbf{h}}_t$不断累积存储新的输入信息，会发生饱和现象。假设$g(\cdot )$为 Logistic 函数，随时间$t$的增长，${\mathbf{h}}_t$会变得越来越大，从而导致$\mathbf{h}$变得饱和。也就是说，隐状态${\mathbf{h}}_t$可以存储的信息有限，随着记忆单元存储的内容越来越多，其丢失的信息也越来越多。

为了解决这个问题，我们引入门控机制来控制信息的累积速度。包括有选择的加入新信息，并有选择的遗忘之前的累积信息。

1.4.2 长短期记忆网络

Long Short-Term Memory Network，LSTM，1997。可以有效的解决简单循环神经网络的梯度爆炸和消失问题。

在${\mathbf{h}}_t={\mathbf{h}}_{t-1}+g\left({\mathbf{x}}_t,{\mathbf{h}}_{t-1};\theta \right)$的基础上，LSTM 网络的主要改进有两个方面：新的内部状态和门控机制。

1.4.2.1 新的内部状态

LSTM 引入了一个新的内部状态（internal state）${\mathbf{c}}_t\in {\mathbb{R}}^D$专门进行线性的循环信息传递。同时（非线性地）输出信息给隐藏层的外部状态${\mathbf{h}}_t\in {\mathbb{R}}^D$。内部状态${\mathbf{c}}_t$通过下面的公式计算：
$$\begin{array}{l}{\mathbf{c}}_t={\mathbf{f}}_t\odot {\mathbf{c}}_{t-1}+{\mathbf{i}}_t\odot \widetilde{{\mathbf{c}}_t}\\ {\mathbf{h}}_t={\mathbf{o}}_t\odot \tanh \left({\mathbf{c}}_t\right)\end{array}$$
其中${\mathbf{f}}_t\in [0,1{]}^D,{\mathbf{i}}_t\in [0,1{]}^D$ 和 ${\mathbf{o}}_t\in [0,1{]}^D$为三个门（gate）来控制信息传递的路径；$\odot$为向量元素乘积；${\mathbf{c}}_{t-1}$为上一时刻的记忆单元；${\tilde{\mathbf{c}}}_t\in {\mathbb{R}}^D$是通过非线性函数得到的候选状态：$${\tilde{\mathbf{c}}}_t=\tanh \left({\mathbf{W}}_c{\mathbf{x}}_t+{\mathbf{U}}_c{\mathbf{h}}_{t-1}+{\mathbf{b}}_c\right)$$
在每个时刻$t$，LSTM 网络的内部状态 ${\mathbf{c}}_t$ 记录了到当前时刻为止的历史信息。

1.4.2.2 门控机制

在数字电路中，门(gate)为一个二值变量{0,1}分别代表关闭和开放状态。
LSTM 引入门控机制来控制信息的传递路径。上节所三个门分别为：

• 遗忘门${\mathbf{f}}_t\in [0,1{]}^D$,控制上一时刻的内部状态${\mathbf{c}}_{t-1}$需要遗忘多少信息。

• 输入门 ${\mathbf{i}}_t\in [0,1{]}^D$ 控制当前时刻的候选状态${\tilde{\mathbf{c}}}_t$有多少信息需要保存。

• 输出门 ${\mathbf{o}}_t\in [0,1{]}^D$，控制当前时刻的内部状态${\mathbf{c}}_t$有多少信息需要输出给外部状态${\mathbf{h}}_t$。

当${\mathbf{f}}_t=0,{\mathbf{i}}_t=1$时，记忆单元将历史信息清空，并将候选状态向量${\tilde{\mathbf{c}}}_t$写入。但此时记忆单元${\mathbf{c}}_t$依然和上一时刻的历史信息相关。当${\mathbf{f}}_t=1,{\mathbf{i}}_t=0$时，记忆单元将复制上一时刻的内容，不写入新信息。

LSTM 的门是一种“软”门,取值在（0，1）之间，表示以一定的比例允许信息通过，三个门的计算方式为：
$$\begin{array}{rl}{\mathbf{i}}_t& =\sigma \left({\mathbf{W}}_i{\mathbf{x}}_t+{\mathbf{U}}_i{\mathbf{h}}_{t-1}+{\mathbf{b}}_i\right)\\ {\mathbf{f}}_t& =\sigma \left({\mathbf{W}}_f{\mathbf{x}}_t+{\mathbf{U}}_f{\mathbf{h}}_{t-1}+{\mathbf{b}}_f\right)\\ {\mathbf{o}}_t& =\sigma \left({\mathbf{W}}_o{\mathbf{x}}_t+{\mathbf{U}}_o{\mathbf{h}}_{t-1}+{\mathbf{b}}_o\right)\end{array}$$
其中$\sigma (\cdot )$为 Logistic 函数，其输出区间为（0，1），${\mathbf{x}}_t$为当前时刻的输入，${\mathbf{h}}_{t-1}$为上一时刻的外部状态。

1.4.2.3 LSTM

下图给出了 LSTM 网络的循环单元结构，其计算过程为：
1）利用上一时刻的外部状态${\mathbf{h}}_{t-1}$和当前时刻的输入${\mathbf{x}}_t$计算出三个门，以及候选状态${\tilde{\mathbf{c}}}_t$；
$$\left[\begin{array}{c}{\tilde{\mathbf{c}}}_t\\ {\mathbf{o}}_t\\ {\mathbf{i}}_t\\ {\mathbf{f}}_t\end{array}\right]=\left[\begin{array}{c}\tanh \\ \sigma \\ \sigma \\ \sigma \end{array}\right]\left(\mathbf{W}\left[\begin{array}{c}{\mathbf{x}}_t\\ {\mathbf{h}}_{t-1}\end{array}\right]+\mathbf{b}\right)$$
其中$\sigma (\cdot )$为 Logistic 函数，其输出区间为$(0,1)$。

2）结合遗忘门${\mathbf{f}}_t$和输入门${\mathbf{i}}_t$来更新记忆单元${\mathbf{c}}_t$;
$${\mathbf{c}}_t={\mathbf{f}}_t\odot {\mathbf{c}}_{t-1}+{\mathbf{i}}_t\odot \widetilde{{\mathbf{c}}_t}$$
3）结合输出门${\mathbf{o}}_t$，将内部状态信息传递给外部状态${\mathbf{h}}_t$。
$${\mathbf{h}}_t={\mathbf{o}}_t\odot \tanh \left({\mathbf{c}}_t\right)$$

通过 LSTM 循环单元，整个网络可以建立较长距离的时序依赖关系。

遗忘的参数初始值一般都设置的比较大，其偏置向量${\mathbf{b}}_f$设置为 1 或 2。因为在训练 LSTM 网络时，过小的值会使得遗忘门的值比较小。这意味着前一时刻的信息大部分都丢失了，这样网络很难捕捉到长距离的依赖信息。并且相邻时间间隔的梯度会非常小，这会导致梯度弥散问题。

记忆
RNN 中的隐状态$\mathbf{h}$存储了历史信息，可以看做一种记忆（memory）。在简单循环网络中，隐状态每个时刻都会被重写，因此可以看做一种短期记忆（short-term memory）。在神经网络中，长期记忆（long-term memory）可以看做网络参数，隐含了从训练数据中学到的经验，其更新周期要远远慢于短期记忆。而在 LSTM 中，记忆单元$\mathbf{c}$可以在某个时刻捕捉到某个关键信息，并有能力将此关键信息保存一定的时间间隔。记忆单元$\mathbf{c}$中保持信息的生命周期芽哟长于短期记忆$\mathbf{h}$，但又短于长期记忆，因此称为长短期记忆（long short-term memory）即长的“短期记忆”。

1.4.3 门控循环单元网络

Gated Recurrent Unit,GRU,2014.是一种比 LSTM 更加简单的循环神经网络。

和 LSTM 不同，GRU不引入额外的记忆单元，而是在公式 ${\mathbf{h}}_t={\mathbf{h}}_{t-1}+g\left({\mathbf{x}}_t,{\mathbf{h}}_{t-1};\theta \right)$的基础上引入一个更新门（Up-date Gate）来控制当前状态需要从历史状态中保留多少信（不经过非线性变换）息，以及需要从候选状态中接受多少新信息，即
$${\mathbf{h}}_t={\mathbf{z}}_t\odot {\mathbf{h}}_{t-1}+\left(1-{\mathbf{z}}_t\right)\odot {\tilde{\mathbf{h}}}_t$$ 其中，${\mathbf{z}}_t\in [0,1{]}^D$为更新门：
$${\mathbf{z}}_t=\sigma \left({\mathbf{W}}_z{\mathbf{x}}_t+{\mathbf{U}}_z{\mathbf{h}}_{t-1}+{\mathbf{b}}_z\right)$$ 在LSTM 中，输入门和遗忘门是互补关系，具有一定的冗余性，GRU 网络直接使用一个更新门来控制输入和遗忘之间的平衡。

${\tilde{\mathbf{h}}}_t$为当前时刻的候选状态（即函数$g\left({\mathbf{x}}_t{\mathbf{h}}_{t-1};\theta \right)$的定义）：
$${\tilde{\mathbf{h}}}_t=\tanh \left({\mathbf{W}}_h{\mathbf{x}}_t+{\mathbf{U}}_h\left({\mathbf{r}}_t\odot {\mathbf{h}}_{t-1}\right)+{\mathbf{b}}_h\right)$$
${\mathbf{r}}_t\in [0,1{]}^D$为重置门（reset gate）：
$${\mathbf{r}}_t=\sigma \left({\mathbf{W}}_r{\mathbf{x}}_t+{\mathbf{U}}_r{\mathbf{h}}_{t-1}+{\mathbf{b}}_r\right)$$
用来控制候选状态 ${\tilde{\mathbf{h}}}_t$的计算是否依赖上一时刻的状态 ${\mathbf{h}}_{t-1}$。

可以看出，当${\mathbf{z}}_t=0,\mathbf{r}=1$ 时，GRU 网络退化为简单循环神经网络；若${\mathbf{z}}_t=0,\mathbf{r}=0$时，当前状态${\mathbf{h}}_t$只和当前输入 ${\mathbf{x}}_t$相关，和历史状态${\mathbf{h}}_{t-1}$无关。当${\mathbf{z}}_t=1$时，当前状态${\mathbf{h}}_t={\mathbf{h}}_{t-1}$，和当前输入${\mathbf{x}}_t$无关。

GRU网络的循环单元结构：

1.5 深层循环神经网络

增加循环神经网络的深度可以增强网络的能力。此处的“深度”主要是增加同一时刻网络输入到输出之间的路径${\mathbf{x}}_t\to {\mathbf{y}}_t$，比如增加输入到隐状态${\mathbf{x}}_t\to {\mathbf{h}}_t$以及隐状态到输出${\mathbf{h}}_t\to {\mathbf{y}}_t$之间的路径的深度。

1.5.1 堆叠循环神经网络

一种常见的增加 RNN 深度的做法是将多个循环网络堆叠起来，称为堆叠循环神经网络（Stacked Recurrent Neural Network，SRNN）。一个堆叠的简单循网络（Stacked SRN）也称为循环多层感知机（Recurrent Multi-Layer Perceptron，RMLP）
下图给出了按时间展开的堆叠循环神经网络，第$l$层网络的输入是第$l-1$层网络的输出。

1.5.2 双向循环神经网络

在有些任务中，一个时刻的输出不但和过去时刻的信息有关，也和后续时刻的信息有关。如一个句子的词的词性由它的上下文决定。因此这些任务中，我们可以增加一个按照时间的逆序来传递信息的网络层，来增强网络的能力。

双向循环神经网络（Bidirectional Recurrent Neural Network，Bi-RNN）由两层循环神经网络组成，他们的输入相同，只是信息传递的方向不同。

假设第 1 层按时间顺序，第2层按时间逆序，在时刻$t$时的隐状态定义为${\mathbf{h}}_t^{(1)}$和${\mathbf{h}}_t^{(2)}$，则
$$\begin{array}{rl}{\mathbf{h}}_t^{(1)}& =f\left({\mathbf{U}}^{(1)}{\mathbf{h}}_{t-1}^{(1)}+{\mathbf{W}}^{(1)}{\mathbf{x}}_t+{\mathbf{b}}^{(1)}\right)\\ {\mathbf{h}}_t^{(2)}& =f\left({\mathbf{U}}^{(2)}{\mathbf{h}}_{t+1}^{(2)}+{\mathbf{W}}^{(2)}{\mathbf{x}}_t+{\mathbf{b}}^{(2)}\right)\\ {\mathbf{h}}_t& ={\mathbf{h}}_t^{(1)}\oplus {\mathbf{h}}_t^{(2)}\end{array}$$
其中$\oplus$为向量拼接操作。

下图为按时间展开的双向循环神经网络：

最后

以上就是激昂哈密瓜为你收集整理的神经网络与深度学习（五）—— 循环神经网络1.循环神经网络的全部内容，希望文章能够帮你解决神经网络与深度学习（五）—— 循环神经网络1.循环神经网络所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。