个人学习笔记7-1：动手学深度学习pytorch版-李沐

#深度学习# #人工智能# #神经网络# #计算机视觉# #python#

计算机视觉

13.1 图像增广（或者数据增广）

图像增广在对训练图像进行一系列的随机变化之后，生成相似但不同的训练样本，从而扩大了训练集的规模。此外，应用图像增广的原因是，随机改变训练样本可以减少模型对某些属性的依赖，从而提高模型的泛化能力。

13.1.1 常用的图像增广方法

数据增强方式：翻转、切割（裁剪）、颜色......等等

代码实现：

#导入相关工具包：
%matplotlib inline
import torch
import torchvision
from torch import nn
from d2l import torch as d2l

#展示原图，400 × 500的图像
d2l.set_figsize()
img = d2l.Image.open('../img/cat1.jpg')
d2l.plt.imshow(img);

结果输出：

大多数图像增广方法都具有一定的随机性。为了便于观察图像增广的效果，定义辅助函数apply。 此函数在输入图像img上多次运行图像增广方法aug并显示所有结果。

def apply(img, aug, num_rows=2, num_cols=4, scale=1.5):#img图片，aug增强方法，生成的结果2行4列（作用8次），scale=1.5画图大一点
    Y = [aug(img) for _ in range(num_rows * num_cols)]
    d2l.show_images(Y, num_rows, num_cols, scale=scale)

左右翻转图像：

apply(img, torchvision.transforms.RandomHorizontalFlip())#RandomHorizontalFli水平方向随机翻转

结果输出：

上下翻转：

apply(img, torchvision.transforms.RandomVerticalFlip())#RandomVerticalFlip上下随机翻转

结果输出：

通过对图像进行随机裁剪，使物体以不同的比例出现在图像的不同位置。可以降低模型对目标位置的敏感性。将随机裁剪一个面积为原始面积10%到100%的区域，该区域的宽高比从0.5～2之间随机取值。然后，区域的宽度和高度都被缩放到200像素。在本节中（除非另有说明），a和b之间的随机数指的是在区间[a, b]中通过均匀采样获得的连续值。

shape_aug = torchvision.transforms.RandomResizedCrop(
    (200, 200), scale=(0.1, 1), ratio=(0.5, 2))#输出大小200x200；裁剪需要保存的范围scale=(0.1, 1)；高宽比ratio=(0.5, 2)为1/2或者2/1
apply(img, shape_aug)

结果输出：

改变颜色:改变图像颜色的四个方面：亮度、对比度、饱和度和色调.

例子：随机更改图像的亮度，随机值为原始图像的50%（1 − 0.5）到150%（1 + 0.5）之间。

apply(img, torchvision.transforms.ColorJitter(
    brightness=0.5, contrast=0, saturation=0, hue=0))#（亮度，对比度，饱和度，色调），0.5表示上下0.5之间。

结果输出：

更改图像的色调：

apply(img, torchvision.transforms.ColorJitter(
    brightness=0, contrast=0, saturation=0, 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)

 结果输出：

结合多种图像增广方法：

augs = torchvision.transforms.Compose([
    torchvision.transforms.RandomHorizontalFlip(), color_aug, shape_aug])#先RandomHorizontalFlip随机水平翻转，再color_aug颜色，再shape_aug形状。color_aug，shape_aug操作已经在前面存起来了。
apply(img, augs)

结果输出：

13.1.2 使用图像增广进行训练

使用图像增广来训练模型，使用CIFAR‐10数据集，CIFAR-10数据集中对象的颜色和大小差异更明显。 CIFAR-10数据集中的前32个训练图像如下所示。

all_images = torchvision.datasets.CIFAR10(train=True, root="../data",
                                          download=True)
d2l.show_images([all_images[i][0] for i in range(32)], 4, 8, scale=0.8);

结果输出：

为了在预测过程中得到确切的结果，我们通常对训练样本只进行图像增广，且在预测过程中不使用随机操作的图像增广。

只使用最简单的随机左右翻转。 使用ToTensor实例将一批图像转换为深度学习框架所要求的格式，即形状为（批量大小，通道数，高度，宽度）的32位浮点数，取值范围为0～1。

train_augs = torchvision.transforms.Compose([
     torchvision.transforms.RandomHorizontalFlip(),
     torchvision.transforms.ToTensor()])#ToTensor转变为（n，c，h，w）形状

test_augs = torchvision.transforms.Compose([
     torchvision.transforms.ToTensor()])

定义一个辅助函数，以便于读取图像和应用图像增广]。PyTorch数据集提供的transform参数应用图像增广来转化图像。

def load_cifar10(is_train, augs, batch_size):
    dataset = torchvision.datasets.CIFAR10(root="../data", train=is_train,
                                           transform=augs, download=True)
    dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,
                    shuffle=is_train, num_workers=d2l.get_dataloader_workers())#这里可以num_workers=4。
    return dataloader

