P21-RNN-心脏病预测

• 🍨 本文为🔗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与losstrain_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()train_loss += loss.item()train_acc  /= sizetrain_loss /= num_batchesreturn 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)# 计算losstarget_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  /= sizetest_loss /= num_batchesreturn test_acc, test_loss

4.模型训练

loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-4   # 学习率
opt        = torch.optim.Adam(model.parameters(),lr=learn_rate)
epochs     = 30train_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 ====================