我的猫狗大战分类

Cats vs Dogs based on VGG16

1.准备数据集

from google.colab import drive
drive.mount('/content/drive')
%cd /content/drive/My Drive
!unzip cat_dog.zip

2.数据预处理

#先为数据集划分合理的文件存储结构
import shutil
import os

os.mkdir('train_/cat/')
os.mkdir('train_/dog/')

for f in os.listdir('cat_dog/train'):
    if f.split('_')[0] == 'cat':
        shutil.move('cat_dog/train/'+f,'train_/cat/'+f)
    else:
        shutil.move('cat_dog/train/'+f,'train_/dog/'+f)
        
train_dir = 'train_'
# 对训练集做数据扩充
train_transform = transforms.Compose([
  transforms.Resize(256),
  transforms.CenterCrop(224),
  transforms.RandomRotation(30),
  transforms.RandomHorizontalFlip(),
  transforms.ToTensor(),
  transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])


train_dataset = datasets.ImageFolder(train_dir,transform=train_transform)

train_dataloader = torch.utils.data.DataLoader(
  train_dataset,  
  batch_size = 128,
  shuffle = True
)

查看图片

import matplotlib.pyplot as plt

def imshow(image, ax=None, title=None, normalize=True):
    """Imshow for Tensor."""
    if ax is None:
        fig, ax = plt.subplots()
    image = image.numpy().transpose((1, 2, 0))

    if normalize:
        mean = np.array([0.485, 0.456, 0.406])
        std = np.array([0.229, 0.224, 0.225])
        image = std * image + mean
        image = np.clip(image, 0, 1)

    ax.imshow(image)
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    ax.spines['left'].set_visible(False)
    ax.spines['bottom'].set_visible(False)
    ax.tick_params(axis='both', length=0)
    ax.set_xticklabels('')
    ax.set_yticklabels('')

    return ax



images, labels = next(iter(train_dataloader))

title = 'Dog' if labels[0].item() == 1 else 'Cat'
imshow(images[0])

3.训练模型

#先获取预训练好的VGG16
model = models.vgg16(pretrained=True)
model

冻结特征提取部分的参数

for param in model.parameters():
  param.requires_grad = False

修改自己的分类器

from collections import OrderedDict

#修改2个层
classifier = nn.Sequential(OrderedDict([
  # Layer 1
  ('dropout1',nn.Dropout(0.3)),
  ('fc1', nn.Linear(25088,500)),
  ('relu', nn.ReLU()),
  # output layer
  ('fc2', nn.Linear(500,2)),
  ('output', nn.LogSoftmax(dim=1))
]))

model.classifier = classifier

# 损失函数选取NLLLoss()
criterion = nn.NLLLoss()

# 优化器采用Adam
optimizer = optim.Adam(model.classifier.parameters(),lr =0.001)

model = model.to(device)

迭代训练

from tqdm import tqdm
epochs = 5


for e in range(epochs):
  running_loss, total, correct = 0, 0 , 0

  model.train()
    
  for images,labels in tqdm(train_dataloader):
    
    # Moving input to GPU
    images, labels = images.to(device), labels.to(device)

    # Forward prop
    outputs = model(images)
    loss = criterion(outputs,labels)

    # Backward prop
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    # Metrics 
    running_loss += loss.item()
    total += labels.size(0)

    _, predicted = torch.max(torch.exp(outputs).data,1)
    correct += (predicted == labels).sum().item()
  else:
    # Logs 
    print(f'Epoch {e} Training: Loss={running_loss:.5f} Acc={correct/total * 100:.2f}')

4.保存模型

checkpoints = {
     'pre-trained':'vgg16',
     'classifier':nn.Sequential(OrderedDict([
          # 修改的Layer 1
          ('dropout1',nn.Dropout(0.3)),
          ('fc1', nn.Linear(25088,500)),
          ('relu', nn.ReLU()),
          # 修改的output layer
          ('fc2', nn.Linear(500,2)),
          ('output', nn.LogSoftmax(dim=1))
    ])),
    'state_dict':model.state_dict()
}

torch.save(checkpoints,'vgg16_catsVdogs.pth')

def load_saved_model(path):
    checkpoint = torch.load(path)
    
    model = models.vgg16(pretrained=True)
    for param in model.parameters():
        param.requires_grad = False
    model.classifier = checkpoint['classifier']
    model.load_state_dict(checkpoints['state_dict'])
    model.eval（)
    return model

loaded_model = load_saved_model('vgg16_catsVdogs.pth')
loaded_model.to(device)

5.测试模型

test_transform = transforms.Compose([
          transforms.Resize(256),
          transforms.CenterCrop(224),
          transforms.ToTensor(),
          transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
        ])

predictions = []

for i in tqdm(range(0,2000)):
    path = 'catdog/test/'+str(i)+'.jpg'
    X = Image.open(path).convert('RGB')
    X = test_transform(X)[:3,:,:]
    X = X.unsqueeze(0)
    X = X.to(device)
    outputs = loaded_model(X)
    predictions.append(torch.argmax(outputs).item())

6.生成结果

# 对测试集的2000图片预测
data = {'id':list(range(0,2000)),'label':predictions}
df = pd.DataFrame(data)
df.to_csv('cats-dogs-submission.csv',index=False)

7.总结与结果分析

• 仅仅训练最后一层时，得到的准确率为96.5
• 多训练一层参数时(Layer1)，得到的准确率为97.45
• 加入数据扩增方法(对原图片进行水平竖直平移、翻转、缩放)、换用损失函数$NLLLoss$、增加迭代epoch为5后得到的准确率为98.45