PyTorch教程-14.1. 圖像增強

在8.1 節(jié)中，我們提到大型數(shù)據(jù)集是深度神經網絡在各種應用中取得成功的先決條件。圖像增強在對訓練圖像進行一系列隨機變化后生成相似但不同的訓練示例，從而擴大了訓練集的大小?；蛘撸瑘D像增強的動機可能是訓練示例的隨機調整允許模型減少對某些屬性的依賴，從而提高它們的泛化能力。例如，我們可以通過不同的方式裁剪圖像，使感興趣的對象出現(xiàn)在不同的位置，從而減少模型對對象位置的依賴。我們還可以調整亮度和顏色等因素，以降低模型對顏色的敏感度。圖像增強對于當時 AlexNet 的成功來說可能是不可或缺的。在本節(jié)中，我們將討論這種在計算機視覺中廣泛使用的技術。

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

%matplotlib inline
from mxnet import autograd, gluon, image, init, np, npx
from mxnet.gluon import nn
from d2l import mxnet as d2l

npx.set_np()

14.1.1。常見的圖像增強方法

在我們對常見圖像增強方法的研究中，我們將使用以下方法400×500形象一個例子。

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

d2l.set_figsize()
img = image.imread('../img/cat1.jpg')
d2l.plt.imshow(img.asnumpy());

大多數(shù)圖像增強方法都具有一定的隨機性。為了方便我們觀察圖像增強的效果，接下來我們定義一個輔助函數(shù)apply。aug此函數(shù)在輸入圖像上多次運行圖像增強方法img 并顯示所有結果。

def apply(img, aug, num_rows=2, num_cols=4, scale=1.5):
  Y = [aug(img) for _ in range(num_rows * num_cols)]
  d2l.show_images(Y, num_rows, num_cols, scale=scale)

def apply(img, aug, num_rows=2, num_cols=4, scale=1.5):
  Y = [aug(img) for _ in range(num_rows * num_cols)]
  d2l.show_images(Y, num_rows, num_cols, scale=scale)

14.1.1.1。翻轉和裁剪

左右翻轉圖像通常不會改變對象的類別。這是最早和最廣泛使用的圖像增強方法之一。接下來，我們使用該transforms模塊創(chuàng)建實例RandomHorizontalFlip，它以 50% 的幾率左右翻轉圖像。

apply(img, torchvision.transforms.RandomHorizontalFlip())

上下翻轉不像左右翻轉那樣常見。但至少對于這個示例圖像，上下翻轉并不妨礙識別。接下來，我們創(chuàng)建一個RandomVerticalFlip實例，以 50% 的幾率上下翻轉圖像。

apply(img, torchvision.transforms.RandomVerticalFlip())

Flipping the image left and right usually does not change the category of the object. This is one of the earliest and most widely used methods of image augmentation. Next, we use the transforms module to create the RandomFlipLeftRight instance, which flips an image left and right with a 50% chance.

apply(img, gluon.data.vision.transforms.RandomFlipLeftRight())

Flipping up and down is not as common as flipping left and right. But at least for this example image, flipping up and down does not hinder recognition. Next, we create a RandomFlipTopBottom instance to flip an image up and down with a 50% chance.

apply(img, gluon.data.vision.transforms.RandomFlipTopBottom())

在我們使用的示例圖像中，貓位于圖像的中間，但一般情況下可能并非如此。在7.5 節(jié)中，我們解釋了池化層可以降低卷積層對目標位置的敏感性。此外，我們還可以隨機裁剪圖像，讓物體以不同的尺度出現(xiàn)在圖像中的不同位置，這樣也可以降低模型對目標位置的敏感度。

在下面的代碼中，我們隨機裁剪一個面積為 10%～100%每次都是原始區(qū)域的大小，這個區(qū)域的寬高比是隨機選擇的 0.5～2. 然后，該區(qū)域的寬度和高度都縮放為 200 像素。除非另有說明，之間的隨機數(shù)a和b本節(jié)中指的是從區(qū)間中隨機均勻采樣得到的連續(xù)值 [a,b].

shape_aug = torchvision.transforms.RandomResizedCrop(
  (200, 200), scale=(0.1, 1), ratio=(0.5, 2))
apply(img, shape_aug)

