PyTorch使用DataLoader自定义加载糖尿病患者数据集

最新推荐文章于 2023-04-05 10:14:53 发布
最新推荐文章于 2023-04-05 10:14:53 发布
阅读量1.2k 收藏 7
点赞数 1
分类专栏： PyTorch 文章标签： 深度学习 pytorch 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43051346/article/details/121668805
版权

Index 目录索引

写在前面

本文将承接上文，继续借助糖尿患者病情数据分析的分类案例，使用PyTorch来搭建人工智能神经网络1。主要探讨如何使用DataLoader来自定义数据集类，后面在此基础上做一个小的拓展2，将数据分为训练集和测试集，并在模型的评价指标中引入准确率acc。【这是深度学习数学原理专题系列的第六篇文章】

本案例的PyTorch代码实现

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time    : 2021/12/1 22:50
# @Author  : William Baker
# @FileName: lesson8_dataset_batch.py
# @Software: PyCharm
# @Blog    : https://blog.csdn.net/weixin_43051346

import os
os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'
import numpy as np
import torch
import matplotlib.pyplot as plt
from torch.utils.data import Dataset
from torch.utils.data import DataLoader


class DiabetsDateset(Dataset):
    def __init__(self, filepath):
        xy = np.loadtxt(filepath, delimiter=',', dtype=np.float32)
        self.len = xy.shape[0]
        self.x_data = torch.from_numpy(xy[:, :-1])
        self.y_data = torch.from_numpy(xy[:, [-1]])

    def __getitem__(self, index):
        return self.x_data[index], self.y_data[index]

    def __len__(self):
        return self.len

dataset = DiabetsDateset('./dataset/diabetes.csv.gz')
train_loader = DataLoader(dataset=dataset, batch_size=32,
                          shuffle=True, num_workers=2)

class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.linear1 = torch.nn.Linear(8, 6)
        self.linear2 = torch.nn.Linear(6, 4)
        self.linear3 = torch.nn.Linear(4, 1)
        self.sigmoid = torch.nn.Sigmoid()       # 将其看作是网络的一层，而不是简单的函数使用

    def forward(self, x):
        x = self.sigmoid(self.linear1(x))
        x = self.sigmoid(self.linear2(x))
        x = self.sigmoid(self.linear3(x))       # y_hat
        return x

model = Model()

criterion = torch.nn.BCELoss(reduction='mean')
optimizer = torch.optim.SGD(model.parameters(), lr=0.001)

if __name__ == '__main__':
    epoch_list = []
    loss_list = []
    for epoch in range(1000):
        for i, data in enumerate(train_loader, 0):
            inputs, labels = data
            y_pred = model(inputs)
            loss = criterion(y_pred, labels)
            print('Epoch:{}, iter:{}, Loss:{}'.format(epoch, i, loss.item()))

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

        epoch_list.append(epoch)
        loss_list.append(loss.item())

    plt.plot(epoch_list, loss_list)
    plt.xlabel('epoch')
    plt.ylabel('loss')
    plt.show()

输出结果为：

