第P6周：VGG16-PyTorch人脸识别

zoey123456789

已于 2024-05-31 23:10:00 修改

阅读量688

点赞数 27

文章标签： pytorch 深度学习 python

于 2024-05-31 21:58:19 首次发布

本文链接：https://blog.csdn.net/zoey123456789/article/details/139362020

版权

第P6周：VGG16-PyTorch人脸识别

🍨 本文为🔗365天深度学习训练营中的学习记录博客
🍖 原作者：K同学啊

我的环境：

语言：python 3.10.12
编译器：Google Colab
深度学习环境：PyTorch
torch == 2.3.0+cu121
torchvision == 0.18.0+cu121
数据：和鲸

一、前期准备

1.设置GPU（无则用CPU）

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

warnings.filterwarnings("ignore") #忽略警告信息

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

device(type='cuda')

!nvidia-smi

    Wed May 29 14:47:12 2024       
    +---------------------------------------------------------------------------------------+
    | NVIDIA-SMI 535.104.05             Driver Version: 535.104.05   CUDA Version: 12.2     |
    |-----------------------------------------+----------------------+----------------------+
    | GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |
    | Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |
    |                                         |                      |               MIG M. |
    |=========================================+======================+======================|
    |   0  Tesla T4                       Off | 00000000:00:04.0 Off |                    0 |
    | N/A   41C    P8               9W /  70W |      3MiB / 15360MiB |      0%      Default |
    |                                         |                      |                  N/A |
    +-----------------------------------------+----------------------+----------------------+
                                                                                             
    +---------------------------------------------------------------------------------------+
    | Processes:                                                                            |
    |  GPU   GI   CI        PID   Type   Process name                            GPU Memory |
    |        ID   ID                                                             Usage      |
    |=======================================================================================|
    |  No running processes found                                                           |
    +---------------------------------------------------------------------------------------+

2.导入数据

from google.colab import drive
drive.mount("/content/drive/")

Mounted at /content/drive/

%cd "/content/drive/MyDrive/Colab Notebooks/jupyter notebook/data/P6"

/content/drive/Othercomputers/My laptop/jupyter notebook/data/P6

data_dir = './'
data_dir = pathlib.Path(data_dir)

data_paths  = list(data_dir.glob('*'))
ClassNames = [str(path).split("\\")[0] for path in data_paths]
ClassNames

  ['Brad Pitt',
     'Angelina Jolie',
     'Denzel Washington',
     'Jennifer Lawrence',
     'Hugh Jackman',
     'Johnny Depp',
     'Leonardo DiCaprio',
     'Kate Winslet',
     'Megan Fox',
     'Nicole Kidman',
     'Natalie Portman',
     'Robert Downey Jr',
     'Sandra Bullock',
     'Scarlett Johansson',
     'Tom Cruise',
     'Tom Hanks',
     'Will Smith']

# 关于transforms.Compose的更多介绍可以参考：https://blog.csdn.net/qq_38251616/article/details/124878863
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("./",transform = train_transforms)
total_data

    Dataset ImageFolder
        Number of datapoints: 1800
        Root location: ./
        StandardTransform
    Transform: Compose(
                   Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=True)
                   ToTensor()
                   Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
               )

total_data.class_to_idx

    {'Angelina Jolie': 0,
     'Brad Pitt': 1,
     'Denzel Washington': 2,
     'Hugh Jackman': 3,
     'Jennifer Lawrence': 4,
     'Johnny Depp': 5,
     'Kate Winslet': 6,
     'Leonardo DiCaprio': 7,
     'Megan Fox': 8,
     'Natalie Portman': 9,
     'Nicole Kidman': 10,
     'Robert Downey Jr': 11,
     'Sandra Bullock': 12,
     'Scarlett Johansson': 13,
     'Tom Cruise': 14,
     'Tom Hanks': 15,
     'Will Smith': 16}

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])
train_dataset, test_dataset

    (<torch.utils.data.dataset.Subset at 0x7d1f7a3ee980>,
     <torch.utils.data.dataset.Subset at 0x7d1f7a3eeef0>)

batch_size = 32

train_dl = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,
                     shuffle = True, num_workers = 1)
test_dl = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,
                    shuffle = True, num_workers = 1)

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模型

在这里插入图片描述

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

以下是VGG-16的主要特点：

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

VGG-16结构说明：