shape_aug = gluon.data.vision.transforms.RandomResizedCrop(
  (200, 200), scale=(0.1, 1), ratio=(0.5, 2))
apply(img, shape_aug)

14.1.1.2。改變顏色

另一種增強方法是改變顏色。我們可以改變圖像顏色的四個方面：亮度、對比度、飽和度和色調。在下面的示例中，我們將圖像的亮度隨機更改為 50% (1?0.5) 和 150% (1+0.5) 的原始圖像。

apply(img, torchvision.transforms.ColorJitter(
  brightness=0.5, contrast=0, saturation=0, hue=0))

apply(img, gluon.data.vision.transforms.RandomBrightness(0.5))

同樣，我們可以隨機改變圖像的色調。

apply(img, torchvision.transforms.ColorJitter(
  brightness=0, contrast=0, saturation=0, hue=0.5))

apply(img, gluon.data.vision.transforms.RandomHue(0.5))

我們也可以創(chuàng)建一個RandomColorJitter實例，同時設置如何隨機改變圖片的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)

color_aug = gluon.data.vision.transforms.RandomColorJitter(
  brightness=0.5, contrast=0.5, saturation=0.5, hue=0.5)
apply(img, color_aug)

14.1.1.3。結合多種圖像增強方法

在實踐中，我們將結合多種圖像增強方法。例如，我們可以組合上面定義的不同圖像增強方法，并通過實例將它們應用于每個圖像Compose。

augs = torchvision.transforms.Compose([
  torchvision.transforms.RandomHorizontalFlip(), color_aug, shape_aug])
apply(img, augs)

augs = gluon.data.vision.transforms.Compose([
  gluon.data.vision.transforms.RandomFlipLeftRight(), color_aug, shape_aug])
apply(img, augs)

14.1.2。圖像增強訓練

讓我們訓練一個具有圖像增強功能的模型。這里我們使用 CIFAR-10 數(shù)據(jù)集而不是我們之前使用的 Fashion-MNIST 數(shù)據(jù)集。這是因為 Fashion-MNIST 數(shù)據(jù)集中物體的位置和大小已經歸一化，而 CIFAR-10 數(shù)據(jù)集中物體的顏色和大小有更顯著的差異。CIFAR-10 數(shù)據(jù)集中的前 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);

Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ../data/cifar-10-python.tar.gz

 0%|     | 0/170498071 [00:00 

Extracting ../data/cifar-10-python.tar.gz to ../data

d2l.show_images(gluon.data.vision.CIFAR10(
  train=True)[:32][0], 4, 8, scale=0.8);

為了在預測過程中獲得確定的結果，我們通常只對訓練樣例進行圖像增強，而不會在預測過程中使用帶有隨機操作的圖像增強。這里我們只使用最簡單的隨機左右翻轉的方法。此外，我們使用 ToTensor實例將一小批圖像轉換為深度學習框架所需的格式，即 0 到 1 之間的 32 位浮點數(shù)，形狀為（批量大小，通道數(shù)，高度，寬度).

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

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

接下來，我們定義一個輔助函數(shù)以方便讀取圖像和應用圖像增強。PyTorch 數(shù)據(jù)集提供的參數(shù)transform應用增強來轉換圖像。詳細介紹DataLoader請參考 4.2節(jié)。

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())
  return dataloader

train_augs = gluon.data.vision.transforms.Compose([
  gluon.data.vision.transforms.RandomFlipLeftRight(),
  gluon.data.vision.transforms.ToTensor()])

test_augs = gluon.data.vision.transforms.Compose([
  gluon.data.vision.transforms.ToTensor()])

Next, we define an auxiliary function to facilitate reading the image and applying image augmentation. The transform_first function provided by Gluon’s datasets applies image augmentation to the first element of each training example (image and label), i.e., the image. For a detailed introduction to DataLoader, please refer to Section 4.2.

def load_cifar10(is_train, augs, batch_size):
  return gluon.data.DataLoader(
    gluon.data.vision.CIFAR10(train=is_train).transform_first(augs),
    batch_size=batch_size, shuffle=is_train,
    num_workers=d2l.get_dataloader_workers())

14.1.2.1。多 GPU 訓練

我們在 CIFAR-10 數(shù)據(jù)集上訓練第 8.6 節(jié)中的 ResNet-18 模型?；叵胍幌?3.6 節(jié)中對多 GPU 訓練的介紹 。在下文中，我們定義了一個函數(shù)來使用多個 GPU 訓練和評估模型。

