循环神经网络 (RNN) 深度解析#

循环神经网络 (Recurrent Neural Network, RNN) 是处理序列数据的核心架构。本文深入探讨 RNN 的原理、变体和实际应用。

一、序列建模的挑战#

1.1 序列数据的特点#

可变长度：句子、时间序列长度不固定
时序依赖：当前输出依赖历史信息
上下文关联：词义依赖于上下文

1.2 为什么不用全连接网络？#

问题	说明
固定输入长度	无法处理可变长序列
无参数共享	不同位置使用不同参数
无记忆机制	无法捕获时序依赖

二、RNN 基本结构#

2.1 核心公式#

RNN 递归公式
$h_t = \tanh(W_{hh} h_{t-1} + W_{xh} x_t + b_h)$ $y_t = W_{hy} h_t + b_y$
其中：

$x_t$ : 时刻 $t$ 的输入

$h_t$ : 时刻 $t$ 的隐藏状态（记忆）

$y_t$ : 时刻 $t$ 的输出

2.2 计算图展开#

graph LR x0[x₀] --> h0[h₀] x1[x₁] --> h1[h₁] x2[x₂] --> h2[h₂] x3[x₃] --> h3[h₃] h0 --> h1 h1 --> h2 h2 --> h3 h0 --> y0[y₀] h1 --> y1[y₁] h2 --> y2[y₂] h3 --> y3[y₃]

2.3 PyTorch 实现#

1
import torch
2
import torch.nn as nn
3

4
class SimpleRNN(nn.Module):
5
    def __init__(self, input_size, hidden_size, output_size):
6
        super().__init__()
7
        self.hidden_size = hidden_size
8
        # 输入到隐藏
9
        self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
10
        # 隐藏到输出
11
        self.h2o = nn.Linear(hidden_size, output_size)
12

13
    def forward(self, x, hidden):
14
        combined = torch.cat([x, hidden], dim=1)
15
        hidden = torch.tanh(self.i2h(combined))
16
        output = self.h2o(hidden)
17
        return output, hidden
18

19
    def init_hidden(self, batch_size):
20
        return torch.zeros(batch_size, self.hidden_size)

三、梯度问题#

3.1 BPTT (时间反向传播)#

梯度沿时间展开的链式法则：

\frac{\partial L}{\partial W} = \sum_{t=1}^{T} \frac{\partial L_t}{\partial W}

\frac{\partial L_t}{\partial h_k} = \frac{\partial L_t}{\partial h_t} \prod_{i=k+1}^{t} \frac{\partial h_i}{\partial h_{i-1}}

3.2 梯度消失#

当 $\|W_{hh}\| < 1$ 时：

\prod_{i=k}^{t} \frac{\partial h_i}{\partial h_{i-1}} \approx \prod_{i=k}^{t} W_{hh} \to 0

后果：无法学习长距离依赖。

3.3 梯度爆炸#

当 $\|W_{hh}\| > 1$ 时，梯度指数增长。

解决方案：梯度裁剪

1
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)

四、LSTM (长短期记忆)#

4.1 核心思想#

引入门控机制和细胞状态，解决长距离依赖问题。

4.2 三个门#

LSTM 门控机制
遗忘门 (Forget Gate)：决定丢弃哪些历史信息
$f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)$
输入门 (Input Gate)：决定添加哪些新信息
$i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i)$ $\tilde{C}_t = \tanh(W_C \cdot [h_{t-1}, x_t] + b_C)$
输出门 (Output Gate)：决定输出什么
$o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)$

4.3 状态更新#

C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t

h_t = o_t \odot \tanh(C_t)

4.4 PyTorch LSTM#

1
# 单层 LSTM
2
lstm = nn.LSTM(
3
    input_size=128,      # 输入维度
4
    hidden_size=256,     # 隐藏层维度
5
    num_layers=2,        # 层数
6
    batch_first=True,    # 输入格式 (batch, seq, feature)
7
    dropout=0.2,         # Dropout
8
    bidirectional=True   # 双向 LSTM
9
)
10

11
# 前向传播
12
# x: (batch, seq_len, input_size)
13
# h0, c0: (num_layers * num_directions, batch, hidden_size)
14
output, (hn, cn) = lstm(x, (h0, c0))

五、GRU (门控循环单元)#

5.1 简化的门控#

GRU 合并了遗忘门和输入门，参数更少：

z_t = \sigma(W_z \cdot [h_{t-1}, x_t]) \quad \text{(更新门)}

r_t = \sigma(W_r \cdot [h_{t-1}, x_t]) \quad \text{(重置门)}

\tilde{h}_t = \tanh(W \cdot [r_t \odot h_{t-1}, x_t])

h_t = (1 - z_t) \odot h_{t-1} + z_t \odot \tilde{h}_t

5.2 LSTM vs GRU#

特性	LSTM	GRU
门数量	3 (遗忘、输入、输出)	2 (更新、重置)
参数量	较多	较少 (~75%)
性能	复杂任务更好	简单任务足够
训练速度	较慢	较快

1
gru = nn.GRU(input_size=128, hidden_size=256, num_layers=2, batch_first=True)

六、变体架构#