Epoch:0, iter:0, Loss:0.5866138935089111
Epoch:0, iter:1, Loss:0.7563868165016174
Epoch:0, iter:2, Loss:0.568118691444397
Epoch:0, iter:3, Loss:0.6052914261817932
Epoch:0, iter:4, Loss:0.6238793134689331
Epoch:0, iter:5, Loss:0.6244214177131653
Epoch:0, iter:6, Loss:0.6615402698516846
Epoch:0, iter:7, Loss:0.6803194284439087
Epoch:0, iter:8, Loss:0.6616236567497253
Epoch:0, iter:9, Loss:0.6055610179901123
Epoch:0, iter:10, Loss:0.6427847743034363
Epoch:0, iter:11, Loss:0.6243879199028015
Epoch:0, iter:12, Loss:0.6052394509315491
Epoch:0, iter:13, Loss:0.6425594091415405
Epoch:0, iter:14, Loss:0.6997544765472412
Epoch:0, iter:15, Loss:0.6616796851158142
Epoch:0, iter:16, Loss:0.6804618835449219
Epoch:0, iter:17, Loss:0.6429725885391235
Epoch:0, iter:18, Loss:0.6803658604621887
Epoch:0, iter:19, Loss:0.7556402087211609
Epoch:0, iter:20, Loss:0.5494366884231567
Epoch:0, iter:21, Loss:0.5864083766937256
Epoch:0, iter:22, Loss:0.6809739470481873
Epoch:0, iter:23, Loss:0.6454336047172546
Epoch:1, iter:0, Loss:0.6619009971618652
Epoch:1, iter:1, Loss:0.6054559350013733
Epoch:1, iter:2, Loss:0.5673891305923462
Epoch:1, iter:3, Loss:0.5676637887954712
Epoch:1, iter:4, Loss:0.6054767370223999
Epoch:1, iter:5, Loss:0.6617451906204224
Epoch:1, iter:6, Loss:0.7186353206634521
Epoch:1, iter:7, Loss:0.6050671339035034
Epoch:1, iter:8, Loss:0.6805665493011475
Epoch:1, iter:9, Loss:0.6429550051689148
Epoch:1, iter:10, Loss:0.6995329260826111
Epoch:1, iter:11, Loss:0.5868749022483826
Epoch:1, iter:12, Loss:0.6609913110733032
Epoch:1, iter:13, Loss:0.736927330493927
Epoch:1, iter:14, Loss:0.6614935398101807
Epoch:1, iter:15, Loss:0.7184151411056519
Epoch:1, iter:16, Loss:0.7373064160346985
Epoch:1, iter:17, Loss:0.6053014993667603
Epoch:1, iter:18, Loss:0.6615592241287231
Epoch:1, iter:19, Loss:0.5683175921440125
Epoch:1, iter:20, Loss:0.6054319739341736
Epoch:1, iter:21, Loss:0.6805724501609802
Epoch:1, iter:22, Loss:0.6430844068527222
Epoch:1, iter:23, Loss:0.5671136379241943
Epoch:2, iter:0, Loss:0.6806985139846802
Epoch:2, iter:1, Loss:0.6431689262390137
Epoch:2, iter:2, Loss:0.6054792404174805
Epoch:2, iter:3, Loss:0.6427459120750427
Epoch:2, iter:4, Loss:0.7186117768287659
Epoch:2, iter:5, Loss:0.6427768468856812
Epoch:2, iter:6, Loss:0.6996884346008301
Epoch:2, iter:7, Loss:0.7186328768730164
Epoch:2, iter:8, Loss:0.5862993001937866
Epoch:2, iter:9, Loss:0.6806195378303528
Epoch:2, iter:10, Loss:0.6244773268699646
Epoch:2, iter:11, Loss:0.661752462387085
Epoch:2, iter:12, Loss:0.5865373611450195
Epoch:2, iter:13, Loss:0.6242547035217285
Epoch:2, iter:14, Loss:0.643303632736206
Epoch:2, iter:15, Loss:0.6615922451019287
Epoch:2, iter:16, Loss:0.6052978038787842
Epoch:2, iter:17, Loss:0.7180856466293335
Epoch:2, iter:18, Loss:0.623708963394165
...
Epoch:998, iter:21, Loss:0.7610572576522827
Epoch:998, iter:22, Loss:0.6822502017021179
Epoch:998, iter:23, Loss:0.7005165219306946
Epoch:999, iter:0, Loss:0.6421785354614258
Epoch:999, iter:1, Loss:0.7613226175308228
Epoch:999, iter:2, Loss:0.6625707745552063
Epoch:999, iter:3, Loss:0.6627084612846375
Epoch:999, iter:4, Loss:0.7413778305053711
Epoch:999, iter:5, Loss:0.6616511344909668
Epoch:999, iter:6, Loss:0.6027993559837341
Epoch:999, iter:7, Loss:0.5633026957511902
Epoch:999, iter:8, Loss:0.6229657530784607
Epoch:999, iter:9, Loss:0.6030195951461792
Epoch:999, iter:10, Loss:0.6025324463844299
Epoch:999, iter:11, Loss:0.622697114944458
Epoch:999, iter:12, Loss:0.8208112120628357
Epoch:999, iter:13, Loss:0.6619958281517029
Epoch:999, iter:14, Loss:0.6227477788925171
Epoch:999, iter:15, Loss:0.6026306748390198
Epoch:999, iter:16, Loss:0.6423561573028564
Epoch:999, iter:17, Loss:0.5632070899009705
Epoch:999, iter:18, Loss:0.6031973958015442
Epoch:999, iter:19, Loss:0.6428719758987427
Epoch:999, iter:20, Loss:0.6228582262992859
Epoch:999, iter:21, Loss:0.7022585868835449
Epoch:999, iter:22, Loss:0.6028652191162109
Epoch:999, iter:23, Loss:0.6170942187309265

在这里插入图片描述

