RNN

Recurrent Neural Network 循环神经网络

RNN 通过隐藏状态的循环连接实现对序列数据的建模，使网络具备"记忆"能力，能够捕捉时间步之间的依赖关系。 属于深度学习中处理变长序列数据的基础架构，是 LSTM、GRU 及现代序列模型的理论起点。

核心思想：隐状态的循环传递

与前馈神经网络不同，RNN 在隐藏层中引入循环连接：每个时间步的隐藏状态不仅依赖当前输入，还依赖前一时间步的隐藏状态。这使得网络能够将历史信息编码到隐状态中，实现对序列上下文的建模。

h_{t} = f_{W} (h_{t - 1}, x_{t})

其中 $h_{t}$ 是时间步 $t$ 的隐藏状态， $x_{t}$ 是当前输入， $f_{W}$ 是参数共享的状态转移函数。

数学公式

隐藏状态更新：

h_{t} = \tanh (W_{x h} x_{t} + W_{h h} h_{t - 1} + b_{h})

输出计算：

y_{t} = g (W_{h y} h_{t} + b_{y})

其中：

$x_{t} \in R^{d}$ 是时间步 $t$ 的输入向量
$h_{t} \in R^{n}$ 是隐藏状态向量
$W_{x h} \in R^{n \times d}$ 是输入到隐藏状态的权重矩阵
$W_{h h} \in R^{n \times n}$ 是隐藏状态到隐藏状态的权重矩阵（所有时间步共享）
$W_{h y} \in R^{m \times n}$ 是隐藏状态到输出的权重矩阵
$b_{h}, b_{y}$ 是偏置向量
$g$ 是输出层的激活函数（如 softmax 用于分类）

参数共享

RNN 的关键特性是权重在所有时间步上共享（ $W_{x h}, W_{h h}, W_{h y}$ 不随 $t$ 变化）。这使得网络可以处理任意长度的序列，且参数量与序列长度无关。

训练：BPTT

RNN 使用时间反向传播 (Backpropagation Through Time, BPTT) 进行训练。将 RNN 沿时间轴展开后，等价于一个深度前馈网络，然后应用标准的反向传播算法计算梯度。

对于损失函数 $L = \sum_{t = 1}^{T} L_{t}$ ，参数梯度涉及沿时间步的链式求导：

\frac{\partial L}{\partial W_{h h}} = \sum_{t = 1}^{T} \sum_{k = 1}^{t} \frac{\partial L_{t}}{\partial h_{t}} (\prod_{j = k + 1}^{t} \frac{\partial h_{j}}{\partial h_{j - 1}}) \frac{\partial h_{k}}{\partial W_{h h}}

梯度问题

梯度消失与梯度爆炸

由于 BPTT 中梯度需要经过多个时间步的连乘 $\prod \frac{\partial h_{j}}{\partial h_{j - 1}}$ ，当序列较长时：

若 $∥ W_{h h} ∥$ 的谱范数 $< 1$ ：梯度指数衰减 → 梯度消失，无法学习长距离依赖
若 $∥ W_{h h} ∥$ 的谱范数 $> 1$ ：梯度指数增长 → 梯度爆炸，训练不稳定

缓解策略：

问题	解决方案	说明
梯度爆炸	梯度裁剪 (Gradient Clipping)	当梯度范数超过阈值时进行缩放
梯度消失	门控机制 (LSTM/GRU)	通过门控制信息流，维持长距离梯度
梯度消失	残差连接	提供梯度的"捷径"
梯度消失	正交初始化	使 $W_{h h}$ 初始化为正交矩阵，谱范数为 1

主要变种

LSTM (Long Short-Term Memory)

LSTM 引入细胞状态 $c_{t}$ 和三个门控机制来解决长距离依赖问题：

\begin{aligned} f_{t} & = σ (W_{f} [h_{t - 1}, x_{t}] + b_{f}) & （遗忘门） \\ i_{t} & = σ (W_{i} [h_{t - 1}, x_{t}] + b_{i}) & （输入门） \\ {\tilde{c}}_{t} & = \tanh (W_{c} [h_{t - 1}, x_{t}] + b_{c}) & （候选状态） \\ c_{t} & = f_{t} ⊙ c_{t - 1} + i_{t} ⊙ {\tilde{c}}_{t} & （细胞状态更新） \\ o_{t} & = σ (W_{o} [h_{t - 1}, x_{t}] + b_{o}) & （输出门） \\ h_{t} & = o_{t} ⊙ \tanh (c_{t}) & （隐藏状态） \end{aligned}

细胞状态 $c_{t}$ 通过线性的自循环路径传递，梯度可以几乎无衰减地流过多个时间步。

GRU (Gated Recurrent Unit)

GRU 是 LSTM 的简化版本，将遗忘门和输入门合并为更新门，参数更少：

\begin{aligned} z_{t} & = σ (W_{z} [h_{t - 1}, x_{t}]) & （更新门） \\ r_{t} & = σ (W_{r} [h_{t - 1}, x_{t}]) & （重置门） \\ {\tilde{h}}_{t} & = \tanh (W [r_{t} ⊙ h_{t - 1}, x_{t}]) & （候选状态） \\ h_{t} & = (1 - z_{t}) ⊙ h_{t - 1} + z_{t} ⊙ {\tilde{h}}_{t} & （状态更新） \end{aligned}

RNN 变种架构对比

特性	Vanilla RNN	LSTM	GRU
参数量	$O (n^{2})$	$O (4 n^{2})$	$O (3 n^{2})$
长距离依赖	差	好	好
门控机制	无	3 个门	2 个门
训练速度	快	慢	中等
适用场景	短序列	长序列、复杂任务	数据量较小的任务

序列建模模式

RNN 支持多种输入-输出模式：

一对一 (One-to-One)：标准前馈网络，非序列任务
一对多 (One-to-Many)：如图像描述生成（输入图像，输出文字序列）
多对一 (Many-to-One)：如情感分析（输入文本序列，输出情感标签）
多对多 (Many-to-Many)：如机器翻译（Encoder-Decoder）、视频分类

PyTorch 示例

python

import torch
import torch.nn as nn

class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x, h0=None):
        # x: (batch, seq_len, input_size)
        out, hn = self.rnn(x, h0)
        # 取最后一个时间步的输出用于分类
        out = self.fc(out[:, -1, :])
        return out

# 使用 LSTM 替代
class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers=2):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size,
                           num_layers=num_layers, batch_first=True,
                           dropout=0.2)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        out, (hn, cn) = self.lstm(x)
        return self.fc(out[:, -1, :])

局限与后续发展

并行计算困难：RNN 的时间步必须顺序执行，无法充分利用 GPU 并行能力
长距离依赖仍有限：即使 LSTM/GRU 缓解了梯度消失，超长序列仍面临信息瓶颈
被 Transformer 取代：在 NLP 领域，基于自注意力机制的 Transformer 架构已大幅取代 RNN，实现更好的并行性和长距离建模能力

发展脉络

Vanilla RNN → LSTM (1997) → GRU (2014) → Attention 机制 → Transformer (2017) → 大语言模型

神经网络 | 机器学习 | 深度学习 | CNN