【pytorch】|Dataloader dataset sampler torchvision

pytorch 数据读取机制

PyTorch中对于数据集的处理有三个非常重要的类：Dataset、Dataloader、Sampler，它们均是 torch.utils.data 包下的模块（类）。

torch/utils/data下面一共含有4个主文件

|---- dataloader.py
|---- dataset.py
|---- distributed.py
|---- sample.py

pytorch 的数据加载到模型的操作顺序是这样的：

① 创建一个 Dataset 对象
② 创建一个 DataLoader 对象
③ 循环这个 DataLoader 对象，通过dataset、sampler参数将img, label加载到模型中进行训练

dataloader \dataset \sampler概述

dataloader \dataset \sampler三者关系

• Dataset是数据集的类，主要用于定义数据集
• Sampler是采样器的类，用于定义从数据集中选出数据的规则，比如是随机取数据还是按照顺序取等等
• Dataloader是数据的加载类，Dataset和Sampler会作为参数传递给Dataloader，是对于Dataset和Sampler的进一步包装，用于实际读取数据，可以理解为它是这个工作的真正实践者，而Dataset和Sampler则负责定义。我们训练、测试所获得的数据也是Dataloader直接给我们的。

torch.utils.data Dataset

我们通过定义继承自这个类的子类来自定义数据集。它有两个最重要的方法需要重写，实际上它们都是类的特殊方法：

getitem(self, index)：传入参数index为下标，返回数据集中对应下标的数据组（数据和标签）
len(self)：返回数据集的大小
Dataset的目标是根据你输入的索引输出对应的image和label，而且这个功能是要在__getitem__()函数中完成的，所以当你自定义数据集的时候，首先要继承Dataset类，还要复写__getitem__()函数。

torch.utils.data DataLoader

Dataloader对Dataset（和Sampler等）打包，完成最后对数据的读取的执行工作，一般不需要自己定义或者重写一个Dataloader的类（或子类），直接使用即可，通过传入参数定制Dataloader，定制化的功能应该在Dataset（和Sampler等）中完成了。

from torch.utils.data import DataLoader

 def __init__(self, dataset, 
 			batch_size=1, 
 			shuffle=False, 
 			sampler=None,
            batch_sampler=None, 
            num_workers=0, 
            collate_fn=None,
            pin_memory=False, 
            drop_last=False, 
            timeout=0,
            worker_init_fn=None, 
            multiprocessing_context=None):

from torch.utils.data import DataLoader

DataLoader，它是PyTorch中数据读取的一个重要接口，该接口定义在dataloader.py中，只要是用PyTorch来训练模型基本都会用到该接口（除非用户重写…）
该接口的目的：将自定义的Dataset根据batch size大小、是否shuffle等封装成一个Batch Size大小的Tensor，用于后面的训练。

dataset(Dataset): 传入的数据集

• batch_size(int, optional): 每个batch有多少个样本

• shuffle(bool, optional): 在每个epoch开始的时候，对数据进行重新排序

• sampler(Sampler, optional): 自定义从数据集中取样本的策略，如果指定这个参数，那么shuffle必须为False

• batch_sampler(Sampler, optional): 与sampler类似，但是一次只返回一个batch的indices（索引），需要注意的是，一旦指定了这个参数，那么batch_size,shuffle,sampler,drop_last就不能再制定了（互斥——Mutually exclusive）

• num_workers (int, optional): 这个参数决定了有几个进程来处理data loading。0意味着所有的数据都会被load进主进程。（默认为0）

• pin_memory (bool, optional)： 如果设置为True，那么data loader将会在返回它们之前，将tensors拷贝到CUDA中的固定内存（CUDA pinned memory）中.

• collate_fn (callable, optional): 将一个list的sample组成一个mini-batch的函数

• drop_last (bool, optional): 这个是对最后的未完成的batch来说的，比如你的batch_size设置为64，而一个epoch只有100个样本，如果设置为True,那么训练的时候后面的36个就被扔掉了…
  如果为False（默认），那么会继续正常执行，只是最后的batch_size会小一点。

