9.12. 实战Kaggle比赛：图像分类（CIFAR-10）

到目前为止，我们一直在用Gluon的data包直接获取NDArray格式的图像数据集。然而，实际中的图像数据集往往是以图像文件的形式存在的。在本节中，我们将从原始的图像文件开始，一步步整理、读取并将其变换为NDArray格式。

我们曾在“图像增广”一节中实验过CIFAR-10数据集。它是计算机视觉领域的一个重要数据集。现在我们将应用前面所学的知识，动手实战CIFAR-10图像分类问题的Kaggle比赛。该比赛的网页地址是https://www.kaggle.com/c/cifar-10 。

图9.16展示了该比赛的网页信息。为了便于提交结果，请先在Kaggle网站上注册账号。

CIFAR-10图像分类比赛的网页信息。比赛数据集可通过点击“Data”标签获取 图 9.16 CIFAR-10图像分类比赛的网页信息。比赛数据集可通过点击“Data”标签获取

首先，导入比赛所需的包或模块。

  1. In [1]:
  1. import d2lzh as d2l
  2. from mxnet import autograd, gluon, init
  3. from mxnet.gluon import data as gdata, loss as gloss, nn
  4. import os
  5. import pandas as pd
  6. import shutil
  7. import time

9.12.1. 获取和整理数据集

比赛数据分为训练集和测试集。训练集包含5万张图像。测试集包含30万张图像，其中有1万张图像用来计分，其他29万张不计分的图像是为了防止人工标注测试集并提交标注结果。两个数据集中的图像格式都是png，高和宽均为32像素，并含有RGB三个通道（彩色）。图像一共涵盖10个类别，分别为飞机、汽车、鸟、猫、鹿、狗、青蛙、马、船和卡车。图9.16的左上角展示了数据集中部分飞机、汽车和鸟的图像。

9.12.1.1. 下载数据集

登录Kaggle后，可以点击图9.16所示的CIFAR-10图像分类比赛网页上的“Data”标签，并分别下载训练数据集train.7z、测试数据集test.7z和训练数据集标签trainLabels.csv。

9.12.1.2. 解压数据集

下载完训练数据集train.7z和测试数据集test.7z后需要解压缩。解压缩后，将训练数据集、测试数据集以及训练数据集标签分别存放在以下3个路径：

  • ../data/kaggle_cifar10/train/[1-50000].png；
  • ../data/kaggle_cifar10/test/[1-300000].png；
  • ../data/kaggle_cifar10/trainLabels.csv。 为方便快速上手，我们提供了上述数据集的小规模采样，其中train_tiny.zip包含100个训练样本，而test_tiny.zip仅包含1个测试样本。它们解压后的文件夹名称分别为train_tiny和test_tiny。此外，将训练数据集标签的压缩文件解压，并得到trainLabels.csv。如果使用上述Kaggle比赛的完整数据集，还需要把下面demo变量改为False。
  1. In [2]:
  1. # 如果使用下载的Kaggle比赛的完整数据集，把demo变量改为False
  2. demo = True
  3. if demo:
  4.     import zipfile
  5.     for f in ['train_tiny.zip', 'test_tiny.zip', 'trainLabels.csv.zip']:
  6.         with zipfile.ZipFile('../data/kaggle_cifar10/' + f, 'r') as z:
  7.             z.extractall('../data/kaggle_cifar10/')

9.12.1.3. 整理数据集

我们需要整理数据集，以方便训练和测试模型。以下的read_label_file函数将用来读取训练数据集的标签文件。该函数中的参数valid_ratio是验证集样本数与原始训练集样本数之比。

  1. In [3]:
  1. def read_label_file(data_dir, label_file, train_dir, valid_ratio):
  2.     with open(os.path.join(data_dir, label_file), 'r') as f:
  3.         # 跳过文件头行（栏名称）
  4.         lines = f.readlines()[1:]
  5.         tokens = [l.rstrip().split(',') for l in lines]
  6.         idx_label = dict(((int(idx), label) for idx, label in tokens))
  7.     labels = set(idx_label.values())
  8.     n_train_valid = len(os.listdir(os.path.join(data_dir, train_dir)))
  9.     n_train = int(n_train_valid * (1 - valid_ratio))
  10.     assert 0 < n_train < n_train_valid
  11.     return n_train // len(labels), idx_label

下面定义一个辅助函数，从而仅在路径不存在的情况下创建路径。

  1. In [4]:
  1. def mkdir_if_not_exist(path):  # 本函数已保存在d2lzh包中方便以后使用
  2.     if not os.path.exists(os.path.join(*path)):
  3.         os.makedirs(os.path.join(*path))

