• torchvision.transforms : 常用的图像预处理方法
• torchvision.datasets : 常用数据集的dataset实现，MNIST，CIFAR-10，ImageNet等
• torchvision.model : 常用的模型预训练，AlexNet，VGG， ResNet，GoogLeNet等

二、transforms的运行机制

（1）torchvision.transforms：常用的图像预处理方法

数据预处理方法：数据中心化；数据标准化；缩放；裁剪；旋转；填充；噪声添加；灰度变换；线性变换；仿射变换；亮度、饱和度及对比度变换等

compose将一系列transforms方法进行有序组合包装，依次按顺序的对图像进行操作

具体代码段如下：

导入：import torchvision.transforms as transforms


#训练集数据预处理
train_transform = transforms.Compose([
    transforms.Resize((32, 32)),    #缩放
    transforms.RandomCrop(32, padding=4),   #随机裁剪
    transforms.ToTensor(),  #转为tensor，同时进行归一化操作，将像素值的区间从0-255变为0-1
    transforms.Normalize(norm_mean, norm_std),  #数据标准化，均值变为0，标准差变为1
])
 
#验证集数据预处理
valid_transform = transforms.Compose([  #测试时不需要数据增强
    transforms.Resize((32, 32)),
    transforms.ToTensor(),
    transforms.Normalize(norm_mean, norm_std),

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

（2）transforms运行原理

把这两个transforms操作作为参数传给Dataset，在Dataset的__getitem__()方法中做图像增强。

具体代码段如下：


    def __getitem__(self, index):
        path_img, label = self.data_info[index]
        img = Image.open(path_img).convert('RGB')     # 0~255
 
        if self.transform is not None:
            img = self.transform(img)   # 在这里做transform，转为tensor等等
 
        return img, label

进入transforms，跳转到transforms的call函数

依次有序的从compose中调用数据处理方法


    def __call__(self, img):
        for t in self.transforms:
            img = t(img)
        return img

逻辑关系可以用下图表示：

三、数据标准化

`transforms.Normalize()`

功能：逐channel的对图像进行标准化。output = （input - mean）/ std

• mean：各通道的均值

• std：各通道的标准差

• inplace：是否原地操作

具体代码段如下：

此处直接调用的torch中的normalize函数


class Normalize(torch.nn.Module):
 
 
    def __init__(self, mean, std, inplace=False):
        super().__init__()
        self.mean = mean
        self.std = std
        self.inplace = inplace
 
    def forward(self, tensor: Tensor) -> Tensor:
        """
        Args:
            tensor (Tensor): Tensor image to be normalized.
        Returns:
            Tensor: Normalized Tensor image.
        """
        return F.normalize(tensor, self.mean, self.std, self.inplace)
 
    def __repr__(self):
        return self.__class__.__name__ + '(mean={0}, std={1})'.format(self.mean, self.std)

进入torch的normalize函数


def normalize(tensor: Tensor, mean: List[float], std: List[float], inplace: bool = False) -> Tensor:
    #判断是否是tensor
    if not isinstance(tensor, torch.Tensor):
        raise TypeError('Input tensor should be a torch tensor. Got {}.'.format(type(tensor)))
 
    if tensor.ndim < 3:
        raise ValueError('Expected tensor to be a tensor image of size (..., C, H, W). Got tensor.size() = '
                         '{}.'.format(tensor.size()))
    #是否进行原位操作，False则对tensor进行clone
    if not inplace:
        tensor = tensor.clone()
 
    dtype = tensor.dtype
    #将均值和标准差由列表格式转换为tensor格式
    mean = torch.as_tensor(mean, dtype=dtype, device=tensor.device)
    std = torch.as_tensor(std, dtype=dtype, device=tensor.device)
    if (std == 0).any():
        raise ValueError('std evaluated to zero after conversion to {}, leading to division by zero.'.format(dtype))
    if mean.ndim == 1:
        mean = mean.view(-1, 1, 1)
    if std.ndim == 1:
        std = std.view(-1, 1, 1)
    tensor.sub_(mean).div_(std)
    return tensor

四、数据增强

数据增强又称为数据增广，数据扩增，是对训练集进行变换，使训练集更丰富，从而让模型更具泛化能力，下面是一个数据增强的小例子。

4.1 transforms—数据裁剪

（1）transforms.CentorCrop

功能：从图像中心裁剪图片

torchvision.transforms.CenterCrop(size)

• size：所需裁剪图片尺寸

（2）transforms.RandomCrop

功能：从图片中随机裁剪出尺寸为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：镜像填充，最后一个像素不镜像，eg：[1,2,3,4] → [3,2,1,2,3,4,3,2]
symmetric：镜像填充，最后一个像素镜像，eg：[1,2,3,4] → [2,1,1,2,3,4,4,3]

• fill：constant时，设置填充的像素值

具体代码段如下：


# 测试RandomCrop随机裁剪
trans_random = transforms.RandomCrop(300)
trans_compose_2 = transforms.Compose([trans_random, trans_totensor])
for i in range(10):   # 0裁剪10次
    img_crop = trans_compose_2(img)
    writer.add_image("RandomCrop", img_crop, i)

（3）RandomResizedCrop

功能：随机大小、长宽比裁剪图片

• size：所需裁剪图片尺寸
• scale：随机裁剪面积比例，默认（0.08,1）（在0.08-1之间选择一个比例进行裁剪）
• ratio：随机长宽比，默认（3/4，4/3）
• interpolation：插值方法（由于裁剪之后的图片可能会小于size，故进行插值操作）

PIL.Image.NEAREST
PIL.Image.BILINEAR
PIL.Image.BICUBIC

（4）FiveCrop &（5）TenCrop

功能：在图像的上下左右及中心裁剪出尺寸为size的5张图片，TenCrop还在这5张图片的基础上再水平或者垂直镜像得到10张图片

• size：所需裁剪图片尺寸

• vertical_flip：是否垂直翻转

4.2 transforms——翻转和旋转

（1）RandomHorizontalFlip & （2）RandomVerticalFlip

功能：依概率水平（左右）或垂直（上下）翻转图片

p：翻转概率

（3）RandomRotation()

功能：随机旋转图片

• degrees：旋转角度
当为a时，在（-a，a）之间选择旋转角度
当为(a, b)时，在(a, b)之间选择旋转角度
• resample：重采样方法
• expand：是否扩大图片，以保持原图信息
• center：旋转点设置，默认中心旋转

完整代码：


# -*- coding: utf-8 -*-
 
import os
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
import numpy as np
import torch
import random
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
from PIL import Image
from matplotlib import pyplot as plt
path_lenet = os.path.abspath(os.path.join(BASE_DIR, "..", "..", "model", "lenet.py"))
path_tools = os.path.abspath(os.path.join(BASE_DIR, "..", "..", "tools", "common_tools.py"))
assert os.path.exists(path_lenet), "{}不存在，请将lenet.py文件放到 {}".format(path_lenet, os.path.dirname(path_lenet))
assert os.path.exists(path_tools), "{}不存在，请将common_tools.py文件放到 {}".format(path_tools, os.path.dirname(path_tools))
 
import sys
hello_pytorch_DIR = os.path.abspath(os.path.dirname(__file__)+os.path.sep+".."+os.path.sep+"..")
sys.path.append(hello_pytorch_DIR)
 
from tools.my_dataset import RMBDataset
from tools.common_tools import set_seed, transform_invert
 
set_seed(1)  # 设置随机种子
 
# 参数设置
MAX_EPOCH = 10
BATCH_SIZE = 1
LR = 0.01
log_interval = 10
val_interval = 1
rmb_label = {"1": 0, "100": 1}
 
# ============================ step 1/5 数据 ============================
split_dir = os.path.abspath(os.path.join("..", "..", "data", "RMB_data", "rmb_split"))
if not os.path.exists(split_dir):
    raise Exception(r"数据 {} 不存在, 回到lesson-06\1_split_dataset.py生成数据".format(split_dir))
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((224, 224)),  #统一图片尺寸
 
    # 1 CenterCrop
    # transforms.CenterCrop(196),     # 512
 
    # 2 RandomCrop
    # transforms.RandomCrop(224, padding=16),
    # transforms.RandomCrop(224, padding=(16, 64)),
    # transforms.RandomCrop(224, padding=16, fill=(255, 0, 0)),
    # transforms.RandomCrop(512, pad_if_needed=True),   # pad_if_needed=True
    # transforms.RandomCrop(224, padding=64, padding_mode='edge'),
    # transforms.RandomCrop(224, padding=64, padding_mode='reflect'),
    # transforms.RandomCrop(1024, padding=1024, padding_mode='symmetric'),
 
    # 3 RandomResizedCrop
    # transforms.RandomResizedCrop(size=224, scale=(0.5, 0.5)),
 
    # 4 FiveCrop
    # transforms.FiveCrop(112),
    # transforms.Lambda(lambda crops: torch.stack([(transforms.ToTensor()(crop)) for crop in crops])),
 
    # 5 TenCrop
    # transforms.TenCrop(112, vertical_flip=False),
    # transforms.Lambda(lambda crops: torch.stack([(transforms.ToTensor()(crop)) for crop in crops])),
 
    # 1 Horizontal Flip
    # transforms.RandomHorizontalFlip(p=1),
 
    # 2 Vertical Flip
    # transforms.RandomVerticalFlip(p=0.5),
 
    # 3 RandomRotation
    # transforms.RandomRotation(90),
    # transforms.RandomRotation((90), expand=True),
    # transforms.RandomRotation(30, center=(0, 0)),
    # transforms.RandomRotation(30, center=(0, 0), expand=True),   # expand only for center rotation
 
    transforms.ToTensor(),
    transforms.Normalize(norm_mean, norm_std),
])
 
