第P6周：好莱坞明星识别

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍦 参考文章：Pytorch实战 | 第P6周：好莱坞明星识别
• 🍖 原作者：K同学啊 | 接辅导、项目定制
• 🚀 文章来源：K同学的学习圈子

一、前期准备

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, warningswarnings.filterwarnings("ignore")   # 忽略警告信息device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)

执行结果：

cuda

2.导入数据

import os, PIL, random, pathlibdata_dir = pathlib.Path('./data/')data_paths = list(data_dir.glob('*'))
classNames = [str(path).split("\\")[1] for path in data_paths]
print(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]), # 将输入图片resize成统一尺寸transforms.RandomHorizontalFlip(),  # 随机水平翻转transforms.ToTensor(),  # 将PIL, Image 或numpy.ndarray转换成tensor， 并归一化transforms.Normalize(   # 标准化处理--> 转换成标准正太分布（高斯分布）， 使模型更容易收敛mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])
])total_data = datasets.ImageFolder("./data/", transform=train_transforms)
print(total_data)

执行结果：

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

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

执行结果：

batch_size = 32train_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=True)

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 vgg16device = "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(classNames))  # 修改vgg模型中的最后一层全连接层，输出目标类别个数model.classifier = nn.Sequential(nn.Linear(512*7*7, 1024),nn.BatchNorm1d(1024),nn.Dropout(0.4),nn.Linear(1024, 128),nn.BatchNorm1d(128),nn.Dropout(0.4),nn.Linear(128, len(classNames)),nn.Softmax())model.to(device)
print(model)

执行结果：

Using cuda device
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=1024, bias=True)(1): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)(2): Dropout(p=0.4, inplace=False)(3): Linear(in_features=1024, out_features=128, bias=True)(4): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)(5): Dropout(p=0.4, inplace=False)(6): Linear(in_features=128, out_features=17, bias=True)(7): Softmax(dim=None))
)

三、训练函数

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()         # 每一步自动更新# 记录acc与losstrain_acc += (pred.argmax(1) == y).type(torch.float).sum().item()train_loss += loss.item()train_acc /= size
train_loss /= num_batchesreturn 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)# 计算losstarget_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_batchesreturn test_acc, test_loss

3.设置动态学习率

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

4.正式训练

