全前馈神经网络，信息单向传递，网络易学习，但能力被减弱。网络输出只依赖于当前的输入。输入输出维数固定。
循环神经网络，具有
短期记忆 能力。其中的神经元可接收
其他神经元 的信息和
本身 的信息。输入输出可不固定。参数学习可通过
随时间反向传播算法 学习。输入序列较长时，错误信息向前传递过长，存在
梯度爆炸 和
梯度消失 问题，即
长程依赖问题 ，一种有效的改进方式：
门控机制 。
循环神经网络易拓展到更广义的记忆网络模型：
递归神经网络 、
图网络 。
时序数据处理需要历史信息。前馈网络无记忆能力。介绍三种方法给网络增加记忆能力 。
延时神经网络通过在前馈网络的非输出层中都添加一个延时器，记录神经元的最近几次活性值，增加前馈网络的短期记忆能力。在 t t t l l l l − 1 l-1 l − 1 K K K
h t ( l ) = f ( h t ( l − 1 ) , h t − 1 ( l − 1 ) , ⋅ ⋅ ⋅ , h t − K ( l − 1 ) )
\pmb{h}_t^{(l)} = f(\pmb{h}_t^{(l-1)},\pmb{h}_{t-1}^{(l-1)},\cdot\cdot\cdot,\pmb{h}_{t-K}^{(l-1)})
h h h t ( l ) = f ( h h h t ( l − 1 ) , h h h t − 1 ( l − 1 ) , ⋅ ⋅ ⋅ , h h h t − K ( l − 1 ) )
其中 h t ( l ) ∈ R M l \pmb{h}_t^{(l)} \in \mathbb{R}^{ \pmb{M}_l } h h h t ( l ) ∈ R M M M l l l l t t t M l M_l M l l l l
a ( l ) = f l ( W ( l ) a ( l − 1 ) + b ( l ) )
\pmb{a}^{(l)} = f_l(\pmb{W}^{(l)}\pmb{a}^{(l-1)} + \pmb{b}^{(l)})
a a a ( l ) = f l ( W W W ( l ) a a a ( l − 1 ) + b b b ( l ) )
自回归模型 （AutoRegressive Model，AR）统计学上的时间序列模型，用一个变量 y t \pmb{y}_t y y y t
y t = w 0 + ∑ k = 1 K w k y t − k + ϵ t
\pmb{y}_t = w_0 + \sum_{k=1}^K w_k \pmb{y}_{t-k} + \epsilon_t
y y y t = w 0 + k = 1 ∑ K w k y y y t − k + ϵ t
其中 K K K w 0 , ⋅ ⋅ ⋅ , w K w_0, \cdot\cdot\cdot, w_K w 0 , ⋅ ⋅ ⋅ , w K ϵ t \epsilon_t ϵ t N ( 0 , σ 2 ) N(0, \sigma^2) N ( 0 , σ 2 ) t t t σ 2 \sigma^2 σ 2
有外部输入的自回归模型 （Nonlinear AutoRegressive with Exogenous Inputs Model，NARX），在每个时刻 t t t x t \pmb{x}_t x x x t y t \pmb{y}_t y y y t K x K_x K x K y K_y K y t t t y t \pmb{y}_t y y y t
y t = f ( x t , x t − 1 , ⋅ ⋅ ⋅ , x t − K x , y t − 1 , y t − 2 , ⋅ ⋅ ⋅ , y t − K y )
\pmb{y}_t = f(\pmb{x}_t,\pmb{x}_{t-1},\cdot\cdot\cdot,\pmb{x}_{t-K_x}, \pmb{y}_{t-1},\pmb{y}_{t-2},\cdot\cdot\cdot,\pmb{y}_{t-K_y})
y y y t = f ( x x x t , x x x t − 1 , ⋅ ⋅ ⋅ , x x x t − K x , y y y t − 1 , y y y t − 2 , ⋅ ⋅ ⋅ , y y y t − K y )
其中 f ( ⋅ ) f(\cdot) f ( ⋅ ) K x K_x K x K y K_y K y
循环神经网络 （Recurrent Neural Network，RNN）通过使用带自反馈的神经元 处理任意长度的时序数据。x 1 : T = ( x 1 , x 2 , . . . , x t , . . . , x T ) \pmb{x}_{1:T} = (\pmb{x_1}, \pmb{x_2}, ... ,\pmb{x_t}, ..., \pmb{x_T}) x x x 1 : T = ( x 1 x 1 x 1 , x 2 x 2 x 2 , . . . , x t x t x t , . . . , x T x T x T ) h t \pmb{h}_t h h h t
h t = f ( h t − 1 , x t )
\pmb{h}_t = f(\pmb{h}_{t-1}, \pmb{x}_t)
h h h t = f ( h h h t − 1 , x x x t )
其中h 0 = 0 \pmb{h}_0 = 0 h h h 0 = 0 f ( ⋅ ) f(\cdot) f ( ⋅ ) h t \pmb{h}_t h h h t
简单循环网络 (SRN)只有一个隐藏层。在一个两层的前馈神经网络 中，连接存在相邻的层与层之间，隐藏层的节点之间无连接。简单循环网络 增加了隐藏层到隐藏层的反馈连接。
假设向量 x t ∈ R M \pmb{x}_t \in \mathbb{R}^M x x x t ∈ R M t t t h t ∈ D M \pmb{h}_t \in \mathbb{D}^M h h h t ∈ D M h t \pmb{h}_t h h h t x t \pmb{x}_t x x x t h t − 1 \pmb{h}_{t-1} h h h t − 1 z t \pmb{z}_t z z z t U ∈ R D × D \pmb{U} \in \mathbb{R}^{D \times D} U U U ∈ R D × D 状态-状态 权重矩阵，W ∈ R D × D \pmb{W} \in \mathbb{R}^{D \times D} W W W ∈ R D × D 状态-输入 权重矩阵，b ∈ R D \pmb{b} \in \mathbb{R}^{D} b b b ∈ R D 偏移向量 ， 其中 f ( ⋅ ) f(\cdot) f ( ⋅ )
前馈神经网络可以模拟任何连续函数，而循环神经网络可以模拟任何程序。定义一个完全连接 的循环神经网络。x t \pmb{x}_t x x x t y t \pmb{y}_t y y y t h t \pmb{h}_t h h h t f ( ⋅ ) f(\cdot) f ( ⋅ ) U \pmb{U} U U U W \pmb{W} W W W b \pmb{b} b b b V \pmb{V} V V V
循环神经网络的拟合能力也十分强大。一个完全连接的循环网络是任何非线性动力系统 的近似器。可用通用近似定理解释：
图灵完备 （Turing Completeness）是指一种数据操作规则，比如一种编程语言，可以实现图灵机 （Turing Machine）的所有功能，解决所有的可计算问题。完全连接 的循环神经网络 可以近似解决所有的可计算问题。
循环神经网络可以应用到三种模式的机器学习任务：：序列到类别 模式、同步的序列到序列 模式、异步的序列到序列 模式。
序列到类别 模式主要用于序列数据的分类问题。比如文本分类任务，输入为单词序列，输出为该文本类别。x 1 : T = ( x 1 , x 2 , . . . , x t , . . . , x T ) \pmb{x}_{1:T} = (\pmb{x_1}, \pmb{x_2}, ... ,\pmb{x_t}, ..., \pmb{x_T}) x x x 1 : T = ( x 1 x 1 x 1 , x 2 x 2 x 2 , . . . , x t x t x t , . . . , x T x T x T ) y ∈ y \in y ∈ x \pmb{x} x x x h 1 \pmb{h}_1 h h h 1 . . . ... . . . h T \pmb{h}_T h h h T h T \pmb{h}_T h h h T g ( ⋅ ) g(\cdot) g ( ⋅ )
y ^ = g ( h T )
\hat{y} = g(\pmb{h}_T)
y ^ = g ( h h h T )
也可以将整个序列的所有状态进行平均，做为整个序列的表示：
y ^ = g ( 1 T ∑ t = 1 T h t )
\hat{y} = g(\frac{1}{T}\sum_{t=1}^{T}\pmb{h}_t)
y ^ = g ( T 1 t = 1 ∑ T h h h t )
两种图示：
同步的序列到序列 模式主要用于序列标注（Sequence Labeling）任务，即每一时刻都有输入输出，输入输出序列长度相同。比如在词性标注 （Part-of-Speech Tagging）中，每一个单词需要标注其词性标签 。x 1 : T = ( x 1 , x 2 , . . . , x t , . . . , x T ) \pmb{x}_{1:T} = (\pmb{x_1}, \pmb{x_2}, ... ,\pmb{x_t}, ..., \pmb{x_T}) x x x 1 : T = ( x 1 x 1 x 1 , x 2 x 2 x 2 , . . . , x t x t x t , . . . , x T x T x T ) y 1 : T = ( y 1 , . . . , y T ) y_{1:T} = (y_1, ... , y_T) y 1 : T = ( y 1 , . . . , y T ) x \pmb{x} x x x h 1 \pmb{h}_1 h h h 1 h T \pmb{h}_T h h h T h t \pmb{h}_t h h h t
y ^ t = g ( h t ) , ∀ t ∈ [ 1 , T ]
\hat{y}_t = g(\pmb{h}_t), \forall t \in [1, T]
y ^ t = g ( h h h t ) , ∀ t ∈ [ 1 , T ]
异步的序列到序列模式 又称编码器-解码器 （Encoder-Decoder）模型，即输入序列和输出序列不需具有严格的对应关系，也不需相同长度。比如机器翻译任务中，输入为源语言单词序列，输出为目标语言单词序列。x 1 : T = ( x 1 , x 2 , . . . , x T ) \pmb{x}_{1:T} = (\pmb{x_1}, \pmb{x_2}, ..., \pmb{x_T}) x x x 1 : T = ( x 1 x 1 x 1 , x 2 x 2 x 2 , . . . , x T x T x T ) y 1 : M = ( y 1 , y 2 , . . . , x M ) \pmb{y}_{1:M} = (\pmb{y_1}, \pmb{y_2}, ... ,\pmb{x_M}) y y y 1 : M = ( y 1 y 1 y 1 , y 2 y 2 y 2 , . . . , x M x M x M ) 异步的序列到序列模式 一般通过先编码后解码的方式来实现。先将样本 x x x h T \pmb{h}_T h h h T y ^ 1 : M \hat{y}_{1:M} y ^ 1 : M f 1 ( ⋅ ) f_1(\cdot) f 1 ( ⋅ ) f 2 ( ⋅ ) f_2(\cdot) f 2 ( ⋅ ) g ( ⋅ ) g(\cdot) g ( ⋅ ) y ^ t \hat{\pmb{y}}_t y y y ^ t y ^ t \hat{y}_t y ^ t
可用梯度下降学习RNN中的参数。以随机梯度下降为例。给定样本 ( x , y ) (\pmb{x}, \pmb{y}) ( x x x , y y y ) x 1 : T = ( x 1 , x 2 , . . . , x T ) \pmb{x}_{1:T} = (\pmb{x_1}, \pmb{x_2}, ..., \pmb{x_T}) x x x 1 : T = ( x 1 x 1 x 1 , x 2 x 2 x 2 , . . . , x T x T x T ) y 1 : T = ( y 1 , y 2 , . . . , x T ) \pmb{y}_{1:T} = (\pmb{y_1}, \pmb{y_2}, ... ,\pmb{x_T}) y y y 1 : T = ( y 1 y 1 y 1 , y 2 y 2 y 2 , . . . , x T x T x T ) y t y_t y t
L t = L ( y t , g ( h t ) )
L_t = L(y_t, g(\pmb{h}_t))
L t = L ( y t , g ( h h h t ) )
其中 g ( h t ) g(\pmb{h}_t) g ( h h h t )
L t = ∑ t = 1 T L t
L_t = \sum_{t=1}^{T}{L_t}
L t = t = 1 ∑ T L t
整个序列的损失函数 L 为关于参数 U 的梯度为每个时刻损失 L_t 对参数U的偏导数之和：
∂ L ∂ U = ∑ t = 1 T ∂ L t ∂ U
\frac{\partial{L}}{\partial{\pmb{U}}} = \sum_{t=1}^{T}\frac{\partial{L}_t}{\partial{\pmb{U}}}
∂ U U U ∂ L = t = 1 ∑ T ∂ U U U ∂ L t
RNN中存在提个递归调用的 f ( ⋅ ) f(\cdot) f ( ⋅ ) 随时间反向传播 （BPTT）算法和实时循环学习 （RTRL）算法.
随时间反向传播 算法类似前馈网络的错误反向传播算法 。
计算偏导数∂ L ∂ U \frac{\partial{L}}{\partial{\pmb{U}}} ∂ U U U ∂ L 先计算时刻 t 的损失对参数U的偏导 ∂ L ∂ U \frac{\partial{L}}{\partial{\pmb{U}}} ∂ U U U ∂ L z k = U h k − 1 + W x k + b \pmb{z}_k = \pmb{Uh}_{k-1} + \pmb{Wx_k} + b z z z k = U h U h U h k − 1 + W x k W x k W x k + b L t L_t L t u i j u_{ij} u i j ∂ + z k ∂ u i j \frac{\partial^{+}z_k}{\partial{\pmb{u}_{ij}}} ∂ u u u i j ∂ + z k 直接偏导数 即 z k = U h k − 1 + W x k + b \pmb{z}_k = \pmb{Uh}_{k-1} + \pmb{Wx}_k + b z z z k = U h U h U h k − 1 + W x W x W x k + b h k − 1 \pmb{h}_{k-1} h h h k − 1 u i j u_{ij} u i j [ h k − 1 ] j [\pmb{h}_{k-1}]_j [ h h h k − 1 ] j I i ( x ) \mathbb{I}_i(x) I i ( x ) z k \pmb{z}_k z z z k 1 ≤ k ≤ t 1 \leq k \leq t 1 ≤ k ≤ t 参数梯度 得到整个序列的损失函数 L 关于参数 U、权重W、偏置b 的梯度：计算复杂度 在BPTT 算法中，参数的梯度需要在一个完整的“前向”计算和“反向”计算后才能得到并进行参数更新。
与反向传播的BPTT不同，实时循环学习 （Real-Time Recurrent earning，RTRL）是通过前向传播的方式来计算梯度。t + 1 t+1 t + 1 h t + 1 \pmb{h}_{t+1} h h h t + 1 u i j u_{ij} u i j ∂ h 1 ∂ u i j \frac{\partial h_1}{\partial{\pmb{u}_{ij}}} ∂ u u u i j ∂ h 1 ∂ h 2 ∂ u i j \frac{\partial h_2}{\partial{\pmb{u}_{ij}}} ∂ u u u i j ∂ h 2 ∂ h 3 ∂ u i j \frac{\partial h_3}{\partial{\pmb{u}_{ij}}} ∂ u u u i j ∂ h 3 W W W b b b
RTRL和BPTT算法比较 两者都是基于梯度下降算法，分别通过前向模式和后向模式利用链式法则计算梯度。RNN中，一般网络输出维数原低于输入维度，因此BPTT算法计算量更小，但要保存所有时刻的中间梯度，空间复杂度高。RTRL不需要梯度回传，适合在线学习和无限序列任务。
RNN在学习过程中主要的问题是梯度消失或梯度爆炸。很难建模长时间间隔 的状态之间的依赖关系。误差项 展开：γ > 1 \gamma > 1 γ > 1 t − k → ∞ t-k \rightarrow \infty t − k → ∞ γ t − k → ∞ \gamma^{t-k} \rightarrow \infty γ t − k → ∞ t − k t - k t − k γ < 1 \gamma < 1 γ < 1 t − k → ∞ t-k \rightarrow \infty t − k → ∞ γ t − k → 0 \gamma^{t-k} \rightarrow 0 γ t − k → 0 t − k t - k t − k ∣ ∣ U ∣ ∣ ||\pmb{U}|| ∣ ∣ U U U ∣ ∣ t − k t - k t − k δ t , k \delta_{t,k} δ t , k y t y_t y t x k \pmb{x}_k x x x k t − k t-k t − k 长程依赖问题 。
为避免梯度爆炸或梯度消失，一种直接方式：选取合适参数 ，使用非饱和激活函数 ，尽量使 d i a g ( f ′ ( z ) ) U T ≈ 1 diag(f^{'}(\pmb{z})) \pmb{U}^T \approx1 d i a g ( f ′ ( z z z ) ) U U U T ≈ 1 模型 或优化方法 。
梯度爆炸 RNN的梯度爆炸更易解决，常通过权重衰减 或梯度截断 。权重衰减 通过给参数增加 l 1 l1 l 1 l 2 l2 l 2 γ ≤ 1 \gamma \leq 1 γ ≤ 1
梯度消失 RNN的主要问题。解决方式：一是用优化技巧；二是改变模型（更有效），如让 U = I \pmb{U} = \pmb{I} U U U = I I I ∂ h t ∂ h t − 1 = I \frac{\partial \pmb{h}_t}{\partial \pmb{h}_{t-1}} = \pmb{I} ∂ h h h t − 1 ∂ h h h t = I I I
h t = h t − 1 + g ( x t ; θ )
\pmb{h}_t = \pmb{h}_{t-1} + g(\pmb{x}_t; \theta)
h h h t = h h h t − 1 + g ( x x x t ; θ )
其中 h t h_t h t h t − 1 h_{t-1} h t − 1
h t = h t − 1 + g ( x t , h t − 1 ; θ )
\pmb{h}_t = \pmb{h}_{t-1} + g(\pmb{x}_t, \pmb{h}_{t-1}; \theta)
h h h t = h h h t − 1 + g ( x x x t , h h h t − 1 ; θ )
这样 h t h_t h t h t − 1 h_{t-1} h t − 1
梯度爆炸：令 z k = U h k − 1 + U x k + b \pmb{z}_k = \pmb{Uh}_{k-1} + \pmb{Ux}_k + \pmb{b} z z z k = U h U h U h k − 1 + U x Ux U x k + b b b k k k g ( ⋅ ) g(\cdot) g ( ⋅ )
记忆容量：随着 h t \pmb{h}_t h h h t g ( ⋅ ) g(\cdot) g ( ⋅ ) h t \pmb{h}_t h h h t h \pmb{h} h h h h t \pmb{h}_t h h h t 门控机制 改进模型，解决这两个问题。
为改善RNN的长程依赖问题 ，在公式：
h t = h t − 1 + g ( x t , h t − 1 ; θ )
\pmb{h}_t = \pmb{h}_{t-1} + g(\pmb{x}_t, \pmb{h}_{t-1}; \theta)
h h h t = h h h t − 1 + g ( x x x t , h h h t − 1 ; θ )
上引入门控机制 来控制信息积累速度，包括有选择地加入新的信息，并有选择地遗忘之前累积的信息。这类网络叫做 基于门控的循环神经网络 （Gated RNN）。
长短期记忆网络（Long Short-Term Memory Network，LSTM）是RNN的一变体，可有效解决RNN的梯度爆炸或梯度消失问题。在以下公式上，进行两方面的改进：
h t = h t − 1 + g ( x t , h t − 1 ; θ )
\pmb{h}_t = \pmb{h}_{t-1} + g(\pmb{x}_t, \pmb{h}_{t-1}; \theta)
h h h t = h h h t − 1 + g ( x x x t , h h h t − 1 ; θ )
新的内部状态 LSTM引入新的内部状态 （internal state）c t ∈ R D \pmb{c}_t \in \mathbb{R}^D c c c t ∈ R D h t ∈ R D \pmb{h}_t \in \mathbb{R}^D h h h t ∈ R D c t \pmb{c}_t c c c t f t ∈ [ 0 , 1 ] D \pmb{f}_t \in [0,1]^D f f f t ∈ [ 0 , 1 ] D i t ∈ [ 0 , 1 ] D \pmb{i}_t \in [0,1]^D i i i t ∈ [ 0 , 1 ] D o t ∈ [ 0 , 1 ] D \pmb{o}_t \in [0,1]^D o o o t ∈ [ 0 , 1 ] D ⨀ \bigodot ⨀ c t − 1 \pmb{c}_{t-1} c c c t − 1 c ^ t ∈ R D \hat{\pmb{c}}_t \in \mathbb{R}^D c c c ^ t ∈ R D 候选状态 ：c t \pmb{c}_t c c c t
门控机制 数字电路中，门为二值变量 {0，1}，0代表关闭，不需信息通过。LSTM引入门控机制 （Gating Mechanism），控制信息传递的路径。公式：f t ∈ [ 0 , 1 ] D \pmb{f}_t \in [0,1]^D f f f t ∈ [ 0 , 1 ] D i t ∈ [ 0 , 1 ] D \pmb{i}_t \in [0,1]^D i i i t ∈ [ 0 , 1 ] D o t ∈ [ 0 , 1 ] D \pmb{o}_t \in [0,1]^D o o o t ∈ [ 0 , 1 ] D
f t ∈ [ 0 , 1 ] D \pmb{f}_t \in [0,1]^D f f f t ∈ [ 0 , 1 ] D c t − 1 \pmb{c}_{t-1} c c c t − 1 i t ∈ [ 0 , 1 ] D \pmb{i}_t \in [0,1]^D i i i t ∈ [ 0 , 1 ] D c ^ t \hat{\pmb{c}}_t c c c ^ t o t ∈ [ 0 , 1 ] D \pmb{o}_t \in [0,1]^D o o o t ∈ [ 0 , 1 ] D c t \pmb{c}_t c c c t h t \pmb{h}_t h h h t
当 f t = 0 ， i t = 1 \pmb{f}_t = 0，\pmb{i}_t = 1 f f f t = 0 ， i i i t = 1 c t \pmb{c}_t c c c t f t = 1 ， i t = 0 \pmb{f}_t = 1，\pmb{i}_t = 0 f f f t = 1 ， i i i t = 0 σ ( ⋅ ) \sigma(\cdot) σ ( ⋅ ) x t \pmb{x}_t x x x t h t − 1 \pmb{h}_{t-1} h h h t − 1
LSTM的循环单元结构如图：
利用上一时刻的外部状态 h t − 1 \pmb{h}_{t-1} h h h t − 1 x t \pmb{x}_t x x x t f t \pmb{f}_t f f f t i t \pmb{i}_t i i i t o t \pmb{o}_t o o o t c ^ t \pmb{\hat{c}}_t c ^ c ^ c ^ t
结合遗忘门 f t \pmb{f}_t f f f t i t \pmb{i}_t i i i t c t \pmb{c}_t c c c t
结合输出门 o t \pmb{o}_t o o o t h t \pmb{h}_{t} h h h t
通过LSTM循环单元，整个网络可以建立较长距离的时序依赖关系。给出以上LSTM循环单元公式的简洁描述：x t ∈ R M \pmb{x}_t \in \mathbb{R}^M x x x t ∈ R M W ∈ R 4 D × ( D + M ) \pmb{W} \in \mathbb{R}^{4D \times (D+M)} W W W ∈ R 4 D × ( D + M ) b ∈ R 4 D \pmb{b} \in \mathbb{R}^{4D} b b b ∈ R 4 D
记忆 循环神经网络的隐状态 h h h 记忆 。h h h 短期记忆 （Short-Term Memory）。长期记忆 （Long-Term Memory）可看做是网络参数，隐含从训练数据中学到的经验，更新周期远慢于短期记忆 。c c c c c c 短期记忆 h h h 长期记忆 ，因此称为长短期记忆 （Long Short-Term Memory）。
主流的LSTM用三个门动态控制内部状态 ，遗忘 历史信息、输出 信息、输入 信息的数量。对门控机制 修改，得到LSTM变体。
无遗忘门的LSTM 最早的LSTM是没有遗忘门的，内部状态的更新为：c c c
peephole 连接 三种门不但依赖于输入 x t \pmb{x}_t x x x t h t − 1 \pmb{h}_{t-1} h h h t − 1 c t − 1 \pmb{c}_{t-1} c c c t − 1 V i 、 V f 、 V o \pmb{V}_i、\pmb{V}_f、\pmb{V}_o V V V i 、 V V V f 、 V V V o
耦合输入门和遗忘门 LSTM的输入门和输出门有些互补关系，同时使用两个门较冗余，为减少LSTM的计算复杂度，将输入门输出门合并，令 f t = 1 − i t \pmb{f}_t = 1 - \pmb{i}_t f f f t = 1 − i i i t
门控循环单元 （Gated Recurrent Unit，GRU）网络比LSTM更简单。
h t = h t − 1 + g ( x t , h t − 1 ; θ )
\pmb{h}_t = \pmb{h}_{t-1} + g(\pmb{x}_t, \pmb{h}_{t-1}; \theta)
h h h t = h h h t − 1 + g ( x x x t , h h h t − 1 ; θ )
上，引入一个更新门 控制当前状态需从历史状态中保留多少信息，需从候选状态中接受多少新信息：
h t = z t ⨀ h t − 1 + ( 1 − z t ) ⨀ g ( x t , h t − 1 ; θ ) z t = σ ( W z x t + U z h t − 1 + b z )
\pmb{h}_t = \pmb{z}_t \bigodot \pmb{h}_{t-1} + (1-\pmb{z}_t) \bigodot g(\pmb{x}_t, \pmb{h}_{t-1}; \theta) \\
\pmb{z}_t = \sigma(\pmb{W}_z \pmb{x}_t + \pmb{U}_z \pmb{h}_{t-1} + \pmb{b}_z)
h h h t = z z z t ⨀ h h h t − 1 + ( 1 − z z z t ) ⨀ g ( x x x t , h h h t − 1 ; θ ) z z z t = σ ( W W W z x x x t + U U U z h h h t − 1 + b b b z )
其中 z t ∈ [ 0 , 1 ] D \pmb{z}_t \in [0,1]^D z z z t ∈ [ 0 , 1 ] D
当 z t = 0 \pmb{z}_t = 0 z z z t = 0 h t \pmb{h}_t h h h t h t − 1 \pmb{h}_{t-1} h h h t − 1
当 z t = 1 \pmb{z}_t = 1 z z z t = 1 h t \pmb{h}_t h h h t h t − 1 \pmb{h}_{t-1} h h h t − 1
在GRU中，函数 g ( x t , h t − 1 ; θ ) g(\pmb{x}_t, \pmb{h}_{t-1}; \theta) g ( x x x t , h h h t − 1 ; θ )
其中 h ^ t \pmb{\hat{h}_t} h ^ t h ^ t h ^ t r t ∈ [ 0 , 1 ] D \pmb{r}_t \in [0,1]^D r r r t ∈ [ 0 , 1 ] D
用来控制候选状态 h ^ t \pmb{\hat{h}_t} h ^ t h ^ t h ^ t h t − 1 \pmb{h}_{t-1} h h h t − 1
r t = 0 \pmb{r}_t = 0 r r r t = 0 h ^ t = t a n h ( W c x t + b ) \pmb{\hat{h}_t} = tanh(\pmb{W}_c\pmb{x}_t + \pmb{b} ) h ^ t h ^ t h ^ t = t a n h ( W W W c x x x t + b b b ) x t \pmb{x}_t x x x t r t = 1 \pmb{r}_t = 1 r r r t = 1 h ^ t = t a n h ( W c x t + U h h t − 1 + b ) \pmb{\hat{h}_t} = tanh(\pmb{W}_c\pmb{x}_t + \pmb{U}_h\pmb{h}_{t-1} +\pmb{b} ) h ^ t h ^ t h ^ t = t a n h ( W W W c x x x t + U U U h h h h t − 1 + b b b ) x t \pmb{x}_t x x x t h t − 1 \pmb{h}_{t-1} h h h t − 1
综上，GRU网络的状态更新方式为：
h t = z t ⨀ h t − 1 + ( 1 − z t ) ⨀ h ^ t
\pmb{h}_t = \pmb{z}_t \bigodot \pmb{h}_{t-1} + (1-\pmb{z}_t) \bigodot \pmb{\hat{h}}_t
h h h t = z z z t ⨀ h h h t − 1 + ( 1 − z z z t ) ⨀ h ^ h ^ h ^ t
当 z t = 0 ， r = 1 \pmb{z}_t = 0，\pmb{r} = 1 z z z t = 0 ， r r r = 1
当 z t = 0 ， r = 0 \pmb{z}_t = 0，\pmb{r} = 0 z z z t = 0 ， r r r = 0 h t \pmb{h}_t h h h t x t \pmb{x}_t x x x t h t − 1 \pmb{h}_{t-1} h h h t − 1
当 z t = 1 \pmb{z}_t = 1 z z z t = 1 h t = h t − 1 \pmb{h}_{t} = \pmb{h}_{t-1} h h h t = h h h t − 1 x t \pmb{x}_t x x x t
GRU网络的循环单元结构：
如果将深度定义为网络中中信息传递路径长度的话，RNN可以看作是既“深”又“浅”的网络。因为，把RNN按时间展开，长时间间隔的状态之间的路径很长，RNN可以看作是一个非常深的网络；而果同一时刻网络输入到输出之间的路径x t → y t \pmb{x}_t → \pmb{y}_t x x x t → y y y t x t → y t \pmb{x}_t → \pmb{y}_t x x x t → y y y t h t → y t \pmb{h}_t → \pmb{y}_t h h h t → y y y t x t → h t \pmb{x}_t → \pmb{h}_t x x x t → h h h t
常见的简单做法，将多个RNN堆叠起来，称为堆叠循环神经网络 （Stacked Recurrent Neural Network，SRNN）。一个堆叠的简单循环网络(Stacked SRN) 也称为循环多层感知器（Recurrent Multi-Layer Perceptron，RMLP）。按时间展开的SRNN如下：l l l l − 1 l-1 l − 1 h t ( l ) \pmb{h}_t^{(l)} h h h t ( l ) t t t l l l
其中U ( l ) \pmb{U}^{(l)} U U U ( l ) W ( l ) \pmb{W}^{(l)} W W W ( l ) b ( l ) \pmb{b}^{(l)} b b b ( l ) h t ( 0 ) = x t \pmb{h}_t^{(0)} = \pmb{x}_t h h h t ( 0 ) = x x x t
特定任务中，一个时刻的输出不但和过去时刻的信息有关，也和后续时刻的信息有关。比如给定句子，其中一个词的词性由它的上下文决定。因此，在这些任务中，可以增加一个按时间的逆序来传递信息的网络层，以增强网络的能力。t t t h t ( 1 ) \pmb{h}_t^{(1)} h h h t ( 1 ) h t ( 2 ) \pmb{h}_t^{(2)} h h h t ( 2 ) ⨁ \bigoplus ⨁
如果将RNN按时间展开，每个时刻的隐状态h t \pmb{h}_t h h h t t t t
递归神经网络 （Recursive Neural Network，RecNN）是RNN在有向无循环图 上的拓展，常为树桩层次结构：h 1 \pmb{h}_1 h h h 1 h 2 \pmb{h}_2 h h h 2 h 3 \pmb{h}_3 h h h 3 h 1 \pmb{h}_1 h h h 1 x 1 \pmb{x}_1 x x x 1 x 2 \pmb{x}_2 x x x 2 h i \pmb{h}_i h h h i π i \pi_i π i
h i = f ( h π i )
\pmb{h}_i = f(\pmb{h}_{\pi_i})
h h h i = f ( h h h π i )
其中h π i \pmb{h}_{\pi_i} h h h π i π i \pi_i π i f f f 门控机制 来改进递归神经网络中的长距离依赖问题，比如树结构的长短期记忆模型 （Tree-Structured LSTM），就是将LSTM模型的思想应用到树结构的网络中，来实现更灵活的组合函数。
实际中很多数据是图结构的，比如知识图谱、社交网络、分子网络等。而前馈网络和反馈网络很难处理图结构的数据。图神经网络（Graph Neural Network，GNN）是将消息传递的思想扩展到图结构数据上的神经网络，可用来处理图数据。G ( V , ϵ ) G(V,\epsilon) G ( V , ϵ ) h ( v ) \pmb{h}^{(v)} h h h ( v ) x ( v ) \pmb{x}^{(v)} x x x ( v ) N ( v ) N(v) N ( v ) m t ( v ) \pmb{m}_t^{(v)} m m m t ( v ) e ( u , v ) \pmb{e}^{(u,v)} e e e ( u , v ) e ( u , v ) e^{(u,v)} e ( u , v ) 读出函数 g g g
