深度学习Week7-好莱坞明星识别（Pytorch）

目录

 一、前期准备

1.设置GPU

2. 导入数据

3. 划分数据集

二、调用官方的VGG-16模型

 三、 训练模型

1. 编写训练函数

2. 编写测试函数

3. 设置动态学习率

4. 正式训练

​编辑

四、 结果可视化

1. Loss与Accuracy图

 2.指定图片进行预测

3. 模型评估

*五、优化模型

1.前几次经验，把模型调成Adam的基础上，调整学习率和动态学习率

2.在调用VGG16部分，模型分类器引入BN层，并设置dropout比例为0.4

六、参考

---

本文为[365天深度学习训练营]中的学习记录博客
参考文章：[Pytorch实战 | 第P5周：运动鞋识别]
原作者：[K同学啊|接辅导、项目定制]

要求：

1. 保存训练过程中的最佳模型权重 √
2. 调用官方的VGG-16网络框架 √

拔高（可选）：

1. 测试集准确率达到60%（难度有点大，但是这个过程可以学到不少）X
2. 手动搭建VGG-16网络框架 X

 一、前期准备

1.设置GPU

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import os, PIL, pathlib

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

print(device)

输出：cuda

2. 导入数据

解压后文件夹是许多个带明星的图片集，可以把他们的图片集的名称输出下。

data_dir = './48-data/'
data_dir = pathlib.Path(data_dir)

data_paths  = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[1] for path in data_paths]
print(classeNames)

输出：['Angelina Jolie', 'Brad Pitt', 'Denzel Washington', 'Hugh Jackman', 'Jennifer Lawrence', ...]

 图形变换，输出一下：用到torchvision.transforms.Compose()类，有兴趣的同学可以参考这篇博客：torchvision.transforms.Compose()详解【Pytorch手册】

train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    # transforms.RandomHorizontalFlip(), # 随机水平翻转
    transforms.ToTensor(),  # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    transforms.Normalize(  # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])
total_data = datasets.ImageFolder("./48-data/",transform=train_transforms)

print(total_data.class_to_idx)

因为没有分别的测试集和训练集，我们直接弄一个总集。变换完毕后，输出每个明星的序号

输出{'Angelina Jolie': 0, 'Brad Pitt': 1, 'Denzel Washington': 2, 'Hugh Jackman': 3, ...}

3. 划分数据集

因为不像上周有已经分好的训练集和测试集，所以这次要想以前那样，分为训练集和测试集

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])

batch_size = 32
train_dl = torch.utils.data.DataLoader(train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True,
                                           num_workers=0)
test_dl = torch.utils.data.DataLoader(test_dataset,
                                          batch_size=batch_size,
                                          shuffle=True,
                                          num_workers=0)
for X, y in test_dl:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break

Shape of X [N, C, H, W]:  torch.Size([32, 3, 224, 224])
Shape of y:  torch.Size([32]) torch.int64

二、调用官方的VGG-16模型

这次不用cnn卷积神经网络了，用官方的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)  # 加载预训练的vgg16模型

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

# 修改classifier模块的第6层（即：(6): Linear(in_features=4096, out_features=2, bias=True)）
# 注意查看我们下方打印出来的模型
model.classifier._modules['6'] = nn.Linear(4096, len(classeNames))  # 修改vgg16模型中最后一层全连接层，输出目标类别个数
model.to(device)
print(model)

电脑没有会自动帮你下。最后输出一下模型相关参数。

 三、 训练模型

1. 编写训练函数

训练部分代码和之前cnn网络一样

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小
    num_batches = len(dataloader)   # 批次数目, (size/batch_size，向上取整)

    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)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
        
        # 反向传播
        optimizer.zero_grad()  # grad属性归零
        loss.backward()        # 反向传播
        optimizer.step()       # 每一步自动更新
        
        # 记录acc与loss
        train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()
            
    train_acc  /= size
    train_loss /= num_batches

    return train_acc, train_loss

2. 编写测试函数

训练函数和测试函数差别不大，但是由于不进行梯度下降对网络权重进行更新，所以不用优化器

（所以测试函数代码部分和之前几周一样）

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小
    num_batches = len(dataloader)          # 批次数目
    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()
 
    test_acc  /= size
    test_loss /= num_batches
 
    return test_acc, test_loss

