学习笔记|Pytorch使用教程08(transforms数据预处理方法(二))

学习笔记|Pytorch使用教程08

本学习笔记主要摘自“深度之眼”，做一个总结，方便查阅。
使用Pytorch版本为1.2。

• transforms——图像变换
• transforms——transforms方法操作
• 自定义transforms方法

一.transforms——图像变换

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

• padding：设置填充大小
  当为a时，上下左右均填充a个像素。
  当为（a，b）时，上下填充b个像素，左右填充a个像素。
  当为（a，b，c，d）时，上下左右分别填充a，b，c，d
• padding_mode:填充模式，有4种模式，constant，edge，reflect和symmetric
• fill：constant时，设置填充的像数值，（R，G，B）or（Gray）

完整代码：

import os
import numpy as np
import torch
import random
from matplotlib import pyplot as plt
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
from tools.my_dataset import RMBDataset
from tools.common_tools import transform_invert



def set_seed(seed=1):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)


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.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((224, 224)),

    # 1 Pad
    # transforms.Pad(padding=32, fill=(255, 0, 0), padding_mode='constant'),
    # transforms.Pad(padding=(8, 64), fill=(255, 0, 0), padding_mode='constant'),
    # transforms.Pad(padding=(8, 16, 32, 64), fill=(255, 0, 0), padding_mode='constant'),
    # transforms.Pad(padding=(8, 16, 32, 64), fill=(255, 0, 0), padding_mode='symmetric'),

    # 2 ColorJitter
    # transforms.ColorJitter(brightness=0.5),
    # transforms.ColorJitter(contrast=0.5),
    # transforms.ColorJitter(saturation=0.5),
    # transforms.ColorJitter(hue=0.3),

    # 3 Grayscale
    # transforms.Grayscale(num_output_channels=3),

    # 4 Affine
    # transforms.RandomAffine(degrees=30),
    # transforms.RandomAffine(degrees=0, translate=(0.2, 0.2), fillcolor=(255, 0, 0)),
    # transforms.RandomAffine(degrees=0, scale=(0.7, 0.7)),
    # transforms.RandomAffine(degrees=0, shear=(0, 0, 0, 45)),
    # transforms.RandomAffine(degrees=0, shear=90, fillcolor=(255, 0, 0)),

    # 5 Erasing
    # transforms.ToTensor(),
    # transforms.RandomErasing(p=1, scale=(0.02, 0.33), ratio=(0.3, 3.3), value=(254/255, 0, 0)),
    # transforms.RandomErasing(p=1, scale=(0.02, 0.33), ratio=(0.3, 3.3), value='1234'),

    # 1 RandomChoice
    # transforms.RandomChoice([transforms.RandomVerticalFlip(p=1), transforms.RandomHorizontalFlip(p=1)]),

    # 2 RandomApply
    # transforms.RandomApply([transforms.RandomAffine(degrees=0, shear=45, fillcolor=(255, 0, 0)),
    #                         transforms.Grayscale(num_output_channels=3)], p=0.5),
    # 3 RandomOrder
    # transforms.RandomOrder([transforms.RandomRotation(15),
    #                         transforms.Pad(padding=32),
    #                         transforms.RandomAffine(degrees=0, translate=(0.01, 0.1), scale=(0.9, 1.1))]),

    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
        img = transform_invert(img_tensor, train_transform)
        plt.imshow(img)
        plt.show()
        plt.pause(0.5)
        plt.close()

当设置 transforms.Pad(padding=32, fill=(255, 0, 0), padding_mode=‘constant’) 时：

会在图像四周扩充 32 个像素点，其RGB值为**（255，0，0）**。

当设置 transforms.Pad(padding=(8, 64), fill=(255, 0, 0), padding_mode=‘constant’) 时：

图像左右扩充 8 个像素点，上下扩充 64 个像素点，其RGB值为　（255，0，0）　。

当设置　transforms.Pad(padding=(8, 16, 32, 64), fill=(255, 0, 0), padding_mode=‘constant’)　时：

对应位置添加像素点。

当设置　transforms.Pad(padding=(8, 16, 32, 64), fill=(255, 0, 0), padding_mode=‘symmetric’)　时：

当设置成镜像（symmetric）模式时，fill这个参数就不起作用了。

2.ColorJitter
功能：调整亮度、对比度、饱和度和色相

• brightness：亮度调整因子
  当为a时，从[max(0, 1 - a), 1 + a]中随机选择。
  当为（a，b）时，从[a, b]中选择。
• constant：对比度参数，同brightness。
• saturation：饱和度参数，同brightness。
• hue：色相参数，当为ａ时，从[-a, a]中选择参数，注：0 <= a <= 0.5

当设置　transforms.ColorJitter(brightness=0.5)　时：

原始图片为：

可以看出亮度发生变换，（brightness=0.5＜１）会使得图片变暗，如果大于１，则可以变亮。

当设置　transforms.ColorJitter(contrast=0.5)　时：

可以参考上述原图，发现对比度已经产生了变换。

当设置成　transforms.ColorJitter(saturation=0.5)　时：

可以参考上述原图，发现饱和度已经产生了变换。

当设置成　transforms.ColorJitter(hue=0.3)　时：

可以参考上述原图，发现色相已经产生了变换。

３.Grayscale
４.RandomGrayscale
功能：依概率将图片转换为灰度图

• num_output_channels：输出通道数，只能设置成１或３
• p：概率值，图像被转换为灰度图的概率

当设置　transforms.Grayscale(num_output_channels=3)　时：

变成灰度图。

５.RandomAffine

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

• degrees：旋转角度设置
• translate：平移区间设置，如（ａ，ｂ），ａ设置宽(width)，ｂ设置高(height)。
  图像在宽维度平移的区间为　-img_width * a < dx < img_width * a　。
• scale：缩放比例（以面积为单位）
• fill_colore：一种填充颜色设置。
• shear：错切角度设置，有水平错切和锤子错切。
  若为ａ，则仅在ｘ轴错切，错切角度在（－ａ，ａ）之间
  若为（ａ，ｂ），则ａ设置ｘ轴角度，ｂ设置ｙ的角度。
  若为（ａ，ｂ，ｃ，ｄ），则ａ，ｂ设置ｘ轴角度，ｃ，ｄ设置ｙ轴角度。
• resample：采样方式，有NEAREST、BILINEAR 、BICUBIC。
• fill_color：填充的颜色

当设置　transforms.RandomAffine(degrees=30)　时：

随机旋转角度（-30°， +30°）。

当设置　transforms.RandomAffine(degrees=0, translate=(0.2, 0.2), fillcolor=(255, 0, 0))　时：

当设置　transforms.RandomAffine(degrees=0, scale=(0.7, 0.7))　时：

图像会缩小，但图像所占面积不变，会用黑色像素点进行填充。

当设置　transforms.RandomAffine(degrees=0, shear=(0, 0, 0, 45))　时：

这个是ｙ轴错切。

当设置　transforms.RandomAffine(degrees=0, shear=90, fillcolor=(255, 0, 0))　时：

错切也可以设置填充区域。

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