[人工智能]第四次作业：猫狗大战挑战赛

使用VGG模型进行猫狗大战

1、大赛简介

Kaggle 中的猫狗大战竞赛题目。在这个比赛中，有25000张标记好的猫和狗的图片用做训练，有12500张图片用做测试。这个竞赛是2013年开展的，如果你能够达到80%的准确率，在当年是一个 state-of-the-art 的成绩。

2、数据准备

• 这里我将猫狗大赛的数据同老师的数据集一起写。因为猫狗大赛官网的训练数据是混在一起的，换句话说，就是cat和dog没有分开在两个文件夹，所以直接导入会产生错误，于是我就将官网的20000个数据下载下来。
• 另外，官网的test数据下载并压缩后，上传到谷歌云盘，就能在直接解压。

! unzip testing.zip
! wget http://fenggao-image.stor.sinaapp.com/dogscats.zip
! unzip dogscats.zip

• 接下来就是对数据进行处理。
• 将数据拆分为训练集和有效集，在他整理的数据集中，猫和狗的图片放在单独的文件夹中， 同时还提供了一个Validation数据。

normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])

vgg_format = transforms.Compose([
                transforms.CenterCrop(224),
                transforms.ToTensor(),
                normalize,
            ])

data_dir = '/content/dogscats'

dsets = {x: datasets.ImageFolder(os.path.join(data_dir, x), vgg_format)
         for x in ['train', 'valid']}

dset_sizes = {x: len(dsets[x]) for x in ['train', 'valid']}
dset_classes = dsets['train'].classes

loader_train = torch.utils.data.DataLoader(
dsets['train'], batch_size=64, shuffle=True, num_workers=6)

loader_valid = torch.utils.data.DataLoader(
dsets['valid'], batch_size=5, shuffle=False, num_workers=6)

• 顺便取一部分数据做可视化

# 显示图片的小程序

def imshow(inp, title=None):
#   Imshow for Tensor.
    inp = inp.numpy().transpose((1, 2, 0))
    mean = np.array([0.485, 0.456, 0.406])
    std = np.array([0.229, 0.224, 0.225])
    inp = np.clip(std * inp + mean, 0,1)
    plt.imshow(inp)
    if title is not None:
        plt.title(title)
    plt.pause(0.001)  # pause a bit so that plots are updated

# 显示 labels_try 的5张图片，即valid里第一个batch的5张图片
out = torchvision.utils.make_grid(inputs_try)
imshow(out, title=[dset_classes[x] for x in labels_try])

可视化结果如下图

构建VGG模型

model_vgg = models.vgg16(pretrained=True)

with open('./imagenet_class_index.json') as f:
    class_dict = json.load(f)
dic_imagenet = [class_dict[str(i)][1] for i in range(len(class_dict))]

inputs_try , labels_try = inputs_try.to(device), labels_try.to(device)
model_vgg = model_vgg.to(device)

outputs_try = model_vgg(inputs_try)

print(outputs_try)
print(outputs_try.shape)

'''
可以看到结果为5行，1000列的数据，每一列代表对每一种目标识别的结果。
但是我也可以观察到，结果非常奇葩，有负数，有正数，
为了将VGG网络输出的结果转化为对每一类的预测概率，我们把结果输入到 Softmax 函数
'''
m_softm = nn.Softmax(dim=1)
probs = m_softm(outputs_try)
vals_try,pred_try = torch.max(probs,dim=1)

print( 'prob sum: ', torch.sum(probs,1))
print( 'vals_try: ', vals_try)
print( 'pred_try: ', pred_try)

print([dic_imagenet[i] for i in pred_try.data])
imshow(torchvision.utils.make_grid(inputs_try.data.cpu()), 
       title=[dset_classes[x] for x in labels_try.data.cpu()])
       print(model_vgg)

model_vgg_new = model_vgg;

for param in model_vgg_new.parameters():
    param.requires_grad = False
model_vgg_new.classifier._modules['6'] = nn.Linear(4096, 2)
model_vgg_new.classifier._modules['7'] = torch.nn.LogSoftmax(dim = 1)

model_vgg_new = model_vgg_new.to(device)

print(model_vgg_new.classifier)

输出结果如下图：

• 其次优化并训练模型，包括以下三个步骤：

  1、创建损失函数和优化器

  2、训练模型并保存

  3、测试模型

'''
第一步：创建损失函数和优化器

损失函数 NLLLoss() 的 输入 是一个对数概率向量和一个目标标签. 
它不会为我们计算对数概率，适合最后一层是log_softmax()的网络. 
'''
criterion = nn.NLLLoss()

# 学习率
lr = 0.001

# 随机梯度下降
optimizer_vgg = torch.optim.SGD(model_vgg_new.classifier[6].parameters(),lr = lr)

'''
第二步：训练模型
'''

def train_model(model,dataloader,size,epochs=1,optimizer=None):
    model.train()
    
    for epoch in range(epochs):
        running_loss = 0.0
        running_corrects = 0
        count = 0
        for inputs,classes in dataloader:
            inputs = inputs.to(device)
            classes = classes.to(device)
            outputs = model(inputs)
            loss = criterion(outputs,classes)           
            optimizer = optimizer
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            _,preds = torch.max(outputs.data,1)
            # statistics
            running_loss += loss.data.item()
            running_corrects += torch.sum(preds == classes.data)
            count += len(inputs)
            print('Training: No. ', count, ' process ... total: ', size)
        epoch_loss = running_loss / size
        epoch_acc = running_corrects.data.item() / size
        print('Loss: {:.4f} Acc: {:.4f}'.format(
                     epoch_loss, epoch_acc))
        
        
# 模型训练
train_model(model_vgg_new,loader_train,size=dset_sizes['train'], epochs=1, 
            optimizer=optimizer_vgg)

下面是训练后的结果：

把test.csv文件导出后，放在平台检测，结果如下：

3、总结与感悟

• 样例代码展示了如何使用预训练模型来降低模型训练复杂度，这样训练出来的模型有较好的效果且比重新训练节省时间。但这样的模型还有一些改进的地方，主要有以下几点：1. 用于训练的数据可以优化，包括训练数据的使用量和数据的处理，虽然很难说怎样的图片处理方式更好，但仅使用数据集中少部分图片做训练效果应该不如使用大量的数据做训练。 2. 模型的选用，VGG模型效果不错，但我想试试别的模型。 3. 训练的方式，冻结参数降低了训练的复杂性，但同时也使得模型被冻结参数的部分与实际任务不太相符，与完全冻结相比，也许可以在训练时前面的预训练模型的参数做少量修改。
• 找bug、查bug、改bug花了很多时间。当然，在这期间也学到了许多东西，就比如数据处理部分的几个函数的用法等等，还有就是发现当你训练量越来越大的时候，选择一个算法优化显得尤为重要，在这里我用的是Adam优化器，当然还有许多其他的优化器，比如SGD优化器，但SGD 是最普通的优化器, 也可以说没有加速效果； 而Adam 是SGD优化器添加了诸如动量原则等升级，所以一般效果比SGD优化效果好。