大纲如下：

• Pytorch 的数据读取机制 (DataLoad 和 Dataset， 以一个人民币二分类的任务展开，通过代码调试去看逻辑和原理)
• Pytorch 的图像预处理 transforms（图像增强，选择，自定义 transforms 等）

• 总结梳理

  2. Pytorch 的数据读取机制

  在学习 Pytorch 的数据读取之前，我们得先回顾一下这个数据读取到底是以什么样的逻辑存在的， 上一次，我们已经整理了机器模型学习的五大模块，分别是数据，模型，损失函数，优化器，迭代训练：
  
  而这里的数据读取机制，很显然是位于数据模块的一个小分支，下面看一下数据模块的详细内容：
  
  数据模块中，又可以大致分为上面不同的子模块， 而今天学习的 DataLoader 和 DataSet 就是数据读取子模块中的核心机制。 了解了上面这些框架，有利于把知识进行整合起来，到底学习的内容属于哪一块。下面正式开始 DataLoader 和 Dataset 的学习：

  2.1 DataLoader

  torch.utils.data.DataLoader(): 构建可迭代的数据装载器, 我们在训练的时候，每一个 for 循环，每一次 iteration，就是从 DataLoader 中获取一个 batch_size 大小的数据的。
  
  DataLoader 的参数很多，但我们常用的主要有 5 个：

• dataset: Dataset 类， 决定数据从哪读取以及如何读取

• bathsize: 批大小
• num_works: 是否多进程读取机制
• shuffle: 每个 epoch 是否乱序
• drop_last: 当样本数不能被 batchsize 整除时， 是否舍弃最后一批数据

要理解这个 drop_last， 首先，得先理解 Epoch， Iteration 和 Batchsize 的概念：

• Epoch： 所有训练样本都已输入到模型中，称为一个 Epoch
• Iteration： 一批样本输入到模型中，称为一个 Iteration
• Batchsize： 批大小， 决定一个 Epoch 有多少个 Iteration

举个例子就 Ok 了， 假设样本总数 80， Batchsize 是 8， 那么 1Epoch=10 Iteration。 假设样本总数是 87， Batchsize 是 8， 如果 drop_last=True, 那么 1Epoch=10Iteration, 如果等于 False， 那么 1Epoch=11Iteration, 最后 1 个 Iteration 有 7 个样本。

2.2 Dataset

torch.utils.data.Dataset(): Dataset 抽象类， 所有自定义的 Dataset 都需要继承它，并且必须复写__getitem__()这个类方法。

__getitem__方法的是 Dataset 的核心，作用是接收一个索引， 返回一个样本， 看上面的函数，参数里面接收 index，然后我们需要编写究竟如何根据这个索引去读取我们的数据部分。

2.3 数据读取机制具体怎么用呢？

上面只是介绍了两个数据读取机制用到的两个类，那么具体怎么用呢？ 我们就以人民币二分类的任务进行具体查看， 但是查看之前我们要带着关于数据读取的三个问题去看：

1. 读哪些数据？ 我们每一次迭代要去读取一个 batch_size 大小的样本，那么读哪些样本呢？
2. 从哪读数据？ 也就是在硬盘当中该怎么去找数据，在哪设置这个参数。
3. 怎么读数据？

下面我们从实验中边看边学习：人民币分类的任务其实也非常简单， 就是

我们的数据集是 1 块的图片 100 张，100 的图片 100 张，我们的任务就是训练一个模型，来帮助我们对这两类图片进行分类。 这个说清楚了之后， 我们下面就带着上面的三个问题，来看我们这个任务的数据读取部分。

split_dir = os.path.join('data', 'rmb_split')
train_dir = os.path.join(split_dir, 'train')
valid_dir = os.path.join(split_dir, 'valid')
norm_mean = [0.485, 0.456, 0.406]
norm_std = [0.229, 0.224, 0.225]
train_transform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.RandomCrop(32, padding=4),
    transforms.ToTensor(),
    transforms.Normalize(norm_mean, norm_std),
])
valid_transform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.ToTensor(),
    transforms.Normalize(norm_mean, norm_std),
])
train_data = RMBDataset(data_dir=train_dir, transform=train_transform)
valid_data = RMBDataset(data_dir=valid_dir, transform=valid_transform)
train_loader = DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
valid_loader = DataLoader(dataset=valid_data, batch_size=BATCH_SIZE)