• timeout(numeric, optional): 如果是正数，表明等待从worker进程中收集一个batch等待的时间，若超出设定的时间还没有收集到，那就不收集这个内容了。这个numeric应总是大于等于0。默认为0

• worker_init_fn (callable, optional): 每个worker初始化函数 If not None, this will be called on each
  worker subprocess with the worker id (an int in [0, num_workers - 1]) as input, after seeding and before data loading. (default: None)

torch.utils.data.sampler

from torch.utils.data.sampler import Sampler

Sampler类是一个很抽象的父类，其主要用于设置从一个序列中返回样本的规则，即采样的规则。Sampler是一个可迭代对象，使用step方法可以返回下一个迭代后的结果，因此其主要的类方法就是 iter 方法，定义了迭代后返回的内容。

但是，Dataloader中的sampler和batch_sampler参数默认情况下使用的那些采样器（RandomSampler、SequentialSampler和BatchSampler）一样，PyTorch自己实现了很多Sampler的子类，这些采样器其实可以完成大部分功能，所以基本只需要关注一些Sampler的子类以及他们的用法。

SequentialSampler

SequentialSampler就是一个按照顺序进行采样的采样器，接收一个数据集做参数（实际上任何可迭代对象都可），按照顺序对其进行采样。

from torch.utils.data import SequentialSampler

pseudo_dataset = list(range(10))
for data in SequentialSampler(pseudo_dataset):
    print(data, end=" ")

0 1 2 3 4 5 6 7 8 9 

RandmSampler

RandomSampler 即一个随机采样器，返回随机采样的值，第一个参数依然是一个数据集（或可迭代对象）。还有一组参数如下：

• replacement：bool值，默认是False，设置为True时表示可以采出重复的样本
• num_samples：只有在replacement设置为True的时候才能设置此参数，表示要采出样本的个数，默认为数据集的总长度。有时候由于replacement置True的原因导致重复数据被采样，导致有些数据被采不到，所以往往会设置一个比较大的值.

from torch.utils.data import RandomSampler

pseudo_dataset = list(range(10))

randomSampler1 = RandomSampler(pseudo_dataset)
randomSampler2 = RandomSampler(pseudo_dataset, replacement=True, num_samples=20)

print("for random sampler #1: ")
for data in randomSampler1:
    print(data, end=" ")

print("\n\nfor random sampler #2: ")
for data in randomSampler2:
    print(data, end=" ")

for random sampler #1: 
4 5 2 9 3 0 6 8 7 1 

for random sampler #2: 
4 9 0 6 9 3 1 6 1 8 5 0 2 7 2 8 6 4 0 6 

SubsetRandomSampler

SubsetRandomSampler可以设置子集的随机采样，多用于将数据集分成多个集合，比如训练集和验证集的时候使用：

from torch.utils.data import SubsetRandomSampler

pseudo_dataset = list(range(10))

subRandomSampler1 = SubsetRandomSampler(pseudo_dataset[:7])
subRandomSampler2 = SubsetRandomSampler(pseudo_dataset[7:])

print("for subset random sampler #1: ")
for data in subRandomSampler1:
    print(data, end=" ")

print("\n\nfor subset random sampler #2: ")
for data in subRandomSampler2:
    print(data, end=" ")

for subset random sampler #1: 
0 4 6 5 3 2 1 

for subset random sampler #2: 
7 8 9 

BatchSampler

以上的四个Sampler在每次迭代都只返回一个索引，而BatchSampler的作用是对上述这类返回一个索引的采样器进行包装，按照设定的batch size返回一组索引，因其他的参数和上述的有些不同：

• sampler：一个Sampler对象（或者一个可迭代对象）
• batch_size：batch的大小
• drop_last：是否丢弃最后一个可能不足batch size大小的数据

from torch.utils.data import BatchSampler
pseudo_dataset = list(range(10))

batchSampler1 = BatchSampler(pseudo_dataset, batch_size=3, drop_last=False)
batchSampler2 = BatchSampler(pseudo_dataset, batch_size=3, drop_last=True)

print("for batch sampler #1: ")
for data in batchSampler1:
    print(data, end=" ")

print("\n\nfor batch sampler #2: ")
for data in batchSampler2:
    print(data, end=" ")

