当前位置：首页 > news >正文

（八）深度循环神经网络：长序列建模、注意力机制与多模态融合

news 来源：原创 2025/6/12 23:37:27

1 循环神经网络（RNN）

循环神经网络（Recurrent Neural Network, RNN）是一类专门用于处理序列数据的神经网络。与前馈神经网络不同，RNN 具有记忆功能，能够对序列数据中的时间依赖关系进行建模。RNN 在自然语言处理、语音识别、时间序列预测等任务中取得了显著的成果。

1.1 RNN 的基本概念

RNN 的核心思想是在神经元之间引入循环连接，使得网络能够记住之前时刻的信息，并将其用于当前时刻的计算。这种记忆功能使得 RNN 能够处理变长的序列数据。

简单循环单元

简单循环单元（Simple Recurrent Unit）是 RNN 的基本构建块。它接收当前时刻的输入 $x_t$ 和前一时刻的隐藏状态 $h_{t-1}$ ，并输出当前时刻的隐藏状态 $h_t$ 和输出 $y_t$ 。

数学表达：
$h_t = \sigma(W_{hx} x_t + W_{hh} h_{t-1} + b_h)$
$y_t = W_{yh} h_t + b_y$

其中：

$x_t$ 是当前时刻的输入。
$h_{t-1}$ 是前一时刻的隐藏状态。
$W_{hx}$ 和 $W_{hh}$ 分别是输入到隐藏层和隐藏层到隐藏层的权重矩阵。
$b_h$ 是隐藏层的偏置项。
$\sigma$ 是激活函数，通常使用 $\tanh$ 或 ReLU。
$W_{yh}$ 是隐藏层到输出层的权重矩阵。
$b_y$ 是输出层的偏置项。

代码实现：

import torch
import torch.nn as nnclass SimpleRNN(nn.Module):def __init__(self, input_size, hidden_size, output_size):super(SimpleRNN, self).__init__()self.hidden_size = hidden_sizeself.rnn_cell = nn.RNNCell(input_size, hidden_size)self.fc = nn.Linear(hidden_size, output_size)def forward(self, x, h=None):batch_size = x.size(1)if h is None:h = torch.zeros(batch_size, self.hidden_size).to(x.device)outputs = []for t in range(x.size(0)):h = self.rnn_cell(x[t], h)outputs.append(self.fc(h))return torch.stack(outputs), h

多层 RNN

多层 RNN 通过堆叠多个 RNN 层来构建更深层次的模型。每一层的输出作为下一层的输入。

代码实现：

class MultiLayerRNN(nn.Module):def __init__(self, input_size, hidden_size, output_size, num_layers):super(MultiLayerRNN, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layersself.rnn = nn.RNN(input_size, hidden_size, num_layers=num_layers, batch_first=True)self.fc = nn.Linear(hidden_size, output_size)def forward(self, x):h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)out, hn = self.rnn(x, h0)out = self.fc(out[:, -1, :])return out

1.2 RNN 的训练

RNN 的训练过程与前馈神经网络类似，但需要考虑时间序列的展开。在训练过程中，损失函数通常对每个时间步的输出进行计算，并将所有时间步的损失进行平均或求和。

示例代码：

# 定义模型
model = SimpleRNN(input_size=10, hidden_size=20, output_size=5)# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)# 生成示例数据
inputs = torch.randn(5, 3, 10)  # 序列长度5，批量大小3，输入特征10
targets = torch.randn(5, 3, 5)   # 序列长度5，批量大小3，输出特征5# 前向传播
outputs, _ = model(inputs)
loss = criterion(outputs, targets)# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()

1.3 RNN 的应用场景

RNN 及其变体在多种序列建模任务中表现出色，包括但不限于：

自然语言处理：文本生成、机器翻译、情感分析。
语音识别：将语音信号转换为文本。
时间序列预测：股票价格预测、天气预报。

1.4 RNN 的局限性

尽管 RNN 在处理序列数据方面取得了显著的成功，但它仍然存在一些局限性：

梯度消失和爆炸问题：在训练长序列数据时，梯度可能会变得非常小（消失）或非常大（爆炸），导致模型难以训练。
长期依赖问题：RNN 在处理长期依赖关系时效果不佳，因为梯度在反向传播过程中会逐渐消失。

为了解决这些问题，研究者们提出了长短期记忆网络（LSTM）和门控循环单元（GRU）等改进的 RNN 架构。

好的，我们继续深入第8章循环神经网络的内容，来看8.2节长短期记忆网络（LSTM）。

2 长短期记忆网络（LSTM）

LSTM是一种专门为解决RNN中梯度消失和爆炸问题而设计的循环神经网络架构，它通过引入门控机制来控制信息的流动，使得模型能够更好地捕捉长期依赖关系。

2.1 LSTM的基本结构

LSTM的核心组件是记忆单元（Cell）和三个门控结构：输入门（Input Gate）、遗忘门（Forget Gate）和输出门（Output Gate）。这些门控结构共同决定了信息如何流入、保存和流出记忆单元。

