DataLoader

多线程使用时，最好使用计算机核心数量减1的值，这样是最快的

DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, 
num_workers=0, collate_fn=default_collate, pin_memory=False, 
drop_last=False)
## 主要参数的意义
dataset：加载的数据集(Dataset对象)
batch_size：batch size
shuffle:：是否将数据打乱
sampler： 样本抽样，后续会详细介绍
num_workers：使用多进程加载的进程数，0代表不使用多进程，
collate_fn： 如何将多个样本数据拼接成一个batch，一般使用默认的拼接方式即可
pin_memory：是否将数据保存在pin memory区，pin memory中的数据转到GPU会快一些
drop_last：dataset中的数据个数可能不是batch_size的整数倍，drop_last为True会将多出来不足一个batch的数据丢弃

Dataset类DataLoader（）配合较大数据量

步骤：1.先重新定义一个继承Dataset类的类
重写__init__(self,),____len____(self,),__getitem__(self, index)
2.实例化自己定义的类
3.使用DataLoader（）加载数据

使用的格式如下：

from torch.utils.data import *
class my_dataset(Dataset): # 继承dataset，重写其中的每项函数
    def __init__(self, args):  # args表示的是不定数量的参数
        self.arfs1 = arg_x  # 这个函数定义需要数据的内容
        #这个函数得到整体的数据，一般是list中
    def __len__(self): # 想要输入的数据组长度
        return len(self.args)
    def __getitem__(self, index):  # 输入和输出数据组
        # 通过index对每一对数据访问，最后输出合适格式的数据
        return input_x, output_y,other
## 然后通过
dst = my_dataset(..)
dataload = DataLoader（dst,）

小测试代码

from torch.utils.data import *
a = [2,1,3,4,5,67,]
b = [7,5,5,9,4,7,]

class my_dataset(Dataset): # 继承dataset，重写其中的每项函数
    def __init__(self, a,b):  # args表示的是不定数量的参数
        self.list1 = a  # 这个函数定义需要数据的内容
        self.list2 = b
    def __len__(self): # 想要输入的数据组长度
        return len(self.list1)
    def __getitem__(self, index):  # 输入和输出数据组
        # 通过index对每一对数据访问，最后输出合适格式的数据
        subtract = self.list1[index] - self.list2[index]
        summ = self.list1[index] + self.list2[index]
        return subtract, summ
## 然后通过
dst = my_dataset(a,b)
if __name__=='__main__':
    dataload = DataLoader(dst,batch_size=2,shuffle=False,num_workers=2)
    for i in dataload:
        print(i)

batch_size=2,所以两个为一组，且返回值的两个数据分别在不同的tensor中
shuffle= False,表示不打乱加载的顺序，

下面是shuffle=True后的显示，发现每次随机取两组数据

测试DataLoader的collate_fn参数

# 在上面程序添加batch_sample
def batch_sample(batch):
    for _, sample in enumerate(batch):
        he = [el for el,_ in batch]
        cha = [ell for _,ell in batch]
        return he,cha
# 对DataLoade修改
dataload = DataLoader(dst,batch_size=2,shuffle=False,collate_fn=batch_sample,num_workers=2)

collate_fn：对batch的输出形式进行重新设计，对应（本例中名称）batch_sample的bath包含是[tensor([-5, -4]), tensor([9, 6])]，因为batchsize=2，所以batch_sample的功能是将一个batch的输入和输出分别放在不同的两个列表中，而batch是和函数__getitem__(self, index)的返回值顺序有关

下面是一段论文的一段代码：LPRNet: License Plate Recognition via Deep Neural Networks，

class LPRDataLoader(Dataset): # 继承dataset，重写其中的每项函数
    def __init__(self, img_dir, imgSize, lpr_max_len, PreprocFun=None):
        self.img_dir = img_dir  # 包含图片文件的文件夹路径
        self.img_paths = []  # 记录图片完整的路径和名字,这里定义，下面循环才能使用
        # print(len(img_dir))
        for i in range(len(img_dir)): # 这一步循环得到所有数据的参数
            self.img_paths += [el for el in paths.list_images(img_dir[i])]
        random.shuffle(self.img_paths)  # 打乱不同名字的图片顺序
        self.img_size = imgSize
        self.lpr_max_len = lpr_max_len
        if PreprocFun is not None:  # 如果有图片预处理的函数
            self.PreprocFun = PreprocFun
        else:
            self.PreprocFun = self.transform

    def __len__(self): # 所有图片总数
        return len(self.img_paths)

    def __getitem__(self, index):  # 以生成器方式加载图片和标签
        filename = self.img_paths[index]  # 对数据参数的访问
        # 一些列对数据的处理
        return Image, label, len(label)

TensorDataset()与DataLoader（）配合简单数据

一个简单的例子：需要注意的是，在对DataLoader的对象进行迭代显示或运算时，需要将训练部分放在__name__ == 'main’中
Data.TensorDataset可以将训练中的输入和输出值作为一对数据。再通过DataLoader对象加载数据的方式进行设置，随机训练某批数据

import torch
import torch.utils.data as Data
import numpy as np

BATCH_SIZE = 5

x = torch.linspace(1, 10, 10)
y = torch.linspace(10, 1, 10)

torch_dataset = Data.TensorDataset(x, y)

loader = Data.DataLoader(
    dataset=torch_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,
    num_workers=2,
)
if __name__ == '__main__':
    for epoch in range(3):
        for step, (batch_x, batch_y) in enumerate(loader):
            print('Epoch: ', epoch, '| Step: ', step, '| batch x: ',
                  batch_x.numpy(), '| batch y: ', batch_y.numpy())