深度学习笔记06-VGG16-Pytorch实现人脸识别

本文通过调用预训练模型VGG16并进行模型微调，从而实现人脸识别。

---

前言

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊
  环境：PyTorch:2.1.2 Python:3.10(ubuntu22.04) Cuda:11.8 显卡:RTX 3090 * 1

---

一、加载数据

1. 导入库

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

warnings.filterwarnings("ignore")

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

2. 导入数据

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

data_paths = list(data_dir.glob('*'))
classNames = [str(path).split('/')[-1] for path in data_paths]
classNames

• 注意：如果是windows系统，classNames = [str(path).split(‘\\’)[-1] for path in data_paths]
  

3. 定义transforms

train_transforms = transforms.Compose([
    transforms.Resize((224,224)),
    # transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
total_data = datasets.ImageFolder(root=data_dir,transform=train_transforms)
total_data

本次自定义的transforms方法比较简单，先将照片resize成224 * 224，再转化成tensor，最后进行正则化。

数据集共有1800张照片

4. 查看类别

total_data.class_to_idx

• 可以看到，数据集是由安吉丽娜朱莉、布拉德皮特等17个好莱坞影星组成的照片集，即样本共有17个类别。

5. 划分数据集

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

• 使用torch.utils.data.random_split函数将数据集按照8：2的比例划分为训练集和测试集。

6. 加载数据

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=False)

batchsize设为32

二、调用VGG16

VGG-16（Visual Geometry Group-16）是由牛津大学视觉几何组（Visual Geometry Group）提出的一种深度卷积神经网络架构，用于图像分类和对象识别任务。VGG-16在2014年被提出，是VGG系列中的一种。VGG-16之所以备受关注，是因为它在ImageNet图像识别竞赛中取得了很好的成绩，展示了其在大规模图像识别任务中的有效性。
以下是VGG-16的主要特点：

1. 深度：VGG-16由16个卷积层和3个全连接层组成，因此具有相对较深的网络结构。这种深度有助于网络学习到更加抽象和复杂的特征。
2. 卷积层的设计：VGG-16的卷积层全部采用3x3的卷积核和步长为1的卷积操作，同时在卷积层之后都接有ReLU激活函数。这种设计的好处在于，通过堆叠多个较小的卷积核，可以提高网络的非线性建模能力，同时减少了参数数量，从而降低了过拟合的风险。
3. 池化层：在卷积层之后，VGG-16使用最大池化层来减少特征图的空间尺寸，帮助提取更加显著的特征并减少计算量。
4. 全连接层：VGG-16在卷积层之后接有3个全连接层，最后一个全连接层输出与类别数相对应的向量，用于进行分类。

1. 加载预训练模型

from torchvision.models import vgg16

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

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

1. 从torchvision.models直接导入vgg16模型
2. pretrained=True，使用预训练模型
3. 然后冻结模型的参数，使得模型在训练时只训练最后一层参数

2. 模型微调

先打印原始模型

• 模型最后一层全连接层的输出特征数是1000， 但是我们的数据集只有17，为此可以将模型最后一层全连接层输出特征数改为17，即分类类别数。

# 修改classifier模块的第6层, 修改vgg模型中最后一层全连接层，输出目标类别个数
model.classifier._modules['6'] = nn.Linear(4096, len(classNames))
model.to(device)
model

• 可以通过修改classifier模块的第6层来实现
  
  
  
  model.classifier[6]与model.classifier._modules['6']相同，因此两种写法都可以。

最后打印微调后的模型查看：

三、训练模型

1. 训练函数

def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset) # 训练集大小
    num_batches = len(dataloader) # 批次大小
    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()
        loss.backward()
        optimizer.step()

        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 x, y in dataloader:
            x, y = x.to(device), y.to(device)
            pred = model(x)
            loss = loss_fn(pred, y)

            test_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
            test_loss += loss.item()

    test_acc /= size
    test_loss /= num_batches

    return test_acc, test_loss

3. 动态学习率设置

lambda1 = lambda epoch: 0.92 * (epoch // 4)
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=5e-4)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1)

在pytorch中，优化器的状态字典(optimizer.state_dict())包含一个名为param_groups的列表.这个列表中的每个元素都是一个字典，描述了一个参数组的设置，通常情况下，优化器可以处理多个参数组，但在大多数简单的情况下，只使用一个参数组。
param_groups = [
{
‘lr’: 0.001,
‘momentum’: 0.9, 动量
‘params’: […] 改组的参数
}
]

• 在这个结构中，param_groups是一个列表，列表中的每个字典代表一个参数组。因为我们通常只使用一个参数组，所以我们可以通过索引[0]来访问第一个（也是唯一的）参数组。
  因此，使用[‘0’]是为了获取第一个参数组的学习率。即使在有多个参数组的情况下，使用[0]也可以确保我们获取到第一个参数组的学习率，这在大多数情况下是足够的。如果你有多个参数组并且想要获取特定组的学习率，可以通过相应的索引来访问。

4. 主循环

import copy

loss_fn = nn.CrossEntropyLoss()
epochs = 50

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

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

for epoch in range(epochs):
    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}%, 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(best_model.state_dict(), PATH)
print('Done!')

• 将最佳准确率初始化为0.0
• 在每个epoch中模型训练完后，进行scheduler的更新。
• 将每个epoch的验证集的准确率与当前best_acc比较，如果优于best_acc，那么将epoch_best_epoch更新为best_acc，然后通过copy.deepcopy(model)将具有最佳验证集准确率的最优模型存储到best_model中。
• 并且最后保存最佳模型，通过torch.save(best_model.state_dict(),PATH)

5. 可视化

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

四、预测

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, dim=1)
    pred_class = classes[pred]
    print(f'预测结果是:{pred_class}')

# 预测训练集中的某张照片
predict_one_image(image_path='./6-data/Angelina Jolie/001_fe3347c0.jpg', 
                  model=model, 
                  transform=train_transforms, 
                  classes=classes)

五、模型评估

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

• 打印最优模型测试集准确率
  
  最后查看是否与记录最高准确率一致。

---

总结

• 本文调用了官方的VGG16模型的框架，使用预训练模型，并且对模型的最后全连接层进行修改，进行模型微调，使得模型可用。
• 将模型在每个epoch测试集中的最优准确率记录，最后保存了训练过程中的最佳模型权重。
• 使用了动态学习率
• 由于在50轮训练后，模型在测试集上的准确率仍然不到50%，这意味着模型有着巨大的提升空间。
• 下次考虑复现VGG16框架，并不断提升模型在测试集的准确率，提高模型的泛化能力。