玩转Kaggle：CIFAR-10图像分类

1. CIFAR-10简介

(比赛网址 https://www.kaggle.com/c/cifar-10)

数据集描述:

  比赛数据集分为训练集和测试集，其中训练集包含 50000 张、测试集包含 300000 张图像。在测试集中，10000 张图像将被用于评估，而剩下的 290000 张图像将不会被进行评估，包含它们只是为了防止手动标记测试集并提交标记结果。
  两个数据集中的图像都是 png 格式，高度和宽度均为 32 像素并有三个颜色通道(RGB)。这些图片共涵盖 10 个类别：飞机、汽车、鸟类、猫、鹿、狗、青蛙、马、船和卡车。

2. 获取并组织数据集

两种数据测试的方案：

1. 使用李沐老师课程中提供的小批数据,从训练数据中每一类中抽取出来一部分，然后随机选择测试数据中的5张（包含前 1000 个训练图像和 5 个随机测试图像的数据集的小规模样本）
2. 使用原始数据

我是晚上训练的模型，所以时间比较充裕，使用了全部数据进行模型训练。

import collections 
import math 
import os 
import shutil 
import pandas as pd 
import torch 
import torchvision 
from torch import nn 
from d2l import torch as d2l 

'''数据下载'''
d2l.DATA_HUB['cifar10_tiny'] = (d2l.DATA_URL + 'kaggle_cifar10_tiny.zip',
                                '2068874e4b9a9f0fb07ebe0ad2b29754449ccacd')

# 如果你使用完整的Kaggle竞赛的数据集，设置`demo`为 False
demo = False

if demo:
    data_dir = d2l.download_extract('cifar10_tiny')
else:
    data_dir = '../data/cifar-10/'

看一下我们的数据格式：

train_data_initial = pd.read_csv(os.path.join(data_dir, 'trainLabels.csv'))
train_data_initial.head()

	id	label
0	1	frog
1	2	truck
2	3	truck
3	4	deer
4	5	automobile

这里需要强调说明一下：
CIFAR-10完整数据集的大小大概800M，对于我的电脑而言，将其复制为三份没什么影响；但是如果数据集特别大，我建议不改变数据的保存位置，作一个索引映射比这种方法划算。（不过这样给分类一下也很香，很方便我们查看一下某一类的数据）

'''
数据整理:
    这里是将数据复制了两份：从原始数据中copy一份到train_valid之中，再将这个数据分别放到train data和test data之中
'''
# 读取CSV文件中对应的label
def read_csv_labels(fname):
    with open(fname,'r') as f:
        lines = f.readlines()[1:]
    tokens = [l.rstrip().split(',') for l in lines]
    return dict(((name,label) for name,label in tokens))

# 将文件复制到目标目录。
def copyfile(filename, target_dir):
    os.makedirs(target_dir, exist_ok=True)
    shutil.copy(filename, target_dir)

# 将验证数据从原始的数据集中拆分出来
def reorg_train_valid(data_dir, labels, valid_ratio):
    # 训练数据集中示例最少的类别中的示例数
    n = collections.Counter(labels.values()).most_common()[-1][1]
    # 验证集中每个类别的示例数
    n_valid_per_label = max(1, math.floor(n * valid_ratio))
    label_count = {}
    for train_file in os.listdir(os.path.join(data_dir, 'train')):
        label = labels[train_file.split('.')[0]]
        fname = os.path.join(data_dir, 'train', train_file)
        copyfile(
            fname,
            os.path.join(data_dir, 'train_valid_test', 'train_valid', label))
        if label not in label_count or label_count[label] < n_valid_per_label:
            copyfile(
                fname,
                os.path.join(data_dir, 'train_valid_test', 'valid', label))
            label_count[label] = label_count.get(label, 0) + 1
        else:
            copyfile(
                fname,
                os.path.join(data_dir, 'train_valid_test', 'train', label))
    return n_valid_per_label

# 在预测期间进行数据整理和测试集划分，方便读取
def reorg_test(data_dir):
    for test_file in os.listdir(os.path.join(data_dir,'test')):
        copyfile(
            os.path.join(data_dir, 'test', test_file),
            os.path.join(data_dir, 'train_valid_test', 'test', 'unknown'))

# 调用上面定义的数据整理函数 
def reorg_cifar10_data(data_dir, valid_ratio):
    labels = read_csv_labels(os.path.join(data_dir, 'trainLabels.csv'))
    reorg_train_valid(data_dir, labels, valid_ratio)
    reorg_test(data_dir)

查看一下我们的数据有多少训练集和其类别

labels = read_csv_labels(os.path.join(data_dir, 'trainLabels.csv'))
print('# 训练示例 :', len(labels))
print('# 类别 :', len(set(labels.values())))

# 训练示例 : 50000
# 类别 : 10

最后调用上面定义的函数进行数据整理

'''
如果是示例数据，将样本数据集的批量大小设置为 32。 
在实际训练和测试中，应该使用 Kaggle 竞赛的完整数据集，并将 batch_size 设置为更大的整数，例如 128。
我们将 10％ 的训练示例作为调整超参数的验证集。
'''
batch_size = 32 if demo else 128
valid_ratio = 0.1
reorg_cifar10_data(data_dir,valid_ratio)

3. 图像增广

数据增广的基础知识可以参考我之前写的Blog：动手学深度学习（二十六）——图像增广(一生二，二生三，三生万物？)

"""训练数据中：图片切割+随机水平翻转+对RGB三个通道进行标准化"""
transform_train = torchvision.transforms.Compose([
    # 在高度和宽度上将图像放大到40像素的正方形
    torchvision.transforms.Resize(40),
    # 随机裁剪出一个高度和宽度均为40像素的正方形图像，
    # 生成一个面积为原始图像面积0.64到1倍的小正方形，
    # 然后将其缩放为高度和宽度均为32像素的正方形
    torchvision.transforms.RandomResizedCrop(32, scale=(0.64, 1.0),
                                             ratio=(1.0, 1.0)),
    # 水平翻转
    torchvision.transforms.RandomHorizontalFlip(),
    torchvision.transforms.ToTensor(),
    # 标准化图像的每个通道
    torchvision.transforms.Normalize([0.4914, 0.4822, 0.4465],
                                     [0.2023, 0.1994, 0.2010])])
"""测试数据中：只对图片进行通道标准化，消除评估结果中的随机性"""
transform_test = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor(),
    torchvision.transforms.Normalize([0.4914, 0.4822, 0.4465],
                                     [0.2023, 0.1994, 0.2010])])

