第N2周：NLP中的数据集构建

对于初学者，NLP中最烦人的问题之一就数据集的构建问题，处理不好就会引起shape问题（各种由于shape错乱导致的问题）。这里给出一个模版，大家可根据这个模版来构建。

torch.utils.data是PyTorch中用于数据加载和预处理的模块。其中包括Dataset和DataLoader两个类，它们通常结合使用来加载和处理数据。

一、Dataset

torch.utils.data.Dataset是一个抽象类，用于表示数据集。它需要用户自己实现两个方法：__ len__ 和__getitem__。其中，__len__方法返回数据集的大小，__getitem__方法用于根据给定的索引返回一个数据样本。

以下是一个简单的示例，展示了如何定义一个数据集：

python 复制代码

import torch
from torch import nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset

class MyDataset(Dataset):
    def __init__(self, texts, labels):
        self.texts  = texts
        self.labels = labels

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        texts  = self.texts[idx]
        labels = self.labels[idx]
        
        return texts, labels

在这个示例中，MyDataset继承了torch.utils.data.Dataset类，并实现了__len__和__getitem__方法。__len__方法返回数据集的大小，这里使用了Python内置函数len。__getitem__方法根据给定的索引返回一个数据样本，这里返回的是数据列表中对应的元素。

二、DataLoader

torch.utils.data.DataLoader是PyTorch中一个重要的类，用于高效加载数据集。它可以处理数据的批次化、打乱顺序、多线程数据加载等功能。

以下是一个简单的示例：

python 复制代码

# 假设我们有以下三个样本，分别由不同数量的单词索引组成
text_data = [
    torch.tensor([1, 2, 3, 4], dtype=torch.long),  # 样本1
    torch.tensor([4, 3, 2], dtype=torch.long),     # 样本2
    torch.tensor([1, 2], dtype=torch.long)         # 样本3
]

# 对应的标签
labels = torch.tensor([1, 0, 1], dtype=torch.float)

# 创建数据集和数据加载器
my_dataset  = MyDataset(text_data, labels)
data_loader = DataLoader(my_dataset, batch_size=2, shuffle=True, collate_fn=lambda x: x)

for batch in data_loader:
    print(batch)

代码输出

[(tensor([4, 3, 2]), tensor(0.)), (tensor([1, 2]), tensor(1.))]
[(tensor([1, 2, 3, 4]), tensor(1.))]

在这个示例中，我们首先创建了一个MyDataset实例my_dataset，它包含了一个整数列表。然后，我们使用DataLoader类创建了一个数据加载器data_loader，它将data_loader作为输入，并将数据分成大小为4的批次，并对数据进行随机化。最后，遍历data_loader，并打印出每个批次的数据。

三、DataLoader参数讲解

函数原型：

DataLoader(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, *, prefetch_factor=2,

persistent_workers=False)

常用的参数：

1.dataset：一个数据集对象，必须实现__len__和__getitem__方法。

2.batch_size：每个batch的大小。

3.shuffle：是否对数据进行洗牌（随机打乱）。

4.sampler：一个数据采样器，用于对数据进行自定义采样。

5.batch_sampler：一个batch采样器，用于对batch进行自定义采样。

6.num_workers：用于数据加载的子进程数量。默认值为0，表示在主进程中加载数据。

7.collate_fn：用于将一个batch的数据合并成一个张量或者元组。

8.pin_memory：是否将数据存储在pin memory中（锁定物理内存，用于GPU加速数据传输），默认值为False。

9.drop_last：如果数据不能完全分成batch，是否删除最后一批数据。默认为False。

10.timeout：当数据加载器陷入死锁时，等待数据准备的最大秒数。默认值为0，表示无限等待。

11.worker_init_fn：用于每个数据加载器进程的初始化函数。可以用来设置特定的随机种子。

12.multiprocessing_context：用于创建数据加载器子进程的上下文。

以上是torch.utils.data.DataLoader中一些常用的参数，使用时根据实际情况选择相应的参数组合。

sampler参数详解：

sampler是一个用于指定数据集采样方式的类，它控制DataLoader如何从数据集中选取样本。PyTorch提供了多种Sampler类，例如RandomSampler和SequentialSampler，分别用于随机采样和顺序采样。

以下是一个示例：

python 复制代码

from torch.utils.data.sampler import RandomSampler

my_sampler = RandomSampler(my_dataset)

my_dataloader = data.DataLoader(my_dataset, 
                                batch_size=4, 
                                shuffle=False, 
                                sampler=my_sampler)

在这个示例中，我们使用RandomSampler类来指定随机采样方式，然后将其传递给DataLoader的sampler参数。这将覆盖默认的shuffle参数，使数据集按照sampler指定的采样方式进行

四、自定义Dataset类

除了使用torchvision.datasets中提供的数据集，我们还可以使用torch.utils.data.Dataset类来自定义自己的数据集。自定义数据集需要实现__len__和__getitem__方法。

●init：用来初始化数据集

●len：方法返回数据集中样本的数量

●getitem：给定索引值，返回该索引值对应的数据；它是python built-in方法，其主要作用是能让该类可以像list一样通过索引值对数据进行访问

python 复制代码

class MyDataset(data.Dataset):
    def __init__(self, data_path):
        self.data_list = torch.load(data_path)

    def __len__(self):
        return len(self.data_list)

    def __getitem__(self, index):
        x = self.data_list[index][0]
        y = self.data_list[index][1]
        return x, y

在这个示例中，MyDataset类继承自torch.utils.data.Dataset类，实现了__len__和__getitem__方法。MyDataset类的构造函数接受一个数据路径作为参数，数据集被保存为一个由数据-标签对组成的列表。

五、自定义Sampler类

除了使用torch.utils.data.sampler中提供的采样器，我们还可以使用Sampler类来自定义自己的采样器。自定义采样器需要实现__iter__和__len__方法。

●__iter__方法返回一个迭代器，用于遍历数据集中的样本索引。

●__len__方法返回数据集中样本的数量。

以下是一个示例：

python 复制代码

class MySampler(Sampler):
    def __init__(self, data_source):
        self.data_source = data_source

    def __iter__(self):
        return iter(range(len(self.data_source)))

    def __len__(self):
        return len(self.data_source)

在这个示例中，MySampler类继承自torch.utils.data.sampler.Sampler类，实现了__iter__和__len__方法。

六、自定义Transform类

除了使用torchvision.transforms中提供的变换，我们还可以使用transforms模块中的Compose类来自定义自己的变换。Compose类将多个变换组合在一起，并按照顺序应用它们。

以下是一个示例：

python 复制代码

class MyTransform(object):
    def __call__(self, x):
        x = self.crop(x)
        x = self.to_tensor(x)
        return x

    def crop(self, x):
        # 这里实现裁剪变换
        # .......
        return x

    def to_tensor(self, x):
        # 这里实现张量化变换
        # .......
        return x

my_transform = transforms.Compose([
    MyTransform()
])

# 创建数据集和数据加载器
my_dataset    = MyDataset(data_path)
my_dataloader = DataLoader(my_dataset, 
                           batch_size=32, 
                           shuffle=True, 
                           num_workers=4)

# 遍历数据集
for batch in my_dataloader:
    # 在这里处理数据批次
    pass

在这个示例中，MyTransform类实现了一个自定义的变换，它将裁剪和张量化两个变换组合在一起。transforms.Compose将这个自定义变换组合成一个变换序列，并在数据集中的每个样本上应用这个序列。