PyTorch深度学习实践——加载数据集

常用的定义：

Epoch:One forawrd pass and one backward pass of all the training example
Batch-size:The number of training example in one forward backward pass
Iteration:The number of passes,each pass using [bach-size] number of examples
迭代次数（iteration）=样本总数（epoch）/批尺寸（batchszie）

1.DataSet 是抽象类，不能实例化对象，主要用于记载数据
2.DataLoader是Pytorch中用来处理模型输入数据的一个工具类。组合了数据集（dataset） + 采样器(sampler)，并在数据集上提供单线程或多线程(num_workers )的可迭代对象

定义数据集：

import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader

class DiabetesDataset(Dataset):
    def __init__(self):
        def __init__(self):
            pass
        #获取下标
        def __getitem__(self,index):
            pass
        #获取长度
        def __len__(self):
            pass

dataset = DiabetesDataset()
train_loader = DataLoader(dataset=dataset,
                          batch_size=32,
                          shuffle=True,
                          num_workers=2)  #num_workers 多线程的数量

........
#在Windows环境下
if __name__ == '__main__':
    for epoch in range(100):
        for i,data in enumerate(train_loader,0):
            

'''import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader

class DiabetesDataset(Dataset):
    def __init__(self):
        def __init__(self):
            pass
        #获取
        def __getitem__(self,index):
            pass
        #获取长度
        def __len__(self):
            pass

dataset = DiabetesDataset()
train_loader = DataLoader(dataset=dataset,
                          batch_size=32,
                          shuffle=True,
                          num_workers=2)  #num_workers 多线程的数量

........
#在Windows环境下
if __name__ == '__main__':
    for epoch in range(100):
        for i,data in enumerate(train_loader,0):'''

import torch
import numpy as np
from torch.utils.data import Dataset
from torch.utils.data import DataLoader

class DiabetesDataset(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 = DiabetesDataset(r'C:\Users\22843\pythonProject3\data\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))
        return x

model = Model()

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

if __name__ == '__main__':
    for epoch in  range(1000):
        for i,data in enumerate(train_loader,0):
            #Prepare data
            inputs,labels = data
            #Forward
            y_pred = model(inputs)
            loss = criterion(y_pred,labels)
            print(epoch,loss.item())
            #Backward
            optimizer.zero_grad()
            loss.backward()
            #update
            optimizer.step()