第四次軟工作業：使用VGG模型進行貓狗大戰
學術界當下使用最廣泛的大規模圖像數據集為ImageNet，它有超過1,000萬的圖像和1,000類的物體。但是通常而言我們使用的數據集的規模會小於ImageNet的規模。如果用較小的數據集來訓練適用於ImageNet的復雜模型很可能會導致過擬合。解決的方法主要有兩種，一種是擴大使用的數據集的規模，但是這無疑會增大開銷；另一種方式就是應用遷移學習，將從源數據集學到的知識遷移到目標數據集。源數據集的圖像雖然可能與我們的目標數據集不甚類似，但在ImageNet這種較大規模的數據集上訓練出來的模型可能會提取到更常規的圖像特征，這有助於識別邊緣、紋理、形狀等，很有可能也能用於目標數據集。以下將使用預訓練好的模型來完成貓狗大戰的競賽題目。
代碼
1. 上傳數據
首先將colab掛載到谷歌雲盤。
from google.colab import drive
drive.mount('/content/gdrive')
進入上傳了數據集的目錄。
!cd gdrive
!cd MyDrive
!cd Colab Notebooks
!cd CatDogData/
對數據集進行解壓。
!unzip ./dogscats/test.zip
2. 數據處理
導入常見的包並判斷是否使用了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())
導入數據集。這里不能直接加數據增強， 因為驗證集和測試集用的也是這個transform。如果要加的話需要給訓練集和測試集分別創建transform。
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.RandomHorizontalFlip(),
# transforms.RandomRotation(30), # 隨機旋轉
transforms.ToTensor(),
normalize,
])
data_dir = './dogscats'
dsets = {x: datasets.ImageFolder(os.path.join(data_dir, x), vgg_format)
for x in ['train', 'valid', 'test']}
dset_sizes = {x: len(dsets[x]) for x in ['train', 'valid', 'test']}
dset_classes = dsets['train'].classes
創建Dataloader。
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)
loader_test = torch.utils.data.DataLoader(dsets['test'], batch_size=5, shuffle=False, num_workers=6)
'''
valid 數據一共有2000張圖，每個batch是5張，因此，下面進行遍歷一共會輸出到 400
同時，把第一個 batch 保存到 inputs_try, labels_try，分別查看
'''
count = 1
for data in loader_valid:
print(count, end='\n')
if count == 1:
inputs_try,labels_try = data
count +=1
# 顯示圖片的小程序
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])
3. 創建模型
下載ImageNet1000個類的json文件。
!wget https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json
使用預訓練好的 VGG 模型。這里使用的是VGG16。之后對輸入的5個圖片利用VGG模型進行預測，同時，使用softmax對結果進行處理，隨后展示了識別結果。
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()])
4. 修改最后一層，凍結前面層的參數
VGG 模型如下圖所示
目標是使用預訓練好的模型，但訓練的模型最后的全連接層輸出為1000類（因為是在ImageNet數據集上訓練的），因此，需要把最后的 nn.Linear 層由1000類，替換為2類才能符合貓狗二分類的要求。在訓練中需要凍結前面層的參數，因為這些參數是已經訓練好的，不需要在這個數據集上繼續訓練了，所以需要設置 required_grad=False。這樣，反向傳播訓練梯度時，前面層的權重就不會自動更新了。訓練中，只會更新最后一層的參數。
print(model_vgg)model_vgg_new = model_vgg;for param in model_vgg_new.parameters(): param.requires_grad = Falsemodel_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)
因為使用的NLLoss和CrossEntropyLoss不同，不會自己實現softmax，所以需要在模型最后手動加上LogSoftmax。
5. 訓練並測試全連接層
'''第一步：創建損失函數和優化器損失函數 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)
def test_model(model,dataloader,size): model.eval() predictions = np.zeros(size) all_classes = np.zeros(size) all_proba = np.zeros((size,2)) i = 0 running_loss = 0.0 running_corrects = 0 for inputs,classes in dataloader: inputs = inputs.to(device) classes = classes.to(device) outputs = model(inputs) loss = criterion(outputs,classes) _,preds = torch.max(outputs.data,1) # statistics running_loss += loss.data.item() running_corrects += torch.sum(preds == classes.data) predictions[i:i+len(classes)] = preds.to('cpu').numpy() all_classes[i:i+len(classes)] = classes.to('cpu').numpy() all_proba[i:i+len(classes),:] = outputs.data.to('cpu').numpy() i += len(classes) print('Testing: No. ', i, ' 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)) return predictions, all_proba, all_classes predictions, all_proba, all_classes = test_model(model_vgg_new,loader_valid,size=dset_sizes['valid'])
6. 對測試集進行預測，得到結果
predictions, all_proba, all_classes = test_model(model_vgg_new,loader_test,size=dset_sizes['test'])
結果寫入CSV文件。
import csvwith open('./dogscats/cats_vs_dogs.csv','w',newline="")as f: writer = csv.writer(f) for index,cls in enumerate(predictions): path = datasets.ImageFolder(os.path.join(data_dir,'test'),vgg_format).imgs[index][0] l = path.split("/") img_name = l[-1] order = int(img_name.split(".")[0]) writer.writerow([order,int(predictions[index])])
7. 上傳提交結果
下載得到的CSV文件的第一列標號順序和要求的不一樣（因為是按批預測的），需要全選后右鍵排序，選擇自定義排序后按列A排序。
就可以在平台提交結果啦：
總結
1. 關於VGG模型
長度為4096的向量能夠很好地抓住圖片的語義信息。如果兩個圖片的4096向量十分相似的話那么很可能是同一個/同一類物體。VGG最后使用了三個4096全連接層能夠得到較好的效果。但是由4096維到輸出為2的維度是否跨度有點大？可否再加一個過渡的全連接層？為此我以下文中提到的VGG19優化方案為基礎進行了嘗試：
首先在網絡中添加如下層，取大小為1024的全連接層過渡。
model_vgg_new.classifier._modules['6'] = nn.Linear(4096, 1024) model_vgg_new.classifier._modules['7'] = nn.Linear(1024, 2) model_vgg_new.classifier._modules['8'] = torch.nn.LogSoftmax(dim = 1)
然后修改optimizer，可以用如下語法實現傳遞最后添加的這兩個全連接層的參數：
optimizer_vgg = torch.optim.Adam([{'params': model_vgg_new.classifier[6].parameters()}, {'params': model_vgg_new.classifier[7].parameters()}],lr = lr)
之后訓練即可。提交后的分數為：
相比較之前的98.3分來說有所下降，進而驗證了4096全連接層的優勢。
2. 關於損失函數
這個實驗中的損失函數為NLLoss。
官方文檔中介紹稱： nn.NLLLoss輸入是一個對數概率向量和一個目標標簽，它與nn.CrossEntropyLoss的關系可以描述為：softmax(x)+log(x)+nn.NLLLoss====>nn.CrossEntropyLoss。
那么問題來了，代碼里為什么要在模型里加入Logsoftmax而不是直接使用CrossEntropyLoss呢？
3. 嘗試的改進
VGG16替換為VGG19：
model_vgg = models.vgg19(pretrained=True)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) # 1000類替換為2類（4096為全連接層維度）model_vgg_new.classifier._modules['7'] = torch.nn.LogSoftmax(dim = 1)model_vgg_new = model_vgg_new.to(device)
優化器設置為Adam，修改學習率為3e-4：
（一個總結中提到Adam最優學習率為3e-4）
lr = 0.0003optimizer_vgg = torch.optim.Adam(model_vgg_new.classifier[6].parameters(),lr = lr)
