第四章 PyTorch数据处理工具箱

第四章 PyTorch数据处理工具箱

4.1 数据处理工具箱概述

        PyTorch涉及数据处理（数据装载、数据预处理、数据增强等）主要工具包及相互关系。

        图4-1的左边是torch.utils.data工具包，它包括以下4个类。

• Dataset：是一个抽象类，其他数据集需要继承这个类，并且覆写其中的两个方法（_getitem__、__len__）。
• DataLoader：定义一个新的迭代器，实现批量（batch）读取，打乱数据（shuffle）并提供并行加速等功能。
• random_split：把数据集随机拆分为给定长度的非重叠的新数据集。
• *sampler：多种采样函数

        图4-1中间是PyTorch可视化处理工具（Torchvision），其是PyTorch的一个视觉处理工具包，独立于PyTorch，需要另外安装，使用pip或conda安装即可：pip install torchvision

        它包括4个类，各类的主要功能如下。

• datasets：提供常用的数据集加载，设计上都是继承自 torch.utils.data.Dataset，主要包括MMIST、CIFAR10/100、ImageNet和COCO 等。
• models：提供深度学习中各种经典的网络结构以及训练好的模型（如果选择pretrained=True），包括AlexNet、VGG系列、ResNet系列、 Inception系列等。
• transforms：常用的数据预处理操作，主要包括对Tensor及PIL Image 对象的操作。
• utils：含两个函数，一个是make_grid，它能将多张图片拼接在一个网格中；另一个是save_img，它能将Tensor保存成图片。

4.2 utils.data简介 

        utils.data包括Dataset和DataLoader。torch.utils.data.Dataset为抽象类。自定义数据集需要继承这个类，并实现两个函数，一个是__len__，另一个是 __getitem__，前者提供数据的大小（size），后者通过给定索引获取数据和标签。__getitem__一次只能获取一个数据，所以需要通过 torch.utils.data.DataLoader来定义一个新的迭代器，实现batch读取。

        1）导入需要的模块。

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

        2）定义获取数据集的类。

class TestDataset(data.Dataset):#继承Dataset
    def __init__(self):
        self.Data=np.asarray([[1,2],[3,4],[2,1],[3,4],[4,5]])#一些由2维向量表示的数据集
        self.Label=np.asarray([0,1,0,1,2])#这是数据集对应的标签

    def __getitem__(self, index):
        #把numpy转换为Tensor
        txt=torch.from_numpy(self.Data[index])
        label=torch.tensor(self.Label[index])
        return txt,label 

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

        3）获取数据集中数据。

Test=TestDataset()
print(Test[2])  #相当于调用__getitem__(2)
print(Test.__len__())

(tensor([2, 1], dtype=torch.int32), tensor(0, dtype=torch.int32))
5

        以上数据以tuple返回，每次只返回一个样本。实际上，Dateset只负责数据的抽取，调用一次__getitem__只返回一个样本。如果希望批量处理（batch），还要同时进行shuffle和并行加速等操作，可选择DataLoader。 DataLoader的格式为：

data.DataLoader(
    dataset,                     # 加载的数据集
    batch_size=1,                # 批大小
    shuffle=False,               # 是否打乱
    sampler=None,                # 样本抽样
    batch_sampler=None,          
    num_workers=0,               # 使用多进程加载的进程数，0代表不使用多进程
    collate_fn=<function default_collate at 0x7f108ee01620>, #如何将多个样本数据拼接成一个batch，一般使用默认的拼接方式即可。
    pin_memory=False,            # 是否将数据保存在pin memory区，pin memory中的数据转到GPU会快一些。
    drop_last=False,             # dataset中的数据个数可能不是batch_size的整数倍，drop_last为True会将多出来不足一个batch的数据丢弃
    timeout=0,
    worker_init_fn=None,
)

test_loader = data.DataLoader(Test,batch_size=2,shuffle=False,num_workers=0)
for i,traindata in enumerate(test_loader):
    print('i:',i)
    Data,Label=traindata
    print('data:',Data)
    print('Label:',Label)

        注意这里的num_workers=0

i: 0
data: tensor([[1, 2],
        [3, 4]], dtype=torch.int32)
Label: tensor([0, 1], dtype=torch.int32)
i: 1
data: tensor([[2, 1],
        [3, 4]], dtype=torch.int32)
Label: tensor([0, 1], dtype=torch.int32)
i: 2
data: tensor([[4, 5]], dtype=torch.int32)
Label: tensor([2], dtype=torch.int32)

        从这个结果可以看出，这是批量读取。我们可以像使用迭代器一样使用它，比如对它进行循环操作。不过由于它不是迭代器，我们可以通过iter命令将其转换为迭代器。

dataiter=iter(test_loader)
imgs,labels=next(dataiter)
#imgs.size()

        一般用data.Dataset处理同一个目录下的数据。如果数据在不同目录下， 因为不同的目录代表不同类别（这种情况比较普遍），使用data.Dataset来处理就很不方便。不过，使用PyTorch另一种可视化数据处理工具（即 torchvision）就非常方便，不但可以自动获取标签，还提供很多数据预处 理、数据增强等转换函数。

