- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍖 原作者:K同学啊
前言
要求:
- 自己搭建VGG-16网络框架
- 调用官方的VGG-16网络框架
- 如何查看模型的参数量以及相关指标
拔高:
- 验证集准确率达到100%
- 使用PPT画出VGG-16算法框架图(发论文需要这项技能)
实验环境:
- 语言环境:Python3.10
- 编译器:Pycharm
- 深度学习环境:Pytorch
1.torch == 2.4.0+cu121
2.torchvision == 0.19.0+cu121
一、前期准备
1.设置GPU
iimport torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import os,PIL,pathlib,warnings
import os,PIL,random,pathlib
from torchvision.models import vgg16
import torch.nn.functional as F
import torchsummary as summary
warnings.filterwarnings("ignore") #忽略警告信息
#-------------设置GPU---------------
# 设置硬件设备,如果有GPU则使用,没有则使用cpu
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)
代码输出:
cuda
2.导入数据
输入代码:
#---------------------------导入数据----------------------
data_dir = 'F:/lsydata/PotatoPlants/'
data_dir = pathlib.Path(data_dir)
data_paths = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[3] for path in data_paths]
print(classeNames)
代码输出:
['Early_blight', 'healthy', 'Late_blight']
代码输入:
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("F:/lsydata/PotatoPlants/", transform=train_transforms)
print(total_data)
代码输出:
Dataset ImageFolder
Number of datapoints: 2152
Root location: F:/lsydata/PotatoPlants/
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)
代码输出:
{'Early_blight': 0, 'Late_blight': 1, 'healthy': 2}
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)
print(test_dataset)
代码输出:
<torch.utils.data.dataset.Subset object at 0x000001E0CE25C9A0>
<torch.utils.data.dataset.Subset object at 0x000001E0CE25C910>
代码输入:
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)
if __name__ == '__main__':
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([15, 3, 224, 224])
Shape of y: torch.Size([15]) torch.int64
二、调用官方的VGG-16模型
1.搭建模型
代码输入:
#-------------------------------调用官方的VGG-16模型----------------------------
class vgg16(nn.Module):
def __init__(self):
super(vgg16, self).__init__()
# 卷积块1
self.block1 = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
)
# 卷积块2
self.block2 = nn.Sequential(
nn.Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
)
# 卷积块3
self.block3 = nn.Sequential(
nn.Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
)
# 卷积块4
self.block4 = nn.Sequential(
nn.Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
)
# 卷积块5
self.block5 = nn.Sequential(
nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
nn.ReLU(),
nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
)
# 全连接网络层,用于分类
self.classifier = nn.Sequential(
nn.Linear(in_features=512 * 7 * 7, out_features=4096),
nn.ReLU(),
nn.Linear(in_features=4096, out_features=4096),
nn.ReLU(),
nn.Linear(in_features=4096, out_features=3)
)
def forward(self, x):
x = self.block1(x)
x = self.block2(x)
x = self.block3(x)
x = self.block4(x)
x = self.block5(x)
x = torch.flatten(x, start_dim=1)
x = self.classifier(x)
return x
device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))
model = vgg16().to(device)
model
代码输出:
Using cuda device
vgg16(
(block1): Sequential(
(0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU()
(2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(3): ReLU()
(4): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)
)
(block2): Sequential(
(0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU()
(2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(3): ReLU()
(4): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)
)
(block3): Sequential(
(0): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU()
(2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(3): ReLU()
(4): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(5): ReLU()
(6): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)
)
(block4): Sequential(
(0): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU()
(2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(3): ReLU()
(4): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(5): ReLU()
(6): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)
)
(block5): Sequential(
(0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU()
(2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(3): ReLU()
(4): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(5): ReLU()
(6): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)
)
(classifier): Sequential(
(0): Linear(in_features=25088, out_features=4096, bias=True)
(1): ReLU()
(2): Linear(in_features=4096, out_features=4096, bias=True)
(3): ReLU()
(4): Linear(in_features=4096, out_features=3, bias=True)
)
)
2.查看模型详细
代码输入:
#-----------------查看模型详细-----------------------
summary.summary(model, (3, 224, 224))
代码输出:
----------------------------------------------------------------
Layer (type) Output Shape Param #
================================================================
Conv2d-1 [-1, 64, 224, 224] 1,792
ReLU-2 [-1, 64, 224, 224] 0
Conv2d-3 [-1, 64, 224, 224] 36,928
ReLU-4 [-1, 64, 224, 224] 0
MaxPool2d-5 [-1, 64, 112, 112] 0
Conv2d-6 [-1, 128, 112, 112] 73,856
ReLU-7 [-1, 128, 112, 112] 0
Conv2d-8 [-1, 128, 112, 112] 147,584
ReLU-9 [-1, 128, 112, 112] 0
MaxPool2d-10 [-1, 128, 56, 56] 0
Conv2d-11 [-1, 256, 56, 56] 295,168
ReLU-12 [-1, 256, 56, 56] 0
Conv2d-13 [-1, 256, 56, 56] 590,080
ReLU-14 [-1, 256, 56, 56] 0
Conv2d-15 [-1, 256, 56, 56] 590,080
ReLU-16 [-1, 256, 56, 56] 0
MaxPool2d-17 [-1, 256, 28, 28] 0
Conv2d-18 [-1, 512, 28, 28] 1,180,160
ReLU-19 [-1, 512, 28, 28] 0
Conv2d-20 [-1, 512, 28, 28] 2,359,808
ReLU-21 [-1, 512, 28, 28] 0
Conv2d-22 [-1, 512, 28, 28] 2,359,808
ReLU-23 [-1, 512, 28, 28] 0
MaxPool2d-24 [-1, 512, 14, 14] 0
Conv2d-25 [-1, 512, 14, 14] 2,359,808
ReLU-26 [-1, 512, 14, 14] 0
Conv2d-27 [-1, 512, 14, 14] 2,359,808
ReLU-28 [-1, 512, 14, 14] 0
Conv2d-29 [-1, 512, 14, 14] 2,359,808
ReLU-30 [-1, 512, 14, 14] 0
MaxPool2d-31 [-1, 512, 7, 7] 0
Linear-32 [-1, 4096] 102,764,544
ReLU-33 [-1, 4096] 0
Linear-34 [-1, 4096] 16,781,312
ReLU-35 [-1, 4096] 0
Linear-36 [-1, 3] 12,291
================================================================
Total params: 134,272,835
Trainable params: 134,272,835
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 218.52
Params size (MB): 512.21
Estimated Total Size (MB): 731.30
----------------------------------------------------------------
三、训练模型
1.编写训练函数
#-------------------编写训练函数-----------------
#训练循环
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset) #训练集的大小,一共60000张图片
num_batches = len(dataloader) #批次数目,1875(60000/32)
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) #测试集的大小,一共10000张图片
num_batches = len(dataloader) #批次数目,313(10000/32=312.5,向上取整)
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.正式训练
optimizer = torch.optim.Adam(model.parameters(), lr= 1e-4)
loss_fn = nn.CrossEntropyLoss() # 创建损失函数
epochs = 20
train_loss = []
train_acc = []
test_loss = []
test_acc = []
best_acc = 0 # 设置一个最佳准确率,作为最佳模型的判别指标
if __name__ == '__main__':
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)
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:46.8%, Train_loss:0.926, Test_acc:47.6%, Test_loss:0.891, Lr:1.00E-04
Epoch: 2, Train_acc:47.8%, Train_loss:0.867, Test_acc:79.4%, Test_loss:0.631, Lr:1.00E-04
Epoch: 3, Train_acc:80.8%, Train_loss:0.552, Test_acc:85.8%, Test_loss:0.392, Lr:1.00E-04
Epoch: 4, Train_acc:84.3%, Train_loss:0.445, Test_acc:86.3%, Test_loss:0.395, Lr:1.00E-04
Epoch: 5, Train_acc:88.6%, Train_loss:0.344, Test_acc:91.6%, Test_loss:0.240, Lr:1.00E-04
Epoch: 6, Train_acc:88.7%, Train_loss:0.311, Test_acc:82.6%, Test_loss:0.432, Lr:1.00E-04
Epoch: 7, Train_acc:89.4%, Train_loss:0.272, Test_acc:92.8%, Test_loss:0.182, Lr:1.00E-04
Epoch: 8, Train_acc:90.8%, Train_loss:0.212, Test_acc:95.1%, Test_loss:0.152, Lr:1.00E-04
Epoch: 9, Train_acc:92.7%, Train_loss:0.171, Test_acc:97.4%, Test_loss:0.081, Lr:1.00E-04
Epoch:10, Train_acc:94.2%, Train_loss:0.154, Test_acc:97.2%, Test_loss:0.098, Lr:1.00E-04
Epoch:11, Train_acc:96.6%, Train_loss:0.093, Test_acc:97.2%, Test_loss:0.094, Lr:1.00E-04
Epoch:12, Train_acc:96.0%, Train_loss:0.104, Test_acc:92.3%, Test_loss:0.241, Lr:1.00E-04
Epoch:13, Train_acc:96.3%, Train_loss:0.096, Test_acc:97.9%, Test_loss:0.062, Lr:1.00E-04
Epoch:14, Train_acc:97.9%, Train_loss:0.065, Test_acc:97.9%, Test_loss:0.065, Lr:1.00E-04
Epoch:15, Train_acc:98.4%, Train_loss:0.050, Test_acc:98.6%, Test_loss:0.052, Lr:1.00E-04
Epoch:16, Train_acc:97.0%, Train_loss:0.084, Test_acc:95.4%, Test_loss:0.160, Lr:1.00E-04
Epoch:17, Train_acc:97.6%, Train_loss:0.079, Test_acc:94.0%, Test_loss:0.143, Lr:1.00E-04
Epoch:18, Train_acc:97.2%, Train_loss:0.085, Test_acc:97.4%, Test_loss:0.059, Lr:1.00E-04
Epoch:19, Train_acc:98.6%, Train_loss:0.048, Test_acc:97.9%, Test_loss:0.063, Lr:1.00E-04
Epoch:20, Train_acc:99.1%, Train_loss:0.029, Test_acc:98.1%, Test_loss:0.070, Lr:1.00E-04
Done
四、结果可视化
1. Loss与Accuracy图
#--------------------------------结果可视化------------------------
warnings.filterwarnings("ignore") #忽略警告信息
plt.rcParams['font.sans-serif'] = ['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False #用来正常显示负号
plt.rcParams['figure.dpi'] = 100 #分辨率
epochs_range = range(epochs)
if len(train_acc) > 0 and len(test_acc) > 0:
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()
else:
print("No data available for plotting.")
代码输出:
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='./6-data/Angelina Jolie/001_fe3347c0.jpg',
model=model,
transform=train_transforms,
classes=classes)
输出代码:
预测结果是:Early_blight
3. 模型评估
代码输入:
best_model.eval()
epoch_test_acc, epoch_test_loss = test(test_dl, best_model, loss_fn)
epoch_test_acc, epoch_test_loss
代码输出:
(0.9907192575406032, 0.05570455381010626)
五、总结
本周练习过程中,运行代码有些不顺利,但一件件的解决了。
首先,学习了关于如何自己搭建VGG-16网络框架
其次如何调用官方的VGG-16网络框架
最后,如何查看模型的参数量以及相关指标