使用pytorch实现VGG16模型(小白学习,详细注释)

已于 2023-06-12 11:08:32 修改
阅读量3w 收藏 421
点赞数 60
分类专栏： 深度学习 文章标签： 深度学习 pytorch VGG16 cifar10
于 2021-05-19 20:38:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50127633/article/details/117045008
版权

VGG16的模型

在这里插入图片描述
在这里插入图片描述
首先我们可以看到VGG一共有六个模型,每个模型根据卷积层和全连接层的层数进行分类,第二张图就是VGG16的基本模型.

代码实现

Vgg16Net.py

from torch import nn

class Vgg16_net(nn.Module):
    def __init__(self):
        super(Vgg16_net, self).__init__()


        self.layer1=nn.Sequential(
            nn.Conv2d(in_channels=3,out_channels=64,kernel_size=3,stride=1,padding=1), #(32-3+2)/1+1=32   32*32*64
            nn.BatchNorm2d(64),
            #inplace-选择是否进行覆盖运算
            #意思是是否将计算得到的值覆盖之前的值，比如
            nn.ReLU(inplace=True),
            #意思就是对从上层网络Conv2d中传递下来的tensor直接进行修改，
            #这样能够节省运算内存，不用多存储其他变量

            nn.Conv2d(in_channels=64,out_channels=64,kernel_size=3,stride=1,padding=1), #(32-3+2)/1+1=32    32*32*64
            #Batch Normalization强行将数据拉回到均值为0，方差为1的正太分布上，
            # 一方面使得数据分布一致，另一方面避免梯度消失。
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(kernel_size=2,stride=2)   #(32-2)/2+1=16         16*16*64
        )


        self.layer2=nn.Sequential(
            nn.Conv2d(in_channels=64,out_channels=128,kernel_size=3,stride=1,padding=1),  #(16-3+2)/1+1=16  16*16*128
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=128,out_channels=128,kernel_size=3,stride=1,padding=1), #(16-3+2)/1+1=16   16*16*128
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(2,2)    #(16-2)/2+1=8     8*8*128
        )

        self.layer3=nn.Sequential(
            nn.Conv2d(in_channels=128,out_channels=256,kernel_size=3,stride=1,padding=1),  #(8-3+2)/1+1=8   8*8*256
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),


            nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,stride=1,padding=1),  #(8-3+2)/1+1=8   8*8*256
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,stride=1,padding=1),  #(8-3+2)/1+1=8   8*8*256
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(2,2)     #(8-2)/2+1=4      4*4*256
        )

        self.layer4=nn.Sequential(
            nn.Conv2d(in_channels=256,out_channels=512,kernel_size=3,stride=1,padding=1),  #(4-3+2)/1+1=4    4*4*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),   #(4-3+2)/1+1=4    4*4*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),   #(4-3+2)/1+1=4    4*4*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(2,2)    #(4-2)/2+1=2     2*2*512
        )

        self.layer5=nn.Sequential(
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),   #(2-3+2)/1+1=2    2*2*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),  #(2-3+2)/1+1=2     2*2*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),  #(2-3+2)/1+1=2      2*2*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(2,2)   #(2-2)/2+1=1      1*1*512
        )


        self.conv=nn.Sequential(
            self.layer1,
            self.layer2,
            self.layer3,
            self.layer4,
            self.layer5
        )

        self.fc=nn.Sequential(
            #y=xA^T+b  x是输入,A是权值,b是偏执,y是输出
            #nn.Liner(in_features,out_features,bias)
            #in_features:输入x的列数  输入数据:[batchsize,in_features]
            #out_freatures:线性变换后输出的y的列数,输出数据的大小是:[batchsize,out_features]
            #bias: bool  默认为True
            #线性变换不改变输入矩阵x的行数,仅改变列数
            nn.Linear(512,512),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),

            nn.Linear(512,256),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),

            nn.Linear(256,10)
        )


    def forward(self,x):
        x=self.conv(x)
        #这里-1表示一个不确定的数，就是你如果不确定你想要reshape成几行，但是你很肯定要reshape成512列
        # 那不确定的地方就可以写成-1

        #如果出现x.size(0)表示的是batchsize的值
        # x=x.view(x.size(0),-1)
        x = x.view(-1, 512)
        x=self.fc(x)
        return x

