深度学习 06 — VGG 算法 PyToch 实现人脸识别

TOMWilliamLIN

已于 2024-04-18 21:51:19 修改

阅读量562

点赞数 22

分类专栏：深度学习文章标签：深度学习人工智能

于 2024-04-18 21:49:06 首次发布

本文链接：https://blog.csdn.net/TOMWilliamLIN/article/details/137821317

版权

深度学习专栏收录该内容

11 篇文章 1 订阅

订阅专栏

🍨 本文为[🔗365天深度学习训练营]中的学习记录博客

🍖 原作者：[K同学啊]

一、前期准备

1. 设置GPU

如果设备上支持GPU就使用GPU,否则使用CPU

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

import torchvision.transforms as transforms

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

2.导入数据

import os, pathlib, warnings, random

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

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

train_transforms = 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",transform=train_transforms)
total_data

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

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

二、调用官方的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个卷积层（Convolutional Layer），分别用blockX_convX表示；
3个全连接层（Fully connected Layer），用classifier表示；
5个池化层（Pool layer）。

VGG-16包含了16个隐藏层（13个卷积层和3个全连接层），故称为VGG-16

from torchvision.models import vgg16

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

print(f'Using {device} 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)
model

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

三、训练模型

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()#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 imgs, target in dataloader:
            imgs, target = imgs.to(device),target.to(device)
            
            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):
    lr = start_lr* (0.92 ** (epoch//2))
    for param_group in optimizer.param_groups:
        param_group["lr"] = lr

start_lr = 1e-4
optimizer = torch.optim.SGD(model.parameters(),lr=start_lr)

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

4.正式训练

import copy

loss_fn = nn.CrossEntropyLoss()

epochs = 40

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

best_acc = 0
for epoch in range(epochs):
    adjust_learning_rate(optimizer,epoch,start_lr)

    model.train()

    epoch_train_acc, epoch_train_loss = train(train_dl,model,loss_fn,optimizer)

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

print('Done')

Epoch: 1, Train_acc:6.7%, Train_loss:2.916, Test_acc:6.7%, Test_loss:2.853, Lr:1.00E-04
Epoch: 2, Train_acc:7.6%, Train_loss:2.879, Test_acc:7.8%, Test_loss:2.816, Lr:1.00E-04
Epoch: 3, Train_acc:8.7%, Train_loss:2.854, Test_acc:10.6%, Test_loss:2.790, Lr:9.20E-05
Epoch: 4, Train_acc:8.3%, Train_loss:2.839, Test_acc:12.5%, Test_loss:2.770, Lr:9.20E-05
Epoch: 5, Train_acc:10.4%, Train_loss:2.802, Test_acc:13.3%, Test_loss:2.740, Lr:8.46E-05
Epoch: 6, Train_acc:11.2%, Train_loss:2.764, Test_acc:14.2%, Test_loss:2.724, Lr:8.46E-05
Epoch: 7, Train_acc:10.8%, Train_loss:2.759, Test_acc:14.2%, Test_loss:2.707, Lr:7.79E-05
Epoch: 8, Train_acc:12.1%, Train_loss:2.765, Test_acc:13.1%, Test_loss:2.690, Lr:7.79E-05
Epoch: 9, Train_acc:13.5%, Train_loss:2.728, Test_acc:13.6%, Test_loss:2.681, Lr:7.16E-05
Epoch:10, Train_acc:13.5%, Train_loss:2.707, Test_acc:14.4%, Test_loss:2.672, Lr:7.16E-05
Epoch:11, Train_acc:13.7%, Train_loss:2.698, Test_acc:14.4%, Test_loss:2.663, Lr:6.59E-05
Epoch:12, Train_acc:12.8%, Train_loss:2.696, Test_acc:14.7%, Test_loss:2.654, Lr:6.59E-05
Epoch:13, Train_acc:14.0%, Train_loss:2.696, Test_acc:15.0%, Test_loss:2.648, Lr:6.06E-05
Epoch:14, Train_acc:14.4%, Train_loss:2.656, Test_acc:15.0%, Test_loss:2.631, Lr:6.06E-05
Epoch:15, Train_acc:14.7%, Train_loss:2.659, Test_acc:15.6%, Test_loss:2.627, Lr:5.58E-05
Epoch:16, Train_acc:13.8%, Train_loss:2.648, Test_acc:15.3%, Test_loss:2.598, Lr:5.58E-05
Epoch:17, Train_acc:14.4%, Train_loss:2.640, Test_acc:15.3%, Test_loss:2.603, Lr:5.13E-05
Epoch:18, Train_acc:14.9%, Train_loss:2.620, Test_acc:15.3%, Test_loss:2.599, Lr:5.13E-05
Epoch:19, Train_acc:15.2%, Train_loss:2.615, Test_acc:15.3%, Test_loss:2.593, Lr:4.72E-05
Epoch:20, Train_acc:16.0%, Train_loss:2.600, Test_acc:15.3%, Test_loss:2.594, Lr:4.72E-05
Epoch:21, Train_acc:15.6%, Train_loss:2.621, Test_acc:15.3%, Test_loss:2.584, Lr:4.34E-05
Epoch:22, Train_acc:14.1%, Train_loss:2.609, Test_acc:15.3%, Test_loss:2.586, Lr:4.34E-05
Epoch:23, Train_acc:15.3%, Train_loss:2.597, Test_acc:15.3%, Test_loss:2.584, Lr:4.00E-05
Epoch:24, Train_acc:16.7%, Train_loss:2.591, Test_acc:15.3%, Test_loss:2.571, Lr:4.00E-05
Epoch:25, Train_acc:16.9%, Train_loss:2.593, Test_acc:15.3%, Test_loss:2.557, Lr:3.68E-05
Epoch:26, Train_acc:15.6%, Train_loss:2.596, Test_acc:15.6%, Test_loss:2.561, Lr:3.68E-05
Epoch:27, Train_acc:15.6%, Train_loss:2.596, Test_acc:15.6%, Test_loss:2.570, Lr:3.38E-05
Epoch:28, Train_acc:16.0%, Train_loss:2.574, Test_acc:15.6%, Test_loss:2.558, Lr:3.38E-05
Epoch:29, Train_acc:17.2%, Train_loss:2.557, Test_acc:15.6%, Test_loss:2.543, Lr:3.11E-05
Epoch:30, Train_acc:18.1%, Train_loss:2.555, Test_acc:15.6%, Test_loss:2.550, Lr:3.11E-05
Epoch:31, Train_acc:17.5%, Train_loss:2.550, Test_acc:15.8%, Test_loss:2.538, Lr:2.86E-05
Epoch:32, Train_acc:17.6%, Train_loss:2.554, Test_acc:15.8%, Test_loss:2.530, Lr:2.86E-05
Epoch:33, Train_acc:17.4%, Train_loss:2.543, Test_acc:15.8%, Test_loss:2.536, Lr:2.63E-05
Epoch:34, Train_acc:18.1%, Train_loss:2.549, Test_acc:15.8%, Test_loss:2.531, Lr:2.63E-05
Epoch:35, Train_acc:15.9%, Train_loss:2.553, Test_acc:15.8%, Test_loss:2.515, Lr:2.42E-05
Epoch:36, Train_acc:16.9%, Train_loss:2.547, Test_acc:16.1%, Test_loss:2.524, Lr:2.42E-05
Epoch:37, Train_acc:16.7%, Train_loss:2.548, Test_acc:15.8%, Test_loss:2.516, Lr:2.23E-05
Epoch:38, Train_acc:17.6%, Train_loss:2.537, Test_acc:16.1%, Test_loss:2.524, Lr:2.23E-05
Epoch:39, Train_acc:17.7%, Train_loss:2.527, Test_acc:16.1%, Test_loss:2.517, Lr:2.05E-05
Epoch:40, Train_acc:16.4%, Train_loss:2.534, Test_acc:16.1%, Test_loss:2.514, Lr:2.05E-05

四、结果可视化

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 Accuracy')
plt.plot(epochs_range,test_loss,label='Test Accuracy')
plt.legend(loc='lower 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_image = Image.open(image_path).convert('RGB')

   
    plt.show(test_image)
    test_image = transform(test_image)
    img = test_image.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='./data/Angelina Jolie/001_fe3347c0.jpg',model=model,transform=train_transforms,classes=classes)

3.模型评估

五、个人总结

在本次实战中，主要学习Vgg16 网络结构的组成部分以及网络参数，但是在整个训练的过程中，模型表现的不是很好最高的test_acc 在16.1%以至于在指定预测图片时预测失败。

更改参数将优化器SGD更改为Adam 再次训练下面是训练过程中变化

预测结果：Angelina Jolie

在更改完优化器之后，模型的表现有了很大进步test_acc最高达到了41.1%指定但还没有达到实战测试集准确率的要求

更改初始学习率为1.5 并增加epoch 次数

        Epoch: 1, Train_acc:20.9%, Train_loss:575.922, Test_acc:28.3%, Test_loss:365.763, Lr:1.50E+00
		Epoch: 2, Train_acc:34.3%, Train_loss:467.888, Test_acc:26.4%, Test_loss:401.650, Lr:1.50E+00
		Epoch: 3, Train_acc:41.7%, Train_loss:431.524, Test_acc:38.6%, Test_loss:325.496, Lr:1.38E+00
		Epoch: 4, Train_acc:41.7%, Train_loss:446.953, Test_acc:33.3%, Test_loss:496.364, Lr:1.38E+00
		Epoch: 5, Train_acc:48.4%, Train_loss:399.028, Test_acc:37.5%, Test_loss:407.026, Lr:1.27E+00
		Epoch: 6, Train_acc:52.4%, Train_loss:388.247, Test_acc:42.2%, Test_loss:378.893, Lr:1.27E+00
		Epoch: 7, Train_acc:52.4%, Train_loss:377.559, Test_acc:40.0%, Test_loss:401.215, Lr:1.17E+00
		Epoch: 8, Train_acc:53.4%, Train_loss:368.183, Test_acc:40.8%, Test_loss:384.509, Lr:1.17E+00
		Epoch: 9, Train_acc:53.4%, Train_loss:365.307, Test_acc:42.8%, Test_loss:396.013, Lr:1.07E+00
		Epoch:10, Train_acc:55.2%, Train_loss:350.748, Test_acc:41.4%, Test_loss:428.332, Lr:1.07E+00
		Epoch:11, Train_acc:58.3%, Train_loss:344.587, Test_acc:41.1%, Test_loss:467.244, Lr:9.89E-01
		Epoch:12, Train_acc:59.0%, Train_loss:325.402, Test_acc:41.4%, Test_loss:416.905, Lr:9.89E-01
		Epoch:13, Train_acc:59.6%, Train_loss:330.772, Test_acc:42.2%, Test_loss:478.612, Lr:9.10E-01
		Epoch:14, Train_acc:60.0%, Train_loss:331.145, Test_acc:41.1%, Test_loss:455.810, Lr:9.10E-01
		Epoch:15, Train_acc:64.0%, Train_loss:256.217, Test_acc:44.2%, Test_loss:483.922, Lr:8.37E-01
		Epoch:16, Train_acc:62.4%, Train_loss:285.570, Test_acc:48.1%, Test_loss:420.824, Lr:8.37E-01
		Epoch:17, Train_acc:64.7%, Train_loss:265.459, Test_acc:45.0%, Test_loss:440.225, Lr:7.70E-01
		Epoch:18, Train_acc:66.5%, Train_loss:255.883, Test_acc:43.3%, Test_loss:496.751, Lr:7.70E-01
		Epoch:19, Train_acc:64.9%, Train_loss:262.010, Test_acc:43.9%, Test_loss:457.924, Lr:7.08E-01
		Epoch:20, Train_acc:66.0%, Train_loss:250.392, Test_acc:42.5%, Test_loss:520.675, Lr:7.08E-01
		Epoch:21, Train_acc:66.9%, Train_loss:244.626, Test_acc:43.9%, Test_loss:446.395, Lr:6.52E-01
		Epoch:22, Train_acc:67.4%, Train_loss:237.543, Test_acc:45.3%, Test_loss:439.068, Lr:6.52E-01
		Epoch:23, Train_acc:67.9%, Train_loss:233.148, Test_acc:44.4%, Test_loss:464.862, Lr:5.99E-01
		Epoch:24, Train_acc:67.2%, Train_loss:249.844, Test_acc:46.7%, Test_loss:469.783, Lr:5.99E-01
		Epoch:25, Train_acc:71.7%, Train_loss:206.887, Test_acc:46.9%, Test_loss:473.792, Lr:5.51E-01
		Epoch:26, Train_acc:70.9%, Train_loss:207.709, Test_acc:43.9%, Test_loss:432.867, Lr:5.51E-01
		Epoch:27, Train_acc:71.2%, Train_loss:195.462, Test_acc:46.7%, Test_loss:456.010, Lr:5.07E-01
		Epoch:28, Train_acc:71.8%, Train_loss:192.576, Test_acc:45.8%, Test_loss:464.668, Lr:5.07E-01
		Epoch:29, Train_acc:71.9%, Train_loss:176.019, Test_acc:50.3%, Test_loss:409.153, Lr:4.67E-01
		Epoch:30, Train_acc:72.0%, Train_loss:196.592, Test_acc:48.3%, Test_loss:425.270, Lr:4.67E-01
		Epoch:31, Train_acc:71.4%, Train_loss:182.458, Test_acc:47.5%, Test_loss:426.613, Lr:4.29E-01
		Epoch:32, Train_acc:72.0%, Train_loss:172.622, Test_acc:49.2%, Test_loss:421.888, Lr:4.29E-01
		Epoch:33, Train_acc:73.6%, Train_loss:175.606, Test_acc:46.7%, Test_loss:414.485, Lr:3.95E-01
		Epoch:34, Train_acc:74.2%, Train_loss:167.895, Test_acc:46.4%, Test_loss:408.843, Lr:3.95E-01
		Epoch:35, Train_acc:75.8%, Train_loss:148.233, Test_acc:47.2%, Test_loss:443.957, Lr:3.63E-01
		Epoch:36, Train_acc:73.6%, Train_loss:166.622, Test_acc:46.9%, Test_loss:437.096, Lr:3.63E-01
		Epoch:37, Train_acc:74.4%, Train_loss:160.391, Test_acc:46.7%, Test_loss:424.060, Lr:3.34E-01
		Epoch:38, Train_acc:73.0%, Train_loss:181.560, Test_acc:47.5%, Test_loss:408.414, Lr:3.34E-01
		Epoch:39, Train_acc:74.9%, Train_loss:162.634, Test_acc:51.4%, Test_loss:408.263, Lr:3.08E-01
		Epoch:40, Train_acc:74.9%, Train_loss:155.642, Test_acc:48.9%, Test_loss:420.067, Lr:3.08E-01
		Epoch:41, Train_acc:76.7%, Train_loss:142.470, Test_acc:48.1%, Test_loss:422.047, Lr:2.83E-01
		Epoch:42, Train_acc:74.9%, Train_loss:148.504, Test_acc:46.9%, Test_loss:400.454, Lr:2.83E-01
		Epoch:43, Train_acc:76.8%, Train_loss:133.604, Test_acc:46.9%, Test_loss:451.091, Lr:2.60E-01
		Epoch:44, Train_acc:75.6%, Train_loss:151.245, Test_acc:46.7%, Test_loss:393.242, Lr:2.60E-01
		Epoch:45, Train_acc:76.0%, Train_loss:134.574, Test_acc:48.1%, Test_loss:365.224, Lr:2.40E-01
		Epoch:46, Train_acc:77.2%, Train_loss:144.469, Test_acc:49.7%, Test_loss:386.555, Lr:2.40E-01
		Epoch:47, Train_acc:76.9%, Train_loss:137.106, Test_acc:47.2%, Test_loss:391.518, Lr:2.20E-01
		Epoch:48, Train_acc:76.5%, Train_loss:135.680, Test_acc:49.4%, Test_loss:376.219, Lr:2.20E-01
		Epoch:49, Train_acc:77.4%, Train_loss:127.854, Test_acc:48.3%, Test_loss:371.291, Lr:2.03E-01
		Epoch:50, Train_acc:79.4%, Train_loss:119.382, Test_acc:47.8%, Test_loss:404.348, Lr:2.03E-01
		Epoch:51, Train_acc:78.3%, Train_loss:119.582, Test_acc:48.3%, Test_loss:405.559, Lr:1.87E-01
		Epoch:52, Train_acc:77.5%, Train_loss:120.911, Test_acc:46.7%, Test_loss:392.094, Lr:1.87E-01
		Epoch:53, Train_acc:79.4%, Train_loss:106.500, Test_acc:47.8%, Test_loss:413.349, Lr:1.72E-01
		Epoch:54, Train_acc:76.0%, Train_loss:123.710, Test_acc:49.7%, Test_loss:425.194, Lr:1.72E-01
		Epoch:55, Train_acc:77.4%, Train_loss:125.460, Test_acc:49.2%, Test_loss:391.667, Lr:1.58E-01
		Epoch:56, Train_acc:78.9%, Train_loss:112.271, Test_acc:49.2%, Test_loss:385.217, Lr:1.58E-01
		Epoch:57, Train_acc:78.4%, Train_loss:120.161, Test_acc:49.7%, Test_loss:377.026, Lr:1.45E-01
		Epoch:58, Train_acc:79.0%, Train_loss:99.286, Test_acc:46.9%, Test_loss:409.233, Lr:1.45E-01
		Epoch:59, Train_acc:81.2%, Train_loss:98.583, Test_acc:49.2%, Test_loss:396.102, Lr:1.34E-01
		Epoch:60, Train_acc:78.8%, Train_loss:111.317, Test_acc:50.3%, Test_loss:378.100, Lr:1.34E-01
		Done

在最后一次调参中，虽然模型表现又有了进步，但是将初始学习率是不推荐的因为这会导致

梯度爆炸：更新的步长太大，参数可能会越过最优点，导致损失函数值迅速增加。
训练不稳定：模型的权重更新过大，可能在潜在的最小值附近震荡，无法收敛到最小值点。
收敛失败：模型完全无法收敛到合理的解。

继续更改学习率为1e-3并将动态学习率衰减频率改为每四个epoch下降一次，test_acc最高达到了54.2%

本次实战经过多次尝试都没有达到预期准确度，但还是有其他方法可以提高准确度比如在Vgg 模型里添加注意力机制来提高准确度

TOMWilliamLIN

关注

22
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
深度学习 06 — VGG 算法 PyToch 实现人脸识别

在本次实战中，主要学习Vgg16 网络结构的组成部分以及网络参数，但是在整个训练的过程中，模型表现的不是很好最高的test_acc 在16.1%以至于在指定预测图片时预测失败。更改参数将优化器SGD更改为Adam 再次训练下面是训练过程中变化预测结果：Angelina Jolie在更改完优化器之后，模型的表现有了很大进步test_acc最高达到了41.1%指定但还没有达到实战测试集准确率的要求更改初始学习率为1.5 并增加epoch 次数Done。
复制链接

扫一扫