import copyloss_fn = nn.CrossEntropyLoss()  # 创建损失函数
epochs = 40train_loss = []
train_acc = []
test_loss = []
test_acc = []best_acc = 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_accbest_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:25.3%, Train_loss:2.701225, Test_acc:31.7%, Test_loss:2.652, lr:1.00E-03
Epoch: 2, Train_acc:45.8%, Train_loss:2.517270, Test_acc:42.5%, Test_loss:2.549, lr:1.00E-03
Epoch: 3, Train_acc:62.4%, Train_loss:2.376256, Test_acc:45.6%, Test_loss:2.513, lr:1.00E-03
Epoch: 4, Train_acc:73.0%, Train_loss:2.263205, Test_acc:49.4%, Test_loss:2.488, lr:9.20E-04
Epoch: 5, Train_acc:82.8%, Train_loss:2.171489, Test_acc:54.7%, Test_loss:2.445, lr:9.20E-04
Epoch: 6, Train_acc:86.6%, Train_loss:2.111034, Test_acc:54.4%, Test_loss:2.440, lr:9.20E-04
Epoch: 7, Train_acc:91.5%, Train_loss:2.060514, Test_acc:54.2%, Test_loss:2.439, lr:9.20E-04
Epoch: 8, Train_acc:94.3%, Train_loss:2.019957, Test_acc:58.1%, Test_loss:2.395, lr:8.46E-04
Epoch: 9, Train_acc:96.0%, Train_loss:1.991039, Test_acc:60.0%, Test_loss:2.376, lr:8.46E-04
Epoch:10, Train_acc:96.9%, Train_loss:1.979146, Test_acc:57.2%, Test_loss:2.388, lr:8.46E-04
Epoch:11, Train_acc:97.6%, Train_loss:1.969196, Test_acc:60.3%, Test_loss:2.380, lr:8.46E-04
Epoch:12, Train_acc:98.1%, Train_loss:1.962847, Test_acc:60.6%, Test_loss:2.370, lr:7.79E-04
Epoch:13, Train_acc:98.5%, Train_loss:1.952939, Test_acc:61.4%, Test_loss:2.377, lr:7.79E-04
Epoch:14, Train_acc:98.6%, Train_loss:1.950777, Test_acc:60.0%, Test_loss:2.383, lr:7.79E-04
Epoch:15, Train_acc:98.9%, Train_loss:1.946038, Test_acc:59.7%, Test_loss:2.367, lr:7.79E-04
Epoch:16, Train_acc:99.0%, Train_loss:1.946594, Test_acc:59.4%, Test_loss:2.400, lr:7.16E-04
Epoch:17, Train_acc:99.4%, Train_loss:1.940797, Test_acc:61.4%, Test_loss:2.384, lr:7.16E-04
Epoch:18, Train_acc:99.4%, Train_loss:1.940632, Test_acc:58.6%, Test_loss:2.381, lr:7.16E-04
Epoch:19, Train_acc:99.6%, Train_loss:1.938285, Test_acc:61.7%, Test_loss:2.360, lr:7.16E-04
Epoch:20, Train_acc:99.4%, Train_loss:1.938684, Test_acc:59.7%, Test_loss:2.360, lr:6.59E-04
Epoch:21, Train_acc:99.5%, Train_loss:1.938040, Test_acc:59.4%, Test_loss:2.361, lr:6.59E-04
Epoch:22, Train_acc:99.7%, Train_loss:1.936073, Test_acc:58.6%, Test_loss:2.365, lr:6.59E-04
Epoch:23, Train_acc:99.6%, Train_loss:1.936016, Test_acc:60.6%, Test_loss:2.354, lr:6.59E-04
Epoch:24, Train_acc:99.9%, Train_loss:1.934400, Test_acc:61.1%, Test_loss:2.347, lr:6.06E-04
Epoch:25, Train_acc:99.7%, Train_loss:1.934313, Test_acc:61.9%, Test_loss:2.344, lr:6.06E-04
Epoch:26, Train_acc:99.8%, Train_loss:1.933916, Test_acc:60.8%, Test_loss:2.364, lr:6.06E-04
Epoch:27, Train_acc:99.8%, Train_loss:1.933582, Test_acc:61.1%, Test_loss:2.356, lr:6.06E-04
Epoch:28, Train_acc:99.7%, Train_loss:1.934784, Test_acc:63.9%, Test_loss:2.352, lr:5.58E-04
Epoch:29, Train_acc:99.9%, Train_loss:1.932888, Test_acc:62.5%, Test_loss:2.339, lr:5.58E-04
Epoch:30, Train_acc:99.9%, Train_loss:1.932713, Test_acc:61.9%, Test_loss:2.343, lr:5.58E-04
Epoch:31, Train_acc:99.7%, Train_loss:1.934161, Test_acc:60.6%, Test_loss:2.342, lr:5.58E-04
Epoch:32, Train_acc:99.9%, Train_loss:1.931782, Test_acc:61.9%, Test_loss:2.350, lr:5.13E-04
Epoch:33, Train_acc:99.9%, Train_loss:1.930995, Test_acc:60.8%, Test_loss:2.342, lr:5.13E-04
Epoch:34, Train_acc:100.0%, Train_loss:1.930503, Test_acc:61.1%, Test_loss:2.342, lr:5.13E-04
Epoch:35, Train_acc:100.0%, Train_loss:1.930512, Test_acc:61.1%, Test_loss:2.349, lr:5.13E-04
Epoch:36, Train_acc:99.9%, Train_loss:1.931295, Test_acc:60.3%, Test_loss:2.363, lr:4.72E-04
Epoch:37, Train_acc:99.9%, Train_loss:1.931137, Test_acc:61.9%, Test_loss:2.365, lr:4.72E-04
Epoch:38, Train_acc:100.0%, Train_loss:1.930198, Test_acc:59.4%, Test_loss:2.370, lr:4.72E-04
Epoch:39, Train_acc:99.9%, Train_loss:1.930910, Test_acc:60.0%, Test_loss:2.354, lr:4.72E-04
Epoch:40, Train_acc:100.0%, Train_loss:1.930276, Test_acc:59.2%, Test_loss:2.358, lr:4.34E-04
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 Imageclasses = 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='./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)

执行结果：

0.6277777777777778 2.33515993754069
0.6277777777777778

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！