代码不用具体看懂，看懂这里的逻辑就可以，首先一开始，是路径部分， 也就是训练集和测试集的位置，这个其实就是我们上面的第二个问题从哪读数据，然后是 transforms 图像数据的预处理部分， 这个不用管， 后面会介绍 transforms 这个模块，这次最重要的就是 MyDataset 实例还有后面的 DataLoader，这个才是我们这次介绍的重点。 我们下面详细剖析（这个地方会涉及到代码的一些调试，所以尽量慢一些）：
我们从train_data = RMBDataset(data_dir=train_dir, transform=train_transform)开始， 这一句话里面的核心就是 RMBDataset，这个是我们自己写的一个类，继承了上面的抽象类 Dataset，并且重写了__getitem__()方法， 这个类的目的就是传入数据的路径，和预处理部分（看参数），然后给我们返回数据，下面看它是怎么实现的 (Pycharm 里面按住控制键，然后点击这个类就进入具体实现）：

class RMBDataset(Dataset):
    def __init__(self, data_dir, transform=None):
        """
        rmb面额分类任务的Dataset
        :param data_dir: str, 数据集所在路径
        :param transform: torch.transform，数据预处理
        """
        self.label_name = {"1": 0, "100": 1}
        self.data_info = self.get_img_info(data_dir)  
        self.transform = transform
    def __getitem__(self, index):
        path_img, label = self.data_info[index]
        img = Image.open(path_img).convert('RGB')     
        if self.transform is not None:
            img = self.transform(img)   
        return img, label
    def __len__(self):
        return len(self.data_info)
    @staticmethod
    def get_img_info(data_dir):
        data_info = list()
        for root, dirs, _ in os.walk(data_dir):
            for sub_dir in dirs:
                img_names = os.listdir(os.path.join(root, sub_dir))
                img_names = list(filter(lambda x: x.endswith('.jpg'), img_names))
                for i in range(len(img_names)):
                    img_name = img_names[i]
                    path_img = os.path.join(root, sub_dir, img_name)
                    label = rmb_label[sub_dir]
                    data_info.append((path_img, int(label)))
        return data_info

看到这么多代码估计又看不下去了，但是得养成读源码的习惯，依然是看逻辑关系，我觉得看源代码最好是先把逻辑关系给看懂， 然后再具体深入进去看具体细节。 逻辑的话其实也很简单，这里面重点就是__getitem__()这个方法的实现了，我们说过从这里面，我们要拿到我们的训练样本， 那么怎么拿呢？ 这个函数的第一行，会看到有个data_info[index]， 我们只要给定了 index， 那么就是通过这句代码进行获取样本的，因为这个方法后面的都比较好理解，无非就是拿到图片，然后处理，然后返回的一个逻辑。
所以上面的重点又落在了data_info[index]上面， 这句代码干了个什么事情呢？ 那么就得看看它是咋来的，所以就该往上看这个类的初始化部分__init__，我们可以看到这个data_info是 RMBDataset 这个类的成员，我们会看到self.data_info = self.get_img_info(data_dir)这句代码， 就找到了data_info的来源， 那么完了吗？ 当然没有，我们又发现这个又调用了get_img_info(data_dir)方法， 这个才是最终的根源。 所以我们又得看这个函数get_img_info(data_dir)做了什么？ 我们会发现这个函数的参数是 datadir, 也就是数据在的路径，那么如果想想的话，这个函数应该是要根据这个路径去找数据的， 果然，我们把目光聚焦到这个函数发现，这个函数写了这么多代码，其实就干了一件事，根据我们给定的路径去找数据，然后返回这个数据的位置和标签。 返回的是一个 list， 而 list 的每个元素是元组，格式就是[(样本 1loc, label_1), (样本 2_loc, label_2), …(样本 n_loc, label_n)]。这个其实就是data_info拿到的一个 list。 有了这个 list，然后又给了data_info一个 index，那么取数据不就很容易了吗？ data_info[index] 不就取出了某个 (样本 i_loc, label_i)。
这样再回到`__getitem()这个方法， 是不是很容易理解了， 第一行我们拿到了一个样本的图片路径和标签。然后第二行就是去找到图片，然后转成 RGB 数值。 第三行就是做了图片的数据预处理，最后返回了这张图片的张量形式和它的标签。 注意，这里是一个样本的张量形式和标签。 这就是 RMBDataset 这个类做的事情。应该讲明白了吧， 讲源码还真没经验，我也是第一次看，第一次讲。 有了这样的一个逻辑，知道每个函数大致在做什么事情之后，然后就可以取看具体的实现细节了，这个就不带着看了，哈哈。<br />那么你可能有个疑问了，我们肯定不是要获取一张图片啊， 我们不是要获取 batch_size 张图片吗？ 这个应该怎么实现呢？ 这是个好问题， 那么这个就要问下面的 DataLoader 了。<br />我们看这句代码train_loader = DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)， 看 DataLoader 这个类，接收的参数就是上面的RMBDataset，我们知道这个是返回一个样本的张量和标签，然后又跟了一个BATCH_SIZE, 看到这个，你心里应该有数了，这个不就是说这些样本要分成多少批吗？ 如果有了批次数，有了样本总数，不就相当于指定了一次取多少张吗？ 后面的shuffle，这个是说我取图片的时候，把顺序打乱一下，不是重点。 那么你是不是又好奇点东西了， 这个 DataLoader 在干啥事情呢？ 其实它在干这样的事情，我们只要指定了 Batch_SIZE， 比如指定个 10 批， 我们总共是有 100 个训练样本，那么就直接可以通过 DataLoader 把样本分成 10 批顺序打乱的数据，每一个 Batch_size 里面的有 10 个样本且都是张量和标签的形式，那么 DataLoader 是怎么做到的呢？ 哈哈，如果想弄明白这个问题，又得看看 DataLoader 的源码了， 但是我看了一下发现，这个不得了，源码太长了，没法在这里具体显示， 那怎么办呢？ 我们可以先看看这个 train_loader 到底是个啥，打印了一下，是这样的一个东西：`， 看了这是一个 DataLoader 对象了， 也没法进行研究了，现在只知道这个东西能够返回那 Batch_size 个批次的数据，赋值给了 train_loader, 显然这是一个可迭代的对象。 那么很容易就可以想到，如果下面我们具体训练的时候，肯定是要遍历这个 train_loader, 然后每一次取一批数据进行训练。 哈哈，机智如你，果不其然，我们从具体使用的时候，看看每一批数据究竟是如何获得的？ 下面我们就直接从训练的部分看，像中间的模型，损失函数，优化器不是重点，所以这里先不放上来：

for epoch in range(MAX_EPOCH):
    loss_mean = 0.
    correct = 0.
    total = 0.
    net.train()
    for i, data in enumerate(train_loader):
        inputs, labels = data
        outputs = net(inputs)
        optimizer.zero_grad()
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

上面就是训练部分的核心了，这个比较好理解， 两层循环，外循环表示的迭代 Epoch，也就是全部的训练样本喂入模型一次， 内循环表示的批次的循环，每一个 Epoch 中，都是一批批的喂入， 那么数据读取具体使用的核心就是for i, data in enumerate(train_loader)这句话了， 所以我们以调试的方式看看这个函数究竟是怎么去得到数据的？

在这一行打断点，然后 debug，程序运行到这一行，然后点击下面的 stepinto 步入这个函数里面，我们看看调用的 DataLoader 里面的哪个方法， 由于 DataLoader 的源码太多，方法很多，所以在具体使用的时候看这个流程就不用放上一些不必要的代码， 减少冗余。

这样就会看到，程序跳转到了 DataLoader 的__iter__(self)这个方法，毕竟这是个迭代的过程， 但是简单的瞄一眼这个函数，就会发现就一个判断，说的啥呢？ 原来在说是用单进程还是用多进程读取机制进行处理， 关于读取数据啥也没干。 所以这个也不是重点， 我们使用 stepover 进行下一步，然后在 stepinto 进入单进程的这个机制里面

在这里面会看到点玄机了，这个机制里面比较重要的一个方法就是__next__(self), 上面不是说 RMBDataset 函数是能返回一个样本和标签吗？ 这里的这个 next， 看其字面意义就知道这个是获取下一个样本和标签，重要的两行代码就是红框的那两行，self.__next__index()获取下一个样本的 index， 然后self.dataset_fetcher.fetch(index)根据 index 去获取下一个样本， 那么是怎么做到的？ 继续调试：将光标放到__next__index()这一行，然后点击下面的 run to cursor 图表，就会跳到这一行，然后 stepinto

发现，这里是返回了一个return next(self.sampler_iter) , 所以重点应该是这个东西，我们继续 stepinto

这里发现进入了sampler.py, 这里面重要的就是这个__iter__(self), 这个方法正是一次次的去采样我们的数据的索引，然后够了一个 batch_size 了就返回了。 那这一次取到的哪些样本的索引呢？ 我们可以跳出这个函数，回去看看（连续两次跳出函数，回到 dataloader.py）：

然后 stepover 到 data 这一行， 这个意思就是说，index 这一样代码执行完毕，我们可以看到最下面取到的 index（可以和上上张图片，没执行这个函数的时候对比一下），我们的 batch_size 设置的 16， 所以通过上面的sampler.py获得了 16 个样本的索引。

这样，我们就有了一个批次的 index， 那么就好说了，根据 index 取不就完事了， 所以第二行代码data = self.dataset_fetcher.fetch(index)就是取数据去了，重点就是这里的dataset_fetcher.fetch方法， 我们继续调试看看它是怎么取数据的。

这样进入了 fetch.py， 然后核心是这里的 fetch 方法，这里面会发现调用了self.dataset[idx]去获取数据， 那么我们再步入一步，就看到了奇迹：

会发现，这个方法跳到了我们写的 RMBDataset 这个类里面，调用了__getitem__方法，这个我们知道是获取一个样本的， 那么就拿到了这个样本的张量和标签。而 fetch 里面的那个方法是一个列表推导式，所以通过这个方法就能够获取一个 batch 大小的样本。

取完了一个批次， 然后进入self.collate_fn(data)进行整合，就得到了我们一个批次的 data，最终我们返回来。

就看到了我们第一个批次获得的数据样本了。 我们知道，这个 train_loader 已经把样本分成了一个个的 batch, 共 batch_size 批，所以通过 enumerate 进行迭代就可以一批批的获取，然后训练模型了。 这样所有的批次数据都喂入了模型，就完成了一次 epoch。

好了， 上面就是 DataLoader 读取数据的过程了，可能代码调试的过程确实比较乱，或许看不大懂，所以我们基于那三个问题梳理一遍逻辑，把逻辑关系看懂就好了， 并且最后用灵魂画笔来个流程图再进行梳理。 还记得我们的三个问题吗？

1. 读哪些数据？ 这个我们是根据 Sampler 输出的 index 决定的
2. 从哪读数据？ 这个是 Dataset 的 data_dir 设置数据的路径，然后去读
3. 怎么读数据？ 这个是 Dataset 的 getitem 方法，可以帮助我们获取一个样本

我们知道，DataLoader 读取数据的过程比较麻烦，用到了四五个. py 文件的跳转，所以梳理这个逻辑关系最好的方式就是流程图：

通过这个流程图，把 DataLoader 读取数据的流程梳理了一遍，具体细节不懂没有关系，但是这个逻辑关系应该要把握住，这样才能把握宏观过程，也能够清晰的看出 DataLoader 和 Dataset 的关系。 根据前面介绍，DataLoader 的作用就是构建一个数据装载器， 根据我们提供的 batch_size 的大小， 将数据样本分成一个个的 batch 去训练模型，而这个分的过程中需要把数据取到，这个就是借助 Dataset 的 getitem 方法。

这样也就清楚了，如果我们想使用 Pytorch 读取数据的话，首先应该自己写一个 MyDataset，这个要继承 Dataset 类并且实现里面的__getitem__方法，在这里面告诉机器怎么去读数据。 当然这里还有个细节，就是还要覆盖里面的__len__方法，这个是告诉机器一共用多少个样本数据。 要不然机器没法去根据 batch_size 的个数去确定每一个 batch 应该多大啊。这个写起来也很简单，返回总的样本的个数即可。

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

这样， 机器就可以根据 Dataset 去硬盘中读取数据，接下来就是用 DataLoader 构建一个可迭代的数据装载器，传入如何读取数据的机制 Dataset，传入 batch_size, 就可以返回一批批的数据了。 当然这个装载器具体使用是在模型训练的时候。

好了，上面就是 Pytorch 读取机制 DataLoader 和 Dataset 的原理部分了。

人民币二分类的数据模块里面，除了数据读取机制 DataLoader，还涉及了一个图像的预处理模块 transforms， 是对图像进行预处理的，下面我们再看看这个的原理， 再搞定这个细节，人民币二分类任务的数据模块就无死角了。

3. Pytorch 的图像预处理 transforms

transforms 是常用的图像预处理方法， 这个在 torchvision 计算机视觉工具包中，我们在安装 Pytorch 的时候顺便安装了这个 torchvision(可以看看上面的搭建环境）。 在 torchvision 中，有三个主要的模块：

• torchvision.transforms: 常用的图像预处理方法, 比如标准化，中心化，旋转，翻转等操作
• trochvision.datasets: 常用的数据集的 dataset 实现， MNIST, CIFAR-10, ImageNet 等
• torchvision.models: 常用的模型预训练, AlexNet, VGG, ResNet, GoogLeNet 等。

我们这次看图像预处理模块 transforms， 主要包括下面的方法：

数据中心化，数据标准化，缩放，裁剪，旋转，翻转，填充，噪声添加，灰度变换，线性变换，仿射变换，亮度、饱和度及对比度变换。

3.1 看看二分类任务中用到的 transforms 的方法

下面我们可以看看人民币二分类任务中用到的图像预处理的方法了：
导入：import torchvision.transforms as transforms。

• transforms.Compose 方法是将一系列的 transforms 方法进行有序的组合包装，具体实现的时候，依次的用包装的方法对图像进行操作。
• transforms.Resize 方法改变图像大小
• transforms.RandomCrop 方法对图像进行裁剪（这个在训练集里面用，验证集就用不到了）
• transforms.ToTensor 方法是将图像转换成张量，同时会进行归一化的一个操作，将张量的值从 0-255 转到 0-1
• transforms.Normalize 方法是将数据进行标准化

这个机制是怎么运行的这里就不多说了，因为我们这个函数是在 RMBDataset 的__getitem__方法中调用的。也就是在这里处理的图像。 至于 transform 函数的源码，这里就不去看了。

    def __getitem__(self, index):
        path_img, label = self.data_info[index]
        img = Image.open(path_img).convert('RGB')     
        if self.transform is not None:
            img = self.transform(img)   
        return img, label

但是逻辑关系依然要知道：

了解了图像处理的 transforms 机制，我们下面学习一个比较常用的数据预处理机制，叫做数据标准化：
transforms.Normalize: 逐 channel 的对图像进行标准化。 o u t p u t = (i n p u t − m e a n) / s t d output = (input - mean) / std output\=(input−mean)/std

这个参数就不用解释了吧。 好吧， 再进行调试一下，看看是怎么变的吧：
依然是先打断点，然后步入这个函数：

我们进入了 transforms.py， 这里面的__call__里面就是那一系列的数据处理方法

然后点几次 stepover 就到了 Normalize 这个操作，这时候我们再次步入，到了 Normalize 类， 这里面有一个 call 函数调用了 pytorch 库里面的 Normalize 函数， 我们再次步入：

这里就有图有真相了。

Normalize 的处理作用就是有利于加快模型的收敛速度。 关于细节，这里可能没有必要整理的这么细， 我这里整理是顺便学习一下代码的 debug 的过程，这个比了解 Normalize 的细节本身更加重要。

3.2 transforms 的其他图像增强方法

1. 数据增强
   数据增强又称为数据增广， 数据扩增，是对训练集进行变换，使训练集更丰富，从而让模型更具泛化能力， 下面是一个数据增强的小例子 (原来当初的我们就类似于机器啊，哈哈)。
   
2. 图像裁剪
   • transforms.CenterCrop(size): 图像中心裁剪图片, size 是所需裁剪的图片尺寸，如果比原始图像大了， 会默认填充 0。
   • transforms.RandomCrop(size, padding=None, pad_if_needed=False, fill=0, padding_mode='constant): 从图片中位置随机裁剪出尺寸为 size 的图片， size 是尺寸大小，padding 设置填充大小（当为 a， 上下左右均填充 a 个像素， 当为 (a,b), 上下填充 b 个，左右填充 a 个，当为 (a,b,c,d)， 左，上，右，下分别填充 a,b,c,d 个）， pad_if_need: 若图像小于设定的 size, 则填充。 padding_mode 表示填充模型， 有 4 种，constant 像素值由 fill 设定， edge 像素值由图像边缘像素设定，reflect 镜像填充， symmetric 也是镜像填充， 这俩镜像是怎么做的看官方文档吧。镜像操作就类似于复制图片的一部分进行填充。
   • transforms.RandomResizedCrop(size, scale=(0.08, 1.0), ratio=(3/4, 4/3), interpolation): 随机大小，长宽比裁剪图片。 scale 表示随机裁剪面积比例，ratio 随机长宽比， interpolation 表示插值方法。
   • FiveCrop, TenCrop: 在图像的上下左右及中心裁剪出尺寸为 size 的 5 张图片，后者还在这 5 张图片的基础上再水平或者垂直镜像得到 10 张图片，具体使用这里就不整理了。
3. 图像的翻转和旋转
   1. RandomHorizontalFlip(p=0.5), RandomVerticalFlip(p=0.5): 依概率水平或者垂直翻转图片， p 表示翻转概率
   2. RandomRotation(degrees, resample=False, expand=False, center=None): 随机旋转图片， degrees 表示旋转角度 ， resample 表示重采样方法， expand 表示是否扩大图片，以保持原图信息。
4. 图像变换
   • transforms.Pad(padding, fill=0, padding_mode='constant'): 对图片边缘进行填充
   • transforms.ColorJitter(brightness=0, contrast=0, saturation=0, hue=0): 调整亮度、对比度、饱和度和色相， 这个是比较实用的方法， brightness 是亮度调节因子， contrast 对比度参数， saturation 饱和度参数， hue 是色相因子。
   • transfor.RandomGrayscale(num_output_channels, p=0.1): 依概率将图片转换为灰度图， 第一个参数是通道数， 只能 1 或 3， p 是概率值，转换为灰度图像的概率
   • transforms.RandomAffine(degrees, translate=None, scale=None, shear=None, resample=False, fillcolor=0): 对图像进行仿射变换， 反射变换是二维的线性变换， 由五中基本原子变换构成，分别是旋转，平移，缩放，错切和翻转。 degrees 表示旋转角度， translate 表示平移区间设置，scale 表示缩放比例，fill_color 填充颜色设置， shear 表示错切
   • transforms.RandomErasing(p=0.5, scale=(0.02, 0.33), ratio=(0.3, 3.3), value=0, inplace=False): 这个也比较实用， 对图像进行随机遮挡， p 概率值，scale 遮挡区域的面积， ratio 遮挡区域长宽比。 随机遮挡有利于模型识别被遮挡的图片。value 遮挡像素。 这个是对张量进行操作，所以需要先转成张量才能做
   • transforms.Lambda(lambd): 用户自定义的 lambda 方法， lambd 是一个匿名函数。lambda [arg1 [, arg2…argn]]: expression
   • .Resize, .ToTensor, .Normalize: 这三个方法上面具体说过，在这里只是提一下子。

3.3 transforms 的选择操作

对几个 transforms 的操作进行选择，使得图像预处理更加的灵活。

1. transforms.RandomChoice([transforms1, transforms2, transforms3]): 从一系列 transforms 方法中随机选一个
2. transforms.RandomApply([transforms1, transforms2, transforms3], p=0.5): 依据概率执行一组 transforms 操作
3. transforms.RandomOrder([transforms1, transforms2, transforms3]): 对一组 transforms 操作打乱顺序

到这里，关于 Pytorch 的 transforms 操作基本上就搞定， 上面只是整理了一些常用的函数，如果真的需要，具体细节还得去看官方文档。 虽然 Pytorch 提供了很多的 transforms 方法， 但是在实际工作中，可能需要自己的项目去自定义一些 transforms 方法，那么如果想自己定义方法，怎么做呢？

3.4 自定义 transforms

我们上面的代码调试中看到了在 Compose 这个类里面调用了一系列的 transforms 方法， 还记得这个吗？ 我们再回顾一遍这个运行机制：

我们对 Compose 里面的这些 transforms 方法执行一个 for 循环，每次挑取一个方法进行执行。 也就是transforms 方法仅接收一个参数，返回一个参数，然后就是 for 循环中，上一个 transforms 的输出正好是下一个 transforms 的输入，所以数据类型要注意匹配。 这就是自定义 transforms 的两个要素。

下面给出一个自定义 transforms 的结构：

上面就是整个 transforms 的图像增强处理的技术了。但是实际工作中，最关键的还不是技术，而是战术，这些技术我们现在都知道了， 到时候用到的时候可以随时去查然后拿过来用。 但是我们如何去选择图像增强的策略呢？ 这个才是重点。

数据增强策略原则： 让训练集与测试集更接近。

• 空间位置上： 可以选择平移
• 色彩上： 灰度图，色彩抖动
• 形状： 仿射变换
• 上下文场景： 遮挡，填充

4 总结梳理

通过这篇文章就把 Pytorch 的数据模块给整理完毕，依然是快速的回顾一遍：首先是整理了 Pytorch 的数据读取机制， 学习到了两个数据读取的关键 DataLoader 和 Dataset，并通过一个人民币二分类的例子具体看了下这两个是如何使用的，以及它们之间的关系和原理，这个是通过 debug 进行描述的，debug 的这种操作本身也非常重要，并且也要养成看源码的习惯。

然后又学习了 Pytorch 的图像处理模块 transforms， 这一模块主要是整理了各种图像处理的方法，transforms 的选择操作，并且从战术的角度看了一下这些方法到底什么时候用。 至于这些方法的细节，具体用到的时候查看官方文档即可， 关于 transforms，我们还可以自定义。

下面也是通过思维导图的方式把这一块的内容拎起来，方便以后查看学习：

关于 Pytorch 的数据模块，到这里就基本结束， 我们的逻辑就是按照机器学习的那五大步骤进行的查看， 数据模块 -> 模型模块 -> 损失函数 -> 优化器 -> 训练等。 所以下一次我们进入模型模块，看看模型模块的具体细节， 继续 rush 😉

PS: 本次学习视频来自 B 站https://www.bilibili.com/video/BV1EE41177ot?from=search&seid=13894259699897815176, 时间长了就有可能被和谐了。 所有代码链接：

链接：https://pan.baidu.com/s/1c5EYdd0w8j6w3g54KTxJJA
提取码：k7rh
https://blog.csdn.net/wuzhongqiang/article/details/105499476