遗忘门：决定哪些信息应该从记忆单元中丢弃。
输入门：决定哪些新信息应该存储到记忆单元中。
记忆单元：存储序列中的长期信息。
输出门：决定哪些信息应该从记忆单元输出。

数学表达如下：

遗忘门：
$f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)$
输入门：
$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)$
记忆单元更新：
$C_t = f_t \cdot C_{t-1} + i_t \cdot \tilde{C}_t$
输出门：
$o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)$
隐藏状态更新：
$h_t = o_t \cdot \tanh(C_t)$

其中：

$x_t$ 是当前时刻的输入。
$h_{t-1}$ 是前一时刻的隐藏状态。
$C_{t-1}$ 是前一时刻的记忆单元状态。
$W_f, W_i, W_C, W_o$ 是权重矩阵。
$b_f, b_i, b_C, b_o$ 是偏置项。
$\sigma$ 是 sigmoid 激活函数。
$\tanh$ 是双曲正切激活函数。

2.2 LSTM的代码实现

import torch
import torch.nn as nnclass LSTM(nn.Module):def __init__(self, input_size, hidden_size, output_size):super(LSTM, self).__init__()self.hidden_size = hidden_sizeself.lstm_cell = nn.LSTMCell(input_size, hidden_size)self.fc = nn.Linear(hidden_size, output_size)def forward(self, x, h=None, c=None):batch_size = x.size(1)if h is None or c is None:h = torch.zeros(batch_size, self.hidden_size).to(x.device)c = torch.zeros(batch_size, self.hidden_size).to(x.device)outputs = []for t in range(x.size(0)):h, c = self.lstm_cell(x[t], (h, c))outputs.append(self.fc(h))return torch.stack(outputs), (h, c)# 测试LSTM
if __name__ == "__main__":model = LSTM(input_size=10, hidden_size=20, output_size=5)input_data = torch.randn(5, 3, 10)  # 序列长度5，批量大小3，输入特征10outputs, (h_n, c_n) = model(input_data)print(outputs.shape)  # 输出应为torch.Size([5, 3, 5])

2.3 LSTM的训练

LSTM的训练过程与简单RNN类似，但在实现上需要同时维护隐藏状态和记忆单元状态。

# 定义模型
model = LSTM(input_size=10, hidden_size=20, output_size=5)# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)# 生成示例数据
inputs = torch.randn(5, 3, 10)  # 序列长度5，批量大小3，输入特征10
targets = torch.randn(5, 3, 5)   # 序列长度5，批量大小3，输出特征5# 前向传播
outputs, _ = model(inputs)
loss = criterion(outputs, targets)# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()

2.4 LSTM的应用场景

LSTM在处理需要捕捉长期依赖关系的序列数据时表现出色，广泛应用于以下领域：

自然语言处理：如机器翻译、文本生成、情感分析等任务。
语音识别：将语音信号转换为文本。
时间序列预测：如金融时间序列预测、气象数据预测等。

2.5 LSTM的局限性

尽管LSTM在捕捉长期依赖关系方面优于简单RNN，但它仍然存在一些局限性：

计算复杂度较高：LSTM的门控结构增加了计算复杂度。
训练时间较长：由于复杂的门控机制，LSTM的训练时间通常比简单RNN更长。

通过理解LSTM的结构和原理，你可以更好地应用它来解决需要捕捉长期依赖关系的序列建模任务。

3 门控循环单元（GRU）

GRU 是另一种改进的 RNN 架构，通过简化 LSTM 的结构，在一定程度上减少了计算复杂度，同时保持了对长期依赖关系的捕捉能力。

3.1 GRU 的基本结构

GRU 的核心思想是将遗忘门和输入门合并为一个更新门（Update Gate），并引入重置门（Reset Gate）来控制信息的更新。GRU 的结构比 LSTM 更简单，但在很多任务中表现相当甚至更好。

数学表达：

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

其中：

$x_t$ 是当前时刻的输入。
$h_{t-1}$ 是前一时刻的隐藏状态。
$W_z, W_r, W$ 是权重矩阵。
$b_z, b_r, b$ 是偏置项。
$\sigma$ 是 sigmoid 激活函数。
$\tanh$ 是双曲正切激活函数。

代码实现：

class GRU(nn.Module):def __init__(self, input_size, hidden_size, output_size):super(GRU, self).__init__()self.hidden_size = hidden_sizeself.gru = nn.GRUCell(input_size, hidden_size)self.fc = nn.Linear(hidden_size, output_size)def forward(self, x, h=None):batch_size = x.size(1)if h is None:h = torch.zeros(batch_size, self.hidden_size).to(x.device)outputs = []for t in range(x.size(0)):h = self.gru(x[t], h)outputs.append(self.fc(h))return torch.stack(outputs), h

3.2 GRU 的训练

