深度学习R6周：LSTM实现糖尿病探索与预测

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

学习目标：

1.学习使用LSTM对糖尿病进行探索预测

2.尝试预测准确率提升到70％以上

环境：

语言环境：python3.8

编译器：pycharm

深度学习环境：pytorch

一、数据预处理

1.1设置GPU

python 复制代码

#设置GPU 
import torch.nn as nn 
import torch.nn.functional as F 
import torchvision,torch 

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

print(device)

结果输出：

1.2 数据导入

python 复制代码

#导入数据
import numpy   as np
import pandas  as pd
import seaborn as sns
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
plt.rcParams['savefig.dpi'] = 500 #图片像素
plt.rcParams['figure.dpi'] = 500 #分辨率

plt.rcParams['font.sans-serif'] = ['SimHei'] #用来正常显示中文标签

import warnings
warnings.filterwarnings('ignore')

DataFrame = pd.read_excel('/pythonProject/dia.xls')
print(DataFrame.head())

print(DataFrame.shape)

遇到问题：没有安装xlrd模块

解决方法：pip手动安装xlrd模块

结果输出：

1.3数据检查

python 复制代码

#查看数据是否有缺失值
print('数据缺失值--------------------------')
print(DataFrame.isnull().sum())

结果输出：

python 复制代码

#查看数据是否有重复值
print('数据重复值--------------------------')
print('数据集的重复值为：'f'{DataFrame.duplicated().sum()}')

结果输出：

1.4数据分布分析

python 复制代码

feature_map = { '年龄': '年龄',
    '高密度脂蛋白胆固醇': '高密度脂蛋白胆固醇',
    '低密度脂蛋白胆固醇': '低密度脂蛋白胆固醇',
    '极低密度脂蛋白胆固醇': '极低密度脂蛋白胆固醇',
    '甘油三酯': '甘油三酯',
    '总胆固醇': '总胆固醇',
    '脉搏': '脉搏',
    '舒张压':'舒张压',
    '高血压史':'高血压史',
    '尿素氮':'尿素氮',
    '尿酸':'尿酸',
    '肌酐':'肌酐',
    '体重检查结果':'体重检查结果'}

plt.figure(figsize=(15,10))

for i, (col, col_name) in enumerate(feature_map.items(), 1):
    plt.subplot(3,5,i)
    sns.boxplot(x=DataFrame['是否糖尿病'], y=DataFrame[col])
    plt.title(f'{col_name}的箱线图', fontsize=14)
    plt.ylabel('数值', fontsize=12)
    plt.grid(axis='y', linestyle='--', alpha=0.7)
    
plt.tight_layout()
plt.show()

结果输出：

可能某个地方出了问题，但还没找到

二、LSTM模型

2.1数据集构建

python 复制代码

#数据集构建

from sklearn.preprocessing import StandardScaler

# '高密度脂蛋白胆固醇'字段与糖尿病负相关，故而在 X 中去掉该字段
X = DataFrame.drop(['卡号','是否糖尿病','高密度脂蛋白胆固醇'],axis=1)
y = DataFrame['是否糖尿病']

# sc_X    = StandardScaler()
# X = sc_X.fit_transform(X)

X = torch.tensor(np.array(X), dtype=torch.float32)
y = torch.tensor(np.array(y), dtype=torch.int64)

train_X, test_X, train_y, test_y = train_test_split(X, y, 
                                                    test_size=0.2,
                                                    random_state=1)
print(train_X.shape, train_y.shape)

from torch.utils.data import TensorDataset, DataLoader

train_dl = DataLoader(TensorDataset(train_X, train_y),batch_size=64,shuffle=False)
test_dl  = DataLoader(TensorDataset(test_X, test_y),batch_size=64,shuffle=False)

结果输出：

2.2定义模型

python 复制代码

#定义模型
class model_lstm(nn.Module):
    def __init__(self):
        super(model_lstm, self).__init__()
        self.lstm0 = nn.LSTM(input_size=13,  hidden_size=200, num_layers=1, batch_first=True)
        self.lstm1 = nn.LSTM(input_size=200, hidden_size=200, num_layers=1, batch_first=True)
        self.fc0   = nn.Linear(200, 2)
        
    def forward(self, x):
        out, hidden1 = self.lstm0(x)
        out, _       = self.lstm1(out, hidden1)
        out          = self.fc0(out)
        return out
    
model = model_lstm().to(device)
print(model)

结果输出：

三、训练模型

3.1定义训练函数

python 复制代码

#定义训练函数
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.2定义测试函数

python 复制代码

#定义测试函数
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

3.3训练模型

python 复制代码

#训练模型
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)

结果输出：

四、模型评估

4.1Loss与Accuracy图

python 复制代码

#Loss与Accuracy图
import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100        #分辨率

from datetime import datetime
current_time = datetime.now()

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()

结果输出：

五、总结

LSTM实现糖尿病探索与预测，对整个实验有了熟悉，但对具体的数据分析还存在不足，现在得一点一点的学习实验数据的结果了。而且可以通过调整学习率的方法，提升准确率。

①随着训练的进行，训练准确率不断提升，但测试准确率前期停滞，后期上升，但小于训练准确率。

②训练损失持续下降。