我们接下来定义reorg_train_valid函数来从原始训练集中切分出验证集。以valid_ratio=0.1为例，由于原始训练集有50,000张图像，调参时将有45,000张图像用于训练并存放在路径input_dir/train下，而另外5,000张图像将作为验证集并存放在路径input_dir/valid下。经过整理后，同一类图像将被放在同一个文件夹下，便于稍后读取。

  1. In [5]:
  1. def reorg_train_valid(data_dir, train_dir, input_dir, n_train_per_label,
  2.                       idx_label):
  3.     label_count = {}
  4.     for train_file in os.listdir(os.path.join(data_dir, train_dir)):
  5.         idx = int(train_file.split('.')[0])
  6.         label = idx_label[idx]
  7.         mkdir_if_not_exist([data_dir, input_dir, 'train_valid', label])
  8.         shutil.copy(os.path.join(data_dir, train_dir, train_file),
  9.                     os.path.join(data_dir, input_dir, 'train_valid', label))
  10.         if label not in label_count or label_count[label] < n_train_per_label:
  11.             mkdir_if_not_exist([data_dir, input_dir, 'train', label])
  12.             shutil.copy(os.path.join(data_dir, train_dir, train_file),
  13.                         os.path.join(data_dir, input_dir, 'train', label))
  14.             label_count[label] = label_count.get(label, 0) + 1
  15.         else:
  16.             mkdir_if_not_exist([data_dir, input_dir, 'valid', label])
  17.             shutil.copy(os.path.join(data_dir, train_dir, train_file),
  18.                         os.path.join(data_dir, input_dir, 'valid', label))

下面的reorg_test函数用来整理测试集，从而方便预测时的读取。

  1. In [6]:
  1. def reorg_test(data_dir, test_dir, input_dir):
  2.     mkdir_if_not_exist([data_dir, input_dir, 'test', 'unknown'])
  3.     for test_file in os.listdir(os.path.join(data_dir, test_dir)):
  4.         shutil.copy(os.path.join(data_dir, test_dir, test_file),
  5.                     os.path.join(data_dir, input_dir, 'test', 'unknown'))

最后，我们用一个函数分别调用前面定义的read_label_file函数、reorg_train_valid函数以及reorg_test函数。

  1. In [7]:
  1. def reorg_cifar10_data(data_dir, label_file, train_dir, test_dir, input_dir,
  2.                        valid_ratio):
  3.     n_train_per_label, idx_label = read_label_file(data_dir, label_file,
  4.                                                    train_dir, valid_ratio)
  5.     reorg_train_valid(data_dir, train_dir, input_dir, n_train_per_label,
  6.                       idx_label)
  7.     reorg_test(data_dir, test_dir, input_dir)

我们在这里只使用100个训练样本和1个测试样本。训练数据集和测试数据集的文件夹名称分别为train_tiny和test_tiny。相应地，我们仅将批量大小设为1。实际训练和测试时应使用Kaggle比赛的完整数据集，并将批量大小batch_size设为一个较大的整数，如128。我们将10%的训练样本作为调参使用的验证集。

  1. In [8]:
  1. if demo:
  2.     # 注意，此处使用小训练集和小测试集并将批量大小相应设小。使用Kaggle比赛的完整数据集时可
  3.     # 设批量大小为较大整数
  4.     train_dir, test_dir, batch_size = 'train_tiny', 'test_tiny', 1
  5. else:
  6.     train_dir, test_dir, batch_size = 'train', 'test', 128
  7. data_dir, label_file = '../data/kaggle_cifar10', 'trainLabels.csv'
  8. input_dir, valid_ratio = 'train_valid_test', 0.1
  9. reorg_cifar10_data(data_dir, label_file, train_dir, test_dir, input_dir,
  10.                    valid_ratio)

9.12.2. 图像增广

为应对过拟合，我们使用图像增广。例如，加入transforms.RandomFlipLeftRight()即可随机对图像做镜面翻转，也可以通过transforms.Normalize()对彩色图像RGB三个通道分别做标准化。下面列举了其中的部分操作，你可以根据需求来决定是否使用或修改这些操作。

  1. In [9]:
  1. transform_train = gdata.vision.transforms.Compose([
  2.     # 将图像放大成高和宽各为40像素的正方形
  3.     gdata.vision.transforms.Resize(40),
  4.     # 随机对高和宽各为40像素的正方形图像裁剪出面积为原图像面积0.64~1倍的小正方形，再放缩为
  5.     # 高和宽各为32像素的正方形
  6.     gdata.vision.transforms.RandomResizedCrop(32, scale=(0.64, 1.0),
  7.                                               ratio=(1.0, 1.0)),
  8.     gdata.vision.transforms.RandomFlipLeftRight(),
  9.     gdata.vision.transforms.ToTensor(),
  10.     # 对图像的每个通道做标准化
  11.     gdata.vision.transforms.Normalize([0.4914, 0.4822, 0.4465],
  12.                                       [0.2023, 0.1994, 0.2010])])