拓展

将数据分为训练集和测试集，并在模型的评价指标中引入准确率acc。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time    : 2021/12/2 6:01
# @Author  : William Baker
# @FileName: lesson8_train_val.py
# @Software: PyCharm
# @Blog    : https://blog.csdn.net/weixin_43051346
# import os
# os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'
import numpy as np
import torch
import matplotlib.pyplot as plt
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
from sklearn.model_selection import train_test_split


raw_data = np.loadtxt('C:/Users/***/dataset/diabetes.csv.gz', delimiter=',', dtype=np.float32)
X = raw_data[:, :-1]
Y = raw_data[:, [-1]]
Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y, test_size=0.3)
Xtest = torch.from_numpy(Xtest)
Ytest = torch.from_numpy(Ytest)

class DiabetsDateset(Dataset):
    def __init__(self, data, label):
        # xy = np.loadtxt(filepath, delimiter=',', dtype=np.float32)
        self.len = data.shape[0]
        self.x_data = torch.from_numpy(data)
        self.y_data = torch.from_numpy(label)

    def __getitem__(self, index):
        return self.x_data[index], self.y_data[index]

    def __len__(self):
        return self.len

dataset = DiabetsDateset(Xtrain, Ytrain)
train_loader = DataLoader(dataset=dataset, batch_size=32,
                          shuffle=True, num_workers=1)

class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.linear1 = torch.nn.Linear(8, 6)
        self.linear2 = torch.nn.Linear(6, 4)
        self.linear3 = torch.nn.Linear(4, 1)
        self.sigmoid = torch.nn.Sigmoid()       # 将其看作是网络的一层，而不是简单的函数使用

    def forward(self, x):
        x = self.sigmoid(self.linear1(x))
        x = self.sigmoid(self.linear2(x))
        x = self.sigmoid(self.linear3(x))       # y_hat
        return x

model = Model()

criterion = torch.nn.BCELoss(reduction='mean')
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

