作者更新了?真的假的?

循环神经网络(Recurrent Neural Network,RNN)是深度学习发展历程中非常重要的一类神经网络。它不仅推动了自然语言处理、语音识别、时间序列预测等领域的发展,也为后来的 LSTM、GRU、Seq2Seq、Attention,乃至 Transformer 的诞生提供了重要的研究基础。

如果说 CNN(卷积神经网络)解决的核心问题是如何从具有空间结构的数据中提取特征,那么 RNN 试图解决的核心问题就是:

如何让神经网络处理具有时间顺序或前后依赖关系的数据,并利用过去的信息理解当前输入?

一、Motivation

1.1 从普通神经网络的局限开始

在学习 RNN 之前,我们通常已经接触过全连接神经网络(MLP)和卷积神经网络(CNN)。

假设我们要预测一个句子中的下一个词:

今天的天气非常____。

人类可以根据前面的语义推断,空格里很可能是“好”、“热”、“冷”。

但是,如果采用最简单的前馈神经网络,每次只输入一个词,网络就无法自动利用此前处理过的词的信息。

例如,模型在处理“非常”时,已经无法直接知道前面出现过“今天”“天气”。这些历史信息不能一起处理,就像鱼的记忆一样,看了就忘。这也体现了传统前馈网络处理序列数据时的一个核心局限:缺乏能够跨时间步持续传递的信息状态。

当然,我们也可以把整个句子一次性输入 MLP,但这会带来新问题:

  • 不同句子的长度不一样,输入维度不好统一。
  • 直接拼接输入不容易高效共享不同位置上的处理规则。
  • 难以自然地处理逐个到达的实时数据。
  • 当序列很长时,需要建模复杂的跨位置依赖关系。

于是,你作为聪明的研究者,你提出了这样的想法:能否让神经网络拥有一个不断更新的内部状态,用于保存此前处理过的信息?

想法合理,那我们便开始构建思路!

1.2 引入记忆状态

分析一下,我们人是怎么处理信息的呢?在处理上述预测句子中的下一个词的任务时,我们不由自主地提取出关键信息“今天”、”天气”等词作为重要前提。我们也希望神经网络也能有类似这样的一个步骤,以此来模仿我们人,所以我们引入了记忆状态。

普通前馈神经网络的输出可写为:

y=f(Wx+b)(1) y=f(Wx+b) \tag{1}

它的输出主要取决于当前输入 xx。

而我们给设计的新神经网络引入一个隐藏状态(Hidden State),用 hth_t 表示:

ht=f(Wxhxt+Whhht−1+bh)(2) {h_t=f(W_{xh}x_t+W_{hh}h_{t-1}+b_h)} \tag{2}

这里:

  • xtx_t:当前时间步的输入。
  • ht−1h_{t-1}:上一时间步的隐藏状态。
  • hth_t:当前更新后的隐藏状态。
  • WxhW_{xh}:输入到隐藏状态的权重矩阵。
  • WhhW_{hh}:上一隐藏状态到当前隐藏状态的循环权重矩阵。
  • bhb_h:偏置。
  • ff:非线性激活函数,传统 RNN 常使用 tanh⁡\tanh。

和 MLP 相比,最大的区别是增加了 ht−1h_{t-1}。

这意味着:

当前状态=f(当前输入贡献+历史状态贡献+偏置) \boxed{\text{当前状态}=f(\text{当前输入贡献}+\text{历史状态贡献}+\text{偏置})}

1.3 RNN 的结构示意

RNN 基本框架与时间展开

RNN 按时间展开:每一步接收当前输入,并将隐藏状态传递给下一步。图中的 yty_t 表示该步可计算的输出;部分任务只使用最后一步的输出。

可以把 RNN 想象成一个正在阅读文章的人:

第一步读到“今天”,形成状态 h1h_1;第二步读到“天气”,结合 h1h_1 更新得到 h2h_2;第三步读到“非常”,再结合 h2h_2 得到 h3h_3。

因此,h3h_3 不只依赖第三个词,还通过递归计算间接依赖前面的词。

但是在这里,我们思考一下:RNN 有传递历史信息的机制,它能够完整、准确地记住全部历史吗?


二、循环神经网络的发展历史

RNN 技术发展时间线

  1. 1982 年:Hopfield 网络

    John Hopfield 提出具有循环连接的神经网络,推动了神经网络动态系统与联想记忆的研究。它不是今天常用的序列 RNN,但属于重要的早期背景。

  2. 1986—1990 年:RNN 与 BPTT 逐步成型

    循环网络的训练研究不断发展。1986 年的反向传播研究及 1990 年 Werbos 对时间反向传播的系统论述,为 RNN 的训练奠定基础。Elman 在 1990 年发表的工作成为简单循环网络的经典代表。

  3. 1991 年:长期依赖问题受到系统关注

    Bengio 等人在此后的研究中进一步揭示了使用梯度学习长期依赖的困难,尤其是梯度消失和梯度爆炸。

  4. 1997 年:LSTM 诞生

    Hochreiter 与 Schmidhuber 提出 Long Short-Term Memory,通过专门的记忆结构缓解长距离依赖的学习困难。

  5. 2014 年:GRU、Seq2Seq 与注意力机制兴起

    GRU 使用更加紧凑的门控机制。Encoder-Decoder 结构广泛应用于序列转换任务,注意力机制开始缓解固定长度上下文向量的限制。

  6. 2017 年:Transformer 发布

    论文 Attention Is All You Need 提出以自注意力为核心的模型架构,在许多序列建模任务中逐步取代传统循环结构。

  7. 2023 年以来:现代状态空间模型兴起

    Mamba 等架构重新探索通过状态递推与高效计算来建模长序列,为 RNN 思想提供了新的发展方向。

RNN 的发展史可以归纳为三个不断被研究的问题:

  1. 如何保存历史信息? —— RNN 引入隐藏状态,LSTM 和 GRU 改进记忆机制。
  2. 如何学习很长距离的依赖? —— 门控机制与 Attention 逐步改善信息传播。
  3. 如何高效处理长序列? —— Transformer、现代状态空间模型采用不同的计算与建模策略。

三、RNN 的数学原理与前向传播

又到了最头疼但是也最令人兴奋的环节!

3.1 定义输入序列

假设有一个长度为 TT 的序列:

X=(x1,x2,…,xT)(3) X=(x_1,x_2,\ldots,x_T) \tag{3}

例如,我们利用过去 5 天的温度预测未来温度:

X=(22,23,21,25,24) X=(22,23,21,25,24)

每一个 xtx_t 代表一个时间步的数据。

实际应用中,xtx_t 通常不只是一个数字,而是一个向量:

xt∈Rdx(4) x_t\in\mathbb R^{d_x} \tag{4}

如果我们使用传感器测量机器人的状态,那么某一时刻的输入可能包含:

xt=[vtωtθtat] x_t= \begin{bmatrix} v_t\\ \omega_t\\ \theta_t\\ a_t \end{bmatrix}

分别表示线速度、角速度、姿态角和加速度。

因此,RNN 不仅能处理文字,还能处理任意具有时间顺序的特征向量序列。

3.2 隐藏状态的计算

为方便推导,我们先定义中间变量:

at=Wxhxt+Whhht−1+bh(5) a_t=W_{xh}x_t+W_{hh}h_{t-1}+b_h \tag{5}

然后经过激活函数:

ht=tanh⁡(at)(6) {h_t=\tanh(a_t)} \tag{6}

这里假设:

