下載數據集和導入包

import sys
import os
print(os.getcwd())
! wget https://static.leiphone.com/cat_dog.rar
! unrar x cat_dog.rar

import numpy as np
import matplotlib.pyplot as plt
import os
import torch
import torch.nn.functional as F
import torch.nn as nn
import torchvision
from torchvision import models,transforms,datasets
from skimage import io  
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())

---

由于數據集不是標準的ImageFolder格式的需要自己定義一個DataSet類，繼承torch.utils.data.DataSet

主要實現以下幾個函數
__init__
__len__
__getitem__

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

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

print(type(vgg_format))
class Cat_Dog_Data(torch.utils.data.Dataset):   

  def __init__(self, root_dir, transform=None):
    self.img_list = os.listdir(root_dir)
    self.root_dir = root_dir       
    self.transform = transform

  def __len__(self):        
    return len(self.img_list)

  def __getitem__(self, idx):        
    img_name = os.path.join(self.root_dir,                                
    self.img_list[idx])        
    image = io.imread(img_name)
    image = np.array(image)
    label = 0 if self.img_list[idx].split('_')[0]=="cat" else 1
    
    if self.transform:            
      img = self.transform(image)
    return img, label

指定圖片的存放路徑，并創建DataLoader

DataLoader是可以多線程批量加載圖片的類

root_dir = './cat_dog'
data_dir = ['train', 'test', 'val']
img_dir = {x : os.path.join(root_dir,x) for x in data_dir }

train_dataset = Cat_Dog_Data(                                           
	root_dir=img_dir['train'],                                           
	transform = vgg_format)

val_dataset = Cat_Dog_Data(                                           
	root_dir=img_dir['val'],                                           
	transform = vgg_format)

loader_train = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=6)
loader_valid = torch.utils.data.DataLoader(val_dataset, batch_size=5, shuffle=False, num_workers=6)

展示圖片

使用torchvision.utils.make_grid函數
同時因為Tensor是按照CHW排列的，需要轉換成HWC排列才能顯示

inputs_try,labels_try = iter(loader_valid).next()
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

label = ["Cat" if x.item()==0 else "Dog" for x in labels_try]
imshow(torchvision.utils.make_grid(inputs_try), label)

加載VGG16并修改最后一層的網絡結構

當然是直接用的老師的代碼了

model_vgg = models.vgg16(pretrained=True)
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)

訓練模型

這部分也是直接用就好了
嘗試了一下Adam和SGD優化器
SGD大約十輪迭代以后和Adam的準確率差不多，貌似Adam的自適應收斂會更快

'''
第一步：創建損失函數和優化器

損失函數 NLLLoss() 的 輸入 是一個對數概率向量和一個目標標簽. 
它不會為我們計算對數概率，適合最后一層是log_softmax()的網絡. 
'''
criterion = nn.NLLLoss()

# 學習率
lr = 0.001

# 隨機梯度下降
optimizer_vgg = torch.optim.Adam(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=train_dataset.__len__(), epochs=2, 
            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=val_dataset.__len__

生成一個提交文件

import pandas as pd
pred = []
model_vgg_new.eval()
# print(model_vgg_new)
test_img = os.listdir(img_dir['test'])

ans = [0]*len(test_img)
ansf = open('submission.txt','w')
for i,img in enumerate(test_img):
  image = vgg_format(io.imread(os.path.join(img_dir['test'],img)))
  image = image.unsqueeze(0)
  image = image.to(device)
  index = int(os.path.splitext(img)[0])
  print(index)
  output = model_vgg_new(image)
  _,preds = torch.max(output.data,1)
  ans[index]=preds.item()
  pred.append(preds.item())
for i, pred in enumerate(ans):
  print(i, pred, file=ansf, sep=',')
ansf.close()
results = pd.Series(pred)
submission = pd.concat([pd.Series(range(0,2000)),results],axis=1)
print(submission)
submission.to_csv(os.path.join('./','submission.csv'),index=False)

上AI研習社交一發

WOW 起飛
晚餐加可樂了

結果分析：

提升方案

更換主干網絡
VGG是一個多年前的網絡了，可以考慮使用ResNet做主干網絡

采用數據增強技術 可參考 數據增強(Data Augmentation)
對現有的訓練樣本進行平移旋轉等，生成規模更大的樣本

分析vali樣本中的分類錯誤的樣本，看是否有提升空間

畢竟神經網絡理論上可以擬合任意函數,主要還是找一個適合的網絡以及充足的合適的訓練樣本

Crossea_一條有夢想的咸魚

總結

以上是生活随笔為你收集整理的迁移学习： 利用VGG16进行猫狗大战分类的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。