Dataset 和 DataLoader

用于处理数据样本的代码可能会变得凌乱且难以维护；理想情况下，我们希望数据集代码与模型训练代码解耦，以获得更好的可读性和模块化。PyTorch提供的torch.utils.data.DataLoader 和 torch.utils.data.Dataset允许你使用预下载的数据集或自己制作的数据。Dataset用于存储样本及其相应的标签，而DataLoader能为数据集提供一个迭代器，以便于访问样本。

PyTorch域库提供了许多预加载的数据集（如FashionMNIST），且都是torch.utils.data.Dataset的子类。你可以在这里找到它们：图像数据集[3]、文本数据集[4]和音频数据集[5]

Dataset加载数据集

以torchvision加载Fashion MNIST数据集为例。Fashion MNIST是Zalando文章里的图像数据集，包括60000个训练样本和10000个测试样本。每个示例包括一个28×28灰度图像(特征图)和10个类别之一的标签。

我们使用以下参数加载Fashion MNIST数据集：

• root是要存储训练/测试数据的路径

• train指定数据集为训练集或测试集，

• download=True表示如果在root无从获取数据集，则从网上下载。

• transform和target_transform分别指定特征图和标签数据类型变换。

import torch
from torch.utils.data import Dataset
from torchvision import datasets
from torchvision.transforms import ToTensor,Lambda
import matplotlib.pyplot as plt
import numpy as np

training_data = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),
    target_transform = Lambda(lambda y: torch.zeros(
    10, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1))
)

test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor(),
    target_transform = Lambda(lambda y: torch.zeros(
    10, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1))
)

运行以上程序， Out:

Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to data/FashionMNIST/raw/train-images-idx3-ubyte.gz
Extracting data/FashionMNIST/raw/train-images-idx3-ubyte.gz to data/FashionMNIST/raw

Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to data/FashionMNIST/raw/train-labels-idx1-ubyte.gz
Extracting data/FashionMNIST/raw/train-labels-idx1-ubyte.gz to data/FashionMNIST/raw

Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz
Extracting data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz to data/FashionMNIST/raw

Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz
Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz
Extracting data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to data/FashionMNIST/raw

transforms

数据被处理后的形式并不总是适合训练机器学习算法。所以，我们使用transforms对数据执行一些操作，使其适合于训练。

所有TorchVision数据集都有两个参数，其中transform用于修改特征图，target_transform用于修改标签。torchvision.transforms模块提供了几种常用的转换，如下文的ToTensor()、Lambda。

FashionMNIST的特征是PIL图像格式，标签是整数。对于训练，我们需要将特征规范化为张量（tensor），将标签用独热(one-hot)编码张量表示。为了进行这些转换，我们使用ToTensor和Lambda。

ToTensor()