def train(epoch):
    train_loss = 0.0
    count = 0
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data
        y_pred = model(inputs)
        loss = criterion(y_pred, labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
        count = i

    if epoch % 20 == 19:
        print("train loss:", train_loss/count, end=',')

def test():
    with torch.no_grad():
        y_pred = model(Xtest)
        y_pred_label = torch.where(y_pred >= 0.5, torch.tensor([1.0]), torch.tensor([0.0]))
        acc = torch.eq(y_pred_label, Ytest).sum().item() / Ytest.size(0)
        print("test acc:", acc)

if __name__ == '__main__':
    for epoch in range(500):
       train(epoch)
       if epoch % 20 == 19:
           test()

输出为：

train loss: 0.6836073733866215,test acc: 0.6403508771929824
train loss: 0.6811290085315704,test acc: 0.6403508771929824
train loss: 0.683714009821415,test acc: 0.6403508771929824
train loss: 0.6818990334868431,test acc: 0.6403508771929824
train loss: 0.6818503625690937,test acc: 0.6403508771929824
train loss: 0.6826709099113941,test acc: 0.6403508771929824
train loss: 0.6799936965107918,test acc: 0.6403508771929824
train loss: 0.6799548231065273,test acc: 0.6403508771929824
train loss: 0.6781436987221241,test acc: 0.6403508771929824
train loss: 0.6833714731037617,test acc: 0.6403508771929824
train loss: 0.6814881190657616,test acc: 0.6403508771929824
train loss: 0.6823583282530308,test acc: 0.6403508771929824
train loss: 0.6779079474508762,test acc: 0.6403508771929824
train loss: 0.6813166737556458,test acc: 0.6403508771929824
train loss: 0.6830350793898106,test acc: 0.6403508771929824
train loss: 0.6811831593513489,test acc: 0.6403508771929824
train loss: 0.6802380681037903,test acc: 0.6403508771929824
train loss: 0.6784024983644485,test acc: 0.6403508771929824
train loss: 0.6809254698455334,test acc: 0.6403508771929824
train loss: 0.6799669452011585,test acc: 0.6403508771929824
train loss: 0.6808101087808609,test acc: 0.6403508771929824
train loss: 0.6806606911122799,test acc: 0.6403508771929824
train loss: 0.6805795542895794,test acc: 0.6403508771929824
train loss: 0.6778338365256786,test acc: 0.6403508771929824
train loss: 0.676879420876503,test acc: 0.6403508771929824

写到这里，差不多本文也就要结束了，如有错误，敬请指正。如果我的这篇文章帮助到了你，那我也会感到很高兴，一个人能走多远，在于与谁同行。

参考文章

  1. 《PyTorch深度学习实践》完结合集 - 08.加载数据集
     ↩︎

  2. PyTorch 深度学习实践 第8讲
     ↩︎

哈哈哈哈哈嗝哈哈哈
关注
专栏目录
diabetes数据集_pytorch基础8：数据集加载
weixin_31354669的博客
12-28 473
# 加载数据集，拿出一组minibatch,写成嵌套循环 # epoch:把所有样本进行训练; # minibatch:抽取一定数量的小样本进行训练;batch-size:每次抽取的数量 # iteration:内层的迭代执行多少次 # dataloader对dataset进行小批量处理:有shuffle将数据打乱,随后有loader将数据重组,给出batch import torch impor...
使用docker搭建分布式pytorch+cuda训练模型（一）
最新发布
2401_83051627的博客
07-10 1345
由于训练模型所需要的环境一致，因此使用docker创建镜像并在各个服务器中开启容器。随后运行pytorch模型进行分布式训练。过程如下主机使用centos镜像创建容器在容器中搭建环境，上传代码将容器打包成镜像将镜像发布到各个服务器各个服务器开启容器，执行分布式训练。
皮马印第安人糖尿病数据集
05-22
皮马印第安人糖尿病数据集 数据集共9个字段: 0列为pregnants(怀孕次数)； 1列为Plasma_glucose_concentration(口服葡萄糖耐量试验中2小时后的血浆葡萄糖浓度)； 2列为blood_pressure(舒张压,单位:mm Hg） 3列为Triceps_skin_fold_thickness(三头肌皮褶厚度,单位：mm） 4列为serum_insulin(餐后血清胰岛素,单位:mm） 5列为BMI,体重指数(体重(公斤/身高(米)^2) 6列为Diabetes_pedigree_function(糖尿病家系作用) 7列为Age(年龄) 8列为Target(分类变量,0或1）
机器学习+pytorch+diabets数据集（糖尿病数据集）+配合博文“Pytorch深度学习实践（六）”
03-16
1、机器学习入门 2、pytorch 3、已经分类好，并且有标签，配合博文一起食用
糖尿病数据集复现-pytorch
weixin_43907354的博客
09-28 470
import torch import numpy as np #加载数据集 xy = np.loadtxt('./diadata.csv',delimiter=',',dtype=np.float32,skiprows=1) # 此处csv文件为自己再excel中根据老师表格自己创建，成功导入,由于标题是字符串，故使用skiprows=1将第一行删掉，成功导入 x_data = torch.from_numpy(xy[0:,:-1]) #-1表示不要y这一列 y_data = torch.from_nu.
糖尿病数据集训练pytorch
luoshiyong123的博客
08-05 2196
import torch import numpy as np from matplotlib import pyplot as plt #加载数据集 xy = np.loadtxt('diabetes.csv',delimiter=',',dtype=np.float32) x_data = torch.from_numpy(xy[:,:-1]) y_data = torch.from_numpy(xy[:,[-1]]) #print(x_data) #建立模型 class MyModel(torch..
糖尿病预测(使用数据加载器 pytorch)
Batac的博客
02-01 625
import torch from torch.utils.data import Dataset from torch.utils.data import DataLoader import numpy as np # 1. 数据处理 class DiabetesDataset(Dataset): def __init__(self, file_path): xy = np.loadtxt(file_path, delimiter=',', dtype=np.float32) .
《Pytorch深度学习实践》课程合集（刘二大人）笔记
竦貊的博客
05-30 4853
2 线性模型 深度学习步骤 数据集 —— 拿到的训练集，要分成两部分，训练集，交叉验证集 和 测试集 模型 训练 推理 ML常用损失函数
【B站_刘二大人pytorch深度学习实践】笔记作业代码合集
m0_58586235的博客
03-12 3019
手动训练：线性模型，梯度下降，BP Pytorch框架训练：线性回归，LogisticRegression，多维特征输入，加载数据集，多分类，CNN，RNN
win10下使用pycharm实现基于pyg的cora+citeseer+pubmed数据集的JKNET模型测试
图挖掘领域，新晋砖家 ☞ 未来可期，欢迎和静静一起学习交流吖
01-31 1137
目录 前期准备工作 1、数据集基本情况 2、标准数据集划分方式 3、数据集处理和分析 整体数据分析 cora citeseer pubmed 4、代码参考 GraphSAGE实验结果（代码详细注释） 1、代码结构 2、超参数 3、实验结果(pubmed+mean_pool+sum) 2层SageGCN层 实验补充 3层SageGCN层 4、问题分析 GraphSAGE原文使用的citation数据集 GraphSage没有使用cora等着三个数据集的简单分析 关于数据
Diabetic_Reinopathy_Detection:使用Pytorch检测糖尿病性视网膜病变
05-09
糖尿病_视网膜病变_检测 使用Pytorch检测糖尿病性视网膜病变 关于数据集 数据集包含左眼和右眼的图像。 可以在这里找到更多信息： : 数据预处理 由于图像有噪点，因此我通过裁剪图像将其删除，同时也存在类不平衡问题，因此我通过数据扩充将其删除。 关于实施 在这里，我在Kaggle数据集上实现了糖尿病性视网膜病变检测，该存储库中有两种实现方式： 1.二进制分类： 在bin_retinet.py中，该模型可以预测一个人是否患有糖尿病性视网膜病。 2.多类分类： 模型在multi_retinet.py中预测一个人是否患有：0-无DR 1-轻度2-中等3-严重4-增殖性DR
tensorflow糖尿病数据二分类python代码+注释+调参过程
11-24
使用tensorflow集成的神经网络实现的基于糖尿病数据的二分类的python实现，内含代码、分配好的数据集以及调参过程，代码中有详细的注释以及可视化操作。欢迎下载交流！
糖尿病检测
02-07
糖尿病检测
博客：pytorch 搭建神经网络最简版 配套资源
06-24
通过以上步骤，我们已经在PyTorch中构建了一个简单的神经网络模型，用于预测糖尿病数据集。这个模型可以作为进一步改进和扩展的基础，例如添加更多的隐藏层、调整学习率或使用更复杂的优化算法。理解这些基本概念...
糖尿病预测（深度学习pytorch实现-最新）
NangoGreen的博客
04-05 3766
本次做的项目是糖尿病的预测，也是来自kaggle上面的一个小项目。根据一个人的怀孕次数、血糖、血压、皮肤厚度、胰岛素指标、身体质量指数、糖尿病谱系指数、年龄等身体参数来预测一个人是否患有糖尿病。
糖尿病的预测(pytorch)
Batac的博客
02-01 1646
import numpy as np import torch # 糖尿病预测研判 # 1. 处理数据 xy = np.loadtxt('diabetes.csv.gz', delimiter=',', dtype=np.float32) x_data = torch.from_numpy(xy[:, :-1]) y_data = torch.from_numpy(xy[:, [-1]]) # 2. 建立模型 # 2. 设计模型 继承自torch.nn.Module class Model(torch.
(六)处理多维特征的输入（下）+pytorch实现糖尿病数据集的逻辑回归
Queen_sy的博客
10-19 936
pima-indians-diabetes: 一、 数据说明： Pima Indians Diabetes Data Set（皮马印第安人糖尿病数据集） 根据现有的医疗信息预测5年内皮马印第安人糖尿病发作的概率。数据链接：https://archive.ics.uci.edu/ml/datasets/Pima+Indians+Diabetes。
【pytorch记录】torch.utils.data.Dataset、DataLoader、分布式读取并数据
magic_ll的博客
03-07 7812
pytorch提供了一个数据读取的方法，使用了 torch.utils.data.Dataset 和 torch.utils.data.DataLoader。 要自定义自己数据的方法，就要继承 torch.utils.data.Dataset，实现了数据读取以及数据处理方式，并得到相应的数据处理结果。然后将 Dataset封装到 DataLoader中，可以实现了单/多进程迭代输出数据。 1 torch.utils.data.Dataset 要自定义自己的 Dataset 类，需要重载两个方式，【_.
python 自带数据对糖尿病病人线性分析
qq_41198463的博客
04-28 2759
线性分析 """ 使用sklearn自带的糖尿病数据集，进行回归分析 Diabetes：包含442个患者的10个生理特征（年龄，性别、体重、血压）和一年以后疾病级数指标 """ from sklearn import datasets from sklearn import linear_model from sklearn.model_selection import train_test_...
PyTorch自定义数据集加载教程：实例解析
总结来说，PyTorch加载自定义数据集的关键在于理解`Dataset`类的抽象和`DataLoader`的作用，以及如何根据数据集的组织结构进行适当的预处理。通过创建子类并重写必要的方法，可以灵活地处理各种类型和格式的数据集，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值