玩转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 = Falseif 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()

这里需要强调说明一下：
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) + 1else: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 = 10net = 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() # 注意这里需要stepprint(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%？