valid_transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(norm_mean, norm_std)
])
 
# 构建MyDataset实例
train_data = RMBDataset(data_dir=train_dir, transform=train_transform)
valid_data = RMBDataset(data_dir=valid_dir, transform=valid_transform)
 
# 构建DataLoder
train_loader = DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)
valid_loader = DataLoader(dataset=valid_data, batch_size=BATCH_SIZE)
 
 
# ============================ step 5/5 训练 ============================
for epoch in range(MAX_EPOCH):
    for i, data in enumerate(train_loader):
 
        inputs, labels = data   # B C H W
 
        img_tensor = inputs[0, ...]     # C H W
        #invert函数对transforms进行逆操作，可以将浮点数据转为img，便于观察
        img = transform_invert(img_tensor, train_transform)
        plt.imshow(img)
        plt.show()
        plt.pause(0.5)
        plt.close()
 
        # FiveCrop 和 TenCrop的可视化操作，因为输出为5维
        # bs, ncrops, c, h, w = inputs.shape
        # for n in range(ncrops):
        #     img_tensor = inputs[0, n, ...]  # C H W
        #     img = transform_invert(img_tensor, train_transform)
        #     plt.imshow(img)
        #     plt.show()
        #     plt.pause(1)

4.3 transforms—图像变换