GRU 的训练过程与 LSTM 类似，但在实现上更为简单，因为只需要维护隐藏状态。

示例代码：

# 定义模型
model = GRU(input_size=10, hidden_size=20, output_size=5)# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)# 生成示例数据
inputs = torch.randn(5, 3, 10)  # 序列长度5，批量大小3，输入特征10
targets = torch.randn(5, 3, 5)   # 序列长度5，批量大小3，输出特征5# 前向传播
outputs, _ = model(inputs)
loss = criterion(outputs, targets)# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()

3.3 GRU 的应用场景

GRU 在处理序列数据时表现出色，特别是在计算资源有限的情况下。它的常见应用场景包括：

自然语言处理：文本分类、序列生成。
语音识别：语音信号处理。
时间序列预测：预测未来的数据点。

3.4 GRU 的局限性

尽管 GRU 在计算效率上有一定优势，但它仍然存在一些局限性：

复杂度：虽然比 LSTM 简单，但 GRU 仍然比简单 RNN 复杂。
特定任务表现：在某些任务中，GRU 可能不如 LSTM 或其他专门设计的架构表现好。

4 循环神经网络的训练技巧

训练循环神经网络（RNN）时，可以采用一些特定的技巧来提高模型的性能和稳定性。这些技巧包括梯度裁剪、教师强制、正则化和学习率调整等。

4.1 梯度裁剪

梯度裁剪是一种防止梯度爆炸的常用方法。在训练过程中，如果梯度的范数超过了一个预定义的阈值，就将其缩放到该阈值。这有助于稳定训练过程，避免梯度变得过大。

代码实现：

import torch
import torch.nn as nn# 定义模型、损失函数和优化器
model = SimpleRNN(input_size=10, hidden_size=20, output_size=5)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)# 生成示例数据
inputs = torch.randn(5, 3, 10)  # 序列长度5，批量大小3，输入特征10
targets = torch.randn(5, 3, 5)   # 序列长度5，批量大小3，输出特征5# 前向传播
outputs, _ = model(inputs)
loss = criterion(outputs, targets)# 反向传播和优化
optimizer.zero_grad()
loss.backward()# 梯度裁剪
nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)optimizer.step()

4.2 教师强制（Teacher Forcing）

教师强制是一种训练技巧，其中在训练过程中使用真实的目标值作为下一个时间步的输入，而不是使用模型的预测值。这可以加快训练速度，但需要注意在测试时模型不能依赖真实目标值。

代码实现：

# 假设 model 是定义好的 RNN 模型
# inputs 是输入序列，targets 是目标序列# 前向传播，使用教师强制
outputs = []
h = None
for t in range(inputs.size(0)):# 使用真实的目标值作为下一个时间步的输入if t == 0:out, h = model(inputs[t].unsqueeze(0))else:out, h = model(targets[t-1].unsqueeze(0))outputs.append(out)outputs = torch.stack(outputs)
loss = criterion(outputs, targets)# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()

4.3 正则化

正则化技术如Dropout和L2正则化可以帮助防止模型过拟合。在RNN中，可以在隐藏状态或输出上应用Dropout。

代码实现：

import torch
import torch.nn as nnclass RegularizedRNN(nn.Module):def __init__(self, input_size, hidden_size, output_size, dropout_rate=0.5):super(RegularizedRNN, self).__init__()self.hidden_size = hidden_sizeself.rnn = nn.RNN(input_size, hidden_size, batch_first=True)self.dropout = nn.Dropout(dropout_rate)self.fc = nn.Linear(hidden_size, output_size)def forward(self, x):h0 = torch.zeros(1, x.size(0), self.hidden_size).to(x.device)out, _ = self.rnn(x, h0)out = self.dropout(out)out = self.fc(out[:, -1, :])return out# 定义模型
model = RegularizedRNN(input_size=10, hidden_size=20, output_size=5, dropout_rate=0.5)# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=0.01)# 生成示例数据
inputs = torch.randn(3, 10, 10)  # 批量大小3，序列长度10，输入特征10
targets = torch.randn(3, 5)       # 批量大小3，输出特征5# 前向传播
outputs = model(inputs)
loss = criterion(outputs, targets)# 反向传播和优化
optimizer.zero_grad()
loss.backward()
optimizer.step()

4.4 学习率调整

根据训练进度动态调整学习率可以帮助模型更快地收敛。可以使用学习率调度器来实现这一点。

代码实现：

# 定义模型、损失函数、优化器和学习率调度器
model = SimpleRNN(input_size=10, hidden_size=20, output_size=5)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)# 生成示例数据
inputs = torch.randn(5, 3, 10)  # 序列长度5，批量大小3，输入特征10
targets = torch.randn(5, 3, 5)   # 序列长度5，批量大小3，输出特征5for epoch in range(10):# 前向传播outputs, _ = model(inputs)loss = criterion(outputs, targets)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()# 更新学习率scheduler.step()print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}, Learning Rate: {scheduler.get_last_lr()[0]:.6f}")