4.3 torchvision简介

        torchvision有4个功能模块：model、datasets、transforms和utils。

4.3.1 transforms

        transforms提供了对PIL Image对象和Tensor对象的常用操作。

1）对PIL Image的常见操作如下。

• Scale/Resize：调整尺寸，长宽比保持不变。
• CenterCrop、RandomCrop、RandomSizedCrop：裁剪图片，CenterCrop 和RandomCrop在crop时是固定size，RandomResizedCrop则是random size的 crop。
• Pad：填充。
• ToTensor：把一个取值范围是[0,255]的PIL.Image转换成Tensor。形状为（H,W,C）的Numpy.ndarray转换成形状为[C,H,W]，取值范围是[0,1.0]的 torch.FloatTensor。
• RandomHorizontalFlip：图像随机水平翻转，翻转概率为0.5。
• RandomVerticalFlip：图像随机垂直翻转。
• ColorJitter：修改亮度、对比度和饱和度。

2）对Tensor的常见操作如下。

• Normalize：标准化，即，减均值，除以标准差。
• ToPILImage：将Tensor转为PIL Image。

        如果要对数据集进行多个操作，可通过Compose将这些操作像管道一样拼接起来，类似于nn.Sequential。

4.3.2 ImageFolder

        当文件依据标签处于不同文件下时，如：

        我们可以利用torchvision.datasets.ImageFolder来直接构造出dataset，代码如下：

loader = datasets.ImageFolder(path)
loader = data.DataLoader(dataset)

        ImageFolder会将目录中的文件夹名自动转化成序列，当DataLoader载入时，标签自动就是整数序列了。

1）导入相关功能包

from torchvision import transforms, utils
from torchvision import datasets
import torch
import matplotlib.pyplot as plt 
%matplotlib inline

 2）定义图片处理类

my_trans=transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor()
])

3）数据装载

train_data = datasets.ImageFolder('./data/torchvision_data', transform=my_trans)
train_loader = data.DataLoader(train_data,batch_size=8,shuffle=True,)

4）取样展示图片

for i_batch, img in enumerate(train_loader):
    if i_batch == 0:
        print(img[1])
        fig = plt.figure()
        grid = utils.make_grid(img[0])
        plt.imshow(grid.numpy().transpose((1, 2, 0)))
        plt.show()
        utils.save_image(grid,'test01.png')
    break

4.4 可视化工具 

        Tensorboard是Google TensorFlow的可视化工具，它可以记录训练数据、评估数据、网络结构、图像等，并且可以在web上展示，对于观察神经网络训练的过程非常有帮助。

4.4.1 tensorboardX简介

        tensorboardX功能很强大，支持scalar、image、figure、histogram、 audio、text、graph、onnx_graph、embedding、pr_curve and videosummaries 等可视化方式。

        使用tensorboardX的一般步骤如下所示。

1）导入tensorboardX，实例化SummaryWriter类，指明记录日志路径等信息。

2）调用相应的API接口。

3）启动tensorboard服务。

4）web展示。

4.4.2 用tensorboardX可视化神经网络

（1）导入需要的模块

import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from tensorboardX import SummaryWriter

（2）构建神经网络

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.conv2_drop = nn.Dropout2d()
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)
        self.bn = nn.BatchNorm2d(20)

    def forward(self, x):
        x = F.max_pool2d(self.conv1(x), 2)
        x = F.relu(x) + F.relu(-x)
        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
        x = self.bn(x)
        x = x.view(-1, 320)
        x = F.relu(self.fc1(x))
        x = F.dropout(x, training=self.training)
        x = self.fc2(x)
        x = F.softmax(x, dim=1)
        return x

（3）把模型保存为graph

#定义输入
input = torch.rand(32, 1, 28, 28)
#实例化神经网络
model = Net()
#将model保存为graph
with SummaryWriter(log_dir='logs',comment='Net') as w:
    w.add_graph(model, (input, ))

（4）网页展示

 tensorboardX使用教程：Pytorch使用tensorboardX可视化。超详细！！！ - 简书 (jianshu.com)

4.4.3 用tensorboardX可视化损失值

        可视化损失值，需要使用add_scalar函数，这里利用一层全连接神经网络，训练一元二次函数的参数。

import torch
import torch.nn as nn
from tensorboardX import SummaryWriter
import numpy as np

input_size = 1
output_size = 1
num_epoches = 60
learning_rate = 0.01

dtype = torch.FloatTensor
writer = SummaryWriter(log_dir='logs', comment='Linear')
np.random.seed(100)
x_train = np.linspace(-1, 1, 100).reshape(100, 1)
y_train = 3 * np.power(x_train, 2) + 2 + 0.2 * np.random.rand(x_train.size).reshape(100, 1)

model = nn.Linear(input_size, output_size)

criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

for epoch in range(num_epoches):
    inputs = torch.from_numpy(x_train).type(dtype)
    targets = torch.from_numpy(y_train).type(dtype)

    output = model(inputs)
    loss = criterion(output, targets)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    # 保存loss的数据与epoch数值
    writer.add_scalar('训练损失值', loss, epoch)