刘二大人 Dataset and DataLoader with Pytorch代码实现

Dataset and DataLoader

---

步骤

引入库

import torch
#从torch的工具的数据里面引入Dataset(是一个抽象类，不能实例化，只能被其他子类去继承)
from torch.utils.data import Dataset
#从torch的工具的 数据里面引入DataLoader(可以实例化一个DataLoader)
from torch.utils.data import DataLoader
import numpy as np
import matplotlib.pyplot as plt

Prepare dataset

#定义糖尿病数据集分类，继承自Dataset
class DiabetesDataset(Dataset):
    #自身初始化文件路径
    def __init__(self,filepath):
        #加载文本，文件路径，分隔符是逗号，数据类型是32位浮点型
        xy = np.loadtxt(filepath,delimiter=',',dtype=np.float32)
        #长度等于shape[0]，长度等于数据的高度
        self.len = xy.shape[0]
        #x取所有行和除了最后一列的所有列
        self.x_data = torch.from_numpy(xy[:,:-1])
        #y取所有行和最后一列
        self.y_data = torch.from_numpy(xy[:,[-1]])
    #使用getitem方法可以通过数据的索引将数据拿出来
    def __getitem__(self,index):
        #根据x的索引返回x的数据，根据y的索引返回y的数据
        return self.x_data[index],self.y_data[index]
    #返回数据集的长度
    def __len__(self):
        return self.len
#实例化   
dataset = DiabetesDataset('diabetes.csv')
#dataLoader加载器，传递数据集，设置样本数量为32个，打乱，设置并行工作的数量为0
train_loader = DataLoader(dataset=dataset,batch_size=32,shuffle=True,num_workers=0)

Design model using Class

#构造模型
class Model(torch.nn.Module):
    #初始化自身对象
    def __init__(self):
        #super调用父类初始化器
        super(Model,self).__init__()
        #构造一个输入是8维，输出是6维的线性模型
        self.linear1 = torch.nn.Linear(8,6)
        #构造一个输入是6维，输出是4维的线性模型
        self.linear2 = torch.nn.Linear(6,4)
        #构造一个输入是4维，输出是1维的线性模型
        self.linear3 = torch.nn.Linear(4,1)
        #构造一个逻辑回归模型
        self.sigmoid = torch.nn.Sigmoid()
    #前向传播
    def forward(self,x):
        #用sigmoid激活线性模型1，也就是将线性模型1代入到sigmoid里面
        x = self.sigmoid(self.linear1(x))
        #用sigmoid激活线性模型2
        x = self.sigmoid(self.linear2(x))
        #用sigmoid激活线性模型3
        x = self.sigmoid(self.linear3(x))
        #返回x
        return x
#实例化模型
model = Model()

Construct loss and optimizer

#构造二分类交叉熵求损失降维求平均
criterion = torch.nn.BCELoss(reduction='mean')
#优化模块中的SGD模型中的所有参数，学习率为0.05
optimizer = torch.optim.SGD(model.parameters(),lr=0.05)
epoch_list = []
loss_list = []

Training cycle

#封装到if语句里面
if __name__=='__main__':
    #所有数据都跑1000遍
    for epoch in range(1000):
        loss_batch = 0
        #i是记录第几次，data是数据,用列举的方法将loader中的数据取出，从0开始。
        for i,data in enumerate(train_loader,0):
            #将输入x和相应的标签y从数据中拿出来
            inputs,labels = data
            #将输入送入模型中，求y的预测值
            y_pred = model(inputs)
            #计算损失
            loss = criterion(y_pred,labels)
            loss_batch += loss.item()
            #输出总的循环次数，mini-batch的循环次数，和损失的标量
            print(epoch,i,loss.item())
            
            #梯度归零
            optimizer.zero_grad()
            #反向传播
            loss.backward()
            #优化更新
            optimizer.step()
        epoch_list.append(epoch)
        loss_list.append(loss_batch/i)

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