【深度学习基础模型】递归神经网络 (Recurrent Neural Networks, RNN) 详细理解并附实现代码。

【深度学习基础模型】递归神经网络 (Recurrent Neural Networks, RNN)

【深度学习基础模型】递归神经网络 (Recurrent Neural Networks, RNN)

---

---

参考地址：https://www.asimovinstitute.org/neural-network-zoo/
论文地址：https://www.sciencedirect.com/science/article/abs/pii/036402139090002E

欢迎宝子们点赞、关注、收藏！欢迎宝子们批评指正！

1.算法原理介绍：递归神经网络 (Recurrent Neural Networks, RNN)

1.1 递归神经网络 (RNN) 概述

递归神经网络 (RNN) 是前馈神经网络 (FFNN) 的扩展，其主要特点是引入了时间维度上的依赖关系，使得网络具有记忆功能。

RNN 通过在不同时间步上共享权重，并通过递归连接在时间序列上传播信息，从而能够处理时间序列数据或顺序依赖性任务。

相比于传统的 FFNN，RNN 可以理解输入序列的顺序，并根据序列中前面的信息来调整当前的输出。

1.2 RNN 的关键特性

• 时间依赖性：RNN 中的每个神经元不仅接收当前时刻的输入，还接收上一个时刻的隐藏状态。这个特性使得 RNN 可以在序列数据中传播信息。
• 权重共享：所有时刻的隐藏层共享相同的权重矩阵，使得RNN能够处理可变长度的输入序列。
• 递归连接：通过递归连接，RNN 可以将前一时刻的隐藏状态作为当前时刻的输入，从而在时间步之间传播信息。

1.3 RNN 的工作原理