4. 数据读取

利用torchvision的ImageFolder加载数据，利用pytorch的DataLoader进行数据整合成可以用于网络训练的格式

train_ds, train_valid_ds = [
    torchvision.datasets.ImageFolder(
        os.path.join(data_dir, 'train_valid_test', folder),
        transform=transform_train) for folder in ['train', 'train_valid']]

valid_ds, test_ds = [
    torchvision.datasets.ImageFolder(
        os.path.join(data_dir, 'train_valid_test', folder),
        transform=transform_test) for folder in ['valid', 'test']]

train_iter, train_valid_iter = [
    torch.utils.data.DataLoader(dataset, batch_size, shuffle=True,
                                drop_last=True)
    for dataset in (train_ds, train_valid_ds)]

# drop_last 表示如果最后一个batch不够就丢掉 
valid_iter = torch.utils.data.DataLoader(valid_ds, batch_size, shuffle=False,
                                         drop_last=True)

test_iter = torch.utils.data.DataLoader(test_ds, batch_size, shuffle=False,
                                        drop_last=False)

5. 模型定义

使用resnet18作为网络，关于ResNet的详细代码参考：动手学深度学习（二十四）——公式详解ResNet

def get_net():
    num_classes = 10
    net = d2l.resnet18(num_classes,3)
    return net

6. 训练模型

这里我学到了很多炼丹(调参)的经验，顺便记录一下：

