36李沐动手学深度学习v2/图像增广

%matplotlib inline
import torch
import torchvision
from torch import nn
from d2l import torch as d2l

d2l.set_figsize()
img=d2l.Image.open('./img/cat1.jpg')
d2l.plt.imshow(img)

def apply(img, aug, num_rows=2, num_cols=4, scale=1.5):
    '''
    
    :param aug 图像增强方式
    :param num_rows 几行图片，默认2行
    :param num_cols 几列图片，默认4列
    :param scale 图片尺寸
    '''
    # 对图片做num_rows * num_cols（默认8次）次随机增强，并保存到list中
    Y = [aug(img) for _ in range(num_rows * num_cols)]
    # 展示随机增强的图片
    d2l.show_images(Y, num_rows, num_cols, scale=scale)

随机翻转

# 随机水平反转，50%概率保持不变，50%概率水平翻转
apply(img, torchvision.transforms.RandomHorizontalFlip())
# 随机垂直反转，50%概率保持不变，50%概率上下翻转
apply(img, torchvision.transforms.RandomVerticalFlip())

随机裁剪

# 随机尺寸裁剪
shape_aug = torchvision.transforms.RandomResizedCrop(
    # 输出是200*200
    (200, 200), 
    # 裁剪图片尺寸，随机10%到100%，这个随机裁剪大小就是常用的裁剪大小
    scale=(0.1, 1), 
    # 高宽比
    ratio=(0.5, 2))
apply(img, shape_aug)

随机更改图像

• 亮度（brightness）
• 对比度（contrast）
• 饱和度（saturation）
• 色调（hue）

# 随机更改图像的亮度 brightness
apply(img, torchvision.transforms.ColorJitter(
    # 亮度，随机[原亮度-50%, 原亮度+50%]
    brightness=0.5,
    # 对比度，0不改变
    contrast=0, 
    # 饱和度
    saturation=0, 
    # 色调
    hue=0))

# 随机更改图像的色调 hue
apply(img, torchvision.transforms.ColorJitter(
    brightness=0, 
    contrast=0, 
    saturation=0,
    # 色调，随机[原色调-50%, 原色调+50%]
    hue=0.5))

# 随机更改图像的亮度（brightness）、对比度（contrast）、饱和度（saturation）和色调（hue）
# 常用的图像增广参数
color_aug = torchvision.transforms.ColorJitter(
    brightness=0.5, 
    contrast=0.5, 
    saturation=0.5, 
    hue=0.5)

apply(img, color_aug)

结合多种图像增广方法

# 常用，时间情况
# list,先水平翻转》基础上，颜色增强》基础上，形状增强
augs = torchvision.transforms.Compose([
    # 水平翻转
    torchvision.transforms.RandomHorizontalFlip(), 
    # 颜色增强
    color_aug, 
    # 形状增强
    shape_aug])

apply(img, augs)

使用图像增广进行训练

# CIFAR10数据，比Fashion-mnist稍难
# 尺寸为32x32
# 10个类别的RGB彩色图片，每个类别有6000个图像
# 10个类别 飞机（ airplane ）、汽车（ automobile ）、鸟类（ bird ）、猫（ cat ）、鹿（ deer ）、狗（ dog ）、蛙类（ frog ）、马（ horse ）、船（ ship ）和卡车（ truck ）。
# 数据集中一共有5万张训练图片和1万张测试图片
all_images = torchvision.datasets.CIFAR10(
    train=True, 
    root="../data",
    download=True)

d2l.show_images(
    # 取第1列的32张图片
    [all_images[i][0] for i in range(32)], 
    # 4行
    4, 
    # 8列
    8, 
    # 原尺寸的80%
    scale=0.8);

Files already downloaded and verified

# Compose方法，先执行list[0]》基础上，执行list[1]
# 训练集使用图像增广
train_augs = torchvision.transforms.Compose([
    # 随机水平翻转
    # 通常来说，我们还会做一些shape，color变换
    torchvision.transforms.RandomHorizontalFlip(),
    # 张量化，4D 个数，通道数，高，宽
    torchvision.transforms.ToTensor()])

# 测试集没有使用图像增广
test_augs = torchvision.transforms.Compose([
     torchvision.transforms.ToTensor()])

def load_cifar10(is_train, augs, batch_size):
    '''
    多进程 增广和获取增广后的数据
    :param augs 图像增广方式
    :param is_train 是否是训练数据
    :param batch_size 小批量大小
    '''
    # transform读取数据后应用图像增广
    dataset = torchvision.datasets.CIFAR10(
        root="../data", 
        train=is_train,
        # transform读取数据后应用图像增广
        transform=augs, 
        download=True)
    
    # 多进程 增广和获取增广后的数据
    dataloader = torch.utils.data.DataLoader(
        dataset, 
        # 每次迭代读取batch_size大小的数据
        batch_size=batch_size,
        # 如果时训练数据则打乱
        shuffle=is_train, 
        # workers取大一些，使用更多的进程来进行图像增广，因为图像增广比较耗时，耗性能
        num_workers=d2l.get_dataloader_workers())
    return dataloader

