>- **🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/0dvHCaOoFnW8SCp3JpzKxg) 中的学习记录博客**
>- **🍖 原作者:[K同学啊](https://mtyjkh.blog.csdn.net/)**
前期准备
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import warnings
import os
from PIL import Image
import matplotlib.pyplot as plt
from pathlib import Path
warnings.filterwarnings("ignore") #忽略警告信息
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device
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
输出
['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']
输出点图片看看情况
subfolder = Path(data_dir)/"Brad Pitt"
image_files = list(p.resolve() for p in subfolder.glob('*') if p.suffix in [".jpg", ".png", ".jpeg"])
plt.figure(figsize=(10, 6))
for i in range(len(image_files[:12])):
image_file = image_files[i]
ax = plt.subplot(3, 4, i + 1)
img = Image.open(str(image_file))
plt.imshow(img)
plt.axis("off")
# 显示图片
plt.tight_layout()
plt.show()
数据预处理
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("./data/",transform=train_transforms)
total_data
输出
Dataset ImageFolder
Number of datapoints: 1800
Root location: ./data/
StandardTransform
Transform: Compose(
Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=warn)
ToTensor()
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
划分训练集和测试集
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, 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模型结构
加载模型
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) # 加载预训练的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
输出
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=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)
)
)
训练函数
# 训练循环
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
测试函数
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
设置超参数
"""训练模型--设置超参数"""
loss_fn = nn.CrossEntropyLoss() # 创建损失函数,计算实际输出和真实相差多少,交叉熵损失函数,事实上,它就是做图片分类任务时常用的损失函数
learn_rate = 1e-4 # 学习率
#optimizer1 = torch.optim.SGD(model.parameters(), lr=learn_rate)
optimizer2 = torch.optim.Adam(model.parameters(), lr=learn_rate)
lr_opt = optimizer2
model_opt = optimizer2
lambda1 = lambda epoch : 0.92 ** (epoch // 4)
# optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)
scheduler = torch.optim.lr_scheduler.LambdaLR(lr_opt, lr_lambda=lambda1)
此处直接就用了Adam,然后学习率递减速度加快
正式训练
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, optimizer2)
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 = optimizer2.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:12.8%, Train_loss:2.730, Test_acc:18.9%, Test_loss:2.490, Lr:1.00E-04
Epoch: 2, Train_acc:19.9%, Train_loss:2.401, Test_acc:22.8%, Test_loss:2.312, Lr:1.00E-04
Epoch: 3, Train_acc:26.2%, Train_loss:2.236, Test_acc:28.6%, Test_loss:2.195, Lr:1.00E-04
Epoch: 4, Train_acc:27.8%, Train_loss:2.152, Test_acc:31.1%, Test_loss:2.127, Lr:9.20E-05
Epoch: 5, Train_acc:31.2%, Train_loss:2.040, Test_acc:34.7%, Test_loss:2.067, Lr:9.20E-05
Epoch: 6, Train_acc:34.2%, Train_loss:1.971, Test_acc:35.3%, Test_loss:2.022, Lr:9.20E-05
Epoch: 7, Train_acc:37.7%, Train_loss:1.903, Test_acc:35.6%, Test_loss:1.984, Lr:9.20E-05
Epoch: 8, Train_acc:39.3%, Train_loss:1.861, Test_acc:36.1%, Test_loss:1.964, Lr:8.46E-05
Epoch: 9, Train_acc:42.2%, Train_loss:1.812, Test_acc:36.7%, Test_loss:1.944, Lr:8.46E-05
Epoch:10, Train_acc:42.1%, Train_loss:1.788, Test_acc:35.6%, Test_loss:1.908, Lr:8.46E-05
Epoch:11, Train_acc:42.6%, Train_loss:1.733, Test_acc:37.8%, Test_loss:1.903, Lr:8.46E-05
Epoch:12, Train_acc:44.7%, Train_loss:1.712, Test_acc:37.8%, Test_loss:1.859, Lr:7.79E-05
Epoch:13, Train_acc:45.1%, Train_loss:1.673, Test_acc:37.5%, Test_loss:1.843, Lr:7.79E-05
Epoch:14, Train_acc:46.1%, Train_loss:1.651, Test_acc:38.3%, Test_loss:1.822, Lr:7.79E-05
Epoch:15, Train_acc:47.2%, Train_loss:1.651, Test_acc:37.5%, Test_loss:1.854, Lr:7.79E-05
Epoch:16, Train_acc:48.3%, Train_loss:1.598, Test_acc:38.1%, Test_loss:1.819, Lr:7.16E-05
Epoch:17, Train_acc:50.8%, Train_loss:1.588, Test_acc:39.4%, Test_loss:1.779, Lr:7.16E-05
Epoch:18, Train_acc:51.8%, Train_loss:1.568, Test_acc:38.6%, Test_loss:1.810, Lr:7.16E-05
Epoch:19, Train_acc:50.3%, Train_loss:1.550, Test_acc:38.9%, Test_loss:1.800, Lr:7.16E-05
Epoch:20, Train_acc:52.2%, Train_loss:1.533, Test_acc:39.2%, Test_loss:1.795, Lr:6.59E-05
Epoch:21, Train_acc:52.1%, Train_loss:1.518, Test_acc:39.7%, Test_loss:1.762, Lr:6.59E-05
Epoch:22, Train_acc:52.7%, Train_loss:1.513, Test_acc:39.4%, Test_loss:1.747, Lr:6.59E-05
Epoch:23, Train_acc:54.2%, Train_loss:1.480, Test_acc:41.1%, Test_loss:1.737, Lr:6.59E-05
Epoch:24, Train_acc:55.1%, Train_loss:1.458, Test_acc:40.8%, Test_loss:1.765, Lr:6.06E-05
Epoch:25, Train_acc:54.0%, Train_loss:1.468, Test_acc:41.1%, Test_loss:1.735, Lr:6.06E-05
Epoch:26, Train_acc:55.5%, Train_loss:1.430, Test_acc:41.7%, Test_loss:1.731, Lr:6.06E-05
Epoch:27, Train_acc:56.7%, Train_loss:1.437, Test_acc:41.1%, Test_loss:1.750, Lr:6.06E-05
Epoch:28, Train_acc:56.3%, Train_loss:1.415, Test_acc:40.6%, Test_loss:1.741, Lr:5.58E-05
Epoch:29, Train_acc:58.3%, Train_loss:1.392, Test_acc:41.7%, Test_loss:1.710, Lr:5.58E-05
Epoch:30, Train_acc:56.8%, Train_loss:1.408, Test_acc:41.7%, Test_loss:1.706, Lr:5.58E-05
Epoch:31, Train_acc:59.6%, Train_loss:1.387, Test_acc:40.0%, Test_loss:1.698, Lr:5.58E-05
Epoch:32, Train_acc:58.8%, Train_loss:1.367, Test_acc:42.2%, Test_loss:1.709, Lr:5.13E-05
Epoch:33, Train_acc:59.0%, Train_loss:1.360, Test_acc:41.4%, Test_loss:1.686, Lr:5.13E-05
Epoch:34, Train_acc:59.3%, Train_loss:1.345, Test_acc:41.7%, Test_loss:1.684, Lr:5.13E-05
Epoch:35, Train_acc:58.2%, Train_loss:1.344, Test_acc:42.2%, Test_loss:1.699, Lr:5.13E-05
Epoch:36, Train_acc:58.5%, Train_loss:1.352, Test_acc:41.7%, Test_loss:1.700, Lr:4.72E-05
Epoch:37, Train_acc:58.9%, Train_loss:1.329, Test_acc:41.7%, Test_loss:1.676, Lr:4.72E-05
Epoch:38, Train_acc:58.5%, Train_loss:1.329, Test_acc:41.9%, Test_loss:1.668, Lr:4.72E-05
Epoch:39, Train_acc:60.4%, Train_loss:1.310, Test_acc:42.8%, Test_loss:1.690, Lr:4.72E-05
Epoch:40, Train_acc:60.3%, Train_loss:1.305, Test_acc:42.5%, Test_loss:1.689, Lr:4.34E-05
Done
结果绘图
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()
训练效果比示例代码更好,原因是直接用了Adam优化器替代SVG,但是出现明显过拟合现象,训练集的效果比测试集高很多,后续调优的重点之一在于过拟合处理
指定图片进行预测
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='./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)
输出
(0.42777777777777776, 1.6587781608104706)
总结
模型调优需要手搓VGG神经网络,常规的动一下学习率等等做法已经无法实现准确率明显提升了。对于优化策略,dropout层以外,还有正则化,以及全连接层的替换等方式,后续会回来尝试。(最近专攻树模型和特征工程去了,5月会回来全部尝试优化和神经网络手搓,flag先立在这里!)