测试时，为保证输出的确定性，我们仅对图像做标准化。

  1. In [10]:
  1. transform_test = gdata.vision.transforms.Compose([
  2.     gdata.vision.transforms.ToTensor(),
  3.     gdata.vision.transforms.Normalize([0.4914, 0.4822, 0.4465],
  4.                                       [0.2023, 0.1994, 0.2010])])

9.12.3. 读取数据集

接下来，可以通过创建ImageFolderDataset实例来读取整理后的含原始图像文件的数据集，其中每个数据样本包括图像和标签。

  1. In [11]:
  1. # 读取原始图像文件。flag=1说明输入图像有3个通道（彩色）
  2. train_ds = gdata.vision.ImageFolderDataset(
  3.     os.path.join(data_dir, input_dir, 'train'), flag=1)
  4. valid_ds = gdata.vision.ImageFolderDataset(
  5.     os.path.join(data_dir, input_dir, 'valid'), flag=1)
  6. train_valid_ds = gdata.vision.ImageFolderDataset(
  7.     os.path.join(data_dir, input_dir, 'train_valid'), flag=1)
  8. test_ds = gdata.vision.ImageFolderDataset(
  9.     os.path.join(data_dir, input_dir, 'test'), flag=1)

我们在DataLoader中指明定义好的图像增广操作。在训练时，我们仅用验证集评价模型，因此需要保证输出的确定性。在预测时，我们将在训练集和验证集的并集上训练模型，以充分利用所有标注的数据。

  1. In [12]:
  1. train_iter = gdata.DataLoader(train_ds.transform_first(transform_train),
  2.                               batch_size, shuffle=True, last_batch='keep')
  3. valid_iter = gdata.DataLoader(valid_ds.transform_first(transform_test),
  4.                               batch_size, shuffle=True, last_batch='keep')
  5. train_valid_iter = gdata.DataLoader(train_valid_ds.transform_first(
  6.     transform_train), batch_size, shuffle=True, last_batch='keep')
  7. test_iter = gdata.DataLoader(test_ds.transform_first(transform_test),
  8.                              batch_size, shuffle=False, last_batch='keep')

9.12.4. 定义模型

与“残差网络（ResNet）”一节中的实现稍有不同，这里基于HybridBlock类构建残差块。这是为了提升执行效率。

  1. In [13]:
  1. class Residual(nn.HybridBlock):
  2.     def __init__(self, num_channels, use_1x1conv=False, strides=1, **kwargs):
  3.         super(Residual, self).__init__(**kwargs)
  4.         self.conv1 = nn.Conv2D(num_channels, kernel_size=3, padding=1,
  5.                                strides=strides)
  6.         self.conv2 = nn.Conv2D(num_channels, kernel_size=3, padding=1)
  7.         if use_1x1conv:
  8.             self.conv3 = nn.Conv2D(num_channels, kernel_size=1,
  9.                                    strides=strides)
  10.         else:
  11.             self.conv3 = None
  12.         self.bn1 = nn.BatchNorm()
  13.         self.bn2 = nn.BatchNorm()
  14.  
  15.     def hybrid_forward(self, F, X):
  16.         Y = F.relu(self.bn1(self.conv1(X)))
  17.         Y = self.bn2(self.conv2(Y))
  18.         if self.conv3:
  19.             X = self.conv3(X)
  20.         return F.relu(Y + X)

下面定义ResNet-18模型。

  1. In [14]:
  1. def resnet18(num_classes):
  2.     net = nn.HybridSequential()
  3.     net.add(nn.Conv2D(64, kernel_size=3, strides=1, padding=1),
  4.             nn.BatchNorm(), nn.Activation('relu'))
  5.  
  6.     def resnet_block(num_channels, num_residuals, first_block=False):
  7.         blk = nn.HybridSequential()
  8.         for i in range(num_residuals):
  9.             if i == 0 and not first_block:
  10.                 blk.add(Residual(num_channels, use_1x1conv=True, strides=2))
  11.             else:
  12.                 blk.add(Residual(num_channels))
  13.         return blk
  14.  
  15.     net.add(resnet_block(64, 2, first_block=True),
  16.             resnet_block(128, 2),
  17.             resnet_block(256, 2),
  18.             resnet_block(512, 2))
  19.     net.add(nn.GlobalAvgPool2D(), nn.Dense(num_classes))
  20.     return net

CIFAR-10图像分类问题的类别个数为10。我们将在训练开始前对模型进行Xavier随机初始化。

  1. In [15]:
  1. def get_net(ctx):
  2.     num_classes = 10
  3.     net = resnet18(num_classes)
  4.     net.initialize(ctx=ctx, init=init.Xavier())
  5.     return net
  6.  
  7. loss = gloss.SoftmaxCrossEntropyLoss()