xt∈Rdxht∈RdhWxh∈Rdh×dxWhh∈Rdh×dhbh∈Rdh(7) \begin{aligned} x_t&\in\mathbb R^{d_x}\\ h_t&\in\mathbb R^{d_h}\\ W_{xh}&\in\mathbb R^{d_h\times d_x}\\ W_{hh}&\in\mathbb R^{d_h\times d_h}\\ b_h&\in\mathbb R^{d_h} \end{aligned} \tag{7}

其中 dxd_x 是输入特征维度,dhd_h 是隐藏状态维度。

观察一下 WhhW_{hh}:它是一个方阵,因为它将上一时间步的隐藏状态映射到当前时间步的隐藏空间。

3.3 tanh 激活函数

传统 RNN 通常使用双曲正切函数:

tanh⁡(x)=ex−e−xex+e−x(8) \tanh(x)=\frac{e^x-e^{-x}}{e^x+e^{-x}} \tag{8}

tanh 与 sigmoid 的静态对照

tanh 与 sigmoid 激活函数对照

tanh 的主要特点是输出以 0 为中心,而且可以表达正、负的隐藏特征。

它的导数是:

tanh⁡′(x)=1−tanh⁡2(x)(9) {\tanh'(x)=1-\tanh^2(x)} \tag{9}

这个公式非常重要,因为后续分析梯度消失时会用到它。

3.4 从第一个时间步推导到第三个时间步

初始隐藏状态通常设为:

h0=0(10) h_0=\mathbf 0 \tag{10}

第一个时间步:

h1=tanh⁡(Wxhx1+Whhh0+bh)(11) h_1=\tanh(W_{xh}x_1+W_{hh}h_0+b_h) \tag{11}

第二个时间步:

h2=tanh⁡(Wxhx2+Whhh1+bh)(12) h_2=\tanh(W_{xh}x_2+W_{hh}h_1+b_h) \tag{12}

把式 (11) 代入式 (12),得到:

h2=tanh⁡(Wxhx2+Whhtanh⁡(Wxhx1+bh)+bh)(13) h_2=\tanh\left( W_{xh}x_2+ W_{hh}\tanh(W_{xh}x_1+b_h)+b_h \right) \tag{13}

第三个时间步:

h3=tanh⁡(Wxhx3+Whhh2+bh)(14) h_3=\tanh(W_{xh}x_3+W_{hh}h_2+b_h) \tag{14}

由此可见:

h3=F(x1,x2,x3;h0,θ)(15) h_3=F(x_1,x_2,x_3;h_0,\theta) \tag{15}

也就是说,第三个时间步的隐藏状态是之前所有输入经过递归计算后的函数。一般而言,hth_t 通过递推依赖于 x1,…,xtx_1,\ldots,x_t,因此能够携带历史信息;但隐藏状态是压缩后的表示,并不保证完整保存或恢复每个历史输入。

这里有一个需要特别理解的知识点:RNN 并不需要给每个时间步分别设计一组权重。

从 t=1t=1 到 t=Tt=T,使用的是同一组参数:

Wxh,Whh,bh W_{xh},\quad W_{hh},\quad b_h

这叫做时间维度上的参数共享(Parameter Sharing)。

例如,一个隐藏维度为 128 的 RNN,即使输入序列从 10 个时间步变成 100 个时间步,也不会因此产生 10 倍的模型参数。变化的是计算次数和需要处理的中间状态数量,而不是循环单元自身的参数数量。

3.5 输出是如何计算的?

隐藏状态不是最终预测结果。通常还需要一个输出层:

ot=Whyht+by(16) o_t=W_{hy}h_t+b_y \tag{16}

如果任务是分类,可以接 softmax:

y^t,k=eot,k∑j=1Keot,j(17) \hat y_{t,k}= \frac{e^{o_{t,k}}} {\sum_{j=1}^{K}e^{o_{t,j}}} \tag{17}

其中 KK 表示类别数。

到这里,一个最基础的 RNN 单元就完整了:

ht=tanh⁡(Wxhxt+Whhht−1+bh)ot=Whyht+byy^t=softmax⁡(ot)(18) \boxed{ \begin{aligned} h_t&=\tanh(W_{xh}x_t+W_{hh}h_{t-1}+b_h)\\ o_t&=W_{hy}h_t+b_y\\ \hat y_t&=\operatorname{softmax}(o_t) \end{aligned} } \tag{18}

3.6 手算一个简单 RNN

下面我们用最简单的标量 RNN,真正计算一次前向传播。计算时保留中间结果的完整精度,展示时四舍五入到小数点后四位。

设定:

ht=tanh⁡(0.5xt+0.8ht−1) h_t=\tanh(0.5x_t+0.8h_{t-1})

输入序列:

x1=1,x2=2,x3=1 x_1=1,\quad x_2=2,\quad x_3=1

初始状态:

h0=0 h_0=0

第一步:

h1=tanh⁡(0.5)≈0.4621 h_1=\tanh(0.5)\approx0.4621

第二步:

h2=tanh⁡(0.5×2+0.8h1)≈tanh⁡(1.3697)≈0.8786 \begin{aligned} h_2&=\tanh(0.5\times2+0.8h_1)\\ &\approx\tanh(1.3697)\\ &\approx0.8786 \end{aligned}

第三步:

h3=tanh⁡(0.5×1+0.8h2)≈tanh⁡(1.2029)≈0.8345 \begin{aligned} h_3&=\tanh(0.5\times1+0.8h_2)\\ &\approx\tanh(1.2029)\\ &\approx0.8345 \end{aligned}

RNN 如何积累历史信息?

原交互实验的循环权重 WhhW_{hh} 默认值为 0.80.8,可调范围为 [−1.5,1.5][-1.5,1.5],步长为 0.10.1。输入为 [1,2,1][1,2,1],输入权重为 0.50.5,初始状态为 h0=0h_0=0。以下给出三组固定参数的结果:

循环权重对三个时间步隐藏状态的影响

尝试把循环权重设置为 0,观察历史状态是否还会影响下一步;再尝试设置为负值,观察状态如何变化。

从这个实验可以发现,当前隐藏状态的数值不仅与 xtx_t 有关,也会随着 WhhW_{hh} 的变化而发生变化。

思考题:如果 Whh=0W_{hh}=0,那么这个网络还有跨时间步传递信息的能力吗?

答案是没有,因为此时:

ht=tanh⁡(Wxhxt+bh) h_t=\tanh(W_{xh}x_t+b_h)

每个时间步的隐藏状态仅依赖当前输入,已经退化为逐时间步共享参数的前馈计算。

四、RNN 如何训练:时间反向传播 BPTT

骗你的这一章也很头疼。

在 MLP 中,我们使用反向传播(Backpropagation)计算梯度;而在 RNN 中,由于参数在多个时间步重复使用,我们通常采用:

Backpropagation Through Time,BPTT,时间反向传播算法。

4.1 首先定义损失函数

以每个时间步都进行分类的任务为例。

假设模型在第 tt 步的预测为 y^t\hat y_t,真实标签为 yty_t。

可以定义交叉熵损失:

Lt=−∑k=1Kyt,klog⁡y^t,k(19) \mathcal L_t=-\sum_{k=1}^{K}y_{t,k}\log\hat y_{t,k} \tag{19}

总损失:

L=∑t=1TLt(20) \boxed{\mathcal L=\sum_{t=1}^{T}\mathcal L_t} \tag{20}

如果只在最后一个时间步进行一次分类,那么损失就可以写为:

L=LT \mathcal L=\mathcal L_T

需要注意,求和与取平均只差一个缩放系数,但会影响梯度大小和学习率选择。

4.2 为什么不能直接使用普通的单步反向传播?

我们看一条序列:

BPTT 的前向状态与反向梯度流向

假设只有最后一步存在损失 L4\mathcal L_4。

虽然损失在第 4 步产生,但它与之前的隐藏状态存在依赖:

L4→h4→h3→h2→h1 \mathcal L_4\rightarrow h_4\rightarrow h_3\rightarrow h_2\rightarrow h_1

因此,更新 WhhW_{hh} 时,不能只考虑第四步的直接贡献,还必须考虑它在前三个时间步对后续结果产生的间接影响。

4.3 使用链式法则推导梯度

我们先从最容易理解的情况入手:只有最后一个时间步存在损失。

与第五章保持一致,以下将隐藏状态及损失对隐藏状态的梯度均写成列向量。定义局部雅可比矩阵 Jt=∂ht∂ht−1J_t=\frac{\partial h_t}{\partial h_{t-1}},其维度为 dh×dhd_h\times d_h。

根据链式法则,反向传播使用雅可比矩阵的转置:

∂LT∂hT−1=(∂hT∂hT−1)T∂LT∂hT(21) \frac{\partial\mathcal L_T}{\partial h_{T-1}} = \left(\frac{\partial h_T}{\partial h_{T-1}}\right)^{\mathsf T} \frac{\partial\mathcal L_T}{\partial h_T} \tag{21}

类似地:

∂LT∂hT−2=(∂hT−1∂hT−2)T(∂hT∂hT−1)T∂LT∂hT(22) \frac{\partial\mathcal L_T}{\partial h_{T-2}} = \left(\frac{\partial h_{T-1}}{\partial h_{T-2}}\right)^{\mathsf T} \left(\frac{\partial h_T}{\partial h_{T-1}}\right)^{\mathsf T} \frac{\partial\mathcal L_T}{\partial h_T} \tag{22}

推广到任意时间步 k<Tk<T:

∂LT∂hk=Jk+1TJk+2T⋯JTT∂LT∂hT(23) \boxed{ \frac{\partial\mathcal L_T}{\partial h_k} = J_{k+1}^{\mathsf T}J_{k+2}^{\mathsf T}\cdots J_T^{\mathsf T} \frac{\partial\mathcal L_T}{\partial h_T} } \tag{23}

式 (23) 中的矩阵从左到右按时间索引递增排列;实际作用于最右侧梯度时,先乘 JTTJ_T^{\mathsf T},再逐步向更早的时间传播。矩阵乘法通常不可交换,不能随意颠倒顺序。

这里最关键的不是公式的长度,而是其中的连续相乘。

假设要让第 100 步的损失影响第 1 步,就需要连续经过 99 个时间步的梯度传播。

这正是梯度消失和梯度爆炸问题产生的根本原因。

4.4 推导 RNN 的局部梯度

隐藏状态更新:

ht=tanh⁡(at) h_t=\tanh(a_t)

其中:

at=Wxhxt+Whhht−1+bh a_t=W_{xh}x_t+W_{hh}h_{t-1}+b_h

定义对角矩阵:

Dt=diag⁡(1−ht2)(24) D_t=\operatorname{diag}(1-h_t^2) \tag{24}

根据链式法则:

∂ht∂ht−1=DtWhh(25) \boxed{ \frac{\partial h_t}{\partial h_{t-1}} =D_tW_{hh} } \tag{25}

它说明,隐藏状态的梯度传播由两个因素共同决定:

  • 激活函数的导数 DtD_t
  • 循环权重矩阵 WhhW_{hh}

在列向量梯度的约定下,反向传播对应使用雅可比矩阵的转置。

4.5 BPTT 的实际递推公式

前面只分析了最终损失。现在考虑每一步都有损失的情况。

定义:

δt=∂L∂at(26) \delta_t=\frac{\partial\mathcal L}{\partial a_t} \tag{26}

如果输出层为:

ot=Whyht+by o_t=W_{hy}h_t+b_y

则有:

δt=(WhyT∂Lt∂ot+WhhTδt+1)⊙(1−ht2)(27) \boxed{ \delta_t= \left( W_{hy}^{\mathsf T}\frac{\partial\mathcal L_t}{\partial o_t} + W_{hh}^{\mathsf T}\delta_{t+1} \right) \odot(1-h_t^2) } \tag{27}

其中 ⊙\odot 表示逐元素乘法,且设 δT+1=0\delta_{T+1}=0。

这是 BPTT 中非常核心的递推关系。

它分成两个部分:

第一部分:当前时间步的直接梯度

WhyT∂Lt∂ot W_{hy}^{\mathsf T}\frac{\partial\mathcal L_t}{\partial o_t}

当前预测产生误差,误差经过输出层传回隐藏层。

第二部分:未来时间步传回的梯度

WhhTδt+1 W_{hh}^{\mathsf T}\delta_{t+1}

由于当前隐藏状态会影响未来的隐藏状态,所以未来的损失也会影响当前参数。

最后与 tanh 的导数相乘,得到当前时间步的误差项。

进而得到参数梯度:

∂L∂Wxh=∑t=1TδtxtT(28) \boxed{ \frac{\partial\mathcal L}{\partial W_{xh}} =\sum_{t=1}^{T}\delta_tx_t^{\mathsf T} } \tag{28} ∂L∂Whh=∑t=1Tδtht−1T(29) \boxed{ \frac{\partial\mathcal L}{\partial W_{hh}} =\sum_{t=1}^{T}\delta_th_{t-1}^{\mathsf T} } \tag{29} ∂L∂bh=∑t=1Tδt(30) \frac{\partial\mathcal L}{\partial b_h} =\sum_{t=1}^{T}\delta_t \tag{30}

这也解释了为什么参数共享不意味着只更新一次贡献:同一组权重在所有时间步都参与计算,因此它的最终梯度需要汇总各个时间步的贡献。

五、BPTT公式推导

这一部分是 RNN 数学原理中最核心的内容之一,也是理解 LSTM、GRU 训练机制的基础。(害不害怕)

我们从最基础的反向传播出发,逐步推导 RNN 中每个梯度的来源,最后得到完整的 BPTT 递推公式。

尤其要解决以下几个问题:

  1. 为什么 BPTT 要从最后一个时间步向前计算?
  2. 为什么当前时间步的梯度由两部分相加?
  3. 为什么公式中会出现矩阵转置 WhhTW_{hh}^{\mathsf T}?
  4. 为什么还要乘上 1−ht21-h_t^2?
  5. 为什么参数梯度需要对所有时间步求和?
  6. BPTT 与普通神经网络的反向传播到底有什么不同?

读完后,你应该能够独立推导下面这个核心公式:

δt=(WhyT∂Lt∂ot+WhhTδt+1)⊙(1−ht2)(31) \boxed{ \delta_t= \left( W_{hy}^{\mathsf T} \frac{\partial\mathcal L_t}{\partial o_t} + W_{hh}^{\mathsf T}\delta_{t+1} \right) \odot(1-h_t^2) } \tag{31}

5.1 首先明确:BPTT 到底要计算什么?

假设输入序列为:

X=(x1,x2,…,xT) X=(x_1,x_2,\ldots,x_T)

RNN 在时间步 tt 的前向传播可以分成三步。

第一步:计算隐藏层的线性变换

at=Wxhxt+Whhht−1+bh(32) \boxed{ a_t=W_{xh}x_t+W_{hh}h_{t-1}+b_h } \tag{32}

第二步:计算隐藏状态

ht=tanh⁡(at)(33) \boxed{ h_t=\tanh(a_t) } \tag{33}

第三步:计算输出

ot=Whyht+by(34) \boxed{ o_t=W_{hy}h_t+b_y } \tag{34}

如果是分类任务,再通过 softmax 得到预测概率:

y^t=softmax⁡(ot)(35) \hat y_t=\operatorname{softmax}(o_t) \tag{35}

这里的 ata_t 和 oto_t 都是激活前的线性输出,而 hth_t 是经过非线性激活得到的隐藏状态。

为了后面的求导不产生歧义,我们统一采用列向量约定,并规定梯度与对应变量具有相同的形状。

符号 含义 维度
xtx_t 当前输入 dx×1d_x\times1
hth_t 当前隐藏状态 dh×1d_h\times1
ata_t 隐藏层激活前变量 dh×1d_h\times1
oto_t 输出层 logits dy×1d_y\times1
WxhW_{xh} 输入权重 dh×dxd_h\times d_x
WhhW_{hh} 循环权重 dh×dhd_h\times d_h
WhyW_{hy} 输出权重 dy×dhd_y\times d_h

假设每个时间步都有一个损失:

Lt=ℓ(ot,yt)(36) \mathcal L_t=\ell(o_t,y_t) \tag{36}

整条序列的总损失为:

L=∑t=1TLt(37) \boxed{ \mathcal L=\sum_{t=1}^{T}\mathcal L_t } \tag{37}

BPTT 的目标是计算:

∂L∂Wxh,∂L∂Whh,∂L∂Why \frac{\partial\mathcal L}{\partial W_{xh}}, \qquad \frac{\partial\mathcal L}{\partial W_{hh}}, \qquad \frac{\partial\mathcal L}{\partial W_{hy}}

以及各个偏置的梯度。

然后用梯度下降更新参数。例如:

Whh←Whh−η∂L∂Whh(38) W_{hh}\leftarrow W_{hh} -\eta\frac{\partial\mathcal L}{\partial W_{hh}} \tag{38}

这里 η\eta 是学习率。

关键问题:同一个 WhhW_{hh} 会在每一个时间步重复使用,所以它对总损失的影响不只来自一个时间步。

这就是 BPTT 要解决的问题。

5.2 RNN 的计算图

我们用一个长度为 3 的 RNN 序列来研究。

计算图的重点是:每个时间步产生损失,隐藏状态也会影响未来时间步。下方箭头表示前向依赖关系,梯度沿这些依赖关系的反方向传播。

这个计算图中存在两种不同的依赖。

第一种是当前损失直接依赖当前隐藏状态:

ht→ot→Lt h_t\rightarrow o_t\rightarrow\mathcal L_t

第二种是未来损失通过后续隐藏状态间接依赖当前隐藏状态:

ht→ht+1→ht+2→⋯ h_t\rightarrow h_{t+1}\rightarrow h_{t+2}\rightarrow\cdots

比如,h2h_2 不仅影响 L2\mathcal L_2,还会影响 h3h_3,进而影响 L3\mathcal L_3。

因此,总损失对 h2h_2 的梯度必须包含两个来源。

5.3 先不考虑时间递推:单个时间步怎么反向传播?

为了降低难度,我们先只分析当前时间步的损失 Lt\mathcal L_t 对隐藏状态的直接影响。

已知:

ot=Whyht+by o_t=W_{hy}h_t+b_y

以及:

Lt=ℓ(ot,yt) \mathcal L_t=\ell(o_t,y_t)

我们希望计算:

∂Lt∂ht \frac{\partial\mathcal L_t}{\partial h_t}

按照链式法则:(如果这步不理解的去补一下矩阵的导数,虽然后面也有,你可能看不懂)

∂Lt∂ht=(∂ot∂ht)T∂Lt∂ot(39) \frac{\partial\mathcal L_t}{\partial h_t} = \left( \frac{\partial o_t}{\partial h_t} \right)^{\mathsf T} \frac{\partial\mathcal L_t}{\partial o_t} \tag{39}

因为:

∂ot∂ht=Why \frac{\partial o_t}{\partial h_t}=W_{hy}

所以:

∂Lt∂ht=WhyT∂Lt∂ot(40) \boxed{ \frac{\partial\mathcal L_t}{\partial h_t} = W_{hy}^{\mathsf T} \frac{\partial\mathcal L_t}{\partial o_t} } \tag{40}

为什么是矩阵转置?

这涉及向量求导时的方向。

假设:

o=Wh o=Wh

其中:

W=[w11w12w21w22] W= \begin{bmatrix} w_{11}&w_{12}\\ w_{21}&w_{22} \end{bmatrix}

那么:

o1=w11h1+w12h2o2=w21h1+w22h2 \begin{aligned} o_1&=w_{11}h_1+w_{12}h_2\\ o_2&=w_{21}h_1+w_{22}h_2 \end{aligned}

我们想知道总损失对 h1h_1 的影响。

因为 h1h_1 同时影响 o1o_1 和 o2o_2,所以:

∂L∂h1=∂L∂o1w11+∂L∂o2w21(41) \frac{\partial\mathcal L}{\partial h_1} = \frac{\partial\mathcal L}{\partial o_1}w_{11} + \frac{\partial\mathcal L}{\partial o_2}w_{21} \tag{41}

同理:

∂L∂h2=∂L∂o1w12+∂L∂o2w22(42) \frac{\partial\mathcal L}{\partial h_2} = \frac{\partial\mathcal L}{\partial o_1}w_{12} + \frac{\partial\mathcal L}{\partial o_2}w_{22} \tag{42}

写成矩阵:

[∂L∂h1∂L∂h2]=[w11w21w12w22]⏟WT[∂L∂o1∂L∂o2] \begin{bmatrix} \frac{\partial\mathcal L}{\partial h_1}\\ \frac{\partial\mathcal L}{\partial h_2} \end{bmatrix} = \underbrace{ \begin{bmatrix} w_{11}&w_{21}\\ w_{12}&w_{22} \end{bmatrix} }_{W^{\mathsf T}} \begin{bmatrix} \frac{\partial\mathcal L}{\partial o_1}\\ \frac{\partial\mathcal L}{\partial o_2} \end{bmatrix}

于是:

∇hL=WT∇oL(43) \boxed{ \nabla_h\mathcal L=W^{\mathsf T}\nabla_o\mathcal L } \tag{43}

你可以这样理解:

  • 前向传播使用 WW,把隐藏状态映射到输出。
  • 反向传播使用 WTW^{\mathsf T},把输出层的梯度传回隐藏层。

如果使用 Softmax + 交叉熵

假设:

y^t,k=eot,k∑jeot,j \hat y_{t,k}= \frac{e^{o_{t,k}}} {\sum_j e^{o_{t,j}}}

真实标签 yty_t 是 one-hot 向量,交叉熵为:

Lt=−∑kyt,klog⁡y^t,k \mathcal L_t=-\sum_k y_{t,k}\log\hat y_{t,k}

则有一个非常方便的求导结果:

∂Lt∂ot=y^t−yt(44) \boxed{ \frac{\partial\mathcal L_t}{\partial o_t} =\hat y_t-y_t } \tag{44}

这个公式成立于标准 softmax 配合交叉熵、目标分布归一化且对类别求和的情形。如果损失进行了额外缩放,梯度也需要相应缩放。

因此,当前时间步的直接梯度就变成:

∂Lt∂ht=WhyT(y^t−yt)(45) \boxed{ \frac{\partial\mathcal L_t}{\partial h_t} = W_{hy}^{\mathsf T}(\hat y_t-y_t) } \tag{45}

这就是当前输出误差传回隐藏状态的过程。

5.4 核心推导

现在开始真正推导 BPTT。

我们暂时不使用复杂的矩阵,而是先从 3 个时间步的 RNN 出发。

假设总损失为:

L=L1+L2+L3(46) \mathcal L=\mathcal L_1+\mathcal L_2+\mathcal L_3 \tag{46}

并且每个时间步都有:

ht=tanh⁡(at) h_t=\tanh(a_t) at=Wxhxt+Whhht−1+bh a_t=W_{xh}x_t+W_{hh}h_{t-1}+b_h

由于第三个时间步已经是最后一步,不存在未来的损失。

因此:

∂L∂h3=∂L3∂h3(47) \frac{\partial\mathcal L}{\partial h_3} = \frac{\partial\mathcal L_3}{\partial h_3} \tag{47}

代入之前的结果:

∂L∂h3=WhyT∂L3∂o3(48) \boxed{ \frac{\partial\mathcal L}{\partial h_3} = W_{hy}^{\mathsf T} \frac{\partial\mathcal L_3}{\partial o_3} } \tag{48}

接下来还需要把梯度从 h3h_3 传递到 a3a_3。

因为:

h3=tanh⁡(a3) h_3=\tanh(a_3)

而 tanh 的导数为:

tanh⁡′(a3)=1−tanh⁡2(a3)=1−h32 \tanh'(a_3)=1-\tanh^2(a_3)=1-h_3^2

所以:

∂L∂a3=∂L∂h3⊙(1−h32)(49) \frac{\partial\mathcal L}{\partial a_3} = \frac{\partial\mathcal L}{\partial h_3} \odot(1-h_3^2) \tag{49}

现在定义 BPTT 中最重要的误差变量:

δt≡∂L∂at(50) \boxed{ \delta_t\equiv\frac{\partial\mathcal L}{\partial a_t} } \tag{50}

于是:

δ3=(WhyT∂L3∂o3)⊙(1−h32)(51) \boxed{ \delta_3= \left( W_{hy}^{\mathsf T} \frac{\partial\mathcal L_3}{\partial o_3} \right) \odot(1-h_3^2) } \tag{51}

现在我们想计算:

∂L∂h2 \frac{\partial\mathcal L}{\partial h_2}

首先问自己:h2h_2 会影响哪些损失?

它直接影响:

h2→o2→L2 h_2\rightarrow o_2\rightarrow\mathcal L_2

它也会通过 a3a_3、h3h_3 影响:

h2→a3→h3→o3→L3 h_2\rightarrow a_3\rightarrow h_3 \rightarrow o_3\rightarrow\mathcal L_3

但是,h2h_2 不会影响过去已经计算的 L1\mathcal L_1。

因此:

∂L∂h2=∂L2∂h2+∂L3∂h2(52) \frac{\partial\mathcal L}{\partial h_2} = \frac{\partial\mathcal L_2}{\partial h_2} + \frac{\partial\mathcal L_3}{\partial h_2} \tag{52}

我们来分别计算。

第一项:来自当前时间步的直接损失

由式 (40):

∂L2∂h2=WhyT∂L2∂o2(53) \boxed{ \frac{\partial\mathcal L_2}{\partial h_2} = W_{hy}^{\mathsf T} \frac{\partial\mathcal L_2}{\partial o_2} } \tag{53}

第二项:来自未来时间步的间接损失

观察第三个时间步:

a3=Wxhx3+Whhh2+bh a_3=W_{xh}x_3+W_{hh}h_2+b_h

因为 L3\mathcal L_3 通过 a3a_3 依赖 h2h_2,所以:

∂L3∂h2=(∂a3∂h2)T∂L3∂a3(54) \frac{\partial\mathcal L_3}{\partial h_2} = \left( \frac{\partial a_3}{\partial h_2} \right)^{\mathsf T} \frac{\partial\mathcal L_3}{\partial a_3} \tag{54}

分别看两部分。

首先:

∂a3∂h2=Whh \frac{\partial a_3}{\partial h_2}=W_{hh}

其次,由于第三步是最后一步:

∂L3∂a3=δ3 \frac{\partial\mathcal L_3}{\partial a_3} =\delta_3

因此:

∂L3∂h2=WhhTδ3(55) \boxed{ \frac{\partial\mathcal L_3}{\partial h_2} = W_{hh}^{\mathsf T}\delta_3 } \tag{55}

现在把式 (53) 和式 (55) 相加:

∂L∂h2=WhyT∂L2∂o2+WhhTδ3(56) \boxed{ \frac{\partial\mathcal L}{\partial h_2} = W_{hy}^{\mathsf T} \frac{\partial\mathcal L_2}{\partial o_2} + W_{hh}^{\mathsf T}\delta_3 } \tag{56}

这就是 BPTT 中“两个梯度来源相加”的本质。

观察 h₂ 的两条梯度回传路径

箭头表示前向依赖关系;反向传播沿箭头反方向回传。由于总损失依赖多条计算路径,梯度在汇合点相加。

现在距离 δ2\delta_2 只差一步。

因为:

h2=tanh⁡(a2) h_2=\tanh(a_2)

所以:

δ2=∂L∂h2⊙(1−h22) \delta_2= \frac{\partial\mathcal L}{\partial h_2} \odot(1-h_2^2)

代入式 (56):

δ2=(WhyT∂L2∂o2+WhhTδ3)⊙(1−h22)(57) \boxed{ \delta_2= \left( W_{hy}^{\mathsf T} \frac{\partial\mathcal L_2}{\partial o_2} + W_{hh}^{\mathsf T}\delta_3 \right) \odot(1-h_2^2) } \tag{57}

这正是我们要推导的公式在第二个时间步的形式。

第一个时间步:重复同样的过程

现在计算:

∂L∂h1 \frac{\partial\mathcal L}{\partial h_1}

因为 h1h_1 影响 L1\mathcal L_1、L2\mathcal L_2、L3\mathcal L_3,所以:

∂L∂h1=∂L1∂h1+∂(L2+L3)∂h1(58) \frac{\partial\mathcal L}{\partial h_1} = \frac{\partial\mathcal L_1}{\partial h_1} + \frac{\partial(\mathcal L_2+\mathcal L_3)}{\partial h_1} \tag{58}

第一项依然是:

∂L1∂h1=WhyT∂L1∂o1(59) \frac{\partial\mathcal L_1}{\partial h_1} = W_{hy}^{\mathsf T} \frac{\partial\mathcal L_1}{\partial o_1} \tag{59}

第二项呢?

注意:

h1→a2→h2 h_1\rightarrow a_2\rightarrow h_2

而 δ2\delta_2 已经包含了 L2\mathcal L_2 和 L3\mathcal L_3 对 a2a_2 的全部梯度。

因此:

∂(L2+L3)∂h1=WhhTδ2(60) \frac{\partial(\mathcal L_2+\mathcal L_3)}{\partial h_1} = W_{hh}^{\mathsf T}\delta_2 \tag{60}

这里特别重要:

虽然 δ2\delta_2 只写了一个下标 2,但它已经汇总了从第二步到最后一步的所有后续损失贡献。

于是:

∂L∂h1=WhyT∂L1∂o1+WhhTδ2 \frac{\partial\mathcal L}{\partial h_1} = W_{hy}^{\mathsf T} \frac{\partial\mathcal L_1}{\partial o_1} + W_{hh}^{\mathsf T}\delta_2

再乘上 tanh 的导数:

δ1=(WhyT∂L1∂o1+WhhTδ2)⊙(1−h12)(61) \boxed{ \delta_1= \left( W_{hy}^{\mathsf T} \frac{\partial\mathcal L_1}{\partial o_1} + W_{hh}^{\mathsf T}\delta_2 \right) \odot(1-h_1^2) } \tag{61}

将三个时间步合并

我们目前推导得到:

δ3=(WhyT∂L3∂o3)⊙(1−h32)δ2=(WhyT∂L2∂o2+WhhTδ3)⊙(1−h22)δ1=(WhyT∂L1∂o1+WhhTδ2)⊙(1−h12)(62) \begin{aligned} \delta_3 &= \left( W_{hy}^{\mathsf T} \frac{\partial\mathcal L_3}{\partial o_3} \right)\odot(1-h_3^2) \\[8pt] \delta_2 &= \left( W_{hy}^{\mathsf T} \frac{\partial\mathcal L_2}{\partial o_2} + W_{hh}^{\mathsf T}\delta_3 \right)\odot(1-h_2^2) \\[8pt] \delta_1 &= \left( W_{hy}^{\mathsf T} \frac{\partial\mathcal L_1}{\partial o_1} + W_{hh}^{\mathsf T}\delta_2 \right)\odot(1-h_1^2) \end{aligned} \tag{62}

观察规律:每个时间步都有完全相同的结构。

因此推广到长度为 TT 的序列:

δt=(WhyT∂Lt∂ot+WhhTδt+1)⊙(1−ht2)(63) \boxed{ \delta_t= \left( W_{hy}^{\mathsf T} \frac{\partial\mathcal L_t}{\partial o_t} + W_{hh}^{\mathsf T}\delta_{t+1} \right) \odot(1-h_t^2) } \tag{63}

其中边界条件:

δT+1=0(64) \boxed{\delta_{T+1}=\mathbf 0} \tag{64}

这样最后一个时间步就可以直接使用相同的公式。

5.5 用更规范的计算图方法理解递推公式

前面的推导是从三个具体时间步展开的。现在我们换一种更适合以后研究 LSTM、GRU 和自动微分的写法。

定义:

gt=∂L∂ht(65) g_t=\frac{\partial\mathcal L}{\partial h_t} \tag{65}

注意区分两个变量:

gt=∂L∂htδt=∂L∂at(66) \boxed{ \begin{aligned} g_t&=\frac{\partial\mathcal L}{\partial h_t}\\ \delta_t&=\frac{\partial\mathcal L}{\partial a_t} \end{aligned} } \tag{66}

因为 ht=tanh⁡(at)h_t=\tanh(a_t),有:

δt=Dtgt(67) \boxed{ \delta_t=D_tg_t } \tag{67}

其中:

Dt=diag⁡(1−ht2) D_t=\operatorname{diag}(1-h_t^2)

现在我们先求 gtg_t。

计算图中,hth_t 有两个直接影响方向:

ht→ot h_t\rightarrow o_t

以及:

ht→at+1 h_t\rightarrow a_{t+1}

因此,在不考虑其他额外连接的标准 RNN 中:

gt=(∂ot∂ht)T∂L∂ot+(∂at+1∂ht)T∂L∂at+1(68) g_t= \left( \frac{\partial o_t}{\partial h_t} \right)^{\mathsf T} \frac{\partial\mathcal L}{\partial o_t} + \left( \frac{\partial a_{t+1}}{\partial h_t} \right)^{\mathsf T} \frac{\partial\mathcal L}{\partial a_{t+1}} \tag{68}

因为当前输出 oto_t 只直接影响 Lt\mathcal L_t,所以:

∂L∂ot=∂Lt∂ot \frac{\partial\mathcal L}{\partial o_t} = \frac{\partial\mathcal L_t}{\partial o_t}

再代入:

∂ot∂ht=Why \frac{\partial o_t}{\partial h_t}=W_{hy} ∂at+1∂ht=Whh \frac{\partial a_{t+1}}{\partial h_t}=W_{hh}

以及:

∂L∂at+1=δt+1 \frac{\partial\mathcal L}{\partial a_{t+1}}=\delta_{t+1}

得到:

gt=WhyT∂Lt∂ot+WhhTδt+1(69) \boxed{ g_t= W_{hy}^{\mathsf T} \frac{\partial\mathcal L_t}{\partial o_t} + W_{hh}^{\mathsf T}\delta_{t+1} } \tag{69}

再由式 (67):

δt=Dtgt \delta_t=D_tg_t

即可得到式 (63)。

为什么先相加,再乘 tanh 导数?

这是一个特别容易产生错误的地方。

公式结构是:

δt=(当前输出梯度+未来传回梯度)⏟gt⊙(1−ht2)⏟tanh 导数 \delta_t= \underbrace{ \left( \text{当前输出梯度}+\text{未来传回梯度} \right) }_{g_t} \odot \underbrace{(1-h_t^2)}_{\text{tanh 导数}}

而不是只让某一个梯度乘上 tanh 的导数。

原因是:两条路径都经过同一个隐藏状态 ht=tanh⁡(at)h_t=\tanh(a_t)。

两条路径先在 hth_t 汇总,然后整体通过激活函数反向传递到 ata_t。

换句话说:

各下游路径梯度汇总⟶经过当前激活函数求导 \boxed{ \text{各下游路径梯度汇总} \longrightarrow \text{经过当前激活函数求导} }

这就是反向传播在计算图分叉、汇合时的通用规则。

对角矩阵形式

我们还可以将递推公式写为:

δt=Dt(WhyT∂Lt∂ot+WhhTδt+1)(70) \boxed{ \delta_t= D_t \left( W_{hy}^{\mathsf T} \frac{\partial\mathcal L_t}{\partial o_t} + W_{hh}^{\mathsf T}\delta_{t+1} \right) } \tag{70}

请注意矩阵乘法的顺序。

这里是:

DtWhhTδt+1 D_tW_{hh}^{\mathsf T}\delta_{t+1}

而不是:

WhhTDtδt+1 W_{hh}^{\mathsf T}D_t\delta_{t+1}

因为矩阵乘法通常不可交换:

AB≠BA AB\ne BA

你在前面学习的局部雅可比矩阵是:

∂ht∂ht−1=DtWhh(71) \frac{\partial h_t}{\partial h_{t-1}} =D_tW_{hh} \tag{71}

它的转置为:

(∂ht∂ht−1)T=WhhTDt(72) \left( \frac{\partial h_t}{\partial h_{t-1}} \right)^{\mathsf T} =W_{hh}^{\mathsf T}D_t \tag{72}

于是从 gtg_t 向 gt−1g_{t-1} 传播梯度时,确实是:

WhhTDtgt W_{hh}^{\mathsf T}D_tg_t

由于:

Dtgt=δt D_tg_t=\delta_t

所以:

gt−1=WhyT∂Lt−1∂ot−1+WhhTδt(73) \boxed{ g_{t-1} = W_{hy}^{\mathsf T} \frac{\partial\mathcal L_{t-1}}{\partial o_{t-1}} + W_{hh}^{\mathsf T}\delta_t } \tag{73}

两种写法完全一致,只是选取的中间变量不同。

六、真正手算一遍 BPTT:从第三步反传到第一步

到这里,我们已经完成理论推导。但只看公式仍然容易觉得抽象。

现在我们做一个可以拿纸笔逐步计算的完整例子。

为了降低矩阵计算的复杂度,先让隐藏状态、输入和输出全部为标量。

这不是改变 BPTT 的原理,而是让所有矩阵运算都退化为普通数字运算。

6.1 设置一个最简单的 RNN

令:

at=wxt+uht−1(74) a_t=wx_t+uh_{t-1} \tag{74} ht=tanh⁡(at)(75) h_t=\tanh(a_t) \tag{75} ot=vht(76) o_t=vh_t \tag{76}

设定参数:

w=0.5,u=0.5,v=1 w=0.5,\qquad u=0.5,\qquad v=1

输入:

x1=1,x2=1,x3=1 x_1=1,\quad x_2=1,\quad x_3=1

初始隐藏状态:

h0=0 h_0=0

目标输出全部设为 0:

y1=y2=y3=0 y_1=y_2=y_3=0

使用平方误差的一半作为单步损失:

Lt=12(ot−yt)2(77) \mathcal L_t=\frac12(o_t-y_t)^2 \tag{77}

于是:

∂Lt∂ot=ot−yt(78) \frac{\partial\mathcal L_t}{\partial o_t} =o_t-y_t \tag{78}

6.2 前向传播

计算时保留中间结果的完整精度,以下展示值四舍五入到小数点后四位;含有舍入值的代入式使用近似等号。

第一步:

a1=0.5×1+0.5×0=0.5 a_1=0.5\times1+0.5\times0=0.5 h1=tanh⁡(0.5)≈0.4621 h_1=\tanh(0.5)\approx0.4621

第二步:

a2=0.5+0.5h1≈0.7311 a_2=0.5+0.5h_1\approx0.7311 h2=tanh⁡(a2)≈0.6237 h_2=\tanh(a_2)\approx0.6237

第三步:

a3=0.5+0.5h2≈0.8119 a_3=0.5+0.5h_2\approx0.8119 h3=tanh⁡(a3)≈0.6706 h_3=\tanh(a_3)\approx0.6706

因为 v=1v=1,所以 ot=hto_t=h_t。

总损失约为:

L=12(h12+h22+h32)≈0.5261 \mathcal L =\frac12(h_1^2+h_2^2+h_3^2) \approx0.5261

下面正式开始反向传播。

6.3 第一步:求 δ3\delta_3

我们知道:

δ3=(v∂L3∂o3)(1−h32) \delta_3= \left( v\frac{\partial\mathcal L_3}{\partial o_3} \right)(1-h_3^2)

因为:

∂L3∂o3=o3=h3≈0.6706 \frac{\partial\mathcal L_3}{\partial o_3} =o_3=h_3\approx0.6706

所以:

δ3≈0.6706(1−0.67062)≈0.3690(79) \begin{aligned} \delta_3 &\approx0.6706(1-0.6706^2)\\ &\approx0.3690 \end{aligned} \tag{79}

6.4 第二步:求 δ2\delta_2

根据 BPTT:

δ2=(vo2+uδ3)(1−h22) \delta_2= (vo_2+u\delta_3)(1-h_2^2)

把数字代入:

δ2≈(0.6237+0.5×0.3690)(1−0.62372)≈0.4938(80) \begin{aligned} \delta_2 &\approx(0.6237+0.5\times0.3690) (1-0.6237^2)\\ &\approx0.4938 \end{aligned} \tag{80}

这里可以明显看到两个梯度来源:

0.6237⏟第二步的直接误差+0.1845⏟第三步传回的误差 \underbrace{0.6237}_{\text{第二步的直接误差}} + \underbrace{0.1845}_{\text{第三步传回的误差}}

如果只计算当前时间步的误差,就会漏掉后面这个 0.18450.1845 左右的贡献。

这正是普通单步反向传播与完整 BPTT 的核心区别。

6.5 第三步:求 δ1\delta_1

同样:

δ1=(vo1+uδ2)(1−h12) \delta_1=(vo_1+u\delta_2)(1-h_1^2)

代入:

δ1≈(0.4621+0.5×0.4938)(1−0.46212)≈0.5576(81) \begin{aligned} \delta_1 &\approx(0.4621+0.5\times0.4938) (1-0.4621^2)\\ &\approx0.5576 \end{aligned} \tag{81}

至此,得到三个误差项:

δ1≈0.5576δ2≈0.4938δ3≈0.3690(82) \boxed{ \begin{aligned} \delta_1&\approx0.5576\\ \delta_2&\approx0.4938\\ \delta_3&\approx0.3690 \end{aligned} } \tag{82}

它们分别描述了总损失对三个时间步激活前变量的敏感程度。

6.6 BPTT 的完整算法流程

现在我们把所有数学推导整合起来。

定义:

et=∂Lt∂ot e_t=\frac{\partial\mathcal L_t}{\partial o_t} δt=∂L∂at \delta_t=\frac{\partial\mathcal L}{\partial a_t}

6.6.1 前向传播阶段

按照时间顺序,从 t=1t=1 到 t=Tt=T:

at=Wxhxt+Whhht−1+bhht=tanh⁡(at)ot=Whyht+byLt=ℓ(ot,yt)(83) \begin{aligned} a_t&=W_{xh}x_t+W_{hh}h_{t-1}+b_h\\ h_t&=\tanh(a_t)\\ o_t&=W_{hy}h_t+b_y\\ \mathcal L_t&=\ell(o_t,y_t) \end{aligned} \tag{83}

保存各时间步的隐藏状态和其他反向传播所需的中间变量。

6.6.2 反向传播阶段

从 t=Tt=T 到 t=1t=1:

先计算当前输出误差:

et=∂Lt∂ot(84) e_t=\frac{\partial\mathcal L_t}{\partial o_t} \tag{84}

再计算隐藏层误差:

δt=(WhyTet+WhhTδt+1)⊙(1−ht2)(85) \boxed{ \delta_t= \left( W_{hy}^{\mathsf T}e_t + W_{hh}^{\mathsf T}\delta_{t+1} \right) \odot(1-h_t^2) } \tag{85}

其中:

δT+1=0 \delta_{T+1}=\mathbf0

然后累积参数梯度:

∇WxhL=∑tδtxtT∇WhhL=∑tδtht−1T∇WhyL=∑tethtT∇bhL=∑tδt∇byL=∑tet(86) \boxed{ \begin{aligned} \nabla_{W_{xh}}\mathcal L &=\sum_t\delta_tx_t^{\mathsf T}\\ \nabla_{W_{hh}}\mathcal L &=\sum_t\delta_th_{t-1}^{\mathsf T}\\ \nabla_{W_{hy}}\mathcal L &=\sum_te_th_t^{\mathsf T}\\ \nabla_{b_h}\mathcal L &=\sum_t\delta_t\\ \nabla_{b_y}\mathcal L &=\sum_te_t \end{aligned} } \tag{86}

最后使用优化器更新参数。

七、BPTT 和梯度消失到底是什么关系?

现在我们可以用已经推导的递推公式,进一步解释为什么 RNN 会出现梯度消失。

先考虑只有最后一个时间步存在损失的情况。

此时对 t<Tt<T,当前直接损失为零:

et=0 e_t=0

那么:

δt=DtWhhTδt+1(87) \delta_t= D_tW_{hh}^{\mathsf T}\delta_{t+1} \tag{87}

逐步展开:

δT−1=DT−1WhhTδT \delta_{T-1} =D_{T-1}W_{hh}^{\mathsf T}\delta_T δT−2=DT−2WhhTDT−1WhhTδT \delta_{T-2} =D_{T-2}W_{hh}^{\mathsf T} D_{T-1}W_{hh}^{\mathsf T}\delta_T

推广:

δk=(DkWhhTDk+1WhhT⋯DT−1WhhT)δT(88) \boxed{ \delta_k= \left( D_kW_{hh}^{\mathsf T} D_{k+1}W_{hh}^{\mathsf T} \cdots D_{T-1}W_{hh}^{\mathsf T} \right)\delta_T } \tag{88}

其中所有矩阵按实际传播顺序相乘。

这里包含两个可能让梯度发生缩小或放大的因素:

一是 DtD_t,即 tanh 激活函数的导数;二是 WhhTW_{hh}^{\mathsf T},即循环权重矩阵。

对于 tanh:

tanh⁡′(a)=1−tanh⁡2(a) \tanh'(a)=1-\tanh^2(a)

当隐藏状态(tanh 的输出)ht=tanh⁡(at)h_t=\tanh(a_t) 接近 11 或 −1-1,即输入 ata_t 进入饱和区时:

tanh⁡′(at)=1−ht2≈0 \tanh'(a_t)=1-h_t^2\approx0

于是部分梯度分量会被明显缩小。

而连续经过很多时间步,就可能发生梯度消失。

不过,真实的矩阵连乘行为还取决于各矩阵的方向和奇异值等因素,并不是只要每个 tanh 导数小于 1,就一定发生严重的梯度消失。

这也解释了为什么 LSTM 和 GRU 要构建门控及加法状态更新路径:它们试图让有用的历史信息与梯度能够更有效地沿时间传播。

7.1 梯度消失

我们把第 4.3 节式 (23) 中的矩阵乘积简化为一个标量模型。

这里的 nn 表示向过去反传的步数,gng_n 是简化模型中的标量梯度,g0g_0 是反传起点的梯度;它们不再表示第 5.5 节按前向时间索引定义的梯度向量。假设每一步梯度传播都需要乘上一个常数 α\alpha,经过 nn 步后:

gn=αng0(89) g_n=\alpha^ng_0 \tag{89}

如果:

∣α∣<1 |\alpha|<1

那么:

lim⁡n→∞αn=0 \lim_{n\to\infty}\alpha^n=0

例如:

0.510≈0.000977 0.5^{10}\approx0.000977 0.520≈9.54×10−7 0.5^{20}\approx9.54\times10^{-7}

如果一个时间步对更早时间步的梯度缩小一半,那么传播 20 步之后,就只剩下原来的约百万分之一。

静态实验:梯度经过多次传播会怎样?

原交互实验的每步梯度倍率 ∣α∣\lvert\alpha\rvert 默认值为 0.80.8,可调范围为 [0.2,1.5][0.2,1.5],步长为 0.050.05。以下将初始梯度大小设为 1,展示倍率连续相乘后的梯度大小:

梯度连乘的衰减、保持与放大

当历史信息需要通过很多步才能影响最终预测时,早期时间步收到的训练信号可能变得非常微弱,模型很难学会长期依赖。

例如:

我昨天在公园看到了一只小猫,后来又去商店、学校、图书馆……最后它突然跑了。

模型需要理解“它”指代前面出现的“小猫”。

如果隐藏状态中的相关信息在多次更新中逐渐丢失,模型就难以正确建立这种联系。

7.2 梯度爆炸

另一个极端是:

∣α∣>1 |\alpha|>1

此时:

lim⁡n→∞∣α∣n=∞ \lim_{n\to\infty}|\alpha|^n=\infty

例如:

1.520≈3325.26 1.5^{20}\approx3325.26

这意味着非常小的梯度可能经过多次传播后迅速放大。

在训练中,可能会表现为损失剧烈震荡、参数更新过大,甚至产生 NaN。

7.3 如何解决?

方法 核心思想 主要作用
梯度裁剪 限制梯度范数 缓解梯度爆炸
合理初始化 控制循环权重的数值特性 改善训练稳定性
LSTM 引入独立记忆单元和门控 缓解长期依赖学习困难
GRU 使用更新门与重置门 缓解长期依赖学习困难
TBPTT 仅反传有限长度的序列 降低计算和内存开销
Attention 直接访问相关位置的信息 缩短部分信息传递路径

这里要特别区分:

梯度裁剪主要针对梯度爆炸,并不能直接解决梯度消失。

截断 BPTT 虽然能够减少训练开销,但它也会限制当前训练更新中梯度能够直接传播的时间范围。

八、RNN 的几种常见网络架构

前面讨论的是单个循环单元,但实际应用中还要考虑:一个网络究竟接收什么样的序列,以及应该输出什么样的结果?

8.1 按输入与输出形式分类

四类典型序列架构

四类典型序列输入输出架构

图中展示四类序列架构的信息流,省略部分内部计算细节。

在实际任务中:

  • 多对一:文本情感分类、动作识别、整段时间序列分类。
  • 多对多同步:词性标注、每帧状态识别、传感器序列异常检测。
  • Encoder-Decoder:机器翻译、文本摘要、多步预测。

8.2 双向 RNN(Bidirectional RNN)

普通 RNN 在时间 tt 时,通常只能使用当前及过去的信息。

但是,在很多任务中,我们希望同时参考前面的内容和后面的内容。

例如:

我坐在苹果树下,吃了一个苹果。

理解某个词的含义时,前后文都可能提供帮助。

双向 RNN 使用两套循环网络:

正向:

h→t=f(Wfxt+Ufh→t−1+bf)(90) \overrightarrow h_t =f(W_f x_t+U_f\overrightarrow h_{t-1}+b_f) \tag{90}

反向:

h←t=f(Wbxt+Ubh←t+1+bb)(91) \overleftarrow h_t =f(W_b x_t+U_b\overleftarrow h_{t+1}+b_b) \tag{91}

最后拼接:

ht=[h→t;h←t](92) \boxed{ h_t=[\overrightarrow h_t;\overleftarrow h_t] } \tag{92}

双向 RNN 的正向、反向与状态拼接

每个时间步将对应的正向和反向隐藏状态拼接,形成该位置的双向表示。

双向结构也可以应用到 LSTM、GRU,因此存在 BiLSTM、BiGRU。

但是存在一个限制:

如果任务要求严格实时预测,而且未来数据尚未到达,那么不能直接使用需要完整未来上下文的双向网络。

例如实时机器人控制或在线时间序列预测,需要特别注意这一点。

8.3 多层 RNN(Stacked RNN)

除了在时间维度展开,也可以在深度方向堆叠。

第一层:

ht(1)=f(Wx(1)xt+Wh(1)ht−1(1)+b(1)) h_t^{(1)}=f(W_x^{(1)}x_t+W_h^{(1)}h_{t-1}^{(1)}+b^{(1)})

第二层:

ht(2)=f(Wx(2)ht(1)+Wh(2)ht−1(2)+b(2)) h_t^{(2)}=f(W_x^{(2)}h_t^{(1)}+W_h^{(2)}h_{t-1}^{(2)}+b^{(2)})

推广:

ht(l)=f(Wx(l)ht(l−1)+Wh(l)ht−1(l)+b(l))(93) \boxed{ h_t^{(l)}= f(W_x^{(l)}h_t^{(l-1)} +W_h^{(l)}h_{t-1}^{(l)} +b^{(l)}) } \tag{93}

其中 ll 表示层编号,并约定 ht(0)=xth_t^{(0)}=x_t。可以把它理解为两个信息传播方向:一是随着时间从前往后传递,二是在同一时间步从低层向高层传递。

多层 RNN 可以学习不同抽象层次的时序特征,但也增加了计算量与训练难度。

九、推荐阅读的经典论文

建议按照技术发展的顺序阅读,不必一开始就完整推导每篇论文的全部细节。

Finding Structure in Time — 1990

Jeffrey L. Elman

理解简单循环网络如何通过内部状态建立上下文相关的表示,是学习早期 RNN 的重要文献。

Long Short-Term Memory — 1997

Sepp Hochreiter、Jürgen Schmidhuber

重点研究长期依赖问题,以及通过特殊记忆结构与门控实现较稳定误差传播的思路。注意原始 LSTM 与今天教材中常见的带遗忘门版本并不完全相同。

Learning Phrase Representations using RNN Encoder–Decoder — 2014

Kyunghyun Cho 等人

了解门控循环单元、编码器—解码器及其在机器翻译中的应用。

Neural Machine Translation by Jointly Learning to Align and Translate — 2014/2015

Dzmitry Bahdanau 等人

理解注意力机制为什么能够改善传统 Encoder-Decoder 的固定上下文瓶颈。

Attention Is All You Need — 2017

Ashish Vaswani 等人

理解 Transformer 如何通过自注意力替代传统循环结构中的主要序列交互方式。

Mamba: Linear-Time Sequence Modeling with Selective State Spaces — 2023

Albert Gu、Tri Dao

了解选择性状态空间模型如何融合状态递推与高效序列计算。