在前馈神经网络中，信息的传递是单向 的，这种限制虽然使得网络变得更容易学习，但在一定程度上也减弱了神经网络模型的能力。
在生物神经网络中，神经元之间的连接关系要复杂得多。前馈神经网络不能解决的两个问题：
前馈神经网络每次输入都是独立的，但是在很多现实任务中，网络的输入不仅和当前时刻的输入相关，也和其过去一段时间的输出相关 ；
前馈网络难以处理时序数据（比如视频、语音、文本等）。时序数据的长度一般是不固定的 ，而前馈神经网络要求输入和输出的维数都是固定的，不能任意改变。
因此，当处理这一类和时序数据相关的问题时，就需要一种能力更强的模型。
循环神经网络 （Recurrent Neural Network，RNN）是一类具有短期记忆能力 的神经网络。在循环神经网络中，神经元不但可以接受其他神经元的信息，也可以接受自身的信息 ，形成具有环路 的网络结构。
循环神经网络的参数学习可以通过随时间反向传播算法 来学习。随时间反向传播算法即按照时间的逆序将错误信息一步步地往前传递。当输入序列比较长时，会存在梯度爆炸和消失问题 ，也称为长程依赖问题 。为了解决这个问题，人们对循环神经网络进行了很多的改进，其中最有效的改进方式引入门控机制 （Gating Mechanism）。
此外，循环神经网络可以很容易地扩展到两种更广义的记忆网络模型：递归神经网络 和图网络 。
为了处理这些时序数据并利用其历史信息，我们需要让网络具有短期记忆能力。而前馈网络是一种静态网络，不具备这种记忆能力。
一般来讲，我们可以通过以下三种方法来给网络增加短期记忆能力。
一种简单的利用历史信息的方法是建立一个额外的延时单元，用来存储网络的历史信息（可以包括输入、输出、隐状态等）。比较有代表性的模型是延时神经网络 （Time Delay Neural Network，TDNN）。
延时神经网络是在前馈网络中的非输出层 都添加一个延时器 ，记录神经元的最近几次活性值。在第
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
)
)
,
h_t^{(l)}=f(h_t^{(l-1)},h_{t-1}^{(l-1)},\cdots,h_{t-K}^{(l-1)}),
h t ( l ) = f ( h t ( l − 1 ) , h t − 1 ( l − 1 ) , ⋯ , h t − K ( l − 1 ) ) ,
其中
h
t
(
l
)
∈
R
M
l
h_t^{(l)}\in\mathbb{R}^{M_l}
h t ( l ) ∈ R M l
l
l
l
t
t
t
M
l
M_l
M l
l
l
l
自回归模型 （AutoRegressive Model，AR）是统计学上常用的一类时间序列模型，用一个变量
y
t
y_t
y t
y
t
=
ω
0
+
∑
k
=
1
K
ω
k
y
t
−
k
+
ϵ
t
,
y_t=\omega_0+\sum_{k=1}^K\omega_k\textbf{y}_{t-k}+\epsilon_t,
y t = ω 0 + k = 1 ∑ K ω k y t − k + ϵ t ,
其中
K
K
K
ω
0
,
⋯
,
ω
K
\omega_0,\cdots,\omega_K
ω 0 , ⋯ , ω K
ϵ
t
∼
N
(
0
,
σ
2
)
\epsilon_t\sim N(0,\sigma^2)
ϵ t ∼ N ( 0 , σ 2 )
t
t
t
σ
2
\sigma^2
σ 2
有外部输入的非线性自回归模型 （Nonlinear AutoRegressive with Exoge-nous Inputs Model，NARX）是自回归模型的扩展，在每个时刻
t
t
t
x
t
x_t
x t
y
t
y_t
y t
K
x
K_x
K x
K
y
K_y
K y
t
t
t
y
t
y_t
y t
y
t
=
f
(
x
t
,
x
t
−
1
,
⋯
,
x
t
−
K
x
,
y
t
−
1
,
y
t
−
2
,
⋯
,
y
t
−
K
y
)
,
y_t=f(x_t,x_{t-1},\cdots,x_{t-K_x},y_{t-1},y_{t-2},\cdots,y_{t-K_y}),
y t = f ( x t , x t − 1 , ⋯ , x t − K x , y t − 1 , y t − 2 , ⋯ , 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
)
\textbf{x}_{1:T}=(\textbf{x}_1,\textbf{x}_2,\cdots,\textbf{x}_t,\cdots,\textbf{x}_T)
x 1 : T = ( x 1 , x 2 , ⋯ , x t , ⋯ , x T ) 带反馈边的隐藏层的活性值
h
t
\textbf{h}_t
h t
h
t
=
f
(
h
t
−
1
,
x
t
)
\textbf{h}_t=f(\textbf{h}_{t-1},\textbf{x}_t)
h t = f ( h t − 1 , x t )
其中
h
0
=
0
,
f
(
⋅
)
\textbf{h}_0=0,f(\cdot)
h 0 = 0 , f ( ⋅ )
从数学上讲，公式
h
t
=
f
(
h
t
−
1
,
x
t
)
\textbf{h}_t=f(\textbf{h}_{t-1},\textbf{x}_t)
h t = f ( h t − 1 , x t )
h
t
\textbf{h}_t
h t 状态 （State）或隐状态 （Hidden State）。理论上，循环神经网络可以近似任意的非线性动力系统。
简单循环网络（Simple Recurrent Network，SRN）是一个非常简单的循环神经网络，只有一个隐藏层的神经网络。在一个两层的前馈神经网络 中，连接存在相邻的层与层之间，隐藏层的节点之间是无连接的。而简单循环网络增加了从隐藏层到隐藏层的反馈连接。
令向量
x
t
∈
R
M
\textbf{x}_t\in\mathbb{R}^M
x t ∈ R M
t
t
t
h
t
∈
R
D
\textbf{h}_t\in\mathbb{R}^D
h t ∈ R D
h
t
\textbf{h}_t
h t
x
t
\textbf{x}_t
x t
h
t
−
1
\textbf{h}_{t-1}
h t − 1
t
t
t
z
t
=
U
h
t
−
1
+
W
x
t
+
b
h
t
=
f
(
z
t
)
\begin{aligned} \textbf{z}_t=&\ \textbf{U}\textbf{h}_{t-1}+\textbf{W}\textbf{x}_t+\textbf{b}\\ \textbf{h}_t=&\ f(\textbf{z}_t) \end{aligned}
z t = h t = U h t − 1 + W x t + b f ( z t )
其中
z
t
\textbf{z}_t
z t
U
∈
R
D
×
D
\textbf{U}\in\mathbb{R}^{D\times D}
U ∈ R D × D 状态-状态权重矩阵 ，
W
∈
R
D
×
M
\textbf{W}\in\mathbb{R}^{D\times M}
W ∈ R D × M 状态-输入权重矩阵 ，
b
∈
R
D
\textbf{b}\in\mathbb{R}^D
b ∈ R D 偏置向量 ，
f
(
⋅
)
f(\cdot)
f ( ⋅ ) 非线性激活函数 ，通常为
L
o
g
i
s
t
i
c
Logistic
L o g i s t i c
T
a
n
h
Tanh
T a n h
h
t
=
f
(
U
h
t
−
1
+
W
x
t
+
b
)
\textbf{h}_t=f(\textbf{U}\textbf{h}_{t-1}+\textbf{W}\textbf{x}_t+\textbf{b})
h t = f ( U h t − 1 + W x t + b )
如果我们把每个时刻的状态都看作是前馈神经网络的一层，循环神经网络可以看作是在时间维度上权值共享的神经网络。下图给出了按时间展开的循环神经网络。
解释：
由于循环神经网络具有短期记忆能力，相当于存储装置，因此其计算能力十分强大。前馈神经网络可以模拟任何连续函数，而循环神经网络可以模拟任何程序 。
我们先定义一个完全连接的循环神经网络，其输入为
x
t
\textbf{x}_t
x t
y
t
\textbf{y}_t
y t
h
t
=
f
(
U
h
t
−
1
+
W
x
t
+
b
)
y
t
=
V
h
t
\begin{aligned} \textbf{h}_t=&\ f(\textbf{U}\textbf{h}_{t-1}+\textbf{W}\textbf{x}_t+\textbf{b})\\ \textbf{y}_t=&\ \textbf{V}\textbf{h}_t \end{aligned}
h t = y t = f ( U h t − 1 + W x t + b ) V h t
其中
h
\textbf{h}
h
f
(
⋅
)
f(\cdot)
f ( ⋅ )
U
,
W
,
b
\textbf{U},\textbf{W},\textbf{b}
U , W , b
V
\textbf{V}
V
循环神经网络的拟合能力也十分强大。一个完全连接的循环网络是任何非线性动力系统的近似器。
图灵完备 （Turing Completeness）是指一种数据操作规则，比如一种计算机编程语言，可以实现图灵机（Turing Machine）的所有功能，解决所有的可计算问题。
目前主流的编程语言（比如 C++、Java、Python 等）都是图灵完备的。
循环神经网络可以应用到很多不同类型的机器学习任务。根据这些任务的特点可以分为以下几种模式：序列到类别模式、同步的序列到序列模式、异步的序列到序列模式。
序列到类别模式主要用于序列数据的分类 问题：输入为序列，输出为类别。
比如在文本分类中，输入数据为单词的序列，输出为该文本的类别。
假设一个样本
x
1
:
T
=
(
x
1
,
x
2
,
⋯
,
x
t
,
⋯
,
x
T
)
\textbf{x}_{1:T}=(\textbf{x}_1,\textbf{x}_2,\cdots,\textbf{x}_t,\cdots,\textbf{x}_T)
x 1 : T = ( x 1 , x 2 , ⋯ , x t , ⋯ , x T )
T
T
T
y
∈
{
1
,
2
,
⋯
,
C
}
y\in\{1,2,\cdots,C\}
y ∈ { 1 , 2 , ⋯ , C }
x
\textbf{x}
x
h
1
,
⋯
,
h
T
\textbf{h}_1,\cdots,\textbf{h}_T
h 1 , ⋯ , h T
h
T
\textbf{h}_T
h T
g
(
⋅
)
g(\cdot)
g ( ⋅ )
y
^
=
g
(
h
T
)
\hat{y}=g(\textbf{h}_T)
y ^ = g ( h T )
其中
g
(
⋅
)
g(\cdot)
g ( ⋅ )
除了将最后时刻的状态作为整个序列的表示之外，我们还可以对整个序列的所有状态进行平均，并用这个平均状态来作为整个序列的表示
y
^
=
g
(
1
T
∑
t
=
1
T
h
t
)
\hat{y}=g(\frac{1}{T}\sum_{t=1}^T\textbf{h}_t)
y ^ = g ( T 1 t = 1 ∑ T h t )
同步的序列到序列模式主要用于序列标注（Sequence Labeling）任务，即每一时刻都有输入和输出，输入序列和输出序列的长度相同 。比如在词性标注（Part-of-Speech Tagging）中，每一个单词都需要标注其对应的词性标签。
在同步的序列到序列模式(如图6.4所示)中，输入为一个长度为
T
T
T
x
1
:
T
=
(
x
1
,
x
2
,
⋯
,
x
t
,
⋯
,
x
T
)
\textbf{x}_{1:T}=(\textbf{x}_1,\textbf{x}_2,\cdots,\textbf{x}_t,\cdots,\textbf{x}_T)
x 1 : T = ( x 1 , x 2 , ⋯ , x t , ⋯ , x T )
y
1
:
T
=
(
y
1
,
y
2
,
⋯
,
y
t
,
⋯
,
y
T
)
y_{1:T}=(y_1,y_2,\cdots,y_t,\cdots,y_T)
y 1 : T = ( y 1 , y 2 , ⋯ , y t , ⋯ , y T )
x
\textbf{x}
x
h
1
,
⋯
,
h
T
\textbf{h}_1,\cdots,\textbf{h}_T
h 1 , ⋯ , h T
h
t
\textbf{h}_t
h t
g
(
⋅
)
g(\cdot)
g ( ⋅ )
y
^
\hat{y}
y ^
y
^
t
=
g
(
h
t
)
,
t
∈
[
1
,
T
]
\hat{y}_t=g(\textbf{h}_t),t\in[1,T]
y ^ t = g ( h t ) , t ∈ [ 1 , T ]
异步的序列到序列模式也称为编码器-解码器（Encoder-Decoder）模型，即输入序列和输出序列不需要有严格的对应关系，也不需要保持相同的长度 。
比如在机器翻译中，输入为源语言的单词序列，输出为目标语言的单词序列。
出为长度为
M
M
M
y
1
:
M
=
(
y
1
,
y
2
,
⋯
,
y
t
,
⋯
,
y
M
)
y_{1:M}=(y_1,y_2,\cdots,y_t,\cdots,y_M)
y 1 : M = ( y 1 , y 2 , ⋯ , y t , ⋯ , y M )
x
\textbf{x}
x
h
T
\textbf{h}_T
h T
y
^
1
:
M
\hat{y}_{1:M}
y ^ 1 : M 非线性的自回归模型 。
h
t
=
f
1
(
h
t
−
1
,
x
t
)
,
t
∈
[
1
,
T
]
h
T
+
t
=
f
2
(
h
T
+
t
−
1
,
y
^
t
−
1
)
,
t
∈
[
1
,
M
]
y
^
t
=
g
(
h
T
+
t
)
,
t
∈
[
1
,
M
]
\begin{aligned} \textbf{h}_t=&\ f_1(\textbf{h}_{t-1},\textbf{x}_t),t\in[1,T] \\ \textbf{h}_{T+t}=&\ f_2(\textbf{h}_{T+t-1},\hat{y}_{t-1}) ,t\in[1,M]\\ \hat{y}_t=&\ g(\textbf{h}_{T+t}),t\in[1,M] \end{aligned}
h t = h T + t = y ^ t = f 1 ( h t − 1 , x t ) , t ∈ [ 1 , T ] f 2 ( h T + t − 1 , y ^ t − 1 ) , t ∈ [ 1 , M ] g ( h T + t ) , t ∈ [ 1 , M ]
其中
f
1
(
⋅
)
f_1(\cdot)
f 1 ( ⋅ )
f
2
(
⋅
)
f_2(\cdot)
f 2 ( ⋅ )
g
(
⋅
)
g(\cdot)
g ( ⋅ )
y
^
t
\hat{y}_t
y ^ t
y
^
t
\hat{y}_t
y ^ t
循环神经网络的参数可以通过梯度下降方法来进行学习。
以随机梯度下降为例，给定一个训练样本
(
x
,
y
)
(\textbf{x},\textbf{y})
( x , y )
x
1
:
T
=
(
x
1
,
x
2
,
⋯
,
x
t
,
⋯
,
x
T
)
\textbf{x}_{1:T}=(\textbf{x}_1,\textbf{x}_2,\cdots,\textbf{x}_t,\cdots,\textbf{x}_T)
x 1 : T = ( x 1 , x 2 , ⋯ , x t , ⋯ , x T )
T
T
T
y
1
:
T
=
(
y
1
,
y
2
,
⋯
,
y
t
,
⋯
,
y
T
)
y_{1:T}=(y_1,y_2,\cdots,y_t,\cdots,y_T)
y 1 : T = ( y 1 , y 2 , ⋯ , y t , ⋯ , y T )
T
T
T
t
t
t
y
t
y_t
y t
t
t
t
L
t
=
L
(
y
t
,
g
(
h
t
)
)
\mathcal{L}_t=\mathcal{L}(y_t,g(\textbf{h}_t))
L t = L ( y t , g ( h t ) )
其中
g
(
h
t
)
g(\textbf{h}_t)
g ( h t )
t
t
t
L
\mathcal{L}
L
L
=
∑
t
=
1
T
L
t
\mathcal{L}=\sum_{t=1}^T\mathcal{L}_t
L = t = 1 ∑ T L t
整个序列的损失函数
L
\mathcal{L}
L
U
\textbf{U}
U
∂
L
∂
U
=
∑
t
=
1
T
∂
L
t
∂
U
\frac{\partial{\mathcal{L}}}{\partial{\textbf{U}}}=\sum_{t=1}^T\frac{\partial{\mathcal{L}_t}}{\partial{\textbf{U}}}
∂ U ∂ L = t = 1 ∑ T ∂ U ∂ L t
即每个时刻损失
L
t
\mathcal{L}_t
L t
U
\textbf{U}
U
循环神经网络中存在一个递归调用的函数
f
(
⋅
)
f(\cdot)
f ( ⋅ ) 随时间反向传播 （BPTT）算法和实时循环学习 （RTRL）算法。
随时间反向传播（BackPropagation Through Time，BPTT）算法的主要思想是通过类似前馈神经网络的错误反向传播 算法来计算梯度。
BPTT 算法将循环神经网络看作是一个展开的多层前馈网络，其中“每一层”对应循环网络中的“每个时刻”这样，如下图所示
循环神经网络就可以按照前馈网络中的反向传播算法计算参数梯度。在“展开”的前馈网络中，所有层的参数是共享的，因此参数的真实梯度是所有“展开层”的参数梯度之和。
介绍一个手动算的例子
与反向传播的 BPTT 算法不同的是，实时循环学习（Real-Time Recurrent Learning，RTRL）是通过前向传播 的方式来计算梯度。
两种算法比较 RTRL 算法和 BPTT 算法都是基于梯度下降的算法，分别通过前向模式和反向模式应用链式法则来计算梯度。在循环神经网络中，一般网络输出维度远低于输入维度，因此 BPTT 算法的计算量会更小，但是 BPTT 算法需要保存所有时刻的中间梯度 ，空间复杂度较高。RTRL 算法不需要梯度回传 ，因此非常适合用于需要在线学习或无限序列的任务中。
RTRL 算法和 BPTT 算法比较
BPTT 算法
RTRL 算法
反向模式应用链式法则来计算梯度
前向模式应用链式法则来计算梯度
BPTT 算法的计算量会更小，但是 BPTT 算法需要保存所有时刻的中间梯度，空间复杂度较高
RTRL 算法不需要梯度回传，因此非常适合用于需要在线学习或无限序列的任务中
z
1
=
U
h
0
+
W
x
1
+
b
=
[
−
1
0
2
1
]
⋅
[
1
2
]
+
[
1
2
3
4
5
6
]
⋅
[
1
0
0
]
+
[
−
2
2
]
=
[
−
2
10
]
\begin{aligned} z_1=&\ Uh_0+Wx_1+b \\ =&\ \begin{bmatrix}-1 & 0\\2 & 1\end{bmatrix}\cdot\begin{bmatrix}1\\2\end{bmatrix}+\begin{bmatrix}1 & 2 & 3\\4 & 5 & 6\end{bmatrix}\cdot\begin{bmatrix}1\\0\\0\end{bmatrix}+\begin{bmatrix}-2\\2\end{bmatrix}\\ =&\ \begin{bmatrix}-2\\10\end{bmatrix} \end{aligned}
z 1 = = = U h 0 + W x 1 + b [ − 1 2 0 1 ] ⋅ [ 1 2 ] + [ 1 4 2 5 3 6 ] ⋅ ⎣ ⎡ 1 0 0 ⎦ ⎤ + [ − 2 2 ] [ − 2 1 0 ]
h
1
=
R
e
l
u
(
z
1
)
=
[
0
10
]
h_1=Relu(z_1)=\ \begin{bmatrix}0\\10\end{bmatrix}
h 1 = R e l u ( z 1 ) = [ 0 1 0 ]
y
1
=
V
h
1
=
[
1
0
2
−
1
3
1
]
⋅
[
0
10
]
=
[
0
−
10
10
]
y_1=Vh_1=\begin{bmatrix}1 & 0\\2 & -1\\3 & 1\end{bmatrix}\cdot\begin{bmatrix}0\\10\end{bmatrix}=\begin{bmatrix}0\\-10\\10\end{bmatrix}
y 1 = V h 1 = ⎣ ⎡ 1 2 3 0 − 1 1 ⎦ ⎤ ⋅ [ 0 1 0 ] = ⎣ ⎡ 0 − 1 0 1 0 ⎦ ⎤
z
2
=
U
h
1
+
W
x
2
+
b
=
[
−
1
0
2
1
]
⋅
[
0
10
]
+
[
1
2
3
4
5
6
]
⋅
[
0
1
0
]
+
[
−
2
2
]
=
[
0
17
]
\begin{aligned}z_2=&\ Uh_1+Wx_2+b \\=&\ \begin{bmatrix}-1 & 0\\2 & 1\end{bmatrix}\cdot\begin{bmatrix}0\\10\end{bmatrix}+\begin{bmatrix}1 & 2 & 3\\4 & 5 & 6\end{bmatrix}\cdot\begin{bmatrix}0\\1\\0\end{bmatrix}+\begin{bmatrix}-2\\2\end{bmatrix}\\=&\ \begin{bmatrix}0\\17\end{bmatrix}\end{aligned}
z 2 = = = U h 1 + W x 2 + b [ − 1 2 0 1 ] ⋅ [ 0 1 0 ] + [ 1 4 2 5 3 6 ] ⋅ ⎣ ⎡ 0 1 0 ⎦ ⎤ + [ − 2 2 ] [ 0 1 7 ]
h
2
=
R
e
l
u
(
z
2
)
=
[
0
17
]
h_2=Relu(z_2)=\ \begin{bmatrix}0\\17\end{bmatrix}
h 2 = R e l u ( z 2 ) = [ 0 1 7 ]
y
2
=
V
h
2
=
[
1
0
2
−
1
3
1
]
⋅
[
0
17
]
=
[
0
−
17
17
]
y_2=Vh_2=\begin{bmatrix}1 & 0\\2 & -1\\3 & 1\end{bmatrix}\cdot\begin{bmatrix}0\\17\end{bmatrix}=\begin{bmatrix}0\\-17\\17\end{bmatrix}
y 2 = V h 2 = ⎣ ⎡ 1 2 3 0 − 1 1 ⎦ ⎤ ⋅ [ 0 1 7 ] = ⎣ ⎡ 0 − 1 7 1 7 ⎦ ⎤
循环神经网络在学习过程中的主要问题是由于梯度消失或爆炸问题，很难建模长时间间隔（Long Range）的状态之间的依赖关系。
虽然简单循环网络理论上可以建立长时间间隔的状态之间的依赖关系，但是由于梯度爆炸或消失问题，实际上只能学习到短期的依赖关系 。这样，如果时刻
t
t
t
y
t
y_t
y t
k
k
k
x
k
\textbf{x}_k
x k
t
−
k
t-k
t − k
为了避免梯度爆炸或消失问题，一种最直接的方式就是选取合适的参数，同时使用非饱和的激活函数 ，尽量使得
d
i
a
g
(
f
′
(
z
)
)
U
T
≈
1
diag(f'(\textbf{z}))\textbf{U}^T\approx1
d i a g ( f ′ ( z ) ) U T ≈ 1
一般而言，循环网络的梯度爆炸问题比较容易解决，一般通过权重衰减 或梯度截断 来避免。
权重衰减是通过给参数增加
l
1
l_1
l 1
l
2
l_2
l 2 正则化项 来限制参数的取值范围，从而使得
γ
≤
1
\gamma\leq1
γ ≤ 1
梯度截断是另一种有效的启发式方法，当梯度的模大于一定阈值时，就将它截断 成为一个较小的数。
梯度消失是循环网络的主要问题。除了使用一些优化技巧外，更有效的方式就是改变模型，比如让
U
=
I
\textbf{U}=\textbf{I}
U = I
∂
h
t
∂
h
t
−
1
=
I
\frac{\partial{\textbf{h}_t}}{\partial{\textbf{h}_{t-1}}}=\textbf{I}
∂ h t − 1 ∂ h t = I
h
t
=
h
t
−
1
+
g
(
x
t
;
θ
)
\textbf{h}_t=\textbf{h}_{t-1}+g(\textbf{x}_t;\theta)
h t = h t − 1 + g ( x t ; θ )
其中
g
(
⋅
)
g(\cdot)
g ( ⋅ )
θ
\theta
θ
上式中，
h
t
\textbf{h}_t
h t
h
t
−
1
\textbf{h}_{t-1}
h t − 1
为了避免这个缺点，我们可以采用一种更加有效的改进策略：
h
t
=
h
t
−
1
+
g
(
x
t
,
h
t
−
1
;
θ
)
\textbf{h}_t=\textbf{h}_{t-1}+g(\textbf{x}_t,\textbf{h}_{t-1};\theta)
h t = h t − 1 + g ( x t , h t − 1 ; θ )
这样
h
t
\textbf{h}_t
h t
h
t
−
1
\textbf{h}_{t-1}
h t − 1
