0
0

动手学习VGG16

VGG 论文

《Very Deep Convolutional Networks for Large-Scale Image Recognition》
论文地址：https://arxiv.org/abs/1409.1556

使用重复元素的网络(VGG)

以学习VGG的收获、VGG16的复现二大部分，简述VGG16网络。

一. 学习VGG的收获

  1. VGG网络明确指出并实践证明了，浅而大的卷积核不如深而小的卷积核。 假设卷积块a、b的输入输出维度相同（不妨设维度=C），其中卷积块a（1个7 * 7的卷积层），卷积块b（由3个3 * 3的卷积层组成）。

特征方面：不论h、w是否发生改变，对于卷积块a都只能得到浅层的特征（轮廓），而卷积块b能得到深层的特征（轮廓，波纹，花边等等）。当h、w发生改变的时候，卷积块a和卷积块b都具有相同的感受野。
参数方面：卷积块a的参数Pa = 7 * 7 * C^2 = 49 * C^2，卷积块b的参数Pb = 3 * (3 * 3 * C^2) = 3 * 9 * C^2 = 27 * C^2，明显 Pa > Pb。

  1. 图片的尺度N（h * w）决定了VGG网络的性能，多尺度N训练有助于提升VGG网络的性能。VGG网络结构图如下所示。在这里插入图片描述

VGG16网络由5个卷积块和1个全连接块组成，每个卷积块后接一个步幅为2的2 * 2的最大池化层，根据图片卷积后的尺寸计算公式：

  1.       h
  2.      
  3.      
  4.       ′
  5.      
  6.     
  7.     
  8.      =
  9.     
  10.     
  11.      (
  12.     
  13.     
  14.      h
  15.     
  16.     
  17.      −
  18.     
  19.     
  20.      F
  21.     
  22.     
  23.      +
  24.     
  25.     
  26.      2
  27.     
  28.     
  29.      P
  30.     
  31.     
  32.      )
  33.     
  34.     
  35.      /
  36.     
  37.     
  38.      S
  39.     
  40.     
  41.      +
  42.     
  43.     
  44.      1
  45.     
  46.    
  47.    
  48.      h' = (h-F+2P)/S+1 
  49.    
  50.   
  51.  h′=(h−F+2P)/S+1
  53.  
  54.   
  55.    
  56.     
  57.      
  58.       w
  59.      
  60.      
  61.       ′
  62.      
  63.     
  64.     
  65.      =
  66.     
  67.     
  68.      (
  69.     
  70.     
  71.      w
  72.     
  73.     
  74.      −
  75.     
  76.     
  77.      F
  78.     
  79.     
  80.      +
  81.     
  82.     
  83.      2
  84.     
  85.     
  86.      P
  87.     
  88.     
  89.      )
  90.     
  91.     
  92.      /
  93.     
  94.     
  95.      S
  96.     
  97.     
  98.      +
  99.     
  100.     
  101.      1
  102.     
  103.    
  104.    
  105.      w' = (w-F+2P)/S+1 
  106.    
  107.   
  108.  w′=(w−F+2P)/S+1

其中输入图片的尺度W(h, w)，Filter大小(卷积层或池化层的卷积核大小) F * F，步幅 S，填充 P，输出图片的尺度N(h’, w’)。
VGG16网的输入图片的尺度必须为32的整数倍。由于组成VGG16的卷积块都是由数个步幅为1，填充为1的3 * 3的卷积层组成，不会改变图片的尺度。对于卷积块后接步幅为2的2 * 2最大池化层，图片的尺度缩小为原尺度的1/2，有5个步幅为2的2 * 2最大池化层，因此图片的尺度缩小为原尺度的(1/2)^5=1/32。

不妨设输入图片的尺度为N，采用多尺度（N-32, N, N+32）可以显著提升VGG16网络的性能。

二. VGG16网络的复现

  1. 数据预处理 VGG网络采用极为简单的处理方式，RGB三通道分别减去样本RGB三通道的均值。