train.py

import torch
from torch import nn,optim,tensor
from torch.utils.data import DataLoader
from torchvision.utils import  make_grid
from torchvision import datasets,transforms
import numpy as np
from matplotlib import pyplot as plt
import time

#全局变量
batch_size=32   #每次喂入的数据量

# num_print=int(50000//batch_size//4)
num_print=100

epoch_num=30 #总迭代次数

lr=0.01
step_size=10  #每n次epoch更新一次学习率

#数据获取(数据增强,归一化)
def transforms_RandomHorizontalFlip():

    #transforms.Compose(),将一系列的transforms有序组合,实现按照这些方法依次对图像操作

    #ToTensor()使图片数据转换为tensor张量,这个过程包含了归一化,图像数据从0~255压缩到0~1,这个函数必须在Normalize之前使用
    #实现原理,即针对不同类型进行处理,原理即各值除以255,最后通过torch.from_numpy将PIL Image或者 numpy.ndarray()针对具体类型转成torch.tensor()数据类型

    #Normalize()是归一化过程,ToTensor()的作用是将图像数据转换为(0,1)之间的张量,Normalize()则使用公式(x-mean)/std
    #将每个元素分布到(-1,1). 归一化后数据转为标准格式,
    transform_train=transforms.Compose([transforms.RandomHorizontalFlip(),
                                         transforms.ToTensor(),
                                         transforms.Normalize((0.485,0.456,0.406),(0.229,0.224,0.225))])


    transform=transforms.Compose([transforms.ToTensor(),
                                  transforms.Normalize((0.485,0.456,0.406),(0.226,0.224,0.225))])


    #root:cifar-10 的根目录,data_path
    #train:True=训练集, False=测试集
    #transform:(可调用,可选)-接收PIL图像并返回转换版本的函数
    #download:true=从互联网上下载数据,并将其放在root目录下,如果数据集已经下载,就什么都不干
    train_dataset=datasets.CIFAR10(root='../../data_hub/cifar10/data_1',train=True,transform=transform_train,download=True)
    test_dataset=datasets.CIFAR10(root='../../data_hub/cifar10/data_1',train=False,transform=transform,download=True)

    return train_dataset,test_dataset

#数据增强:随机翻转
train_dataset,test_dataset=transforms_RandomHorizontalFlip()


'''
#Dataloader(....)
dataset:就是pytorch已有的数据读取接口,或者自定义的数据接口的输出,该输出要么是torch.utils.data.Dataset类的对象,要么是继承自torch.utils.data.Dataset类的自定义类的对象

batch_size:如果有50000张训练集,则相当于把训练集平均分成(50000/batch_size)份,每份batch_size张图片
train_loader中的每个元素相当于一个分组,一个组中batch_size图片,

shuffle:设置为True时会在每个epoch重新打乱数据(默认:False),一般在训练数据中会采用
num_workers:这个参数必须>=0,0的话表示数据导入在主进程中进行,其他大于0的数表示通过多个进程来导入数据,可以加快数据导入速度
drop_last:设定为True如果数据集大小不能被批量大小整除的时候,将丢到最后一个不完整的batch(默认为False)
'''

train_loader=DataLoader(train_dataset,batch_size=batch_size,shuffle=True)
test_loader=DataLoader(test_dataset,batch_size=batch_size,shuffle=False)

#模型,优化器
device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
from VggNet import *
model=Vgg16_net().to(device)

#在多分类情况下一般使用交叉熵
criterion=nn.CrossEntropyLoss()
'''
params(iterable)-待优化参数的iterable或者定义了参数组的dict
lr(float):学习率

momentum(float)-动量因子

weight_decay(float):权重衰减,使用的目的是防止过拟合.在损失函数中,weight decay是放在正则项前面的一个系数,正则项一般指示模型的复杂度
所以weight decay的作用是调节模型复杂度对损失函数的影响,若weight decay很大,则复杂的模型损失函数的值也就大.

dampening:动量的有抑制因子


optimizer.param_group:是长度为2的list,其中的元素是两个字典
optimzer.param_group:长度为6的字典,包括['amsgrad','params','lr','weight_decay',eps']
optimzer.param_group:表示优化器状态的一个字典

'''
optimizer=optim.SGD(model.parameters(),lr=lr,momentum=0.8,weight_decay=0.001)