（1）pad

功能：对图片边缘进行填充

• padding：设置填充大小
当为a时，上下左右均填充a个像素
当为（a，b）时，上下填充b个像素，左右填充a个像素
当为（a，b，c，d）时，左，上，右，下分别填充a，b，c，d
• padding_mode：填充模式，有四种模式，constant、edge、reflect和symmetric（具体请见三.2.(2)节）
• fill：constant时，设置填充的像素值，（R，G，B）or（Gray）
padding_mode优先级高于fill

（2）ColorJitter

功能：调整亮度、对比度、饱和度和色相，这个是比较实用的方法。

• brightness：亮度调整因子

当为a时，从[max（0,1-a），1+a]中随机选择
当为（a，b）时，从[a，b]中选择

• contrast：对比度参数，同brightness
• saturation：饱和度参数，同brightness
• hue：色相参数

当为a时，从[-a，a]中选择参数，注：0<=a<=0.5
当为（a，b）时，从[a，b]中选择参数，注：-0.5<=a<=b<=0.5

（3）Greyscale

功能：将图片转换为灰度图

• num_output_channels: 输出的通道数。只能设置为 1 或者 3 (如果在后面使用了transforms.Normalize，则要设置为 3，因为transforms.Normalize只能接收 3 通道的输入)

（4）RandomGreyscale

