PyTorch学习笔记（9）transforms(3)

Pad

功能 对图片边缘进行填充
padding 设置填充大小
当为a时，上下左右均填充a个像素
当为(a,b)时，上下填充b个像素,左右填充a个像素
当为(a,b,c,d)时，左，上，右，下分别填充a,b,c,d,
padding_mode 填充模式 有四种模式 constant,edge,reflect,symmetric
fill constant时，设置填充的像素值(R,G,B)

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

Grayscale

RandomGrayscale

功能 依概率将图片转换为灰度图
num_output_channels 输出通道数 只能设1或3
p概率值，图像呗转换为灰度图的概率

RandomAffine

功能 对图像进行仿射变换，仿射变换是二维的线性变换，由物种基本院子变换构成，分别是旋转、平移、缩放、错切、翻转
degrees 旋转角度设置
translate 平移区间设置 如(a,b),a设置宽(width),b设置高(height)
图像在宽维度评议的区间为-img_widtha < dx <img_widtha
scale 缩放比例(以面积为单位)
fill_color 填充颜色设置
shear 错切角度设置，有水平错切和垂直错切
若为a，则仅在x轴错切，错切角度在(-a,a)之间
若为(a,b)，则a设置x轴角度，b设置y轴角度
若为(a,b,c,d)，则a,b设置x轴角度，c,d设置y轴角度
resample 重采样方式，有NEAREST BLINEAR BICUBIC

RandomErasing

功能 对图像进行随机遮挡
p 概率值 执行该操作的概率
scale 遮挡区域的面积
ratio 遮挡区域长宽比
value 设置遮挡区域的像素值(R,G,B) or (Gray)

transforms.Lambda

功能 用户自定义lambda方法
lambd： lambda匿名函数 lambda[arg1[,arg2,…,argn]]:expression

1.transforms.RandomChoic

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

2.transforms.RandomApply

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

3.transforms.RandomOrder

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

# -*- coding: utf-8 -*-

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
    # 上下左右都填充32个元素 填充的颜色是红色 模式是固定模式
    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()