多GPU训练：

#@save
def train_batch_ch13(net, X, y, loss, trainer, devices):
    """用多GPU进行小批量训练"""
    if isinstance(X, list):
        # 微调BERT中所需
        X = [x.to(devices[0]) for x in X]
    else:
        X = X.to(devices[0])
    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


#@save
def train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs,
               devices=d2l.try_all_gpus()):
    """用多GPU进行模型训练"""
    timer, num_batches = d2l.Timer(), len(train_iter)
    animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0, 1],
                            legend=['train loss', 'train acc', 'test acc'])
    net = nn.DataParallel(net, device_ids=devices).to(devices[0])
    for epoch in range(num_epochs):
        # 4个维度：储存训练损失，训练准确度，实例数，特点数
        metric = d2l.Accumulator(4)
        for i, (features, labels) in enumerate(train_iter):
            timer.start()
            l, acc = train_batch_ch13(
                net, features, labels, loss, trainer, devices)
            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))
        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)}')

定义train_with_data_aug函数，使用图像增广来训练模型。该函数获取所有的GPU，并使用Adam作为训练的优化算法，将图像增广应用于训练集，最后调用刚刚定义的用于训练和评估模型的train_ch13函数。

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]:
        nn.init.xavier_uniform_(m.weight)

net.apply(init_weights)

def train_with_data_aug(train_augs, test_augs, net, lr=0.001):
    train_iter = load_cifar10(True, train_augs, batch_size)
    test_iter = load_cifar10(False, test_augs, batch_size)
    loss = nn.CrossEntropyLoss(reduction="none")
    trainer = torch.optim.Adam(net.parameters(), lr=lr)
    train_ch13(net, train_iter, test_iter, loss, trainer, 10, devices)

基于随机左右翻转的图像增广来[训练模型]：

train_with_data_aug(train_augs, test_augs, net)

结果输出：

13.2 微调

应用迁移学习（transfer learning）将从源数据集学到的知识迁移到目标数据集。例如，尽管ImageNet数据集中的大多数图像与椅子无关，但在此数据集上训练的模型可能会提取更通用的图像特征，这有助于识别边缘、纹理、形状和对象组合。

13.2.1 步骤

本节将介绍迁移学习中的常见技巧:微调（fine‐tuning）。微调包括以下四个步骤。
1. 在源数据集（例如ImageNet数据集）上预训练神经网络模型，即源模型。
2. 创建一个新的神经网络模型，即目标模型。这将复制源模型上的所有模型设计及其参数（输出层除外）。
我们假定这些模型参数包含从源数据集中学到的知识，这些知识也将适用于目标数据集。我们还假设源模型的输出层与源数据集的标签密切相关；因此不在目标模型中使用该层。
3. 向目标模型添加输出层，其输出数是目标数据集中的类别数。然后随机初始化该层的模型参数。
4. 在目标数据集（如椅子数据集）上训练目标模型。输出层将从头开始进行训练，而所有其他层的参数将根据源模型的参数进行微调。

当目标数据集比源数据集小得多时，微调有助于提高模型的泛化能力。

微调训练：

微调通过使用在大数据上得到的预训练好的模型来初始化模型权重来完成提升精度；预训练模型质量很重要；微调通常速度更快、精度更高。

13.2.2 热狗识别

演示微调：热狗识别。我们将在一个小型数据集上微调ResNet模型。该模型已在ImageNet数据集上进行了预训练。这个小型数据集包含数千张包含热狗和不包含热狗的图像，我们将使用微调模型来识别图像中是否包含热狗。

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

获取数据集：解压下载的数据集，我们获得了两个文件夹hotdog/train和hotdog/test。这两个文件夹都有hotdog（有热狗）和not-hotdog（无热狗）两个子文件夹，子文件夹内都包含相应类的图像。

#@save
d2l.DATA_HUB['hotdog'] = (d2l.DATA_URL + 'hotdog.zip',
                         'fba480ffa8aa7e0febbb511d181409f899b9baa5')

data_dir = d2l.download_extract('hotdog')

创建两个实例来分别读取训练和测试数据集中的所有图像文件：

train_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'train'))
test_imgs = torchvision.datasets.ImageFolder(os.path.join(data_dir, 'test'))

显示前8个正类样本图片和最后8张负类样本图片：

hotdogs = [train_imgs[i][0] for i in range(8)]
not_hotdogs = [train_imgs[-i - 1][0] for i in range(8)]
d2l.show_images(hotdogs + not_hotdogs, 2, 8, scale=1.4);

结果输出：

在训练期间，首先从图像中裁切随机大小和随机长宽比的区域，然后将该区域缩放为224×224输入图像。在测试过程中，我们将图像的高度和宽度都缩放到256像素，然后裁剪中央224 × 224区域作为输入。此外，对于RGB（红、绿和蓝）颜色通道，我们分别标准化每个通道。具体而言，该通道的每个值减去该通道的平均值，然后将结果除以该通道的标准差。

