pytorch读取数据（Dataset, DataLoader, DataLoaderIter）

pytorch数据读取

参考资料：
pytorch数据读取
pytorch对nlp数据的处理博客（以短文本匹配为例）
dataloader使用教程博客
pytorch使用DataLoader对数据集进行批处理简单示例

Pytorch的数据读取主要包含三个类：

1. Dataset
2. DataLoader
3. DataLoaderIter

这三者是依次封装的关系，Dataset被装进DataLoader，DataLoder被装进DataLoaderIter。

Dataloader的处理逻辑是先通过Dataset类里面的__getitem__函数获取单个的数据，然后组合成batch，再使用collate_fn所指定的函数对这个batch做一些操作，比如padding。

torch.utils.data.Dataset

是一个抽象类，自定义的Dataset需要继承它并实现两个成员方法

1. __getitem__()：从数据集中得到一个数据片段（如：数据，标签）
2. __len__()：返回整个数据集的长度

自定义Dataset基本的框架是：

class CustomDataset(data.Dataset):#需要继承data.Dataset 
    def __init__(self): 
        # TODO 
        # 1. Initialize file path or list of file names. 
        pass 
        def __getitem__(self, index): 
            # TODO 
            # 1. Read one data from file (e.g. using numpy.fromfile, PIL.Image.open). 
            # 2. Preprocess the data (e.g. torchvision.Transform). 
            # 3. Return a data pair (e.g. image and label). 
            #这里需要注意的是，第一步：read one data，是一个data 
            pass 
        def __len__(self): 
            # You should change 0 to the total size of your dataset. 
            return 0

以短文本匹配为例，判断两个文本是否相似，数据格式为（句子1，句子2，是否相似标签0或1，示例如下图所示：

对于这样的数据集，我们构建的Dataset类可以是：

class Dataset(torch.utils.data.Dataset):
    def __init__(self, texta, textb, label):
        self.texta = texta
        self.textb = textb
        self.label = label
    
    def __getitem__(self, item):
        return self.texta[item], self.textb[item], self.label[item]
        
    def __len__(self):
        return len(self.texta)

接下来可以向自己实现的Dataset类中传值：

train_data = Dataset(train_texta, train_textb, train_label)

torch.utils.data.DataLoader

类的定义为：

class torch.utils.data.DataLoader(
    dataset, 
    batch_size=1, 
    shuffle=False, 
    sampler=None, 
    batch_sampler=None, 
    num_workers=0, 
    collate_fn=<function default_collate>,
    pin_memory=False, 
    drop_last=False
)

主要的参数有：

1. dataset：即我们自定义的Dataset
2. collate_fn：这个函数用来打包batch。定义如何把一批dataset的实例转换为包含mini-batch数据的张量。可以通过自定义collate_fn=myfunction来设计数据打包的方式，通常在myfunction函数中做padding，将同一个batch中不一样长的句子补全成一样的长度。
3. num_workers：设置>=1时，可多线程读数据。设置=0时，单线程读数据
4. shuffle：代表是否要打乱数据，一般对于训练集数据都是要打乱的，验证集可以打乱也可以不打乱，但是测试集数据不打乱。

这个类是DataLoaderIter的一个框架，一共做了两件事情：

1. 定义成员变量，到时候赋给DataLoaderIter
2. 有一个__iter__()函数，把自己装进DataLoaderIter中

def __iter__(self):
    return DataLoaderIter(self)

仍然以短文本匹配任务为例，上面已经得到了train_data，然后就可以使用DataLoader进行处理，DataLoader每次返回一个batch的数据。

train_iter = DataLoader(dataset=train_data, batch_size=args.batch_size, shuffle=True, collate_fn=myfunction)

这里的myfunction可以定义为：

def myfunction(batch_data, pad=0):
    texta,textb,label = list(zip(*batch_data))#batch_data的结构是[([texta_1],[textb_1],[label_1]),([texta_2],[textb_2],[label_2])，...]，所以需要使用zip函数对它解压
    max_len_a = max([len(seq_a) for seq_a in texta])
    max_len_b = max([len(seq_b) for seq_b in textb])
    max_len = max(max_len_a,max_len_b) #这里我使用的是一个batch中text_a或者是text_b的最大长度作为max_len,也可以自定义长度
    texta = [seq+[pad]*(max_len-len(seq)) for seq in texta]
    textb = [seq+[pad]*(max_len-len(seq)) for seq in textb]
    texta = torch.LongTensor(texta)
    textb = torch.LongTensor(textb)
    label = torch.FloatTensor(label)
    return (texta,textb,label)

torch.utils.data.dataloader.DataLoaderIter

这里其实是迭代调用DataLoader的过程。一般加载数据的整个流程为：

class Dataset(Dataset)
    # 自定义的Dataset
    # 返回（data, label）

dataset = Dataset()
dataloader = DataLoader(dataset, ...)
for data in dataloader:
    # training

在for循环中，总共有三个操作：

1. 调用DataLoder的__iter__()方法，产生一个DataLoaderIter
2. 反复调用DataLoaderIter 的__next__()来得到batch, 具体操作就是, 多次调用dataset的__getitem__()方法 (如果num_worker>0就多线程调用), 然后用collate_fn来把它们打包成batch
3. 当数据读完后, next()抛出一个StopIteration异常, for循环结束, dataloader 失效

以上的短文本匹配的例子中，for循环部分可以写成：

for batch_data in tqdm(train_iter):
    texta, textb, tag = map(lambda x: x.to(device), batch_data)
    output = model(texta, textb)