#@save
def train_batch_ch13(net, X, y, loss, trainer, devices):
  """Train for a minibatch with multiple GPUs (defined in Chapter 13)."""
  if isinstance(X, list):
    # Required for BERT fine-tuning (to be covered later)
    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()):
  """Train a model with multiple GPUs (defined in Chapter 13)."""
  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):
    # Sum of training loss, sum of training accuracy, no. of examples,
    # no. of predictions
    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)}')

#@save
def train_batch_ch13(net, features, labels, loss, trainer, devices,
           split_f=d2l.split_batch):
  """Train for a minibatch with multiple GPUs (defined in Chapter 13)."""
  X_shards, y_shards = split_f(features, labels, devices)
  with autograd.record():
    pred_shards = [net(X_shard) for X_shard in X_shards]
    ls = [loss(pred_shard, y_shard) for pred_shard, y_shard
       in zip(pred_shards, y_shards)]
  for l in ls:
    l.backward()
  # The `True` flag allows parameters with stale gradients, which is useful
  # later (e.g., in fine-tuning BERT)
  trainer.step(labels.shape[0], ignore_stale_grad=True)
  train_loss_sum = sum([float(l.sum()) for l in ls])
  train_acc_sum = sum(d2l.accuracy(pred_shard, y_shard)
            for pred_shard, y_shard in zip(pred_shards, y_shards))
  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(), split_f=d2l.split_batch):
  """Train a model with multiple GPUs (defined in Chapter 13)."""
  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'])
  for epoch in range(num_epochs):
    # Sum of training loss, sum of training accuracy, no. of examples,
    # no. of predictions
    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, split_f)
      metric.add(l, acc, labels.shape[0], labels.size)
      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_gpus(net, test_iter, split_f)
    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)}')

現(xiàn)在我們可以定義train_with_data_aug函數(shù)來訓練帶有圖像增強的模型。該函數(shù)獲取所有可用的 GPU，使用 Adam 作為優(yōu)化算法，對訓練數(shù)據(jù)集應用圖像增強，最后調用train_ch13剛剛定義的函數(shù)來訓練和評估模型。

batch_size, devices, net = 256, d2l.try_all_gpus(), d2l.resnet18(10, 3)
net.apply(d2l.init_cnn)

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)
  net(next(iter(train_iter))[0])
  train_ch13(net, train_iter, test_iter, loss, trainer, 10, devices)

batch_size, devices, net = 256, d2l.try_all_gpus(), d2l.resnet18(10)
net.initialize(init=init.Xavier(), ctx=devices)

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 = gluon.loss.SoftmaxCrossEntropyLoss()
  trainer = gluon.Trainer(net.collect_params(), 'adam',
              {'learning_rate': lr})
  train_ch13(net, train_iter, test_iter, loss, trainer, 10, devices)

讓我們使用基于隨機左右翻轉的圖像增強來訓練模型。

train_with_data_aug(train_augs, test_augs, net)

loss 0.224, train acc 0.922, test acc 0.820
3237.5 examples/sec on [device(type='cuda', index=0), device(type='cuda', index=1)]

train_with_data_aug(train_augs, test_augs, net)

loss 0.168, train acc 0.942, test acc 0.837
1933.3 examples/sec on [gpu(0), gpu(1)]

14.1.3。概括

圖像增強是在現(xiàn)有訓練數(shù)據(jù)的基礎上生成隨機圖像，以提高模型的泛化能力。

為了在預測過程中獲得確定的結果，我們通常只對訓練樣例進行圖像增強，而不會在預測過程中使用帶有隨機操作的圖像增強。

深度學習框架提供了許多不同的圖像增強方法，可以同時應用。

14.1.4。練習

在不使用圖像增強的情況下訓練模型： 。比較使用和不使用圖像增強時的訓練和測試準確性。這個對比實驗能否支持圖像增強可以減輕過擬合的論點？為什么？train_with_data_aug(test_augs, test_augs)

在 CIFAR-10 數(shù)據(jù)集的模型訓練中結合多種不同的圖像增強方法。它會提高測試準確性嗎？

參考深度學習框架的在線文檔。它還提供了哪些其他圖像增強方法？