# 使用RGB通道的均值和标准差，以标准化每个通道
normalize = torchvision.transforms.Normalize(
    [0.485, 0.456, 0.406], [0.229, 0.224, 0.225])

train_augs = torchvision.transforms.Compose([
    torchvision.transforms.RandomResizedCrop(224),
    torchvision.transforms.RandomHorizontalFlip(),
    torchvision.transforms.ToTensor(),
    normalize])

test_augs = torchvision.transforms.Compose([
    torchvision.transforms.Resize([256, 256]),
    torchvision.transforms.CenterCrop(224),
    torchvision.transforms.ToTensor(),
    normalize])

定义和初始化模型

#使用在ImageNet数据集上预训练的ResNet‐18作为源模型。在这里，指定pretrained=True以自动下载预训练的模型参数。
pretrained_net = torchvision.models.resnet18(pretrained=True)

结果输出：

预训练的源模型实例包含许多特征层和一个输出层fc。此划分的主要目的是促进对除输出层以外所有层的模型参数进行微调。下面给出了源模型的成员变量fc。

pretrained_net.fc

结果输出：

可见在ResNet的全局平均汇聚层后，全连接层转换为ImageNet数据集的1000个类输出。们构建一个新的神经网络作为目标模型。它的定义方式与预训练源模型的定义方式相同，只是最终层中的输出数量被设置为目标数据集中的类数（2个）。
在下面的代码中，目标模型finetune_net中成员变量features的参数被初始化为源模型相应层的模型参数。由于模型参数是在ImageNet数据集上预训练的，并且足够好，因此通常只需要较小的学习率即可微调这些参数。成员变量output的参数是随机初始化的，通常需要更高的学习率才能从头开始训练。假设Trainer实例中的学习率为η，我们将成员变量output中参数的学习率设置为10η。

#初始化
finetune_net = torchvision.models.resnet18(pretrained=True)
finetune_net.fc = nn.Linear(finetune_net.fc.in_features, 2)#将最后一层初始化为一个线性的层，类别输出为2，输入in_features为预训练模型的512
nn.init.xavier_uniform_(finetune_net.fc.weight);#将最后一层的weight做随机初始化。

微调模型：定义一个训练函数train_fine_tuning，该函数使用微调，可以多次调用。

# 如果param_group=True，输出层中的模型参数将使用十倍的学习率
def train_fine_tuning(net, learning_rate, batch_size=128, num_epochs=5,
                      param_group=True):
    train_iter = torch.utils.data.DataLoader(torchvision.datasets.ImageFolder(
        os.path.join(data_dir, 'train'), transform=train_augs),
        batch_size=batch_size, shuffle=True)
    test_iter = torch.utils.data.DataLoader(torchvision.datasets.ImageFolder(
        os.path.join(data_dir, 'test'), transform=test_augs),
        batch_size=batch_size)
    devices = d2l.try_all_gpus()
    loss = nn.CrossEntropyLoss(reduction="none")
    if param_group:#如果=ture
        params_1x = [param for name, param in net.named_parameters()
             if name not in ["fc.weight", "fc.bias"]]#不是最后一层的所有参数拿出来
        trainer = torch.optim.SGD([{'params': params_1x},
                                   {'params': net.fc.parameters(),#最后一次fc用的10倍 learning_rate，因为最后一层是随机初始化的，希望学的更快一些。
                                    'lr': learning_rate * 10}],
                                lr=learning_rate, weight_decay=0.001)
    else:
        trainer = torch.optim.SGD(net.parameters(), lr=learning_rate,
                                  weight_decay=0.001)
    d2l.train_ch13(net, train_iter, test_iter, loss, trainer, num_epochs,
                   devices)

使用较小的学习率，通过微调预训练获得的模型参数。

train_fine_tuning(finetune_net, 5e-5)

结果输出：

为了进行比较，我们定义了一个相同的模型，但是将其所有模型参数初始化为随机值。由于整个模型需要从头开始训练，因此我们需要使用更大的学习率。

scratch_net = torchvision.models.resnet18()
scratch_net.fc = nn.Linear(scratch_net.fc.in_features, 2)
train_fine_tuning(scratch_net, 5e-4, param_group=False)

结果输出：

对比结果：微调模型往往表现更好，因为它的初始参数值更有效。

总结：

• 迁移学习将从源数据集中学到的知识迁移到目标数据集，微调是迁移学习的常见技巧。
• 除输出层外，目标模型从源模型中复制所有模型设计及其参数，并根据目标数据集对这些参数进行微调。但是，目标模型的输出层需要从头开始训练。
• 通常，微调参数使用较小的学习率，而从头开始训练输出层可以使用更大的学习率。