P6 VGG-16算法-Pytorch实现人脸识别

最新推荐文章于 2025-07-03 20:20:19 发布

原创最新推荐文章于 2025-07-03 20:20:19 发布 · 849 阅读

18 ·

CC 4.0 BY-SA版权

文章标签：

#pytorch #人工智能

部署运行你感兴趣的模型镜像

一、前期准备

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,warnings

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

device(type=‘cuda’)

2.导入数据

import os,PIL,random,pathlib

data_dir = r'D:\z_temp\data\48-data\48-data'
data_dir = pathlib.Path(data_dir)

data_paths = list(data_dir.glob('*'))
classNames = [str(path).split('\\')[5] for path in data_paths]
classNames

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

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(r'D:\z_temp\data\48-data\48-data',transform = train_transforms)
total_data

Dataset ImageFolder
Number of datapoints: 1800
Root location: D:\z_temp\data\48-data\48-data
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 0x1e38d321490>,
<torch.utils.data.dataset.Subset at 0x1e38d3217c0>)

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

from torchvision.models import vgg16
device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))

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)

for param in model.parameters():
    param.requires_grad = False
    
model.classifier._modules['6']= nn.Linear(4096,len(classNames))
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)   # 批次数目, (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.设置动态学习率

learn_rate = 1e-4 # 初始学习率
# 调用官方动态学习率接口时使用
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) #选定调整方法

4.正式训练

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