for batch sampler #1: 
[0, 1, 2] [3, 4, 5] [6, 7, 8] [9] 

for batch sampler #2: 
[0, 1, 2] [3, 4, 5] [6, 7, 8] 

torchvision

torchvision 是PyTorch中专门用来处理图像的库，PyTorch官网的安装教程，也会让你安装上这个包。

这个包中有四个大类。

torchvision.datasets

torchvision.models

torchvision.transforms

torchvision.utils

torchvision.datasets

import torchvision.datasets as datasets

torchvision.datasets 是用来进行数据加载的，PyTorch团队在这个包中帮我们提前处理好了很多很多图片数据集。

__all__ = ('LSUN', 'LSUNClass',
           'ImageFolder', 'DatasetFolder', 'FakeData',
           'CocoCaptions', 'CocoDetection',
           'CIFAR10', 'CIFAR100', 'EMNIST', 'FashionMNIST', 'QMNIST',
           'MNIST', 'KMNIST', 'STL10', 'SVHN', 'PhotoTour', 'SEMEION',
           'Omniglot', 'SBU', 'Flickr8k', 'Flickr30k',
           'VOCSegmentation', 'VOCDetection', 'Cityscapes', 'ImageNet',
           'Caltech101', 'Caltech256', 'CelebA', 'WIDERFace', 'SBDataset',
           'VisionDataset', 'USPS', 'Kinetics400', 'HMDB51', 'UCF101',
           'Places365')

import torchvision

trainset= torchvision.dataset.MNIST(root='./data'
															train=True,
															transform=None)
train_Loader=Dataloader(dataset=trainset,
										batch_size=32,
										shuffle=False)
print("训练集大小"，len(trainset))
print("训练集批次"，len(train_loader))
															

torchvision.models

torchvision.models 中为我们提供了已经训练好的模型，让我们可以加载之后，直接使用。

torchvision.models模块的 子模块中包含以下模型结构。

from .alexnet import *
from .resnet import *
from .vgg import *
from .squeezenet import *
from .inception import *
from .densenet import *
from .googlenet import *
from .mobilenet import *
from .mnasnet import *
from .shufflenetv2 import *
from . import segmentation
from . import detection
from . import video
from . import quantization

快速创建一个权重随机初始化的模型

import torchvision.models as models
resnet18 = models.resnet18()
alexnet = models.alexnet()
squeezenet = models.squeezenet1_0()
densenet = models.densenet_161()

也可以通过使用 pretrained=True 来加载一个别人预训练好的模型

import torchvision.models as models
resnet18=models.resnet18(pretrained = True)
print(resnet18)

torchvision.transforms

transforms 模块提供了一般的图像转换操作类。

class torchvision.transforms.ToTensor 

把shape=(H x W x C)的像素值范围为[0, 255]的PIL.Image或者numpy.ndarray转换成shape=(C x H x W)的像素值范围为[0.0, 1.0]的torch.FloatTensor。

class torchvision.transforms.Normalize(mean, std) 

给定均值(R, G, B)和标准差(R, G, B)，用公式channel = (channel - mean) / std进行规范化。

# 我们这里还是对MNIST进行处理，初始的MNIST是 28 * 28，我们把它处理成 96 * 96 的torch.Tensor的格式
from torchvision import transforms as transforms
import torchvision
from torch.utils.data import DataLoader

# 图像预处理步骤
transform = transforms.Compose([
    transforms.Resize(96), # 缩放到 96 * 96 大小
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # 归一化
])

DOWNLOAD = True
BATCH_SIZE = 32

train_dataset = torchvision.datasets.MNIST(root='./data/', train=True, transform=transform, download=DOWNLOAD)


train_loader = DataLoader(dataset=train_dataset,
                          batch_size=BATCH_SIZE,
                          shuffle=True)

print(len(train_dataset))
print(len(train_loader))

ref
https://github.com/LianHaiMiao/pytorch-lesson-zh/
https://zhuanlan.zhihu.com/p/91521705
https://blog.csdn.net/g11d111/article/details/81504637
https://zhuanlan.zhihu.com/p/400830261