深度学习基础：循环神经网络(RNN)原理剖析与B站机器学习第二版第十章实战

1次阅读

共计 2659 个字符，预计需要花费 7 分钟才能阅读完成。

循环神经网络（RNN）是处理序列数据的核心架构之一，在自然语言处理、时间序列预测等领域具有不可替代的作用。B 站机器学习第二版第十章将 RNN 作为深度学习基础的重要组成部分，着重讲解其在序列建模中的独特优势。与传统前馈神经网络相比，RNN 通过引入隐藏状态（hidden state）的记忆机制，能够有效捕捉数据中的时序依赖关系。

RNN 的核心思想是通过循环连接实现信息的持久化。其数学表示为：

h_t = σ(W_hh h_{t-1} + W_xh x_t + b_h)
y_t = W_hy h_t + b_y

其中：
– h_t表示 t 时刻的隐藏状态
– σ为激活函数（通常使用 tanh 或 ReLU）
– W_*为可学习参数矩阵
– b_*为偏置项

初始化隐藏状态 h_0（通常为零向量）
对于序列中的每个时间步 t：
计算当前隐藏状态 h_t
基于 h_t 计算输出 y_t
汇总所有时间步的输出

RNN 通过时间反向传播算法更新参数，其梯度计算需考虑所有时间步的贡献：

∂L/∂W = Σ_{t=1}^T ∂L_t/∂W

由于 RNN 需要将梯度沿时间步连续相乘，当序列较长时会出现：
– 梯度消失：梯度值指数级衰减，导致早期时间步的参数无法有效更新
– 梯度爆炸：梯度值指数级增长，造成数值不稳定

数学上可通过分析雅可比矩阵的特征值解释这种现象：

||∂h_t/∂h_{t-1}|| = ||diag(σ'(...))W_hh||

标准 RNN 难以学习超过 10 个时间步的长程依赖关系，这在语言建模等任务中表现尤为明显。

import torch
import torch.nn as nn

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

    def forward(self, x):
        # x shape: (batch, seq_len, input_size)
        h0 = torch.zeros(1, x.size(0), self.hidden_size)
        out, _ = self.rnn(x, h0)
        out = self.fc(out[:, -1, :])  # 只取最后时间步的输出
        return out

完整训练流程包含：

数据预处理

# 示例：构造正弦波序列数据
def create_dataset(seq_length=50):
    time_steps = np.linspace(0, 10*np.pi, 1000)
    data = np.sin(time_steps)
    sequences = [data[i:i+seq_length] for i in range(len(data)-seq_length)]
    return torch.FloatTensor(sequences).unsqueeze(-1)

训练循环

model = SimpleRNN(input_size=1, hidden_size=32, output_size=1)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

for epoch in range(100):
    outputs = model(train_data[:, :-1])
    loss = criterion(outputs, train_data[:, 1:])
    optimizer.zero_grad()
    loss.backward()
    torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)  # 梯度裁剪
    optimizer.step()

长短期记忆网络通过门控机制解决梯度问题：

遗忘门：f_t = σ(W_f[h_{t-1}, x_t] + b_f)
输入门：i_t = σ(W_i[h_{t-1}, x_t] + b_i)
输出门：o_t = σ(W_o[h_{t-1}, x_t] + b_o)
候选记忆：\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
隐藏状态：h_t = o_t ⊙ tanh(C_t)

门控循环单元简化了 LSTM 的结构：

更新门：z_t = σ(W_z[h_{t-1}, x_t] + b_z)
重置门：r_t = σ(W_r[h_{t-1}, x_t] + b_r)
候选激活：\tilde{h}_t = tanh(W[r_t ⊙ h_{t-1}, x_t] + b)
隐藏状态：h_t = (1-z_t) ⊙ h_{t-1} + z_t ⊙ \tilde{h}_t

性能对比实验显示：
– 在字符级语言建模任务中，LSTM 比基础 RNN perplexity 降低 37%
– GRU 训练速度比 LSTM 快 20%，在短序列任务中表现相当