7、加载数据集

基本概念介绍

（1）  Batch：全部数据都用，最大化运用向量运算的优势，提升计算的速度，但是性能不佳

SGD：只用一个样本，会得到好的随机性，在优化问题中可以克服鞍点问题，缺点是优化时时间更长，因为没有办法利用CPU或GPU的并行计算

Mini-batch：均衡性能和训练时间

（2）epoch：所有样本都参与训练

（3）batchsize：每次训练用的样本数量

（4）iteration：batch分了多少个，例如10000个样本，batch是1000，iteration=10

（5）shuffle：是否打乱顺序

（6）数据量少时可以在init()中全部读入内存，在getItem()中获取第[i]条数据

         数据量大时：定义一个列表，数据集中每一条数据的文件名放到列表中

（7）使用Mini-batch代码架构：

 （8）本节主要目的是用Dataset和DataLoader加载数据，以糖尿病数据集为例，代码如下：

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

#Dataset是个抽象类，不能被实例化，只能被子类继承
class DiabetesDataset(Dataset):
    def __init__(self, filepath):
        # delimiter分隔符
        xy = np.loadtxt(filepath, delimiter=',', dtype=np.float32)
        # 最后一列不要
        self.x_data = torch.from_numpy(xy[:, :-1])
        # 只要最后一列，加[]保证是矩阵，不是向量
        self.y_data = torch.from_numpy(xy[:, [-1]])
        #N行9列的数据，[N,9]，用shape[0]可把N取出
        self.len = xy.shape[0]

    #可根据索引取第index条数据
    def __getitem__(self, index):
        return self.x_data[index], self.y_data[index]

    def __len__(self):
        return self.len

dataset = DiabetesDataset('diabetes.csv.gz')

#num_workers读数据集时用多线性读，需要几个并行的线程读取
#直接用train_loader在windows训练会报错，把用loader迭代的代码封装起来
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(size_average=True)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(100):
    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, i, loss.item())
        #Backward
        optimizer.zero_grad()
        loss.backward()
        #Update
        optimizer.step()