8.加载数据集（Dataset and DataLoader）

关于 Epoch、Batch-Size、Iteration的解释请看：epochs，batch_size，iterations详解_马鹏森的博客-CSDN博客

DataLoader接收4个参数：分别是实例化后 dataset = Dataset()、batch_size、shuffle、num_workers

train_loader = DataLoader( dataset =dataset,  batch_size = 32 ,  shuffle = True ,  num_workers = 2 )

 DataLoader具体的执行过程如下图所示：（将相当于将dataset的每个epoch把所有的样本shuffle，然后每N个样本为一个batch_size【下面以N为2为例】）

1、实现 Dataset 抽象类的方法： 由于Dataset 是一个抽象类，我们不能实例化，所以我们要继承它， 然后实现，这样就可以实例化我们自己的datasets 类了

from torch.utils.data import Dataset
from torch.utils.data import DataLoader
class DiabetesDataset(Dataset):
    def __init__(self, filepath):
        # 加载数据x及其对应的标签y
        pass
    def __getitem__(self, index):
        # 接收一个索引，返回数据的索引对应的数据
        pass
    def __len__(self):
        # 返回数据的长度
        pass

2、实现DataLoader的方式：

只需要将Dataset实例化，然后传入DataLoader并设置相关的参数就可以了

dataset = DiabetesDataset(filepath='xxx')
train_loader = DataLoader(dataset=dataset, batch_size=32, shuffle=True, num_workers=0)

 

3、使用Dataset and DataLoader 实现Mi-ni Batch 

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

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

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

    def __len__(self):
        return self.len


dataset = DiabetesDataset('diabetes.csv')
train_loader = DataLoader(dataset=dataset, batch_size=32, shuffle=True, num_workers=0)


# 2.Define Model
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.linear1 = nn.Linear(8, 6)
        self.linear2 = nn.Linear(6, 4)
        self.linear3 = nn.Linear(4, 1)
        self.sigmoid = 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()

# 3.Construct Loss and Optimizer
# Mini-Batch Loss Function for Binary Classification
criterion = nn.BCELoss(size_average=True)
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

# 4.Training Cycle
for epoch in range(100):
    for i, data in enumerate(train_loader):
        x_data, y_data = data
        # Forward
        y_pred = model(x_data)
        loss = criterion(y_pred,y_data)
        print("The loss of epoch {} is {} and the iteration is {}".format(epoch, loss.item(), i))

        # Bcakward
        optimizer.zero_grad()
        loss.backward()

        # Updata
        optimizer.step()

torch.save(model.state_dict(), 'diabetes.pth')

在 Training Cycle 过程中与7.处理多维特征的输入（Analysis + Code）_马鹏森的博客-CSDN博客

不同， 第7节使用的全部的数据，相当于整个数据集作为一个batch进行处理，这里我们使用Mi-ni Batch训练网络，

• 整个数据集作为一个batch进行处理：训练速度快，但是精度低，资源消耗严重，可能内存撑不住；
• 使用Batch为1训练网络：训练速度慢，但是精度高，资源消耗低；
• 使用Mi-ni Batch训练网络：上述两种方法的折中处理方式。

与原来的主要的不同在于for epoch的循环这里，我们使用了两个循环，
第一个循环相当于每次一个epoch，总共进行N个epoch，
第二个循环相当于每次进行一个 Mi-ni Batch ，总共进行iteration 次循环

for epoch in range(100):
    for i, data in enumerate(train_loader):
        x_data, y_data = data
        # Forward
        y_pred = model(x_data)
        loss = criterion(y_pred,y_data)
        print("The loss of epoch {} is {} and the iteration is {}".format(epoch, loss.item(), i))

        # Bcakward
        optimizer.zero_grad()
        loss.backward()

        # Updata
        optimizer.step()

《PyTorch深度学习实践》完结合集_哔哩哔哩_bilibili