样本数量较少时

  1. """
  2. path 为文件路径的前缀
  3. folders 为一个字典（类别kind，列表list），其中列表内存放着图片名
  4. """# 样本数量较少import cv2
  5. import numpy as np
  6. means    =[0.,0.,0.]
  7. stdevs   =[0.,0.,0.]
  8. img_list =[]for string in folders:
  9.     path_next = path +"\\"+ string
  10.     forfilein folders[string]:file= path_next +"\\"+file#opencv 读入的矩阵是BGR
  11.         img = cv2.imread(file)
  12.         img = img[:,:,:, np.newaxis]# print(img.shape)# img.shape = (h, w, 3, 1)
  13.         img_list.append(img)
  15. imgs = np.concatenate(img_list, axis=3)# print(imgs.shape)# imgs.shape = (h, w, 3, n)
  16. imgs = imgs.astype(np.float32)/(255.)for i inrange(3):
  17.     pixels    = imgs[:,:, i,:].ravel()# 拉成一行# pixels.shape = (h*w*n, )
  18.     means[i]+= np.mean(pixels)
  19.     stdevs[i]+= np.std(pixels)# BGR --> RGB ， CV读取的需要转换，PIL读取的不用转换# 也可以这么思考，opencv读取的是BGR，PIL读取的是RGB，如果交叉使用则需要使用。
  20. means.reverse()
  21. stdevs.reverse()

样本数量过多时

