第四次作业：猫狗大战挑战赛

使用VGG模型进行猫狗大战

 1 import numpy as np
 2 import matplotlib.pyplot as plt
 3 import os
 4 import torch
 5 import torch.nn as nn
 6 import torchvision
 7 from torchvision import models,transforms,datasets
 8 import time
 9 import json
10 
11 
12 # 判断是否存在GPU设备
13 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
14 print('Using gpu: %s ' % torch.cuda.is_available())

1. 下载数据

2. 数据处理

datasets 是 torchvision 中的一个包，可以用做加载图像数据。它可以以多线程（multi-thread）的形式从硬盘中读取数据，使用 mini-batch 的形式，在网络训练中向 GPU 输送。在使用CNN处理图像时，需要进行预处理。图片将被整理成 $224\times 224 \times 3$ 的大小，同时还将进行归一化处理。

torchvision 支持对输入数据进行一些复杂的预处理/变换（normalization, cropping, flipping, jittering 等）。

3. 创建 VGG Model

torchvision中集成了很多在 ImageNet （120万张训练数据）上预训练好的通用的CNN模型，可以直接下载使用。

在本课程中，我们直接使用预训练好的 VGG 模型。同时，为了展示 VGG 模型对本数据的预测结果，还下载了 ImageNet 1000 个类的 JSON 文件。

在这部分代码中，对输入的5个图片利用VGG模型进行预测，同时，使用softmax对结果进行处理，随后展示了识别结果。可以看到，识别结果是比较非常准确的。

4. 修改最后一层，冻结前面层的参数

VGG 模型如下图所示，注意该网络由三种元素组成：

卷积层（CONV）是发现图像中局部的 pattern
全连接层（FC）是在全局上建立特征的关联
池化（Pool）是给图像降维以提高特征的 invariance

我们的目标是使用预训练好的模型，因此，需要把最后的 nn.Linear 层由1000类，替换为2类。为了在训练中冻结前面层的参数，需要设置 required_grad=False。这样，反向传播训练梯度时，前面层的权重就不会自动更新了。训练中，只会更新最后一层的参数。

5. 训练并测试全连接层

 1 包括三个步骤：第1步，创建损失函数和优化器；第2步，训练模型；第3步，测试模型。
 2 
 3 '''
 4 第一步：创建损失函数和优化器
 5 
 6 损失函数 NLLLoss() 的 输入 是一个对数概率向量和一个目标标签. 
 7 它不会为我们计算对数概率，适合最后一层是log_softmax()的网络. 
 8 '''
 9 criterion = nn.NLLLoss()
10 
11 # 学习率
12 lr = 0.001
13 
14 # 随机梯度下降
15 optimizer_vgg = torch.optim.SGD(model_vgg_new.classifier[6].parameters(),lr = lr)
16 
17 '''
18 第二步：训练模型
19 '''
20 
21 def train_model(model,dataloader,size,epochs=1,optimizer=None):
22     model.train()
23     
24     for epoch in range(epochs):
25         running_loss = 0.0
26         running_corrects = 0
27         count = 0
28         for inputs,classes in dataloader:
29             inputs = inputs.to(device)
30             classes = classes.to(device)
31             outputs = model(inputs)
32             loss = criterion(outputs,classes)           
33             optimizer = optimizer
34             optimizer.zero_grad()
35             loss.backward()
36             optimizer.step()
37             _,preds = torch.max(outputs.data,1)
38             # statistics
39             running_loss += loss.data.item()
40             running_corrects += torch.sum(preds == classes.data)
41             count += len(inputs)
42             print('Training: No. ', count, ' process ... total: ', size)
43         epoch_loss = running_loss / size
44         epoch_acc = running_corrects.data.item() / size
45         print('Loss: {:.4f} Acc: {:.4f}'.format(
46                      epoch_loss, epoch_acc))
47         
48         
49 # 模型训练
50 train_model(model_vgg_new,loader_train,size=dset_sizes['train'], epochs=1, 
51             optimizer=optimizer_vgg)

 1 def test_model(model,dataloader,size):
 2     model.eval()
 3     predictions = np.zeros(size)
 4     all_classes = np.zeros(size)
 5     all_proba = np.zeros((size,2))
 6     i = 0
 7     running_loss = 0.0
 8     running_corrects = 0
 9     for inputs,classes in dataloader:
10         inputs = inputs.to(device)
11         classes = classes.to(device)
12         outputs = model(inputs)
13         loss = criterion(outputs,classes)           
14         _,preds = torch.max(outputs.data,1)
15         # statistics
16         running_loss += loss.data.item()
17         running_corrects += torch.sum(preds == classes.data)
18         predictions[i:i+len(classes)] = preds.to('cpu').numpy()
19         all_classes[i:i+len(classes)] = classes.to('cpu').numpy()
20         all_proba[i:i+len(classes),:] = outputs.data.to('cpu').numpy()
21         i += len(classes)
22         print('Testing: No. ', i, ' process ... total: ', size)        
23     epoch_loss = running_loss / size
24     epoch_acc = running_corrects.data.item() / size
25     print('Loss: {:.4f} Acc: {:.4f}'.format(
26                      epoch_loss, epoch_acc))
27     return predictions, all_proba, all_classes
28   
29 predictions, all_proba, all_classes = test_model(model_vgg_new,loader_valid,size=dset_sizes['valid'])

6. 可视化模型预测结果（主观分析）

主观分析就是把预测的结果和相对应的测试图像输出出来看看，一般有四种方式：

随机查看一些预测正确的图片
随机查看一些预测错误的图片
预测正确，同时具有较大的probability的图片
预测错误，同时具有较大的probability的图片
最不确定的图片，比如说预测概率接近0.5的图片

 1 # 单次可视化显示的图片个数
 2 n_view = 8
 3 correct = np.where(predictions==all_classes)[0]
 4 from numpy.random import random, permutation
 5 idx = permutation(correct)[:n_view]
 6 print('random correct idx: ', idx)
 7 loader_correct = torch.utils.data.DataLoader([dsets['valid'][x] for x in idx],
 8                   batch_size = n_view,shuffle=True)
 9 for data in loader_correct:
10     inputs_cor,labels_cor = data
11 # Make a grid from batch
12 out = torchvision.utils.make_grid(inputs_cor)
13 imshow(out, title=[l.item() for l in labels_cor])
14 
15 # 类似的思路，可以显示错误分类的图片，这里不再重复代码