'''
scheduler 就是为了调整学习率设置的，我这里设置的gamma衰减率为0.5，step_size为10，也就是每10个epoch将学习率衰减至原来的0.5倍。

optimizer(Optimizer):要更改学习率的优化器
milestones(list):递增的list,存放要更新的lr的epoch
gamma:(float):更新lr的乘法因子
last_epoch:：最后一个epoch的index，如果是训练了很多个epoch后中断了，继续训练，这个值就等于加载的模型的epoch。默认为-1表示从头开始训练，即从epoch=1
'''

schedule=optim.lr_scheduler.StepLR(optimizer,step_size=step_size,gamma=0.5,last_epoch=-1)



#训练
loss_list=[]  #为了后续画出损失图
start=time.time()


#train
for epoch in range(epoch_num):
    ww = 0
    running_loss=0.0
    #0是对i的给值(循环次数从0开始技术还是从1开始计数的问题):
    #???
    for i,(inputs,labels) in enumerate(train_loader,0):


        #将数据从train_loader中读出来,一次读取的样本是32个
        inputs,labels=inputs.to(device),labels.to(device)
        #用于梯度清零,在每次应用新的梯度时,要把原来的梯度清零,否则梯度会累加
        optimizer.zero_grad()
        outputs = model(inputs)


        loss=criterion(outputs,labels).to(device)

        #反向传播,pytorch会自动计算反向传播的值
        loss.backward()
        #对反向传播以后对目标函数进行优化
        optimizer.step()


        running_loss+=loss.item()
        loss_list.append(loss.item())

        if(i+1)%num_print==0:
            print('[%d epoch,%d]  loss:%.6f' %(epoch+1,i+1,running_loss/num_print))
            running_loss=0.0

    lr_1=optimizer.param_groups[0]['lr']
    print("learn_rate:%.15f"%lr_1)
    schedule.step()

end=time.time()
print("time:{}".format(end-start))


#测试

#由于训练集不需要梯度更新,于是进入测试模式
model.eval()
correct=0.0
total=0
with torch.no_grad(): #训练集不需要反向传播
    print("=======================test=======================")
    for inputs,labels in test_loader:
        inputs,labels=inputs.to(device),labels.to(device)
        outputs=model(inputs)

        pred=outputs.argmax(dim=1)  #返回每一行中最大值元素索引
        total+=inputs.size(0)
        correct+=torch.eq(pred,labels).sum().item()

print("Accuracy of the network on the 10000 test images:%.2f %%" %(100*correct/total) )
print("===============================================")

训练结果

...
...

[30 epoch,1200]  loss:0.064114
[30 epoch,1300]  loss:0.046721
[30 epoch,1400]  loss:0.070694
[30 epoch,1500]  loss:0.078124
learn_rate:0.002500000000000
time:1579.1085803508759
=======================test=======================
Accuracy of the network on the 10000 test images:87.97 %
===============================================

文章参考自:https://blog.csdn.net/weixin_43467711/article/details/105377584

一个小猴子｀
关注
  • 60
    点赞
  • 踩
  • 421
    收藏
    觉得还不错? 一键收藏
  • 30
    评论