样本数量过多时，采用《概率论与数理统计》中的参数估计的方法。
对于样本x1,x2,x3,…,xn,期望u1,u2,u3,…,un，方差 v1^2, v2^2, v3^2,…, vn^2，都来源于同一个样本X采用随机取样得到。
不妨设 u1,u2,u3,…,un的均值为u，v1^2, v2^2, v3^2,…, vn^2的均值为v。
NX = x1+x2+x3+…+xn
E(NX) = u1+u2+u3+…+un = nu
D(NX) = v1^2 + v2^2 + v3^2 +…+ vn^2 = nv^2
X = NX/n = (x1+x2+x3+…+xn)/n
E(X) = E(NX)/n = u
D(X) = D(NX)/(n*n) = v^2/n
样本X的期望为u，标准差为v/sqrt(n)。

  1. # 样本数量过多import cv2
  2. import random
  3. import math
  4. import numpy as np
  6. means    =[0.,0.,0.]
  7. stdevs   =[0.,0.,0.]for epoch inrange(1000):
  8.     img_list =[]for string in folders:
  9.         path_next = path +"\\"+ string
  10.         forfilein folders[string]:
  11.             random_num = np.random.uniform()# np.random.uniform(0,1) 0-1之间按照均匀分布采样if random_num <0.001:file= path_next +"\\"+file
  12.                 img = cv2.imread(file)#opencv 读入的矩阵是BGR
  13.                 img = img[:,:,:, np.newaxis]# print(img.shape)# img.shape = (h, w, 3, 1)
  14.                 img_list.append(img)
  15.     
  16.     imgs = np.concatenate(img_list, axis=3)#print(imgs.shape)# imgs.shape = (h, w, 3, n)
  17.     imgs = imgs.astype(np.float32)/(255.)for i inrange(3):
  18.         pixels    = imgs[:,:, i,:].ravel()# 拉成一行# print(pixels.shape)# pixels.shape = (h*w*n, )
  19.         means[i]+= np.mean(pixels)
  20.         stdevs[i]+= np.std(pixels)#if (epoch+1)%100 == 0:#print("normMean = {}".format(means))#print("normStd = {}".format(stdevs))# BGR --> RGB ， CV读取的需要转换，PIL读取的不用转换# 也可以这么思考，opencv读取的是BGR，PIL读取的是RGB，如果交叉使用则需要使用。
  21. means.reverse()
  22. stdevs.reverse()
  24. use_means  =[0.,0.,0.]
  25. use_stdevs =[0.,0.,0.]for i inrange(3):
  26.     use_means[i]= means[i]/1000 
  27.     use_stdevs[i]= stdevs[i]/ math.sqrt(1000)print(use_means)print(use_stdevs)
  1. 参数控制
  1. batch_size =8# 每次喂入的数据量，batch_size可以根据电脑的配置调整
  2. lr         =0.01# 学习率
  3. step_size  =1# 每n个epoch更新一次学习率，数据集过大因此调小
  4. epoch_num  =50# 总迭代次数
  5. num_print  =1120# 每n次batch打印一次，数据集过大因此调大
  6. num_check  =1# 每n个epoch验证一次模型，若效果更优则保存模型，数据集过大因此调小
  1. 数据集构建
  1. """
  2. train_path、verification_path、test_path 同为字典（类别kind，列表list），其中列表内存放着图片的绝对路径。
  3. labels 也是一个字典（类别kind，序号number），序号为1~n的数字
  4. """import torch
  5. from torch.autograd import Variable
  6. from torchvision import transforms
  7. from torch.utils.data import Dataset, DataLoader
  8. import cv2
  10. # 独立设置尺寸，有利于VGG网络的多尺度训练
  11. size =224# 均值和标准差均是按照VGG论文设置的，减去样本均值，标准差设置为1。
  12. transform = transforms.Compose([transforms.ToTensor(),
  13.                                 transforms.Normalize((0.5142455680072308,0.4990353952050209,0.5186490820050239),(1.0,1.0,1.0))])# -----------------ready the dataset--------------------------defdefault_loader(path, img_size):
  14.     img = cv2.imread(path)if img_size isnotNone:
  15.         img = cv2.resize(img,(img_size,img_size),interpolation=cv2.INTER_NEAREST)return img
  17. classMyDataset(Dataset):# 构造函数def__init__(self, path, transform=None, target_transform=None, loader=default_loader, img_size =None):
  18.         imgs =[]for classification in path:for i inrange(len(path[classification])):
  19.                 img_path  = path[classification][i]
  20.                 img_label = labels[classification]
  21.                 imgs.append((img_path,int(img_label)))#imgs中包含有图像路径和标签
  22.         self.path             = path
  23.         self.imgs             = imgs
  24.         self.transform        = transform
  25.         self.target_transform = target_transform
  26.         self.loader           = loader
  27.         self.img_size         = img_size
  28.         
  29.     # hash_map建立def__getitem__(self, index):
  30.         img_path, img_label = self.imgs[index]# 调用 opencv 打开图片
  31.         img = self.loader(img_path,self.img_size)if self.transform isnotNone:
  32.             img = self.transform(img)
  33.         img_label -=1return img, img_label
  34.     
  35.     def__len__(self):returnlen(self.imgs)
  37. train_data        = MyDataset(train_path, transform=transform, img_size=size)
  38. verification_data = MyDataset(verification_path, transform=transform, img_size=size)
  39. test_data         = MyDataset(test_path, transform=transform, img_size=size)#train_data 、verification_data和test_data包含多有的训练、验证与测试数据，调用DataLoader批量加载
  40. train_loader        = DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True)
  41. verification_loader = DataLoader(dataset=verification_data, batch_size=batch_size, shuffle=False)
  42. test_loader         = DataLoader(dataset=test_data, batch_size=batch_size, shuffle=False)
  1. VGG16网络构建
  1. import torch
  2. from torch import optim
  3. import torchvision
  4. import matplotlib.pyplot as plt
  5. import numpy as np
  6. from torchvision.utils import make_grid
  7. import time

关于多尺度训练的问题，有两个思路。
思路1：采用模型加载函数**model.load_state_dict(torch.load(PATH), strict=False)**。在加载部分模型参数进行预训练的时候，很可能会碰到键不匹配的情况（模型权重都是按键值对的形式保存并加载回来的）。因此，无论是缺少键还是多出键的情况，都可以通过在load_state_dict()函数中设定strict参数为False来忽略不匹配的键。（不推荐）
思路2：参照《动手学深度学习》的卷积神经网络NiN、GoogLeNet、ResNet、DenseNet等网络，对VGG16网络的全连接块进行魔改，采用卷积块temp代替全连接块的思路。卷积块temp由2个1 * 1的卷积层及1个全局平均池化层组成，最后接2(其中1层为塑造类别的全连接层)个全连接层。