Epoch: 1, Train_acc:7.6%, Train_loss:2.899, Test_acc:11.1%, Test_loss:2.811, Lr:1.00E-04
Epoch: 2, Train_acc:8.3%, Train_loss:2.853, Test_acc:12.5%, Test_loss:2.789, Lr:1.00E-04
Epoch: 3, Train_acc:8.1%, Train_loss:2.843, Test_acc:14.2%, Test_loss:2.757, Lr:1.00E-04
Epoch: 4, Train_acc:11.0%, Train_loss:2.788, Test_acc:16.1%, Test_loss:2.723, Lr:9.20E-05
Epoch: 5, Train_acc:11.9%, Train_loss:2.775, Test_acc:16.1%, Test_loss:2.707, Lr:9.20E-05
Epoch: 6, Train_acc:11.7%, Train_loss:2.748, Test_acc:16.1%, Test_loss:2.687, Lr:9.20E-05
Epoch: 7, Train_acc:13.2%, Train_loss:2.734, Test_acc:16.4%, Test_loss:2.653, Lr:9.20E-05
Epoch: 8, Train_acc:13.5%, Train_loss:2.703, Test_acc:16.7%, Test_loss:2.661, Lr:8.46E-05
Epoch: 9, Train_acc:14.7%, Train_loss:2.698, Test_acc:16.7%, Test_loss:2.655, Lr:8.46E-05
Epoch:10, Train_acc:15.6%, Train_loss:2.681, Test_acc:15.3%, Test_loss:2.621, Lr:8.46E-05
Epoch:11, Train_acc:15.4%, Train_loss:2.654, Test_acc:15.6%, Test_loss:2.613, Lr:8.46E-05
Epoch:12, Train_acc:14.5%, Train_loss:2.664, Test_acc:16.1%, Test_loss:2.604, Lr:7.79E-05
Epoch:13, Train_acc:15.0%, Train_loss:2.647, Test_acc:16.1%, Test_loss:2.596, Lr:7.79E-05
Epoch:14, Train_acc:15.8%, Train_loss:2.622, Test_acc:16.4%, Test_loss:2.566, Lr:7.79E-05
Epoch:15, Train_acc:16.2%, Train_loss:2.609, Test_acc:16.9%, Test_loss:2.550, Lr:7.79E-05
Epoch:16, Train_acc:15.9%, Train_loss:2.605, Test_acc:16.9%, Test_loss:2.558, Lr:7.16E-05
Epoch:17, Train_acc:18.2%, Train_loss:2.585, Test_acc:17.2%, Test_loss:2.564, Lr:7.16E-05
Epoch:18, Train_acc:17.0%, Train_loss:2.571, Test_acc:16.9%, Test_loss:2.550, Lr:7.16E-05
Epoch:19, Train_acc:16.7%, Train_loss:2.576, Test_acc:16.7%, Test_loss:2.540, Lr:7.16E-05
Epoch:20, Train_acc:18.3%, Train_loss:2.571, Test_acc:16.7%, Test_loss:2.514, Lr:6.59E-05
Epoch:21, Train_acc:18.6%, Train_loss:2.539, Test_acc:16.7%, Test_loss:2.526, Lr:6.59E-05
Epoch:22, Train_acc:17.8%, Train_loss:2.565, Test_acc:16.9%, Test_loss:2.517, Lr:6.59E-05
Epoch:23, Train_acc:17.5%, Train_loss:2.536, Test_acc:16.9%, Test_loss:2.498, Lr:6.59E-05
Epoch:24, Train_acc:16.5%, Train_loss:2.531, Test_acc:16.7%, Test_loss:2.517, Lr:6.06E-05
Epoch:25, Train_acc:18.2%, Train_loss:2.517, Test_acc:16.7%, Test_loss:2.499, Lr:6.06E-05
Epoch:26, Train_acc:18.8%, Train_loss:2.489, Test_acc:16.7%, Test_loss:2.476, Lr:6.06E-05
Epoch:27, Train_acc:18.0%, Train_loss:2.509, Test_acc:16.9%, Test_loss:2.472, Lr:6.06E-05
Epoch:28, Train_acc:18.5%, Train_loss:2.499, Test_acc:16.9%, Test_loss:2.460, Lr:5.58E-05
Epoch:29, Train_acc:19.3%, Train_loss:2.490, Test_acc:17.2%, Test_loss:2.484, Lr:5.58E-05
Epoch:30, Train_acc:17.6%, Train_loss:2.509, Test_acc:17.2%, Test_loss:2.470, Lr:5.58E-05
Epoch:31, Train_acc:18.7%, Train_loss:2.481, Test_acc:17.2%, Test_loss:2.443, Lr:5.58E-05
Epoch:32, Train_acc:19.6%, Train_loss:2.475, Test_acc:17.2%, Test_loss:2.455, Lr:5.13E-05
Epoch:33, Train_acc:17.5%, Train_loss:2.477, Test_acc:17.2%, Test_loss:2.447, Lr:5.13E-05
Epoch:34, Train_acc:18.2%, Train_loss:2.472, Test_acc:17.5%, Test_loss:2.441, Lr:5.13E-05
Epoch:35, Train_acc:19.2%, Train_loss:2.470, Test_acc:17.8%, Test_loss:2.450, Lr:5.13E-05
Epoch:36, Train_acc:18.8%, Train_loss:2.457, Test_acc:18.1%, Test_loss:2.447, Lr:4.72E-05
Epoch:37, Train_acc:19.0%, Train_loss:2.461, Test_acc:18.3%, Test_loss:2.444, Lr:4.72E-05
Epoch:38, Train_acc:19.3%, Train_loss:2.436, Test_acc:18.3%, Test_loss:2.400, Lr:4.72E-05
Epoch:39, Train_acc:18.9%, Train_loss:2.436, Test_acc:18.3%, Test_loss:2.429, Lr:4.72E-05
Epoch:40, Train_acc:19.4%, Train_loss:2.438, Test_acc:18.6%, Test_loss:2.432, Lr:4.34E-05

# 保存最佳模型到文件中
PATH = r'D:\z_temp\data\P6_model.pth'  # 保存的参数文件名
torch.save(model.state_dict(), PATH)

print('Done')

四、结果可视化

1.lcc与acc图

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

from datetime import datetime
current_time = datetime.now() # 获取当前时间

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.xlabel(current_time) # 打卡请带上时间戳，否则代码截图无效

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 = classe![请添加图片描述](https://i-blog.csdnimg.cn/direct/6a346d33e94a41dabf62ce11e0649598.png)
s[pred]
    print(f'预测结果是：{pred_class}')

预测结果是：Scarlett Johansson

在这里插入图片描述

3.模型评估

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

epoch_test_acc, epoch_test_loss

(0.18611111111111112, 2.428501307964325)

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

0.18611111111111112

您可能感兴趣的与本文相关的镜像

PyTorch 2.5

PyTorch

Cuda

PyTorch 是一个开源的 Python 机器学习库，基于 Torch 库，底层由 C++ 实现，应用于人工智能领域，如计算机视觉和自然语言处理