《PyTorch深度学习实践》04.Dataset and DataLoader

《PyTorch深度学习实践》.Dataset and DataLoader

1.Mini-Batch

我们之前在做训练用的是自己的数据集，我们每次做前馈的时候都是把整个数据集丢进去。

我们在进行梯度下降的时候，我们有两种选择：

1. 全部的样本(Batch)都用——可以最大化利用向量计算的优势来提高计算的速度。
2. 只用一个样本(随机梯度下降)——有比较好的随机性,可以帮助我们跨越以后可能遇到的鞍点。性能会好，但是用时长(一个样本没法利用gpu并行能力)

为了综合以上两个的优点，我们在深度学习的时候会利用Mini-Batch

2. DataLoader

重要的参数：

• batch_size
• shuffle : 为了提高训练的随机性，我们可以选择对数据集进行打乱。

那么我们的数据集需要支持索引，使得DataLoader能访问到里面的每一个元素，还需要知道这个dataset的长度。

code：

Extra: num_workers in Windows

在windows下运行可能会遇到一些问题，比如以下这个代码，会出现RE的问题：

解决方法：把用loader进行迭代的代码封装一下，也就是上图的for语句封装一下，不要直接暴露在程序里面就行了。

下面来实现一下数据集类：

Using DataLoader

Classifiying Diabetes

3.Code

import numpy as np
import torch
from torch.utils.data import Dataset # 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):# 实例化对象后，该类能支持下标操作，通过index拿出数据
        return self.x_data[index],self.y_data[index]


    def __len__(self):
        return self.len

dataset = DiabetesDataset('diabetes.csv.gz')
# dataset数据集，batch_size小批量的容量，shuffle是否要打乱，num_workers要几个并行进程来读
# DataLoader的实例化对象不能直接使用，因为windows和linux的多线程运行不一样，所以一般要放在函数里运行
train_loader = DataLoader(dataset=dataset,batch_size=32,shuffle=True,num_workers=2)

class Model(torch.nn.Model):
    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)
        # 这是nn下的Sigmoid是一个模块没有参数，在function调用的Sigmoid是函数
        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.1)  # 优化函数，随机梯度递减

# 变成嵌套循环，实现Mini-Batch
for epoch in range(100):
    # 从数据集0开始迭代
    # 可以简写为for i, (inputs, labels) in enumerate(train_loader, 0):
    for i, data in enumerate(train_loader, 0):
        # 准备数据
        inputs, labels = data
        # 前馈
        y_pred = model(inputs)
        loss = criterion(y_pred, labels)
        print(epoch, i, loss.item())
        # 反馈
        optimizer.zero_grad()
        loss.backward()
        # 更新
        optimizer.step()