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

深度学习笔记25-RNN心脏病预测(Pytorch)

news 来源：原创 2025/6/1 12:55:32

🍨 本文为🔗365天深度学习训练营中的学习记录博客
🍖 原作者：K同学啊

一、前期准备

1.数据处理

import torch.nn.functional as F
import numpy as np
import pandas as pd
import torch
from torch import nn

df=pd.read_csv(r"D:\Pytorch\heart.csv")
df

二、构建数据集

1.标准化

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_splitX= 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)
X_train.shape, y_train.shape

3.构建数据加载器

from torch.utils.data import TensorDataset,DataLoader
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()
model

2.定义训练函数

# 训练循环
def train(dataloader,model,loss_fn,optimizer):size=len(dataloader.dataset)num_batches=len(dataloader)train_loss,train_acc=0,0 #初始化训练损失和正确率for X,y in dataloader:#计算预测误差pred=model(X)   #网络输出loss=loss_fn(pred,y) #计算网络输出和真实值之间的差距# 反向传播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:#计算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=50
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)

四、模型评估

1.loss与accuracy图

import matplotlib.pyplot as plt
from datetime import datetime
#隐藏警告
import warnings
warnings.filterwarnings("ignore")#忽略警告信息
current_time=datetime.now()#获取当前时间# 设置 Matplotlib 参数
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()

2.混淆矩阵

print('=======输入数据shape为=======')
print("x_test.shape:",X_test.shape)
print("y_test.shape:",y_test.shape)
pred = model(X_test).argmax(1).cpu().numpy()
print("\n=====输出数据Shape为=====")
print("pred.shape: ",pred.shape)

import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix,ConfusionMatrixDisplay
#计算混淆矩阵
cm = confusion_matrix(y_test, pred)plt.figure(figsize=(6,5))
plt.suptitle('')
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")#修改字体大小
plt.xticks(fontsize=10)
plt.yticks(fontsize=10)
plt.title("Confusion Matrix", fontsize=12)
plt.xlabel("Predicted Label",fontsize=10)
plt.ylabel("True Label",fontsize=10)#显示图
plt.tight_layout() # 调整布局防止重叠
plt.show()

3.调用模型进行预测

test_X=X_test[0].unsqueeze(1)  # X_test[0]即我们的输入数据
pred = model(test_X).argmax(1).item()
print("模型预测结果为：",pred)
print("=="*10)
print("0:不会患心脏病")
print("1:可能患心脏病")

五、总结

RNN 的核心特点是它能够利用序列中的历史信息来影响当前的输出。

RNN 的特点

记忆性：RNN 能够利用历史信息来影响当前的输出，这使得它在处理序列数据时非常有效。例如，在自然语言处理中，RNN 可以利用前面的单词来预测下一个单词。
灵活性：RNN 的结构可以灵活地处理不同长度的序列数据，适用于各种序列任务，如语言建模、机器翻译、语音识别等。
动态性：RNN 的状态是动态变化的，能够适应序列中的时间依赖性。