9.12.5. 定义训练函数

我们将根据模型在验证集上的表现来选择模型并调节超参数。下面定义了模型的训练函数train。我们记录了每个迭代周期的训练时间，这有助于比较不同模型的时间开销。

  1. In [16]:
  1. def train(net, train_iter, valid_iter, num_epochs, lr, wd, ctx, lr_period,
  2.           lr_decay):
  3.     trainer = gluon.Trainer(net.collect_params(), 'sgd',
  4.                             {'learning_rate': lr, 'momentum': 0.9, 'wd': wd})
  5.     for epoch in range(num_epochs):
  6.         train_l_sum, train_acc_sum, n, start = 0.0, 0.0, 0, time.time()
  7.         if epoch > 0 and epoch % lr_period == 0:
  8.             trainer.set_learning_rate(trainer.learning_rate * lr_decay)
  9.         for X, y in train_iter:
  10.             y = y.astype('float32').as_in_context(ctx)
  11.             with autograd.record():
  12.                 y_hat = net(X.as_in_context(ctx))
  13.                 l = loss(y_hat, y).sum()
  14.             l.backward()
  15.             trainer.step(batch_size)
  16.             train_l_sum += l.asscalar()
  17.             train_acc_sum += (y_hat.argmax(axis=1) == y).sum().asscalar()
  18.             n += y.size
  19.         time_s = "time %.2f sec" % (time.time() - start)
  20.         if valid_iter is not None:
  21.             valid_acc = d2l.evaluate_accuracy(valid_iter, net, ctx)
  22.             epoch_s = ("epoch %d, loss %f, train acc %f, valid acc %f, "
  23.                        % (epoch + 1, train_l_sum / n, train_acc_sum / n,
  24.                           valid_acc))
  25.         else:
  26.             epoch_s = ("epoch %d, loss %f, train acc %f, " %
  27.                        (epoch + 1, train_l_sum / n, train_acc_sum / n))
  28.         print(epoch_s + time_s + ', lr ' + str(trainer.learning_rate))

9.12.6. 训练并验证模型

现在，我们可以训练并验证模型了。下面的超参数都是可以调节的，如增加迭代周期等。由于lr_period和lr_decay分别设为80和0.1，优化算法的学习率将在每80个迭代周期后自乘0.1。简单起见，这里仅训练1个迭代周期。

  1. In [17]:
  1. ctx, num_epochs, lr, wd = d2l.try_gpu(), 1, 0.1, 5e-4
  2. lr_period, lr_decay, net = 80, 0.1, get_net(ctx)
  3. net.hybridize()
  4. train(net, train_iter, valid_iter, num_epochs, lr, wd, ctx, lr_period,
  5.       lr_decay)
  1. epoch 1, loss 5.998157, train acc 0.055556, valid acc 0.100000, time 1.34 sec, lr 0.1

9.12.7. 对测试集分类并在Kaggle提交结果

得到一组满意的模型设计和超参数后，我们使用所有训练数据集（含验证集）重新训练模型，并对测试集进行分类。

  1. In [18]:
  1. net, preds = get_net(ctx), []
  2. net.hybridize()
  3. train(net, train_valid_iter, None, num_epochs, lr, wd, ctx, lr_period,
  4.       lr_decay)
  5.  
  6. for X, _ in test_iter:
  7.     y_hat = net(X.as_in_context(ctx))
  8.     preds.extend(y_hat.argmax(axis=1).astype(int).asnumpy())
  9. sorted_ids = list(range(1, len(test_ds) + 1))
  10. sorted_ids.sort(key=lambda x: str(x))
  11. df = pd.DataFrame({'id': sorted_ids, 'label': preds})
  12. df['label'] = df['label'].apply(lambda x: train_valid_ds.synsets[x])
  13. df.to_csv('submission.csv', index=False)
  1. epoch 1, loss 6.620115, train acc 0.090000, time 1.24 sec, lr 0.1

执行完上述代码后，我们会得到一个submission.csv文件。这个文件符合Kaggle比赛要求的提交格式。提交结果的方法与“实战Kaggle比赛：房价预测”一节中的类似。

9.12.8. 小结

  • 可以通过创建ImageFolderDataset实例来读取含原始图像文件的数据集。
  • 可以应用卷积神经网络、图像增广和混合式编程来实战图像分类比赛。

9.12.9. 练习

  • 使用Kaggle比赛的完整CIFAR-10数据集。把批量大小batch_size和迭代周期数num_epochs分别改为128和300。可以在这个比赛中得到什么样的准确率和名次？
  • 如果不使用图像增广的方法能得到什么样的准确率？
  • 参与讨论，在社区交流方法和结果。你能发掘出其他更好的技巧吗？