1. 学习率的调整：太大的学习率会导致收敛不了；太小的学习率又会导致陷入局部最小。使用torch.optim.lr_scheduler.StepLR可以一定程度上优化学习率的调整
2. nn.CrossEntropyLoss()的参数reduction=“none”表示返回一个损失值向量，里面是每一个输入的损失值；而默认的是求这些值的平均值；也可以指定为求和。
3. weight_decay，权重衰退可以缓解过拟合，但是这个值不能太大了。如果过拟合严重，调整一下这个参数试一下。
4. loss直接归零，看一下是不是值太大已经为了nan值。如果是可以尝试设置一下网络的初始化值，可以使用xavier等方法

不写太多了，太多以后不方便查找

def train_batch(net, X, y, loss, trainer, devices):
    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)/len(y)
    return train_loss_sum, train_acc_sum

# lr_period lr_decay 学习率下降方法（每隔多少个epoch减少lr多少 ）
def train(net, train_iter, valid_iter, num_epochs, lr, wd, devices, lr_period,lr_decay):
    trainer = torch.optim.SGD(net.parameters(), lr=lr, momentum=0.9,weight_decay=wd)
    scheduler = torch.optim.lr_scheduler.StepLR(trainer, lr_period, lr_decay) # lr_scheduler学习率调整方法
    num_batches, timer = len(train_iter), d2l.Timer()
    legend = ['train loss', 'train acc']
    if valid_iter is not None:
        legend.append('valid acc')
    animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
                            legend=legend)
    net = nn.DataParallel(net, device_ids=devices).to(devices[0])
    
    # 这里如果使用reduction=“none”结果不收敛，使用默认的elementwise_mean可以
   '''测试发现，如果使用求和的方法，loss非常大,超过了float3的上限'''
    loss = nn.CrossEntropyLoss()
    for epoch in range(num_epochs):
        net.train()
        metric = d2l.Accumulator(3)
        for i, (features, labels) in enumerate(train_iter):
            timer.start()
            l, acc = train_batch(net, features, labels, loss, trainer, devices)
            if i<30:
                print(l)
            metric.add(l, acc,1)
            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[2], None))
        if valid_iter is not None:
            valid_acc = d2l.evaluate_accuracy_gpu(net, valid_iter)
            animator.add(epoch + 1, (None, None, valid_acc))
        scheduler.step() # 注意这里需要step
        print(metric[1]/metric[2])
    measures = (f'train loss {metric[0] / metric[2]:.3f}, '
                f'train acc {metric[1] / metric[2]:.3f}')
    if valid_iter is not None:
        measures += f', valid acc {valid_acc:.3f}'
    print(measures + f'\n{metric[2] * num_epochs / timer.sum():.1f}'
          f' examples/sec on {str(devices)}')

# 定义参数：设备、epoch、学习率、权重衰退
devices, num_epochs, lr, wd = d2l.try_all_gpus(), 20, 0.1, 5e-4
lr_period, lr_decay, net = 10, 0.1, get_net()

# 模型初始化,个人认为非常重要，特别是容易梯度爆炸和消失的情况中。或许在层中添加一个BN层也非常好
def init_weights(m):
    if type(m) in [nn.Linear, nn.Conv2d]:
        nn.init.xavier_uniform_(m.weight)
net.apply(init_weights)

train(net, train_iter, valid_iter, num_epochs, lr, wd, devices, lr_period, lr_decay)

0.9290420227920227
train loss 0.202, train acc 0.929, valid acc 0.833
3.8 examples/sec on [device(type='cuda', index=0)]

7. 测试生成提交结果

preds = []
for X, _ in test_iter:
    y_hat = net(X.to(devices[0]))
    preds.extend(y_hat.argmax(dim=1).type(torch.int32).cpu().numpy())
sorted_ids = list(range(1, len(test_ds) + 1))
sorted_ids.sort(key=lambda x: str(x))
df = pd.DataFrame({'id': sorted_ids, 'label': preds})
df['label'] = df['label'].apply(lambda x: train_valid_ds.classes[x])
df.to_csv('./kaggle_submission/CIFAR-10/submission.csv', index=False)

最后看看我的成绩（只使用了ResNet-18模型，参数也调整不是特别仔细得到的结果）：

这个排名在七年前大概40-50名左右，也还是不错了，仔细调参应该可以排到20名左右，精度达到90%？