ToSensor将PIL图像或NumPy ndarray转换为浮点张量(FloatTensor)。并图像的像素值在[限制在[0,1]范围内。

Lambda Transforms

Lambda转换应用任何用户定义的lambda函数。在这里，我们定义了一个函数来将整数转换为一个独热编码张量。它首先创建一个大小为class_num的零张量（数据集中标签的数量），并调用scatter_，它在标签y给定的索引上指定值为1。

target_transform = Lambda(lambda y: torch.zeros(
    class_num, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1))

迭代和可视化数据集

我们可以像列表一样索引数据集：training_data[index]。我们使用matplotlib可视化训练数据中的一些样本。

labels_map = {
    0: "T-Shirt",
    1: "Trouser",
    2: "Pullover",
    3: "Dress",
    4: "Coat",
    5: "Sandal",
    6: "Shirt",
    7: "Sneaker",
    8: "Bag",
    9: "Ankle Boot",
}
figure = plt.figure(figsize=(8, 8))
cols, rows = 3, 3
for i in range(1, cols * rows + 1):
    sample_idx = torch.randint(len(training_data), size=(1,)).item()
    img, label = training_data[sample_idx]
    figure.add_subplot(rows, cols, i)
    print('one-hot：',label)
    index=torch.nonzero(label)[0][0]   # one-hot转整数标签
    plt.title(labels_map[index.item()])
    plt.axis("off")
    plt.imshow(img.squeeze(), cmap="gray")
plt.show()

one-hot：tensor([0., 0., 0., 0., 0., 0., 0., 1., 0., 0.])
one-hot：tensor([0., 0., 0., 1., 0., 0., 0., 0., 0., 0.])
one-hot：tensor([0., 0., 1., 0., 0., 0., 0., 0., 0., 0.])
one-hot：tensor([0., 0., 0., 1., 0., 0., 0., 0., 0., 0.])
one-hot：tensor([0., 0., 0., 0., 0., 0., 0., 1., 0., 0.])
one-hot：tensor([0., 0., 0., 0., 1., 0., 0., 0., 0., 0.])
one-hot：tensor([0., 0., 0., 1., 0., 0., 0., 0., 0., 0.])
one-hot：tensor([0., 0., 0., 0., 0., 0., 0., 0., 1., 0.])
one-hot：tensor([0., 0., 0., 0., 1., 0., 0., 0., 0., 0.])

自定义数据集类——真假索隆

首先，导入相关库：

import torch
from torch.utils.data import Dataset,DataLoader
from torchvision.transforms import ToTensor, ToPILImage, Lambda
import matplotlib.pyplot as plt
import os
import pandas as pd
from PIL import Image

图像所在文件夹与标签的Excel文件为：

img_path = '.\zoro'
label_path = '.\label_zoro.xlsx'

有10张图片，5张假(用0标记)5张真(用1标记)

链接：https://pan.baidu.com/s/1xGm6IMhq8zBQYZZCwwf3Aw 提取码：1111

自定义数据集类

自定义数据集类必须实现三个函数：__init__, __len__, 和__getitem__：

class ZoroDataset(Dataset):
    def __init__(self, label_file, img_dir, transform=None, target_transform=None):
        # 读取标签文件
        self.labels = pd.read_excel(label_file)
        # 定义文件目录
        self.img_dir = img_dir
        # 定义transform
        self.transform = transform
        self.target_transform = target_transform

    def __len__(self):
        '''返回数据集中的样本数'''
        return len(self.labels)

    def __getitem__(self, index):
        '''获取数据的方法，会和Dataloader连用'''
        # 获取图片路径，0表示Excel文件的第一列
        img_path = os.path.join(self.img_dir, self.labels.iloc[index, 0])
        # 读取图片
        image = Image.open(img_path)
        # 获取图片对应的标签，1表示Excel文件的第二列
        y_label = int(self.labels.iloc[index, 1])
        # 如果使用时附加了transform参数，则对图片、标签应用转换
        if self.transform:
            image = self.transform(image)
        if self.target_transform:
            y_label = self.target_transform(y_label)
        return image, y_label

定义一个图像展示函数

def img_show(img):
    '''将img转化为PIL图像格式后展示'''
    to_pil_image = ToPILImage()
    img = to_pil_image(img)
    plt.imshow(img)

定义一个索隆数据集实例

# 这里标签采用one-hot编码只是为了展示效果，不考虑实际意义
dataset = ZoroDataset(label_file=label_path, img_dir=img_path, transform=ToTensor(),
                      target_transform=Lambda(lambda y: torch.zeros(
                          2, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1)))

读取图片和标签

train_features, train_labels = dataset[0]
img_show(train_features)
print('one-hot标签：',train_labels)
plt.show()

输出：

one-hot标签：tensor([1., 0.])

DataLoader

Dataset一次检索只能检索一个样本。但我们在训练模型时，通常希望以“小批量”的方式采样，并在每个回合(epoch)打乱数据以避免模型过拟合。这就需要DataLoader了。DataLoader通过一个简单的API为我们抽象了这种复杂的功能，且是可迭代的。

batch_size = 2
train_dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
print('数据集样本数：', len(dataset))  # __len__()

遍历DataLoader

我们已经将该数据集加载到DataLoader中，接下来可以根据需要对数据集进行迭代。下面的例子中每次迭代都会返回一批train_features和train_labels（分别包含batch_size个特征和标签）。当我们指定了shuffle=True时，所以在对所有批进行迭代之后，数据顺序将被打乱。

可以用next()或for循环对DataLoader进行迭代：

• 用next()：

for epoch in range(2):
    data_iter = iter(train_dataloader)  # 构建迭代器
    for i in range(int(len(dataset) / batch_size)):
        train_features, train_labels = next(data_iter)
        plt.figure(i)
        for j in range(batch_size):
            plt.subplot(int(f"1{batch_size}{j + 1}"))
            # print(train_features.size())
            img = train_features[j]
            label = train_labels[j]
            img_show(img)

            print(f"Label: {label}")
        plt.show()

• 用for循环

for epoch in range(2):
    data_iter = iter(train_dataloader)
    for i, (train_features, train_labels) in enumerate(data_iter):
        plt.figure(i)
        for j in range(batch_size):
            plt.subplot(int(f"1{batch_size}{j + 1}"))
            # print(train_features.size())
            img = train_features[j]
            label = train_labels[j]
            img_show(img)

            print(f"Label: {label}")
        plt.show()

shuffle=True时，数据集被打乱：

shuffle=False时，按顺序迭代：

全部代码：

import torch
from torch.utils.data import Dataset, DataLoader
from torchvision.transforms import ToTensor, ToPILImage, Lambda
import matplotlib.pyplot as plt
import os
import pandas as pd
from PIL import Image

img_path = '.\zoro'
label_path = '.\label_zoro.xlsx'


class ZoroDataset(Dataset):
    def __init__(self, label_file, img_dir, transform=None, target_transform=None):
        # 读取标签文件
        self.labels = pd.read_excel(label_file)
        # 定义文件目录
        self.img_dir = img_dir
        # 定义transform
        self.transform = transform
        self.target_transform = target_transform

    def __len__(self):
        '''返回数据集中的样本数'''
        return len(self.labels)

    def __getitem__(self, index):
        '''获取数据的方法，会和Dataloader连用'''
        # 获取图片路径，0表示Excel文件的第一列
        img_path = os.path.join(self.img_dir, self.labels.iloc[index, 0])
        # 读取图片
        image = Image.open(img_path)
        # 获取图片对应的标签，1表示Excel文件的第二列
        y_label = int(self.labels.iloc[index, 1])
        # 如果使用时附加了transform参数，则对图片应用转换
        if self.transform:
            image = self.transform(image)
        if self.target_transform:
            y_label = self.target_transform(y_label)
        return image, y_label


def img_show(img):
    '''将img转化为PIL图像格式后展示'''
    to_pil_image = ToPILImage()
    img = to_pil_image(img)
    plt.imshow(img)


# 这里标签采用one-hot编码只是为了展示效果，不考虑实际意义
dataset = ZoroDataset(label_file=label_path, img_dir=img_path, transform=ToTensor(),
                      target_transform=Lambda(lambda y: torch.zeros(
                          2, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1)))

train_features, train_labels = dataset[0]
# img_show(train_features)
# print('one-hot标签：', train_labels)
# plt.show()
batch_size = 2
train_dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False)
print('数据集样本数：', len(dataset))

for epoch in range(2):
    data_iter = iter(train_dataloader)
    for i, (train_features, train_labels) in enumerate(data_iter):
        plt.figure(i)
        for j in range(batch_size):
            plt.subplot(int(f"1{batch_size}{j + 1}"))
            # print(train_features.size())
            img = train_features[j]
            label = train_labels[j]
            img_show(img)
            print(f"Label: {label}")
        plt.show()