13个卷积层：分别用blockX_convX表示
3个全连接层：用classifier表示
5个池化层

from torchvision.models import vgg16

# 加载预训练模型，并且对模型进行微调
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(ClassNames)) # 修改vgg16模型中最后一层全连接层，输出目标类别个数
model.to(device)
model

    Downloading: "https://download.pytorch.org/models/vgg16-397923af.pth" to /root/.cache/torch/hub/checkpoints/vgg16-397923af.pth
    100%|██████████| 528M/528M [00:05<00:00, 105MB/s]


    VGG(
      (features): Sequential(
        (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (1): ReLU(inplace=True)
        (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (3): ReLU(inplace=True)
        (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
        (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (6): ReLU(inplace=True)
        (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (8): ReLU(inplace=True)
        (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
        (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (11): ReLU(inplace=True)
        (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (13): ReLU(inplace=True)
        (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (15): ReLU(inplace=True)
        (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
        (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (18): ReLU(inplace=True)
        (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (20): ReLU(inplace=True)
        (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (22): ReLU(inplace=True)
        (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
        (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (25): ReLU(inplace=True)
        (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (27): ReLU(inplace=True)
        (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (29): ReLU(inplace=True)
        (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
      )
      (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
      (classifier): Sequential(
        (0): Linear(in_features=25088, out_features=4096, bias=True)
        (1): ReLU(inplace=True)
        (2): Dropout(p=0.5, inplace=False)
        (3): Linear(in_features=4096, out_features=4096, bias=True)
        (4): ReLU(inplace=True)
        (5): Dropout(p=0.5, inplace=False)
        (6): Linear(in_features=4096, out_features=17, bias=True)
      )
    )

手动搭建VGG16

引自：https://blog.csdn.net/Galen_xia/article/details/115397608

from torchsummary import summary

class VGG16(nn.Module):
    def __init__(self, num_classes=10):
        super(VGG16, self).__init__()
        self.features = nn.Sequential(
            #1
            nn.Conv2d(3,64,kernel_size=3,padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            #2
            nn.Conv2d(64,96,kernel_size=3,padding=1),
            nn.BatchNorm2d(96),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            #3
            nn.Conv2d(96,128,kernel_size=3,padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(True),
            #4
            nn.Conv2d(128,128,kernel_size=3,padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            #5
            nn.Conv2d(128,256,kernel_size=3,padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            #6
            nn.Conv2d(256,256,kernel_size=3,padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            #7
            nn.Conv2d(256,256,kernel_size=3,padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            #8
            nn.Conv2d(256,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            #9
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            #10
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            #11
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            #12
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            #13
            nn.Conv2d(512,512,kernel_size=3,padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
            )
        self.avgpool = nn.AdaptiveAvgPool2d(output_size=7)

        self.classifier = nn.Sequential(
            #14
            nn.Linear(512*7*7,4096),
            nn.ReLU(True),
            nn.Dropout(),
            #15
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            #16
            nn.Linear(4096,len(ClassNames)),
            )


    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x


device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using {device} device")

model = VGG16().to(device)
summary(model,(3,224,224))

Using cuda device
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 224, 224]           1,792
       BatchNorm2d-2         [-1, 64, 224, 224]             128
              ReLU-3         [-1, 64, 224, 224]               0
            Conv2d-4         [-1, 96, 224, 224]          55,392
       BatchNorm2d-5         [-1, 96, 224, 224]             192
              ReLU-6         [-1, 96, 224, 224]               0
         MaxPool2d-7         [-1, 96, 112, 112]               0
            Conv2d-8        [-1, 128, 112, 112]         110,720
       BatchNorm2d-9        [-1, 128, 112, 112]             256
             ReLU-10        [-1, 128, 112, 112]               0
           Conv2d-11        [-1, 128, 112, 112]         147,584
      BatchNorm2d-12        [-1, 128, 112, 112]             256
             ReLU-13        [-1, 128, 112, 112]               0
        MaxPool2d-14          [-1, 128, 56, 56]               0
           Conv2d-15          [-1, 256, 56, 56]         295,168
      BatchNorm2d-16          [-1, 256, 56, 56]             512
             ReLU-17          [-1, 256, 56, 56]               0
           Conv2d-18          [-1, 256, 56, 56]         590,080
      BatchNorm2d-19          [-1, 256, 56, 56]             512
             ReLU-20          [-1, 256, 56, 56]               0
           Conv2d-21          [-1, 256, 56, 56]         590,080
      BatchNorm2d-22          [-1, 256, 56, 56]             512
             ReLU-23          [-1, 256, 56, 56]               0
        MaxPool2d-24          [-1, 256, 28, 28]               0
           Conv2d-25          [-1, 512, 28, 28]       1,180,160
      BatchNorm2d-26          [-1, 512, 28, 28]           1,024
             ReLU-27          [-1, 512, 28, 28]               0
           Conv2d-28          [-1, 512, 28, 28]       2,359,808
      BatchNorm2d-29          [-1, 512, 28, 28]           1,024
             ReLU-30          [-1, 512, 28, 28]               0
           Conv2d-31          [-1, 512, 28, 28]       2,359,808
      BatchNorm2d-32          [-1, 512, 28, 28]           1,024
             ReLU-33          [-1, 512, 28, 28]               0
        MaxPool2d-34          [-1, 512, 14, 14]               0
           Conv2d-35          [-1, 512, 14, 14]       2,359,808
      BatchNorm2d-36          [-1, 512, 14, 14]           1,024
             ReLU-37          [-1, 512, 14, 14]               0
           Conv2d-38          [-1, 512, 14, 14]       2,359,808
      BatchNorm2d-39          [-1, 512, 14, 14]           1,024
             ReLU-40          [-1, 512, 14, 14]               0
           Conv2d-41          [-1, 512, 14, 14]       2,359,808
      BatchNorm2d-42          [-1, 512, 14, 14]           1,024
             ReLU-43          [-1, 512, 14, 14]               0
        MaxPool2d-44            [-1, 512, 7, 7]               0
           Linear-45                 [-1, 4096]     102,764,544
             ReLU-46                 [-1, 4096]               0
          Dropout-47                 [-1, 4096]               0
           Linear-48                 [-1, 4096]      16,781,312
             ReLU-49                 [-1, 4096]               0
          Dropout-50                 [-1, 4096]               0
           Linear-51                   [-1, 17]          69,649
================================================================
Total params: 134,394,033
Trainable params: 134,394,033
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 361.75
Params size (MB): 512.67
Estimated Total Size (MB): 875.00
----------------------------------------------------------------

三、训练模型

1.编写训练函数

# 训练循环
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)  # 批次数目, (size/batch_size，向上取整)
  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.学习率设置

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

# 调用官方动态学习率接口时使用
lambda1 = lambda epoch: 0.92 ** (epoch // 4)
optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1) #选定调整方法

✨调用官方接口示例

仅为代码讲解示例，不是整体程序的一部分

model = [torch.nn.Parameter(torch.randn(2, 2, requires_grad=True))]
optimizer = SGD(model, 0.1)
scheduler = ExponentialLR(optimizer, gamma=0.9)

for epoch in range(20):
    for input, target in dataset:
        optimizer.zero_grad()
        output = model(input)
        loss = loss_fn(output, target)
        loss.backward()
        optimizer.step()
    scheduler.step()

更多的官方动态学习率设置方式可参考：https://pytorch.org/docs/stable/optim.html

4.正式训练

model.train()、model.eval()训练营往期文章中有详细的介绍。请注意观察我是如何保存最佳模型，与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:6.5%, Train_loss:2.909, Test_acc:8.1%, Test_loss:2.813, Lr:1.00E-04
    Epoch: 2, Train_acc:8.1%, Train_loss:2.890, Test_acc:10.6%, Test_loss:2.786, Lr:1.00E-04
    Epoch: 3, Train_acc:7.9%, Train_loss:2.849, Test_acc:12.2%, Test_loss:2.765, Lr:1.00E-04
    Epoch: 4, Train_acc:11.3%, Train_loss:2.800, Test_acc:14.4%, Test_loss:2.750, Lr:9.20E-05
    ... ...
    Epoch:36, Train_acc:20.6%, Train_loss:2.443, Test_acc:19.7%, Test_loss:2.458, Lr:4.72E-05
    Epoch:37, Train_acc:19.9%, Train_loss:2.452, Test_acc:19.7%, Test_loss:2.450, Lr:4.72E-05
    Epoch:38, Train_acc:20.1%, Train_loss:2.440, Test_acc:19.7%, Test_loss:2.459, Lr:4.72E-05
    Epoch:39, Train_acc:20.1%, Train_loss:2.440, Test_acc:19.7%, Test_loss:2.409, Lr:4.72E-05
    Epoch:40, Train_acc:19.7%, Train_loss:2.433, Test_acc:20.0%, Test_loss:2.440, Lr:4.34E-05
    Done

四、结果可视化

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='./Will Smith/095_8a2dfab4.jpg',
                  model=model,
                  transform=train_transforms,
                  classes=classes)

预测结果是：Robert Downey Jr

在这里插入图片描述

3.模型评估

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

epoch_test_acc, epoch_test_loss

(0.2, 2.4379698634147644)

# 查看是否与我们记录的最高准确率一致
epoch_test_acc

0.2

优化

利用手动搭建的VGG，并且调整了其中的部分卷积层，在每一层卷积操作后添加BatchNorm进行归一化；
尝试了不同的动态学习率方法和不同的初始学习率，发现原本的学习率即可
数据进行随机翻转处理；使用了64的batch size和50 epoch
训练结果如下：


Epoch: 1, Train_acc:7.6%, Train_loss:3.140, Test_acc:10.3%, Test_loss:2.846, Lr:1.00E-04
Epoch: 2, Train_acc:9.1%, Train_loss:2.903, Test_acc:10.6%, Test_loss:2.833, Lr:1.00E-04
Epoch: 3, Train_acc:11.7%, Train_loss:2.832, Test_acc:11.7%, Test_loss:2.801, Lr:1.00E-04
... ...
Epoch:38, Train_acc:93.3%, Train_loss:0.214, Test_acc:56.7%, Test_loss:1.706, Lr:4.72E-05
Epoch:39, Train_acc:95.5%, Train_loss:0.145, Test_acc:65.3%, Test_loss:1.296, Lr:4.72E-05
Epoch:40, Train_acc:97.1%, Train_loss:0.108, Test_acc:63.1%, Test_loss:1.708, Lr:4.34E-05
Epoch:41, Train_acc:97.2%, Train_loss:0.100, Test_acc:61.9%, Test_loss:1.788, Lr:4.34E-05
Epoch:42, Train_acc:96.9%, Train_loss:0.105, Test_acc:63.1%, Test_loss:1.544, Lr:4.34E-05
Epoch:43, Train_acc:97.9%, Train_loss:0.074, Test_acc:60.8%, Test_loss:1.947, Lr:4.34E-05
Epoch:44, Train_acc:98.3%, Train_loss:0.059, Test_acc:65.0%, Test_loss:1.540, Lr:4.00E-05
Epoch:45, Train_acc:99.0%, Train_loss:0.044, Test_acc:60.6%, Test_loss:1.825, Lr:4.00E-05
Epoch:46, Train_acc:98.9%, Train_loss:0.043, Test_acc:63.9%, Test_loss:1.804, Lr:4.00E-05
Epoch:47, Train_acc:99.2%, Train_loss:0.034, Test_acc:61.9%, Test_loss:1.751, Lr:4.00E-05
Epoch:48, Train_acc:99.4%, Train_loss:0.032, Test_acc:63.3%, Test_loss:1.648, Lr:3.68E-05
Epoch:49, Train_acc:99.7%, Train_loss:0.020, Test_acc:65.6%, Test_loss:1.573, Lr:3.68E-05
Epoch:50, Train_acc:99.9%, Train_loss:0.018, Test_acc:62.8%, Test_loss:1.821, Lr:3.68E-05
Done

在这里插入图片描述

 
  预测结果是：Johnny Depp

在这里插入图片描述

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


(0.6416666666666667, 1.6713581085205078)

总结

了解学习VGG16的模型结构，学习调用官方模型并通过修改最后全连接层来识别人脸图片（test acc为20%）
巩固学习动态学习率的设置
通过手动搭建VGG16模型，通过不断调整参数来提高测试正确率（也参考了各种VGG16相关的博文），最终训练准确率达到99%，测试准确率超过60%。

zoey123456789

关注

27
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
第P6周：VGG16-PyTorch人脸识别

了解学习VGG16的模型结构，学习调用官方模型并通过修改最后全连接层来识别人脸图片（test acc为20%）巩固学习动态学习率的设置通过手动搭建VGG16模型，通过不断调整参数来提高测试正确率（也参考了各种VGG16相关的博文），最终训练准确率达到99%，测试准确率超过60%。
复制链接

扫一扫