3. 设置动态学习率

这里用week6的内容，在这里设置动态学习率，但在这里我们相比上一期博客我们直接使用了多分类的对数损失函数。

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 # 初始学习率
optimizer  = torch.optim.SGD(model.parameters(), lr=learn_rate)

4. 正式训练

注意保存最佳模型，与TensorFlow2的保存方式有何异同。

import copy

loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
epochs     = 40

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

best_acc = 0    # 设置一个最佳准确率，作为最佳模型的判别指标

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)
    
    # 保存最佳模型到 best_model
    if epoch_test_acc > best_acc:
        best_acc   = epoch_test_acc
        best_model = copy.deepcopy(model)
    
    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)
    
    # 获取当前的学习率
    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 = './best_model.pth'  # 保存的参数文件名
torch.save(model.state_dict(), PATH)

print('Done')

Epoch: 1, Train_acc:7.5%, Train_loss:2.880, Test_acc:8.1%, Test_loss:2.816, Lr:1.00E-04
Epoch: 2, Train_acc:8.7%, Train_loss:2.867, Test_acc:10.6%, Test_loss:2.782, Lr:1.00E-04

... 

Epoch:39, Train_acc:21.5%, Train_loss:2.360, Test_acc:21.9%, Test_loss:2.328, Lr:1.00E-04
Epoch:40, Train_acc:22.1%, Train_loss:2.340, Test_acc:22.5%, Test_loss:2.327, Lr:1.00E-04
Done

 训练比较久，十分建议用GPU。准确率22%左右。看来人脸识别部分的复杂度比其他的大不少。

四、 结果可视化

1. Loss与Accuracy图

和以前一样，加上。图放上面了。

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        #分辨率

epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

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

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

 2.指定图片进行预测

from PIL import Image
classes = list(total_data.class_to_idx)

def predict_one_image(image_path, model, transform, classes):
    test_img = Image.open(image_path).convert('RGB')
    plt.imshow(test_img)  # 展示预测的图片

    test_img = transform(test_img)
    img = test_img.to(device).unsqueeze(0)

    model.eval()
    output = model(img)

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

# 预测训练集中的某张照片
predict_one_image(image_path='./48-data/Jennifer Lawrence/001_21a7d5e6.jpg',
                  model=model,
                  transform=train_transforms,
                  classes=classes)

 输出：Jennifer Lawrence

3. 模型评估

以往都是看看最后几轮得到准确率，但是跳动比较大就不太好找准确率最高的一回，所以我们用函数返回进行比较。（输出见上面）

best_model.eval()
epoch_test_acc, epoch_test_loss = test(test_dl, best_model, loss_fn)
print(epoch_test_acc, epoch_test_loss)
print(epoch_test_acc)

*五、优化模型

1.前几次经验，把模型调成Adam的基础上，调整学习率和动态学习率

以下调用的官方动态学习率接口（上周内容也有提到）：

学习率有一开始的1e-4调整至1e-3，如果学习率太小，梯度下降的就很慢，我们稍微调大个十倍。但学习率也不能太大，梯度下降的步子过大可能会跨过最优值。

动态学习率也是用到上周提到的torch.optim.LambdaLR，调用自己定义的函数更新学习率（lr_lambda）

learn_rate = 1e-3 # 初始学习率
lambda1 = lambda epoch: 0.92 ** (epoch // 10)
optimizer = torch.optim.Adam(model.parameters(), lr=learn_rate)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1)

准确率到达45%左右，准确率有显著提高 

2.在调用VGG16部分，模型分类器引入BN层，并设置dropout比例为0.4

把 model.classifier._modules['6'] =.... 改为以下内容

model.classifier = nn.Sequential(
            # 14
            nn.Linear(25088, 1024),
            nn.BatchNorm1d(1024),
            # nn.ReLU(True),
            nn.Dropout(0.4),
            # 15
            nn.Linear(1024, 128),
            nn.BatchNorm1d(128),
            # nn.ReLU(True),
            nn.Dropout(0.4),
            # 16
            nn.Linear(128, len(classeNames)),
            nn.Softmax()
        )

 准确率上升，差不多55%了。但也没有上60% orz

六、参考

https://blog.csdn.net/weixin_56118617/article/details/127588915?spm=1001.2014.3001.5502