功能：依概率将图片转换为灰度图

num_output_channels：输出通道数，只能设1或3
p：概率值，图像被转换为灰度图的概率，当p=1，则等价于Greyscale

（5）RandomAffine

功能：对图像进行仿射变换，仿射变换是二维的线性变换，由五种基本原子变换构成，分别是旋转，平移，缩放，错切和翻转

• degrees：旋转角度设置
• translate：平移区间设置，如（a，b），a设置宽（width），b设置高（height），图像在宽维度平移的区间为 -img_width * a < dx < img_width * a
• scale：缩放比例（以面积为单位）
• fill_color：填充颜色设置
• shear：错切角度设置，有水平错切和垂直错切

若为a，则仅在x轴错切，错切角度在（-a，a）之间
若为（a，b），则设置x轴角度，b设置y的角度
若为（a，b，c，d），则a，b设置x轴角度，c，d设置y轴角度

• resample：重采样方式，有NEAREST、BILINEAR、BICUBIC

（6）RandomErasing

功能：对图像进行随机遮挡

p：概率值，执行该操作的概率
scale：遮挡区域的面积
ratio：遮挡区域长宽比
value：设置遮挡区域的像素值，（R，G，B）or（Grey）

注意事项：执行Erasing是对tensor进行操作的，故需要把输入转为张量的类型，transforms.ToTensor()

遮挡效果如下：

（7）transforms.lambda

功能：用户自定义lambda方法

• lambd：lambda匿名函数
• lambda [arg1[,arg2,...,argn]] : expression
TenCrop输出的结果是tuple类型，故需要对输出结果转换为tensor，就可以用到lambda函数

stack将返回的张量进行拼接，输出为4D的张量，stack会创建一个维度将张量进行拼接

举个栗子：


transforms.TenCrop(200, vertical_flip=True),
transforms.Lambda(lambda crops: torch.stack([transforms.Totensor()(crop) for crop in crops])),

4.4 transforms——transforms方法选择操作

（1）transforms.RandomChoice

功能：从一系列transforms方法中随机挑选一个

（2）transforms.RandomApply

功能：依据概率执行一组transforms操作

（3）transforms.RandomOrder

功能：对一组transforms操作打乱顺序

4.5 自定义transforms方法

自定义transforms要素：

仅接收一个参数，返回一个参数
注意上下游的输入与输出

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

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

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

五、总结：二十二种transforms操作

一、裁剪

• transforms.CenterCrop
• transforms.RandomCrop
• transforms.RandomResizedCrop
• transforms.FiveCrop
• transforms.TenCrop

二、翻转和旋转

• transforms.RandomHorizontalFlip
• transforms.RandomVerticalFlip
• transforms.RandomRotation

三、图像变换

• transforms.Pad
• transforms.ColorJitter
• transforms.Grayscale
• transforms.RandomGrayscale
• transforms.RandomAffine
• transforms.LinearTransformation
• transforms.RandomErasing
• transforms.Lambda
• transforms.Resize
• transforms.Totensor
• transforms.Normalize

四、transforms的操作

• transforms.RandomChoice
• transforms.RandomApply
• transforms.RandomOrd

本文参考：

[PyTorch 学习笔记] 2.3 二十二种 transforms 图片数据预处理方法 - 知乎 (zhihu.com)

Pytorch基础学习（第二章-Pytorch数据处理）

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】