- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍖 原作者：K同学啊
一、RNN
循环神经网络（Recurrent Neural Network，简称 RNN）是一类以序列数据为输入，在序列的演进方向进行递归且所有节点（循环单元）按链式连接的递归神经网络。
基本原理 *
RNN 通过引入隐藏层的循环结构，使得网络能够对序列中的历史信息进行记忆和利用。在传统的神经网络中，输入和输出是独立的，而 RNN 则允许信息从一个步骤传递到下一个步骤，从而形成一种 “记忆” 能力。
- 以一个简单的 RNN 单元为例，它接收当前时刻的输入 (x_t) 和上一时刻的隐藏状态 (h_{t-1})，通过激活函数（如 tanh）计算出当前时刻的隐藏状态 (h_t)，然后再根据 (h_t) 计算出当前时刻的输出 (o_t)。
主要特点 *
处理序列信息的能力 ：RNN 能够处理长度可变的序列数据，这使得它在自然语言处理、时间序列预测、语音识别等任务中表现出色，因为这些任务中的数据通常具有序列性和时间依赖性。
参数共享 ：在整个序列中，RNN 的参数（权重矩阵和偏置向量）是共享的，这不仅减少了模型的参数量，还使得模型能够对不同位置的输入进行统一的处理和学习
典型结构
- 简单 RNN（Simple RNN） ：是最基本的 RNN 结构，其隐藏层的激活函数通常采用 tanh 函数。然而，简单 RNN 在处理长序列时容易出现梯度消失和梯度爆炸问题，导致模型难以学习到长期依赖关系。
- 长短期记忆网络（LSTM） ：为了解决简单 RNN 的梯度问题，LSTM 引入了三个门结构（输入门、遗忘门和输出门）以及一个记忆单元（细胞状态），能够有效地控制信息的流动和记忆的更新，从而更好地捕捉长期依赖关系。
- 门控循环单元（GRU） ：GRU 是 LSTM 的一种变体，它将遗忘门和输入门合并为一个更新门，简化了模型结构，同时在一定程度上也能够缓解梯度消失问题，并且在一些任务中具有更快的训练速度。
应用场景
- 自然语言处理（NLP） ：如文本生成、机器翻译、情感分析、命名实体识别等任务，RNN 可以对文本序列中的单词或字符进行建模，捕捉上下文信息。
- 时间序列预测 ：例如股票价格预测、天气预测等，RNN 能够利用历史数据中的时间依赖关系来进行未来值的预测。
- 语音识别 ：将语音信号转换为文字，RNN 可以对语音信号的时序特征进行建模，以识别出对应的词汇和语句。
局限性
- 梯度消失和爆炸问题 ：虽然 LSTM 和 GRU 在一定程度上缓解了这个问题，但在处理非常长的序列时，仍然可能会出现梯度消失或爆炸的情况，导致模型难以收敛或训练不稳定。
- 训练速度较慢 ：由于 RNN 的循环结构，在训练过程中需要按序列步骤进行计算，无法像全连接神经网络或卷积神经网络那样进行高效的并行计算，因此训练速度相对较慢。
- 难以捕捉长期依赖关系 ：尽管 LSTM 和 GRU 等改进的 RNN 结构在一定程度上能够捕捉长期依赖关系，但对于一些特别长的序列，仍然可能无法有效地建模长期的上下文信息。
二、前期准备
1.导入库
import numpy as np
import pandas as pd
import torch
from torch import nn
import torch.nn.functional as F
import seaborn as sns
from torch.utils.data import TensorDataset, DataLoader
#设置GPU训练，也可以使用CPU
device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
2.导入数据
df = pd.read_csv("heart.csv")
三、构建数据集
1.标准化
x= df.iloc[:,:-1]
y = df.iloc[:,-1]
# 将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的
sc = StandardScaler()
X = sc.fit_transform(X)
2.划分数据集
X = torch.tensor(np.array(X), dtype=torch.float32)
y = torch.tensor(np.array(y), dtype=torch.int64)
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size = 0.1,
random_state = 1)
# 维度扩增使其符合RNN模型可接受shape
X_train = X_train.unsqueeze(1)
X_test = X_test.unsqueeze(1)
3.构建数据加载器
train_dl = DataLoader(TensorDataset(X_train, y_train),
batch_size=64,
shuffle=False)
test_dl = DataLoader(TensorDataset(X_test, y_test),
batch_size=64,
shuffle=False)
四、模型训练
1.构建模型
class model_rnn(nn.Module):
def __init__(self):
super(model_rnn, self).__init__()
self.rnn0 = nn.RNN(input_size=13 ,hidden_size=200,
num_layers=1, batch_first=True)
self.fc0 = nn.Linear(200, 50)
self.fc1 = nn.Linear(50, 2)
def forward(self, x):
out, _ = self.rnn0(x)
out = out[:, -1, :] # 只取最后一个时间步的输出
out = self.fc0(out)
out = self.fc1(out)
return out
model = model_rnn().to(device)
print(model)
model_rnn(
(rnn0): RNN(13, 200, batch_first=True)
(fc0): Linear(in_features=200, out_features=50, bias=True)
(fc1): Linear(in_features=50, out_features=2, bias=True)
)
2.训练函数
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset) # 训练集的大小
num_batches = len(dataloader) # 批次数目, (size/batch_size，向上取整)
train_loss, train_acc = 0, 0 # 初始化训练损失和正确率
for X, y in dataloader: # 获取图片及其标签
X, y = X.to(device), y.to(device)
# 计算预测误差
pred = model(X) # 网络输出
loss = loss_fn(pred, y) # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
# 反向传播
optimizer.zero_grad() # grad属性归零
loss.backward() # 反向传播
optimizer.step() # 每一步自动更新
# 记录acc与loss
train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
train_loss += loss.item()
train_acc /= size
train_loss /= num_batches
return train_acc, train_loss
3.测试集
def test (dataloader, model, loss_fn):
size = len(dataloader.dataset) # 测试集的大小
num_batches = len(dataloader) # 批次数目, (size/batch_size，向上取整)
test_loss, test_acc = 0, 0
# 当不进行训练时，停止梯度更新，节省计算内存消耗
with torch.no_grad():
for imgs, target in dataloader:
imgs, target = imgs.to(device), target.to(device)
# 计算loss
target_pred = model(imgs)
loss = loss_fn(target_pred, target)
test_loss += loss.item()
test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()
test_acc /= size
test_loss /= num_batches
return test_acc, test_loss
4.模型训练
loss_fn = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-4 # 学习率
opt = torch.optim.Adam(model.parameters(),lr=learn_rate)
epochs = 30
train_loss = []
train_acc = []
test_loss = []
test_acc = []
for epoch in range(epochs):
model.train()
epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)
model.eval()
epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
train_acc.append(epoch_train_acc)
train_loss.append(epoch_train_loss)
test_acc.append(epoch_test_acc)
test_loss.append(epoch_test_loss)
# 获取当前的学习率
lr = opt.state_dict()['param_groups'][0]['lr']
template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss,
epoch_test_acc*100, epoch_test_loss, lr))
print("="*20, 'Done', "="*20)
warnings.filterwarnings("ignore") #忽略警告信息
current_time = datetime.now() # 获取当前时间
plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号
plt.rcParams['figure.dpi'] = 200 #分辨率
epochs_range = range(epochs)
plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.xlabel(current_time) # 打卡请带上时间戳，否则代码截图无效
plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
Epoch:1, Train_acc:56.2%, Train_loss:0.687, Test_acc:52.8%, Test_loss:0.689, Lr:1.00E-04
Epoch:2, Train_acc:58.6%, Train_loss:0.675, Test_acc:55.4%, Test_loss:0.673, Lr:1.00E-04
Epoch:3, Train_acc:64.3%, Train_loss:0.662, Test_acc:62.3%, Test_loss:0.661, Lr:1.00E-04
Epoch:4, Train_acc:67.8%, Train_loss:0.652, Test_acc:65.6%, Test_loss:0.652, Lr:1.00E-04
Epoch:5, Train_acc:70.4%, Train_loss:0.641, Test_acc:70.2%, Test_loss:0.645, Lr:1.00E-04
Epoch:6, Train_acc:71.8%, Train_loss:0.634, Test_acc:72.3%, Test_loss:0.634, Lr:1.00E-04
Epoch:7, Train_acc:73.5%, Train_loss:0.627, Test_acc:74.2%, Test_loss:0.623, Lr:1.00E-04
Epoch:8, Train_acc:75.2%, Train_loss:0.620, Test_acc:75.8%, Test_loss:0.617, Lr:1.00E-04
Epoch:9, Train_acc:76.4%, Train_loss:0.615, Test_acc:76.8%, Test_loss:0.612, Lr:1.00E-04
Epoch:10, Train_acc:77.6%, Train_loss:0.608, Test_acc:77.9%, Test_loss:0.605, Lr:1.00E-04
Epoch:11, Train_acc:78.7%, Train_loss:0.602, Test_acc:78.2%, Test_loss:0.598, Lr:1.00E-04
Epoch:12, Train_acc:79.5%, Train_loss:0.596, Test_acc:79.3%, Test_loss:0.595, Lr:1.00E-04
Epoch:13, Train_acc:80.4%, Train_loss:0.590, Test_acc:80.1%, Test_loss:0.588, Lr:1.00E-04
Epoch:14, Train_acc:81.0%, Train_loss:0.586, Test_acc:81.5%, Test_loss:0.584, Lr:1.00E-04
Epoch:15, Train_acc:81.5%, Train_loss:0.582, Test_acc:82.0%, Test_loss:0.580, Lr:1.00E-04
Epoch:16, Train_acc:81.8%, Train_loss:0.578, Test_acc:82.2%, Test_loss:0.578, Lr:1.00E-04
Epoch:17, Train_acc:82.0%, Train_loss:0.576, Test_acc:82.1%, Test_loss:0.576, Lr:1.00E-04
Epoch:18, Train_acc:82.2%, Train_loss:0.574, Test_acc:82.3%, Test_loss:0.574, Lr:1.00E-04
Epoch:19, Train_acc:82.3%, Train_loss:0.572, Test_acc:82.2%, Test_loss:0.572, Lr:1.00E-04
Epoch:20, Train_acc:82.4%, Train_loss:0.570, Test_acc:82.3%, Test_loss:0.570, Lr:1.00E-04
Epoch:21, Train_acc:82.4%, Train_loss:0.569, Test_acc:82.3%, Test_loss:0.569, Lr:1.00E-04
Epoch:22, Train_acc:82.5%, Train_loss:0.568, Test_acc:82.3%, Test_loss:0.568, Lr:1.00E-04
Epoch:23, Train_acc:82.5%, Train_loss:0.567, Test_acc:82.4%, Test_loss:0.567, Lr:1.00E-04
Epoch:24, Train_acc:82.5%, Train_loss:0.566, Test_acc:82.4%, Test_loss:0.566, Lr:1.00E-04
Epoch:25, Train_acc:82.5%, Train_loss:0.565, Test_acc:82.4%, Test_loss:0.565, Lr:1.00E-04
Epoch:26, Train_acc:82.5%, Train_loss:0.564, Test_acc:82.4%, Test_loss:0.564, Lr:1.00E-04
Epoch:27, Train_acc:82.5%, Train_loss:0.563, Test_acc:82.4%, Test_loss:0.563, Lr:1.00E-04
Epoch:28, Train_acc:82.5%, Train_loss:0.563, Test_acc:82.4%, Test_loss:0.563, Lr:1.00E-04
Epoch:29, Train_acc:82.5%, Train_loss:0.562, Test_acc:82.4%, Test_loss:0.562, Lr:1.00E-04
Epoch:30, Train_acc:82.5%, Train_loss:0.562, Test_acc:82.4%, Test_loss:0.562, Lr:1.00E-04
==================== Done ====================