CNN实战---猫狗大战

使用VGG模型进行猫狗大战

一、Tom&Spike

• 前面一部分就完全按照代码教程进行编写
• 首先就是进行环境配置，由于我的谷歌云盘GPU次数用完了、所以最后面的检测有没有一个样。

import numpy as np
import matplotlib.pyplot as plt
import os
import torch
import torch.nn as nn
import torchvision
from torchvision import models,transforms,datasets
import time
import json
# 判断是否存在GPU设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print('Using gpu: %s ' % torch.cuda.is_available())

• 这里我是连着猫狗大赛的数据一起写的，由于猫狗大赛官网给的连接中的训练数据是混在一起的，也就是cat和dog并没有分开在两个文件夹、所以直接导入会产生错误，于是我就用了老师给的数据训练，而且老师给的只有1800个数据，官网的有20000个，所以就简单的进行操作。
• 还有就是官网的test数据被我导出来了、然后再压缩，上传到云盘，所以下面的testing就直接解压了

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

• 这一部分就是对数据的处理，如果刚才用官网的直接导入，这一部分就会出现很多bug。
• 将数据拆分为训练集和有效集；

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_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)

'''
输出新的vgg模型
'''
print(model_vgg_new.classifier)

• 下面是模型输出结果
  

• 然后就是优化并训练模型，包括三个步骤：
  • 创建损失函数和优化器；
  • 训练模型与保存；
  • 测试模型。

• 在这里我只训练了5次，因为没有GPU的加持，训练一次花半小时·······

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

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

# 学习率
lr = 0.001
# 这里使用Adam优化器
optimizer_vgg = torch.optim.Adam(model_vgg_new.classifier[6].parameters(),lr = lr)

'''
第二步：训练模型并保存
model: 训练的模型
dataloader: 训练集
size: 训练集大小
epochs: 训练次数
optimizer: 优化器
'''
def train_model(model,dataloader,size,epochs=1,optimizer=None):
  model.train()  #用于模型训练
  
  for epoch in range(epochs):
    epoch_acc_max = 0
    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
        
    if epoch_acc > epoch_acc_max:
	    epoch_acc_max = epoch_acc
	    torch.save(model, 'model_best.pth')	#保存最好模型
        
    print('Loss: {:.4f} Acc: {:.4f}'.format(
                     epoch_loss, epoch_acc))
        
        
# 模型训练
train_model(model_vgg_new, loader_train,size = dset_sizes['train'], 
		epochs = 5, optimizer=optimizer_vgg)

• 下面是每次训练后的结果图
  
  
  
  
  
• 于是就选则了最优的模型进行猫狗大战，输出结果文件。
• 这里要注意测试数据必须放在文件夹里，意思是说test文件夹里全是测试数据，然后再把test文件夹放在另一个文件夹里，且这个文件夹只能有test文件，不然会报错。

dsets = datasets.ImageFolder('/content/texting', vgg_format) 

final = {} #结果数组

loader_test = torch.utils.data.DataLoader(dsets, batch_size=1, shuffle=False, num_workers=0)

model_vgg_new = torch.load("/content/model_best.pth")

def test(model,dataloader,size):
    model.eval()	#参数固定

    cnt = 0	#count
    for inputs,_ in dataloader:
      if cnt < size:
        inputs = inputs.to(device)
        outputs = model(inputs)
        _,preds = torch.max(outputs.data,1) #预测值最大化
        key = dsets.imgs[cnt][0].split("/")[-1].split('.')[0] #对目录项进行分割
        final[key] = preds[0]
        cnt += 1
      else:
        break;
test(model_vgg_new,loader_test,size=2000)

#写表格

with open("/content/test.csv",'a+') as f:
    for key in range(2000):
        f.write("{},{}\n".format(key,final[str(key)]))

• 下面是结果文件的部分图，结果文件在运行完后，会在文件列表生成，右击下载即可
  

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

• 至于第一次为什么得分只有49.95，主要就是把test文件放在训练数据文件一起了，导致测试的是训练数据，输出结果全是dog，也就是全是1。

二、总结与感悟

• 最大的体会就是花了一下午找bug、查bug、改bug，当然，在这期间也学到了许多东西，就比如数据处理部分的几个函数的用法等等，还有就是发现当你训练量越来越大的时候，选择一个算法优化显得尤为重要，在这里我用的是Adam优化器，当然还有许多其他的优化器，比如SGD优化器，但SGD 是最普通的优化器, 也可以说没有加速效果； 而Adam 是SGD优化器添加了诸如动量原则等升级，所以一般效果比SGD优化效果好。