专栏目录
【使用Pytorch实现VGG16网络模型】
vcsir的专栏
07-30 7284
VGG-Network是K.Simonyan和A.Zisserman在论文“VeryDeepConvolutionalNetworksforLarge-ScaleImageRecognition”中提出的卷积神经网络模型。该架构在ImageNet中实现了92.7%的top-5测试准确率，该网络拥有超过1400万张属于1000个类别的图像。•模型的输入是固定大小的224×224224×224RGB图像•预处理是从每个像素中减去训练集RGB值的平均值。......
VGG16结构图
Activewaste
09-02 1131
vgg16构造模型图：http://ethereon.github.io/netscope/#/gist/dc5003de6943ea5a6b8b softmax层一般连接的是全连接层和loss层，现在的CNN都是end-to-end的，最后通过全连接层送入softmax来进行分类。 ...
VGG-16算法-Pytorch实现人脸识别
最新发布
qq_57815235的博客
05-31 298
它主要使用3x3的卷积核和2x2的最大池化层，通过堆叠卷积层和池化层来构建深层网络在VGG网络中，所有的卷积层都使用了相同大小的卷积核（3x3）和相同的步长。VGG网络在多个卷积层和池化层后，包含了三个全连接层。迁移学习适用于数据量不足的情况。在迁移学习中，在大规模数据集上预训练的模型仅需少量的调整即可适应新任务。VGG网络简洁且深层的架构有效捕捉图像的复杂特征。我尝试了对模型的不同层进行微调，理解到每一层网络如何影响最终的学习效果。
Pytorch使用VGG16模型进行预测猫狗二分类
qq_43649937的博客
07-31 3470
pytorch python
Pytorch之VGG16图像分类
风间琉璃的博客
09-26 4223
VGG是Oxford的VisualGeometryGroup的组提出的。该网络是在ILSVRC 2014上的相关工作，主要工作是证明了增加网络的深度能够在一定程度上影响网络最终的性能。斩获该年ImageNet竞赛中Localization Task（定位任务）第一名和Classification Task（分类任务）第二名。
VGG论文及代码复现笔记（PyTorch）
m0_51457734的博客
07-13 376
从网络 A 中的 11 个权重层（8 个卷积层和 3 个 FC 层）到网络 E 中的 19 个权重层（16 个卷积层和 3 个 FC 层）。卷积层的宽度（通道数）相当小，从第一层的 64 开始，然后在每个最大池层之后增加 2 倍，直到达到 512。
VGG论文复现，pytorch代码
sinat_43147829的博客
01-13 1161
VGG论文复现理论加代码。
PyTorch之VGG16网络结构详解以及源码解读
qq_34600424的博客
01-15 1万+
论文：Very Deep Convolutional Networks for Large-Scale Image Recognition 简单介绍 **意义：**证明了增加小卷积核的个数以及网络深度可以提高分类结果的正确率。 **预处理：**各通道减去RGB在训练集上的均值。 特点： 1）使用小的卷积核（3 × 3）叠加的形式代替大的卷积核（5 × 5 or 7 × 7） 2）卷积层不会改变layer大小，而是通过max pooling减小layer大小 3）网络层数比较深 优点： 1）网络结构简洁：
经典卷积神经网络——VGG16
Lightismore的博客
04-30 2万+
VGG16前言一、VGG发展历程二、VGG网络模型三、VGG16代码详解1.VGG网络架构2.VGG16网络验证2.读取数据，进行数据增强3.训练模型，测试准确率四、VGG缺点 前言 我们都知道Alexnet是卷积神经网络的开山之作，但是由于卷积核太大，移动步长大，无填充，所以14年提出的VGG网络解决了这一问题 一、VGG发展历程 VGG网络由牛津大学在2014年ImageNet挑战赛本地和分类追踪分别获得了第一名和第二名。研究卷积网络深度对其影响在大规模图像识别设置中的准确性，主要贡献是全面评估网络
pytorch一步一步在VGG16上训练自己的数据集
hnu_zzt的博客
12-19 3万+
准备数据集及加载，ImageFolder 在很多机器学习或者深度学习的任务中，往往我们要提供自己的图片。也就是说我们的数据集不是预先处理好的，像mnist，cifar10等它已经给你处理好了，更多的是原始的图片。比如我们以猫狗分类为例。在data文件下，有两个分别为train和val的文件夹。然后train下是cat和dog两个文件夹，里面存的是自己的图片数据，val文件夹同train。这样我们的...
利用PyTorch实现VGG16教程
12-17
我就废话不多说了，大家还是直接看代码吧~ import torch import torch.nn as nn import torch.nn.functional as F class VGG16(nn.Module): def __init__(self): super(VGG16, self).__init__() # 3 * 224 * 224 self.conv1_1 = nn.Conv2d(3, 64, 3) # 64 * 222 * 222 self.conv1_2 = nn.Conv2d(64, 64, 3, padding=(1, 1)) # 64 * 2
PyTorch迁移VGG16
AlisaZqq
04-13 5219
PyTorch迁移VGG16错误记录错误1 错误记录 错误1 ProtocolError: (‘Connection broken: OSError("(10054, ‘WSAECONNRESET’)",)’, OSError("(10054, ‘WSAECONNRESET’)",)) --------------------------------------------------------...
PyTorch实现VGG
远方
03-11 1万+
import numpy as np import torch from torch import nn from torch.autograd import Variable 定义VGG的block VGG几乎全部使用3x3的卷积核，以及2x2的池化层，使用小的卷积核进行多层堆叠和一个大的卷积核感受野是相同的，同时VGG小的卷积核还能减少参数，具有更深的结构。 def vgg_block(nu...
pytorch学习 ：vgg做CIFAR10分类代码
xckkcxxck的博客
09-04 6139
# -*- coding: utf-8 -*- """ Created on Tue Sep 4 08:47:56 2018 @author: www """ import sys sys.path.append('...') import numpy as np import torch from torch import nn from torch.autograd import V...
CNN典型模型及pytorch实现 —— VGGNet
biubiusion的博客
04-08 1302
VGG 是一种比较稳定的model（实际上是AlexNet 结构的扩展），连续的 conv 多，计算量巨大，需要更大的存储空间； 2014年竞赛的第二名，但是在一些迁移模型中的表现要优于第一名 GoogleNet；而且在图像中提取 CNN 特征 VGG 是首选模型； VGG 模型特点： 采用更小的卷积核（将卷积核全部替换为3*3，极少还使用1*1的卷积核）； 还采用较小的池化核，相比于 ...
pytorch实现VGG16网络
方悔读书迟
07-27 6997
import torch import torch.nn as nn class VGG16(nn.Module): def __init__(self, nums): super(VGG16, self).__init__() self.nums = nums vgg = [] # 第一个卷积部分 # 112, 112, 64 vgg.append(nn.Conv2d(in_channels=3,.
使用vgg16模型进行图片预测
热门推荐
hadxu的博客
02-24 6万+
使用vgg16模型进行图片预测
【原创】深度学习第17弹：基于VGG16的手势识别
DeepVisionZero的博客
10-18 1876
一、前文回顾 在图像处理章节使用mediapipe进行了手势1-9的识别，但是既然学习了深度学习，所以我尝试使用深度学习来实现手势识别。 二、关键词语 Mediapipe：谷歌的一个训练好的神经网络模型。这个模块可以识别手，脸，姿态等等很多东西。我这次只使用手部识别的功能，以便确定手的位置 Tensorflow：谷歌的开源深度学习框架。这个框架封装了底层算法（比如池化操作，卷积操作，反向求导等等），我们只需要象搭积木一样就可以很快的搭建自己的网络模型。 ※tensorflow版本为2.6.0
VGG16学习笔记
dta0502的博客
03-22 6万+
一. 简述  VGG卷积神经网络是牛津大学在2014年提出来的模型。当这个模型被提出时，由于它的简洁性和实用性，马上成为了当时最流行的卷积神经网络模型。它在图像分类和目标检测任务中都表现出非常好的结果。在2014年的ILSVRC比赛中，VGG 在Top-5中取得了92.3%的正确率。VGG结构图VGG-16VGG模型有一些变种，其中最受欢迎的当然是 VGG-16，这是一个拥有16层的模型。你可以看...
用pytorch搭建vgg16模型
08-25
我可以提供一些关于如何使用PyTorch搭建VGG16模型的指导。首先，你需要创建一个VGG16模型，可以使用PyTorch实现。其次，你需要定义模型的架构，如层数，激活函数，池化层等。紧接着，你需要使用PyTorch定义一个优化器，用于更新模型的参数。最后，你需要使用训练数据进行训练，并在验证集上进行测试，以确定模型的准确率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 30
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值