在一个标准的RNN 中，给定输入序列 $X=(x_1,x_2,\dots ,x_T)$，隐藏状态 $h_t$的更新公式如下：
$h_t=\sigma (W_{ih}{x}_t+W_{hh}{h}_{t-1}+b_h）$
其中：

• $h_t$是当前时刻的隐藏状态。
• $W_{ih}$是输入到隐藏状态的权重矩阵。
• $W_{hh}$是隐藏状态之间的递归权重矩阵。
• $x_t$是当前时间步的输入。
• $b_h$是偏置项。
• $\sigma$是激活函数（如 tanh 或 ReLU）。

最终，输出层的输出$y_t$计算如下：
$y_t=\sigma (W_{ho}{h}_t+b_o）$

1.4 RNN 的问题：梯度消失与梯度爆炸

由于 RNN 在每个时间步上进行梯度传播，如果序列较长，梯度在反向传播时会呈指数增长或减少，导致梯度爆炸或梯度消失问题。这限制了 RNN 处理长期依赖关系的能力。在实际应用中，长短期记忆网络 (LSTM) 和门控循环单元 (GRU) 被提出用来解决这个问题。

1.5 RNN 的应用

RNN 广泛用于处理与序列相关的任务，常见应用包括：

• 自然语言处理 (NLP)：如文本生成、机器翻译、文本分类、情感分析等。
• 语音识别：将语音信号作为输入序列，通过 RNN 处理时间依赖性。
• 时间序列预测：例如股票价格预测、天气预报等。

2.Python 实现 RNN 的应用实例

我们将使用 Python 和深度学习框架 PyTorch 实现一个简单的 RNN，用于文本分类任务。

2.1代码实现：递归神经网络的实现及文本分类应用

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import numpy as np# 创建简单的文本数据
# 假设我们有两个类别的文本数据，每个句子都是单词的索引表示
# 类别 0: "I love machine learning", "deep learning is great"
# 类别 1: "I hate spam emails", "phishing attacks are bad"
X = [[1, 2, 3, 4],     # "I love machine learning"[5, 6, 7, 8],     # "deep learning is great"[1, 9, 10, 11],   # "I hate spam emails"[12, 13, 14, 15]  # "phishing attacks are bad"
]
y = [0, 0, 1, 1]  # 标签，0表示积极类别，1表示消极类别# 转换为Tensor格式
X = torch.tensor(X, dtype=torch.long)
y = torch.tensor(y, dtype=torch.long)# 定义数据集和数据加载器
dataset = TensorDataset(X, y)
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)# 定义 RNN 模型
class RNN(nn.Module):def __init__(self, input_size, hidden_size, output_size, num_layers):super(RNN, self).__init__()self.hidden_size = hidden_sizeself.num_layers = num_layersself.embedding = nn.Embedding(input_size, hidden_size)  # 嵌入层，将输入单词的索引转换为向量self.rnn = nn.RNN(hidden_size, hidden_size, num_layers, batch_first=True)  # RNN层self.fc = nn.Linear(hidden_size, output_size)  # 全连接层，用于分类输出def forward(self, x):# 初始化隐藏状态，形状为 (num_layers, batch_size, hidden_size)h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)# 通过嵌入层转换输入out = self.embedding(x)# 通过 RNN 层out, _ = self.rnn(out, h0)# 取最后一个时间步的隐藏状态作为输出out = out[:, -1, :]# 通过全连接层得到最终的分类输出out = self.fc(out)return out# 模型参数
input_size = 16  # 假设我们有16个不同的单词
hidden_size = 8  # 隐藏层大小
output_size = 2  # 二分类问题
num_layers = 1  # RNN层数# 创建 RNN 模型
model = RNN(input_size, hidden_size, output_size, num_layers)# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()  # 分类任务使用交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.01)# 训练模型
num_epochs = 20
for epoch in range(num_epochs):for data, labels in dataloader:# 前向传播outputs = model(data)loss = criterion(outputs, labels)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()if (epoch+1) % 5 == 0:print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')# 测试模型
with torch.no_grad():test_sentence = torch.tensor([[1, 2, 3, 4]])  # 测试句子 "I love machine learning"prediction = model(test_sentence)predicted_class = torch.argmax(prediction, dim=1)print(f'Predicted class: {predicted_class.item()}')

2.2代码解释

1.定义 RNN 模型：

• self.embedding = nn.Embedding(input_size, hidden_size)：这是嵌入层，用于将输入的单词索引（如“1, 2, 3, 4”）转换为高维向量表示。
• self.rnn = nn.RNN(hidden_size, hidden_size, num_layers, batch_first=True)：定义 RNN 层，输入大小为 hidden_size，输出也为 hidden_size，序列是按批次为第一维度（batch_first=True）。
• self.fc = nn.Linear(hidden_size, output_size)：全连接层，将最后一个时间步的 RNN 输出映射为类别预测（输出大小为2，表示二分类任务）。

2.RNN 的前向传播：

• h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)：初始化隐藏状态为0。
• out, _ = self.rnn(out, h0)：RNN 前向传播，得到每个时间步的隐藏状态。
• out = out[:, -1, :]：取最后一个时间步的输出，作为最终输出。
• out = self.fc(out)：通过全连接层进行分类。

3.数据集生成与加载：

• 我们使用了简单的二分类文本数据（表示为单词索引序列），并转换为 PyTorch 的 TensorDataset 和 DataLoader。

4.训练与测试：

• 使用 Adam 优化器和交叉熵损失函数训练模型，并在每 5 个 epoch 打印一次损失。
• 在测试阶段，我们用一个测试句子进行分类预测，并打印出预测的类别。

3.总结

递归神经网络 (RNN) 是处理序列数据的重要工具，适用于自然语言处理、语音识别、时间序列预测等任务。然而，RNN 存在梯度消失与梯度爆炸问题，尤其是在处理长序列时。

在实际应用中，RNN 已被改进为 LSTM 和 GRU 等架构，解决了这些问题。通过 PyTorch 实现的 RNN 示例展示了其在文本分类中的应用。