6.1 双向 RNN#

同时从前向后和从后向前处理：

1
→ h₁ → h₂ → h₃ →
2
← h₁ ← h₂ ← h₃ ←

1
bilstm = nn.LSTM(128, 256, bidirectional=True, batch_first=True)
2
# 输出维度: hidden_size * 2

6.2 多层 RNN#

堆叠多层以增加模型容量：

1
deep_lstm = nn.LSTM(128, 256, num_layers=4, dropout=0.3, batch_first=True)

6.3 Encoder-Decoder#

用于序列到序列任务（翻译、摘要）：

graph LR subgraph Encoder E1[h₁] --> E2[h₂] E2 --> E3[h₃] end subgraph Decoder E3 --> D1[s₁] D1 --> D2[s₂] D2 --> D3[s₃] end

七、实际应用示例#

7.1 文本分类#

1
class TextClassifier(nn.Module):
2
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes):
3
        super().__init__()
4
        self.embedding = nn.Embedding(vocab_size, embed_dim)
5
        self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True, bidirectional=True)
6
        self.fc = nn.Linear(hidden_dim * 2, num_classes)
7
        self.dropout = nn.Dropout(0.5)
8

9
    def forward(self, x):
10
        # x: (batch, seq_len)
11
        embedded = self.embedding(x)  # (batch, seq_len, embed_dim)
12
        output, (hn, cn) = self.lstm(embedded)
13
        # 取最后时刻的隐藏状态
14
        hidden = torch.cat([hn[-2], hn[-1]], dim=1)  # 双向拼接
15
        hidden = self.dropout(hidden)
16
        return self.fc(hidden)

7.2 序列生成#

1
class CharRNN(nn.Module):
2
    def __init__(self, vocab_size, hidden_size):
3
        super().__init__()
4
        self.hidden_size = hidden_size
5
        self.embed = nn.Embedding(vocab_size, hidden_size)
6
        self.lstm = nn.LSTM(hidden_size, hidden_size, batch_first=True)
7
        self.fc = nn.Linear(hidden_size, vocab_size)
8

9
    def forward(self, x, hidden=None):
10
        x = self.embed(x)
11
        output, hidden = self.lstm(x, hidden)
12
        output = self.fc(output)
13
        return output, hidden
14

15
    def generate(self, start_char, length, temperature=1.0):
16
        """生成文本"""
17
        hidden = None
18
        char = start_char
19
        result = [char]
20

21
        for _ in range(length):
22
            x = torch.tensor([[char]])
23
            output, hidden = self.forward(x, hidden)
24
            probs = F.softmax(output[0, -1] / temperature, dim=0)
25
            char = torch.multinomial(probs, 1).item()
26
            result.append(char)
27

28
        return result

八、训练技巧#

8.1 梯度裁剪#

1
for epoch in range(num_epochs):
2
    for batch in dataloader:
3
        optimizer.zero_grad()
4
        loss = criterion(model(batch), targets)
5
        loss.backward()
6

7
        # 💡 梯度裁剪防止爆炸
8
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)
9

10
        optimizer.step()

8.2 学习率调度#

1
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
2
    optimizer, mode='min', factor=0.5, patience=3
3
)

8.3 Teacher Forcing#

训练时使用真实标签而非模型预测：

1
use_teacher_forcing = random.random() < 0.5
2

3
if use_teacher_forcing:
4
    # 使用真实目标作为下一步输入
5
    for t in range(target_len):
6
        output, hidden = decoder(target[t], hidden)
7
else:
8
    # 使用模型输出作为下一步输入
9
    for t in range(target_len):
10
        output, hidden = decoder(input, hidden)
11
        input = output.argmax(1)

总结#

模型	优势	适用场景
Vanilla RNN	简单	短序列
LSTM	长距离依赖	机器翻译、语言模型
GRU	参数少、快速	一般序列任务
Bi-RNN	双向上下文	文本分类、NER

推荐阅读

Hochreiter & Schmidhuber. LSTM (1997)

Cho et al. GRU (2014)

Understanding LSTM Networks

现代趋势
Transformer 和注意力机制已在许多任务上超越 RNN，但 RNN 在某些场景（如实时流处理）仍有优势。

Goblinunde

循环神经网络 (RNN) 深度解析#

一、序列建模的挑战#

1.1 序列数据的特点#

1.2 为什么不用全连接网络？#

二、RNN 基本结构#

2.1 核心公式#

2.2 计算图展开#

2.3 PyTorch 实现#

三、梯度问题#

3.1 BPTT (时间反向传播)#

3.2 梯度消失#

3.3 梯度爆炸#

四、LSTM (长短期记忆)#

4.1 核心思想#

4.2 三个门#

4.3 状态更新#

4.4 PyTorch LSTM#

五、GRU (门控循环单元)#

5.1 简化的门控#

5.2 LSTM vs GRU#

六、变体架构#

6.1 双向 RNN#

6.2 多层 RNN#

6.3 Encoder-Decoder#

七、实际应用示例#

7.1 文本分类#

7.2 序列生成#

八、训练技巧#

8.1 梯度裁剪#

8.2 学习率调度#

8.3 Teacher Forcing#

总结#