思路1代码实现

  1. from torch import nn
  2. from torchsummary import summary
  4. classVGG16Net(nn.Module):def__init__(self):super(VGG16Net,self).__init__()# 第一层，2个卷积层和1个最大池化层
  5.         self.layer1 = nn.Sequential(# 输入3通道，卷积核3*3，输出64通道（如224*224*3的样本图片，（224+2*1-3）/1+1=224,输出224*224*64）
  6.             nn.Conv2d(3,64,3,padding=1),
  7.             nn.BatchNorm2d(64),
  8.             nn.ReLU(inplace=True),# 输入64通道，卷积核3*3，输出64通道（输入224*224*64，卷积3*3*64*64，输出224*224*64）
  9.             nn.Conv2d(64,64,3,padding=1),
  10.             nn.BatchNorm2d(64),
  11.             nn.ReLU(inplace=True),# 输入224*224*64，输出112*112*64
  12.             nn.MaxPool2d(kernel_size=2,stride=2))# 第二层，2个卷积层和1个最大池化层
  13.         self.layer2 = nn.Sequential(# 输入64通道，卷积核3*3，输出128通道
  14.             nn.Conv2d(64,128,3,padding=1),
  15.             nn.BatchNorm2d(128),
  16.             nn.ReLU(inplace=True),# 输入128通道，卷积核3*3，输出128通道
  17.             nn.Conv2d(128,128,3,padding=1),
  18.             nn.BatchNorm2d(128),
  19.             nn.ReLU(inplace=True),# 输入112*112*128，输出56*56*128
  20.             nn.MaxPool2d(kernel_size=2,stride=2))# 第三层，3个卷积层和1个最大池化层
  21.         self.layer3 = nn.Sequential(# 输入128通道，卷积核3*3，输出256通道
  22.             nn.Conv2d(128,256,3,padding=1),
  23.             nn.BatchNorm2d(256),
  24.             nn.ReLU(inplace=True),# 输入256通道，卷积核3*3，输出256通道
  25.             nn.Conv2d(256,256,3,padding=1),
  26.             nn.BatchNorm2d(256),
  27.             nn.ReLU(inplace=True),# 输入256通道，卷积核3*3，输出256通道
  28.             nn.Conv2d(256,256,3,padding=1),
  29.             nn.BatchNorm2d(256),
  30.             nn.ReLU(inplace=True),#输入56*56*256，输出28*28*256
  31.             nn.MaxPool2d(kernel_size=2,stride=2))# 第四层，3个卷积层和1个最大池化层
  32.         self.layer4 = nn.Sequential(# 输入256通道，卷积核3*3，输出512通道
  33.             nn.Conv2d(256,512,3,padding=1),
  34.             nn.BatchNorm2d(512),
  35.             nn.ReLU(inplace=True),# 输入512通道，卷积核3*3，输出512通道
  36.             nn.Conv2d(512,512,3,padding=1),
  37.             nn.BatchNorm2d(512),
  38.             nn.ReLU(inplace=True),# 输入512通道，卷积核3*3，输出512通道
  39.             nn.Conv2d(512,512,3,padding=1),
  40.             nn.BatchNorm2d(512),
  41.             nn.ReLU(inplace=True),#输入28*28*512，输出14*14*256
  42.             nn.MaxPool2d(kernel_size=2,stride=2))# 第五层，3个卷积层和1个最大池化层
  43.         self.layer5 = nn.Sequential(# 输入512通道，卷积核3*3，输出512通道
  44.             nn.Conv2d(512,512,3,padding=1),
  45.             nn.BatchNorm2d(512),
  46.             nn.ReLU(inplace=True),# 输入512通道，卷积核3*3，输出512通道
  47.             nn.Conv2d(512,512,3,padding=1),
  48.             nn.BatchNorm2d(512),
  49.             nn.ReLU(inplace=True),# 输入512通道，卷积核3*3，输出512通道
  50.             nn.Conv2d(512,512,3,padding=1),
  51.             nn.BatchNorm2d(512),
  52.             nn.ReLU(inplace=True),#输入14*14*512，输出7*7*256
  53.             nn.MaxPool2d(kernel_size=2,stride=2))# VGG16--13个卷积层
  54.         self.conv_layer = nn.Sequential(
  55.             self.layer1,
  56.             self.layer2,
  57.             self.layer3,
  58.             self.layer4,
  59.             self.layer5
  60.         )# VGG16--3个全连接层
  61.         self.fc = nn.Sequential("""
  62.             多尺度训练，代表训练3次
  63.             分别把第一个全连接层，设置成如下
  64.             A、nn.Linear(512 * 6 * 6, 4096)
  65.             B、nn.Linear(512 * 8 * 8, 4096)
  66.             C、nn.Linear(512 * 7 * 7, 4096)
  67.             保证C为最后一次训练即可。
  68.             """
  69.             nn.Linear(512*7*7,4096),
  70.             nn.ReLU(inplace=True),
  71.             nn.Dropout(0.5),# 随机丢弃50%的神经元
  72.             
  73.             nn.Linear(4096,4096),
  74.             nn.ReLU(inplace=True),
  75.             nn.Dropout(0.5),# 随机丢弃50%的神经元"""
  76.             第一种方法
  77.             nn.Linear(4096, n)
  78.             shape = (-1, n)，n表示类别的数量
  79.             第二种方法如下，在VGG16后接1个全连接层
  80.             """
  81.             
  82.             nn.Linear(4096,1000),# 后接1个全连接层，shape = (-1, n)，n表示类别的数量
  83.             nn.Linear(1000,29))defforward(self,x):
  84.         x = self.conv_layer(x)
  85.         x = x.view(x.size(0),-1)
  86.         x = self.fc(x)return x
  87. if __name__ =="__main__": 
  88.     device = torch.device('cuda'if torch.cuda.is_available()else'cpu')
  89.     vgg_model=VGG16Net().to(device)
  90.     summary(vgg_model,(3,224,224))#打印网络结构

思路2代码实现

  1. from torch import nn
  2. from torchsummary import summary
  4. classVGG16Net(nn.Module):def__init__(self):super(VGG16Net,self).__init__()# 第一层，2个卷积层和1个最大池化层
  5.         self.layer1 = nn.Sequential(# 输入3通道，卷积核3*3，输出64通道（如224*224*3的样本图片，（224+2*1-3）/1+1=224,输出224*224*64）
  6.             nn.Conv2d(3,64,3,padding=1),
  7.             nn.BatchNorm2d(64),
  8.             nn.ReLU(inplace=True),# 输入64通道，卷积核3*3，输出64通道（输入224*224*64，卷积3*3*64*64，输出224*224*64）
  9.             nn.Conv2d(64,64,3,padding=1),
  10.             nn.BatchNorm2d(64),
  11.             nn.ReLU(inplace=True),# 输入224*224*64，输出112*112*64
  12.             nn.MaxPool2d(kernel_size=2,stride=2))# 第二层，2个卷积层和1个最大池化层
  13.         self.layer2 = nn.Sequential(# 输入64通道，卷积核3*3，输出128通道
  14.             nn.Conv2d(64,128,3,padding=1),
  15.             nn.BatchNorm2d(128),
  16.             nn.ReLU(inplace=True),# 输入128通道，卷积核3*3，输出128通道
  17.             nn.Conv2d(128,128,3,padding=1),
  18.             nn.BatchNorm2d(128),
  19.             nn.ReLU(inplace=True),# 输入112*112*128，输出56*56*128
  20.             nn.MaxPool2d(kernel_size=2,stride=2))# 第三层，3个卷积层和1个最大池化层
  21.         self.layer3 = nn.Sequential(# 输入128通道，卷积核3*3，输出256通道
  22.             nn.Conv2d(128,256,3,padding=1),
  23.             nn.BatchNorm2d(256),
  24.             nn.ReLU(inplace=True),# 输入256通道，卷积核3*3，输出256通道
  25.             nn.Conv2d(256,256,3,padding=1),
  26.             nn.BatchNorm2d(256),
  27.             nn.ReLU(inplace=True),# 输入256通道，卷积核3*3，输出256通道
  28.             nn.Conv2d(256,256,3,padding=1),
  29.             nn.BatchNorm2d(256),
  30.             nn.ReLU(inplace=True),#输入56*56*256，输出28*28*256
  31.             nn.MaxPool2d(kernel_size=2,stride=2))# 第四层，3个卷积层和1个最大池化层
  32.         self.layer4 = nn.Sequential(# 输入256通道，卷积核3*3，输出512通道
  33.             nn.Conv2d(256,512,3,padding=1),
  34.             nn.BatchNorm2d(512),
  35.             nn.ReLU(inplace=True),# 输入512通道，卷积核3*3，输出512通道
  36.             nn.Conv2d(512,512,3,padding=1),
  37.             nn.BatchNorm2d(512),
  38.             nn.ReLU(inplace=True),# 输入512通道，卷积核3*3，输出512通道
  39.             nn.Conv2d(512,512,3,padding=1),
  40.             nn.BatchNorm2d(512),
  41.             nn.ReLU(inplace=True),#输入28*28*512，输出14*14*256
  42.             nn.MaxPool2d(kernel_size=2,stride=2))# 第五层，3个卷积层和1个最大池化层
  43.         self.layer5 = nn.Sequential(# 输入512通道，卷积核3*3，输出512通道
  44.             nn.Conv2d(512,512,3,padding=1),
  45.             nn.BatchNorm2d(512),
  46.             nn.ReLU(inplace=True),# 输入512通道，卷积核3*3，输出512通道
  47.             nn.Conv2d(512,512,3,padding=1),
  48.             nn.BatchNorm2d(512),
  49.             nn.ReLU(inplace=True),# 输入512通道，卷积核3*3，输出512通道
  50.             nn.Conv2d(512,512,3,padding=1),
  51.             nn.BatchNorm2d(512),
  52.             nn.ReLU(inplace=True),#输入14*14*512，输出7*7*256
  53.             nn.MaxPool2d(kernel_size=2,stride=2))# 魔改VGG16--第六层
  54.         self.layer6 = nn.Sequential(
  55.             
  56.             nn.Conv2d(512,4096,1),
  57.             nn.BatchNorm2d(4096),
  58.             nn.ReLU(inplace=True),
  59.             
  60.             nn.Conv2d(4096,4096,1),
  61.             nn.BatchNorm2d(4096),
  62.             nn.ReLU(inplace=True))# VGG16--15个卷积层
  63.         self.conv_layer = nn.Sequential(
  64.             self.layer1,
  65.             self.layer2,
  66.             self.layer3,
  67.             self.layer4,
  68.             self.layer5,
  69.             self.layer6
  70.         )# VGG16--1个全连接层
  71.         self.fc = nn.Sequential(
  72.             nn.Linear(4096,1000),
  73.             nn.ReLU(inplace=True),
  74.             nn.Dropout(0.5),# 随机丢弃50%的神经元
  75.             
  76.             nn.Linear(1000,29))defforward(self,x):
  77.         x = self.conv_layer(x)# 全局平均池化层
  78.         x = nn.functional.adaptive_avg_pool2d(x,(1,1))
  79.         x = x.view(x.size(0),-1)
  80.         x = self.fc(x)return x
  81. if __name__ =="__main__": 
  82.     device = torch.device('cuda'if torch.cuda.is_available()else'cpu')
  83.     vgg_model=VGG16Net().to(device)
  84.     summary(vgg_model,(3,224,224))#打印网络结构
  1. 模型训练
  1. # VGG16
  2. device = torch.device("cuda:0"if torch.cuda.is_available()else"cpu")
  3. model  = VGG16Net().to(device)
  1. # 调参# 交叉熵
  2. criterion = nn.CrossEntropyLoss()# 迭代器
  3. optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.8, weight_decay=0.001)# 更新学习率
  4. schedule  = optim.lr_scheduler.StepLR(optimizer, step_size=step_size, gamma=0.5, last_epoch=-1)
  1. # 训练# 损失图
  2. loss_list         =[]
  3. start             = time.time()
  4. correct_optimal   =0.0for epoch inrange(epoch_num):
  5.     
  6.     model.train()
  7.     running_loss =0.0for i,(inputs, labels)inenumerate(train_loader,0):# 从train_loader中取出64个数据
  8.         inputs, labels = inputs.to(device), labels.to(device)# 梯度清零
  9.         optimizer.zero_grad()# 模型训练
  10.         outputs = model(inputs)#print(outputs.shape)# 反向传播
  11.         loss = criterion(outputs,labels).to(device)
  12.         loss.backward()
  13.         optimizer.step()
  14.         
  15.         running_loss += loss.item()if(i+1)% num_print ==0:print('[%d epoch, %d]  loss:%.6f'%(epoch+1, i+1, running_loss/num_print))
  16.             loss_list.append(running_loss/num_print)
  17.             running_loss =0.0# 打印学习率及确认学习率是否进行更新
  18.     lr_1 = optimizer.param_groups[0]['lr']print("learn_rate: %.15f"%lr_1)
  19.     schedule.step()# 验证模式if(epoch+1)% num_check ==0:# 不需要梯度更新
  20.         model.eval()
  21.         correct =0.0
  22.         total   =0with torch.no_grad():print("=======================check=======================")for inputs, labels in verification_loader:# 从train_loader中取出batch_size个数据
  23.                 inputs, labels = inputs.to(device), labels.to(device)# 模型验证
  24.                 outputs = model(inputs)
  25.                 pred    = outputs.argmax(dim=1)#返回每一行中最大值的索引
  26.                 total   = total + inputs.size(0)
  27.                 correct = correct + torch.eq(pred, labels).sum().item()
  28.             
  29.         
  30.         correct =100* correct/total
  31.         print("Accuracy of the network on the 19850 verification images:%.2f %%"%correct )print("===================================================")# 模型保存if correct > correct_optimal:
  32.             PATH ="VVG\\VGG16 model_"+str(epoch)+"_"+str(correct)+".pth"
  33.             torch.save(model.state_dict(),'VGG/VGG16_%03d-correct%.3f.pth'%(epoch +1, correct))
  34.             correct_optimal = correct
  36. end=time.time()print("time:{}".format(end-start))
  1. 绘制损失图
  1. import matplotlib.pyplot as plt
  3. x =[ i+1for i inrange(len(loss_list))]# plot函数作图
  4. plt.plot(x, loss_list)# show函数展示出这个图，如果没有这行代码，则程序完成绘图，但看不到
  5. plt.show()

损失图如下，其中5个单位代表1次epoch。
在这里插入图片描述
7. 模型检验

  1. # 检验模式，不需要梯度更新
  2. model.eval()
  3. correct =0.0
  4. total   =0with torch.no_grad():print("=======================check=======================")for inputs, labels in test_loader:# 从train_loader中取出batch_size个数据
  5.         inputs, labels = inputs.to(device), labels.to(device)# 模型检验
  6.         outputs = model(inputs)
  7.         pred    = outputs.argmax(dim=1)#返回每一行中最大值的索引
  8.         total   = total + inputs.size(0)
  9.         correct = correct + torch.eq(pred, labels).sum().item()
  10.             
  11.         
  12.     correct =100* correct/total
  13.     print("Accuracy of the network on the 25907 test images:%.2f %%"%correct )print("===================================================")

最后祝各位永远怀着一颗怀疑的心，时刻仰望理论，不止于纸上谈兵，把想法付诸于实践，并不断思考。

标签： 深度学习 计算机视觉 cnn
本文转载自: https://blog.csdn.net/weixin_49529683/article/details/122729277
版权归原作者 费费川 所有， 如有侵权，请联系我们删除。
登录后发布评论

“动手学习VGG16”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？