def train_batch_ch13(net, X, y, loss, trainer, devices):
    '''
    多GPU训练一个小批量
    :param trainer 训练器 不同的优化算法
    '''
    if isinstance(X, list):
        # X是list类型则生成式方式放到第gpu0上
        # 为什么要放到gpu上，多gpu之间的带宽大于gpu和cpu之间的带宽
        X = [x.to(devices[0]) for x in X]
    else:
        # X不是list类型直接放到gpu0上
        X = X.to(devices[0])
    # 标签放到gpu0上
    y = y.to(devices[0])
    # 开始训练
    net.train()
    # 清空梯度，避免已有累积的梯度
    trainer.zero_grad()
    pred = net(X)
    # 计算损失
    l = loss(pred, y)
    # 后向传播
    l.sum().backward()
    # 前进一步，更新参数
    trainer.step()
    # 总损失
    train_loss_sum = l.sum()
    # 总精度
    train_acc_sum = d2l.accuracy(pred, y)
    return train_loss_sum, train_acc_sum

def train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs,devices=d2l.try_all_gpus()):
    '''
    多GPU模型训练
    :param trainer 训练器 不同的优化算法
    '''
    timer= d2l.Timer()
    # 有多少个小批量数据
    num_batches = len(train_iter)
    # 动画绘制器
    animator = d2l.Animator(xlabel='epoch', 
                            xlim=[1, num_epochs], ylim=[0, 1],
                            legend=['train loss', 'train acc', 'test acc'])
    # 数据并行，将net放到gpu0，并返回1个新的net
    net = nn.DataParallel(net, device_ids=devices).to(devices[0])
    
    for epoch in range(num_epochs):
        metric = d2l.Accumulator(4)
        for i, (features, labels) in enumerate(train_iter):
            timer.start()
            # 多GPU小批量训练
            # l=loss 总损失，acc 总精度
            l, acc = train_batch_ch13(net, features, labels, loss, trainer, devices)
            # l=loss 总损失，acc 总精度，样本数量，类别数量
            metric.add(l, acc, labels.shape[0], labels.numel())
            timer.stop()
            # 
            if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
                animator.add(epoch + (i + 1) / num_batches,
                             (   # 训练损失
                                 metric[0] / metric[2], 
                                 # 测试损失
                                 metric[1] / metric[3],
                                 None))
        # 在gpu上进行测试评估
        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)
        animator.add(epoch + 1, (None, None, test_acc))
    print(f'loss {metric[0] / metric[2]:.3f}, train acc 'f'{metric[1] / metric[3]:.3f}, test acc {test_acc:.3f}')
    print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec on 'f'{str(devices)}')

使用增广图像训练模型

# 10 batch_size，3 通道
batch_size, devices, net = 256, d2l.try_all_gpus(), d2l.resnet18(10, 3)

def init_weights(m):
    '''
    权重初始化
    '''
    if type(m) in [nn.Linear, nn.Conv2d]:
        # 默认也是用的这个权重初始化方式
        # xavier权重初始化方式有助于数值稳定性
        nn.init.xavier_uniform_(m.weight)

net.apply(init_weights)

def train_with_data_aug(train_augs, test_augs, net, lr=0.001):
    '''
    使用增广图像训练模型
    '''
    # 数据
    # True训练数据
    train_iter = load_cifar10(True, train_augs, batch_size)
    # False非训练数据
    test_iter = load_cifar10(False, test_augs, batch_size)
    # 损失函数，交叉熵
    loss = nn.CrossEntropyLoss(reduction="none")
    # Adam优化算法，结合AdaGrad和RMSProp两种优化算法的优点
    trainer = torch.optim.Adam(net.parameters(), lr=lr)
    # 训练
    # 10=num_epochs
    train_ch13(net, train_iter, test_iter, loss, trainer, 10, devices)

# 训练样本进行了增广
train_with_data_aug(train_augs, test_augs, net)

# 测试样本没有进行增广
# 观察没有增广的样本的训练结果
train_with_data_aug(test_augs, test_augs, net)

# 训练样本是否进行增广的训练结果分析
# 经过图像增广之后，训练精度和测试精度之间的gap缩小了，降低了过拟合的程度
# 训练精度和测试精度之间的gap越大，过拟合越严重
# 经过图像增广之后，训练精度可能高于测试精度

loss 0.041, train acc 0.985, test acc 0.856
2580.4 examples/sec on [device(type='cuda', index=0), device(type='cuda', index=1), device(type='cuda', index=2), device(type='cuda', index=3)]

query

原始样本足够多的情况下，不用做增广？

• 答：原始样本多样性足够的情况下可以不用做增广。很多时候，数据多样性不行

num_worker

• 答：CPU核心数

金融风控领域，数据极度偏斜数据（欺诈样本:正样本=1:100）

• 答：欺诈样本增广

测试做什么增广

• 答：测试一般不做增广。实际应用中不做。竞赛可以做做
• 答：测试数据不规范的情况下。例如，imagenet中测试图像不规则时，将短边保留，长边裁剪到和短边一样，最后resize成卷积所需的输入。也可以取图像的左上角，右上角，左下角，右下角部分，往中间缩放一些。多拿到一些图片

增广后的图像

• 答：增广后的图像，可以看看是否符合实际情况
• 答：多样性增加了，分布未变，均值未变，方差变化了

图神经网络

• 答：图神经网络落地很难

马赛克这种增广

• 答：！遮挡方式。让卷积神经网络不要太局限于某些特征

视频方式

• 答：更好，但是更贵

多张图片叠加

• 答：是一种有效的叠加方式，mix-up（很有效），标签也需要叠加到一起

车辆位置识别，如果实际应用场景的样本和原来训练的样本不同

• 答：采集一些实际场景的样本加入到训练中。已经能够正确训练的样本可以不用加入到训练中

图像增广目的

• 答：让训练集样本与测试集样本近似

mix-up图像叠加

• 答：第1张图片x0.6+第2张图片x0.4=叠加后的图片
• 答：第1张图片类别索引号x0.6+第2张图片类别索引号0.4=叠加后的图片类别索引号