Pytorch实战 | P6 好莱坞明星图片识别(深度学习实践pytorch)

• 本文为365天深度学习训练营 中的学习记录博客
• 参考文章：Pytorch实战 | 第P6周：好莱坞明星识别
• 原作者：K同学啊|接辅导、项目定制

一、我的环境

● 语言环境：Python3.8
● 编译器：pycharm
● 深度学习环境：Pytorch
● 数据来源：链接:https://pan.baidu.com/s/1mYTaatLy8rj6gRvwGQOXgw 提取码:sh4d

二、主要代码实现

1、main.py

# -*- coding: utf-8 -*-
import copy
import pathlib
from torch import optim
import torch.utils.data
import torchvision.transforms as transforms
from torchvision import datasets
import torch.nn as nn

# 一、前期准备
data_dir = './data/'
data_dir = pathlib.Path(data_dir)
data_paths = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[1] for path in data_paths]
# 1、将数据处理成dataset
train_transformers = transforms.Compose([
    transforms.Resize([224, 224]),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])
total_data = datasets.ImageFolder("./data/", train_transformers)

# 2、划分数据集
class_to_idx = total_data.class_to_idx

train_size = int(0.8 * len(total_data))
test_size = len(total_data) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])

# 3、将数据处理成dataloader
batch_size = 32
train_dl = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_dl = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=True)

for X, y in test_dl:
    print("X shape:", X.shape)
    print("Y shape:", y.shape, y.dtype)
    break

# 二、加载VGG-16模型
from torchvision.models import vgg16

device = 'cuda' if torch.cuda.is_available() else 'cpu'
print("using {} device".format(device))

# 加载预训练模型，并且对模型进行微调
model = vgg16(pretrained=True).to(device)  # 加载预训练的vgg-16模型

for param in model.parameters():
    param.requires_grad = False  # 冻结模型参数，训练的时候只训练最后一层

# 修改classfier模块的第6层，Linear(in_features=4096, out_features=2, bias=True)）
print(model)
model.classifier._modules['6'] = nn.Linear(4096, len(classeNames))  # 修改vgg16模型中最后一层全连接层，输出目标类别个数
model.to(device)
print(model)


# 三、模型训练与测试方法

def train(dataloader, model, loss_fn, optimizer):
    train_loss, train_acc = 0, 0

    for X, y in dataloader:
        X, y = X.to(device), y.to(device)

        pred = model(X)
        loss = loss_fn(pred, y)

        optimizer.zero_grad()  # grad属性归零
        loss.backward()
        optimizer.step()  # 每一步参数自动更新

        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    size = len(dataloader.dataset)
    num_batchs = len(dataloader)

    train_acc /= size
    train_loss /= num_batchs

    return train_acc, train_loss


def test(dataloader, model, loss_fn):
    test_loss, test_acc = 0, 0
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)
            loss = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    size = len(dataloader.dataset)
    num_batchs = len(dataloader)

    test_acc /= size
    test_loss /= num_batchs

    return test_acc, test_loss


# 四、模型训练
# # 设置动态学习率
# def adjust_learning_rate(optimizer, epoch, start_lr):
#     # 每 2 个epoch衰减到原来的 0.98
#     lr = start_lr * (0.92 ** (epoch // 2))
#     for param_group in optimizer.param_groups:
#         param_group['lr'] = lr

learn_rate = 1e-4  # 初始学习率
lambda1 = lambda epoch: 0.92 ** (epoch // 4)
optimizer = optim.Adam(model.parameters(), lr=learn_rate)
# optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1) #选定调整方法

loss_fn = nn.CrossEntropyLoss()
epochs = 40

train_loss = []
train_acc = []
test_loss = []
test_acc = []

best_acc = 0  # 设置一个最佳准确率，作为最佳模型的判别指标
best_model = {}
for epoch in range(epochs):

    # adjust_learning_rate(optimizer, epoch, learn_rate)

    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)
    scheduler.step()  # 更新学习率（调用官方动态学习率接口时使用）

    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    if (epoch_test_acc > best_acc):
        best_acc = epoch_test_acc
        best_model = copy.deepcopy(model)

        # 获取当前的学习率
    lr = optimizer.state_dict()['param_groups'][0]['lr']

    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
    print(template.format(epoch + 1, epoch_train_acc * 100, epoch_train_loss,
                          epoch_test_acc * 100, epoch_test_loss, lr))


# 保存模型
path = "./model/model.pkl"

torch.save(best_model.state_dict(), path)

print("Done")

# 五、模型评估

import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100        #分辨率

epoch_range = range(epochs)

plt.figure(figsize=(12, 3))

plt.subplot(1, 2, 1)
plt.plot(epoch_range, train_acc, label='Training Accuracy')
plt.plot(epoch_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')


plt.subplot(1, 2, 2)
plt.plot(epoch_range, train_loss, label='Training Loss')
plt.plt(epoch_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

2、test.py

# -*- coding: utf-8 -*-
import pathlib

import matplotlib.pyplot as plt
import torch
from PIL import Image
from torchvision.models import vgg16
import torchvision.transforms as transforms

model = vgg16()

model.load_state_dict(torch.load('./model/model.pkl', map_location=torch.device('cpu')))


def predict_one_image(image_path, model, transfrom, classes):
    test_img = Image.open(image_path).convert('RGB')
    plt.imshow(test_img)
    plt.show()

    test_img = transfrom(test_img)
    img = test_img.unsqueeze(0)

    model.eval()
    output = model(img)

    _, pred = torch.max(output, 1)
    pred_class = classes[pred]
    print(f'预测结果是：{pred_class}')


# 预测某张照片
train_transformers = transforms.Compose([
    transforms.Resize([224, 224]),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

data_dir = './data/'
data_dir = pathlib.Path(data_dir)
data_paths = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[1] for path in data_paths]
predict_one_image(image_path='./test/1.jpg', model=model, transfrom=train_transformers, classes=classeNames)

三、遇到的主要问题

1、自己的笔记本上根本跑不起来，用pycharm跑代码等了几分钟都没反应。
2、vgg16预训练模型跑代码中自动下载到某个位置，但是跑了半天都下不下来，索性复制下载地址用浏览器下载下来然后放到对应的位置下。
3、训练集上准确率跑到30%左右就跑不动了，验证集上只有20%左右。
优化了优化器，之前采用

optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)

改为

optimizer = optim.Adam(model.parameters(), lr=learn_rate)

训练集上超过了60%，但是验证集上只有不到40%，验证集最高可以跑到大概48%后就不动了

5、从某同学那获得的调优方法，优化了vgg16的classifier，准确率得到大幅提升，验证集最高值达到了61%

model.classifier = nn.Sequential(
    nn.Linear(512 * 7 * 7, 1024),
    nn.BatchNorm1d(1024),
    nn.Dropout(0.4),
    nn.Linear(1024, 128),
    nn.BatchNorm1d(128),
    nn.Dropout(0.4),
    nn.Linear(128, len(classeNames)),
    nn.Softmax()
)