现代神经网络(VGG)，并用VGG16进行实战CIFAR10分类

已于 2023-03-07 12:36:33 修改
阅读量2.1k 收藏 25
点赞数
分类专栏： 深度学习 文章标签： 神经网络 深度学习 cnn
于 2023-03-06 12:09:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51957239/article/details/129345446
版权

专栏：神经网络复现目录

本章介绍的是现代神经网络的结构和复现，包括深度卷积神经网络（AlexNet），VGG，NiN，GoogleNet，残差网络（ResNet），稠密连接网络（DenseNet）。
文章部分文字和代码来自《动手学深度学习》

文章目录

使用块的网络(VGG)

VGG是一种深度卷积神经网络，由牛津大学视觉几何组（Visual Geometry Group）在2014年提出。它是由多个卷积层和池化层组成的深度神经网络，具有很强的图像分类能力，特别是在图像识别领域，取得了很好的成果。

VGG的特点在于，它使用相对较小的卷积核（3x3），但是通过叠加多个卷积层和池化层，增加了网络的深度，从而达到更好的图像分类性能。VGG网络包含了多个版本，以卷积层数目为标志，如VGG16和VGG19等，其中VGG16和VGG19是最著名的两个版本。

VGG网络的设计非常简单和规整，容易理解和实现，因此也成为了很多深度学习新手的入门模型。

下图为VGG的六个版本，比较实用的是VGG16和VGG19，本文以VGG16为例子进行讲解
在这里插入图片描述

VGG块

定义

VGG块是VGG网络中的一个基本组成单元，由若干个卷积层和池化层组成，通常用于提取输入图像的特征。每个VGG块都由连续的1或2个卷积层，和一个最大池化层组成。其中，卷积层的卷积核大小都是3x3，而池化层的窗口大小通常是2x2。在每个VGG块中，卷积层的输出通道数都相同，可以通过超参数进行控制。

具体来说，假设一个VGG块由k个卷积层和一个池化层组成，输入为 x x x，则该块的输出可以表示为：

VGG ( x ) = Pool ( conv k ( conv k − 1 ( ⋯ conv 1 ( x ) ) ) ) . \text{VGG}(x) = \text{Pool}(\text{conv}k(\text{conv}{k-1}(\cdots\text{conv}_1(x)))). VGG(x)=Pool(convk(convk−1(⋯conv1​(x)))).

其中， conv i ( ⋅ ) \text{conv}_i(\cdot) convi​(⋅)表示第 i i i个卷积层， Pool ( ⋅ ) \text{Pool}(\cdot) Pool(⋅)表示池化层。在VGG块中，每个卷积层都会使用ReLU激活函数进行非线性变换，而最大池化层则用于下采样和特征压缩。

在VGG网络中，通常通过叠加多个VGG块来构建网络结构。通过增加VGG块的数量，可以增加网络的深度和宽度，从而提高网络的表达能力和泛化性能。

实现

self.conv1=nn.Sequential(
            nn.Conv2d(in_channels=3,out_channels=64,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=64,out_channels=64,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )

inplace=True 表示对于输入的张量进行原地操作，即直接对原始的输入张量进行修改，而不是创建一个新的张量。这样做可以节省内存，但会覆盖原始的输入张量，可能会对后续的计算产生影响。因此，当我们需要保留原始的输入张量时，可以将 inplace 参数设置为 False。

VGG和AlexNet的区别

AlexNet和VGG是两个比较早的深度学习卷积神经网络模型，它们都是在ImageNet数据集上进行训练的。它们的主要区别如下：

  1. 模型深度不同：AlexNet相对于传统的浅层神经网络，深度更深；而VGG更加深层，包含更多的卷积层和参数。

  2. 卷积核尺寸不同：AlexNet中第一个卷积层采用的是11x11的卷积核，而VGG中卷积核的大小为3x3，这个设计使得VGG拥有更多的卷积层和更少的参数。

  3. 全连接层的区别：AlexNet的全连接层较少，VGG的全连接层较多，这使得VGG需要更多的内存和计算资源。

综上所述，AlexNet相对于VGG来说，更浅、更宽，拥有更多的全连接层，而VGG则更深、更窄，拥有更多的卷积层和更少的全连接层。

VGG16

模型设计

VGG16是一个卷积神经网络模型，包含13个卷积层、5个池化层和3个全连接层，是由牛津大学计算机视觉组（Visual Geometry Group）在2014年提出的模型，具有较好的图像识别表现。

VGG16模型的架构如下：

输入层：输入图像的大小为224x224x3。

VGG块1

卷积层1：使用64个3x3大小的卷积核进行卷积操作，得到64张大小为224x224的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

卷积层2：使用64个3x3大小的卷积核进行卷积操作，得到64张大小为224x224的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

池化层1：使用2x2的最大池化操作，将64张大小为224x224的特征图缩小为64张大小为112x112的特征图。采用SAME填充，步长为2。

VGG块2

卷积层3：使用128个3x3大小的卷积核进行卷积操作，得到128张大小为112x112的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

卷积层4：使用128个3x3大小的卷积核进行卷积操作，得到128张大小为112x112的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

池化层2：使用2x2的最大池化操作，将128张大小为112x112的特征图缩小为128张大小为56x56的特征图。采用SAME填充，步长为2。

VGG块3

卷积层5：使用256个3x3大小的卷积核进行卷积操作，得到256张大小为56x56的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

卷积层6：使用256个3x3大小的卷积核进行卷积操作，得到256张大小为56x56的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

卷积层7：使用256个3x3大小的卷积核进行卷积操作，得到256张大小为56x56的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

池化层3：使用2x2的最大池化操作，将256张大小为56x56的特征图缩小为256张大小为28x28的特征图。采用SAME填充，步长为2。

VGG块4

卷积层8-10：使用512个3x3大小的卷积核进行卷积操作，得到512张大小为28x28的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

池化层4：使用2x2的最大池化操作，将512张大小为28x28的特征图缩小为512张大小为14x14的特征图。采用SAME填充，步长为2。

VGG块5

卷积层11-13：使用512个3x3大小的卷积核进行卷积操作，得到512张大小为14x14的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

池化层5：使用2x2的最大池化操作，将512张大小为14x14的特征图缩小为512张大小为7x7的特征图。采用SAME填充，步长为2。

全连接层

3个全连接层，第1、2个都有4096个输出通道，第3个全连接层则有1000个输出通道。

实现

class VGG16(nn.Module):
    def __init__(self):
        super(VGG16,self).__init__()
        self.conv1=nn.Sequential(
            nn.Conv2d(in_channels=3,out_channels=64,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=64,out_channels=64,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )
        self.conv2=nn.Sequential(
            nn.Conv2d(in_channels=64,out_channels=128,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=128,out_channels=128,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )
        self.conv3=nn.Sequential(
            nn.Conv2d(in_channels=128,out_channels=256,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )
        self.conv4=nn.Sequential(
            nn.Conv2d(in_channels=256,out_channels=512,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )
        self.conv5=nn.Sequential(
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )
        self.feature=nn.Sequential(
            self.conv1,
            self.conv2,
            self.conv3,
            self.conv4,
            self.conv5,
        )
        self.flatten=nn.Flatten()
        self.fc=nn.Sequential(
            nn.Linear(512*7*7,4096),
            nn.ReLU(inplace=True),
            nn.Dropout(0.4),
            nn.Linear(4096,4096),
            nn.ReLU(inplace=True),
            nn.Dropout(0.4),
            nn.Linear(4096,1000),
            #nn.Softmax(10)
        )
    def forward(self,x):
        x=self.feature(x)
        # x=self.flatten(x)
        x = x.view(x.size(0), -1)
        x=self.fc(x)
        return x

查看结构

vgg = VGG16()
print(vgg)
x=torch.rand(1,3,224,224)
y=vgg(x)
print(y.shape)

利用VGG16进行CIFAR10分类

import torch.nn as nn
import torch
import torchvision

if(torch.cuda.is_available()):
    device = torch.device("cuda")
    print("使用GPU训练中：{}".format(torch.cuda.get_device_name()))
else:
    device = torch.device("cpu")
    print("使用CPU训练")

数据集

# transform的创建（compose方法）
from torchvision import transforms
def get_dataloader_workers():  #@save
    """使用4个进程来读取数据"""
    return 4

def load_data_cifar10(batch_size, resize=None):  #@save
    trans = [transforms.ToTensor()]
    if resize:
        trans.insert(0, transforms.Resize(resize))
    trans = transforms.Compose(trans)
    mnist_train = torchvision.datasets.CIFAR10(
        root="../data", train=True, transform=trans, download=True)
    mnist_test = torchvision.datasets.CIFAR10(
        root="../data", train=False, transform=trans, download=True)
    return (torch.utils.data.DataLoader(mnist_train, batch_size, shuffle=True,
                            num_workers=get_dataloader_workers()),
            torch.utils.data.DataLoader(mnist_test, batch_size, shuffle=False,
                            num_workers=get_dataloader_workers()))
batch_size=4
train_iter, test_iter = load_data_cifar10(batch_size,resize=224)

超参数，优化器，损失函数

from torch import optim
net=VGG16()
lr=0.001
optimizer=optim.SGD(net.parameters(),lr=lr,momentum=0.9)
loss=nn.CrossEntropyLoss()
epochs=10

训练

def train(net,train_iter,test_iter,num_epochs, lr, device):
    def init_weights(m):
        if type(m) == nn.Linear or type(m) == nn.Conv2d:
            nn.init.xavier_uniform_(m.weight)
    net.apply(init_weights)
    print('training on', device)
    net.to(device)
    for epoch in range(num_epochs):
        net.train()
        train_step = 0
        for i, (X, y) in enumerate(train_iter):
            optimizer.zero_grad()
            X, y = X.to(device), y.to(device)
            y_hat = net(X)
            l=loss(y_hat,y)
            l.backward()
            optimizer.step()
            train_step+=1
            if(train_step%50==0):#每训练一百组输出一次损失
                print("第{}轮的第{}次训练的loss:{}".format((epoch+1),train_step,l.item()))
青云遮夜雨
关注
  • 0
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
现代卷积神经网络(GoogleNet)，并使用GoogleNet进行实战CIFAR10分类
qq_51957239的博客
03-07 2761
Inception模块是GoogleNet中的一个核心组成部分，用于提取图像特征。该模块采用并行的多个卷积层和池化层来提取不同尺度的特征，然后将它们在通道维度上进行拼接，得到更丰富的特征表达。一个基本的Inception模块包含了四个分支（Branch），每个分支都有不同的卷积核或者池化核，如下图所示：在这个模块中，我们可以看到分支1、2、3都是卷积层，分支4则是最大池化层，其目的是提取图像中不同大小的特征。通过这些分支的组合，Inception模块可以有效地提取图像的多尺度特征，且计算代价相对较小。
神经网络之VGG
am_student的博客
07-01 4461
经典卷积神经网络的基本组成部分是下面的这个序列：带填充以保持分辨率的卷积层；非线性激活函数，如ReLU；汇聚层，如最大汇聚层。而一个VGG块与之类似，由一系列卷积层组成，后面再加上用于空间下采样的最大汇聚层。在最初的VGG论文中 ()，作者使用了带有3×3卷积核、填充为1（保持高度和宽度）的卷积层，和带有2×2汇聚窗口、步幅为2（每个块后的分辨率减半）的最大汇聚层。VGG的全称是视觉几何小组，隶属于牛津大学科学与工程系。
2024年Python最全【图像分类】实战——使用VGG16实现对植物幼苗的分类（pytroch
最新发布
2401_84689601的博客
04-30 685
transform_test = transforms.Compose([transforms.Resize((224, 224)),transforms.ToTensor(),transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])读取数据====将数据集解压后放到data文件夹下面，如图：然后我们在dataset文件夹下面新建 __init__.py和dataset.py，在dataset.py文件夹写入下面的代码：说一下代码的核心逻辑。第一步 建
Pytorch入门（四）使用VGG16网络训练CIFAR10数据集
一个非常Cool的人
06-06 4950
本文使用Pytorch+VGG16+CIFAR10数据集完成图像分类
深度学习入门（二十九）卷积神经网络——VGG
ElysiumAILab
11-09 5079
课件 VGG VGG块 VGG架构 进度 总结 教材 1 VGG块 2 VGG网络 3 训练模型 4 小结
pytorch——使用VGG-16实现cifar-10多分类，准确率90.97%
热门推荐
qq_28383747的博客
12-02 1万+
刚入门卷积神经网络，在cifar-10数据集上复现了LeNet、AlexNet和VGG-16网络，发现VGG-16网络分类准确率最高，之后以VGG-16网络为基础疯狂调参，最终达到了90.97%的准确率。（继续进行玄学调参，可以更高）二、VGG-16网络介绍VGG-16论文该模型在2014年的ILSVRC中取得了分类任务第二、定位任务第一的优异成绩。VGG网络架构。
VGG16实现CIFAR10数据集
weixin_51431157的博客
03-28 715
为了防止在梯度下降过程中出现梯度消失或爆炸，还需在每一层卷积后使用归一化处理batchnorm，也可防止过拟合，全连接层和线性层后使用dropout随机失活防止过拟合；此外还需加上非线性激活函数Relu。由tensorboard中的曲线趋势可见，提高epoch轮次，正确率还可进一步提升。简单神经网络实现CIFAR10图片分类效果较差，故将网络结构换成VGG16看看效果。更换model.py文件里的内容（1中博客的model），将Links改为VGG16。比起原代码多了数据增强的步骤（transform）
VGG16实现Cifar10分类训练模型
02-04
VGG16是一种深度卷积神经网络（CNN），在2014年ImageNet图像识别挑战赛中由英国伦敦大学学院的Visual Geometry Group提出，因此得名VGG16。这个模型以其深而狭窄的架构著称，拥有16个处理层，其中13层是卷积层，3层...
vgg16对CIFAR10进行图片分类
03-28
vgg16对CIFAR10进行图片分类，vgg16的CIFAR10与pytorch 使用pytorch 0.4.0构建vgg16，用于CIFAR数据集的分类 我们使用pytorch_gpu 0.4.0来构建网络。
【项目实战】Python基于卷积神经网络CNN模型和VGG16模型进行图片识别项目实战
02-14
在这个【项目实战】中，我们将深入探讨如何使用Python编程语言结合卷积神经网络（CNN）和VGG16模型进行图像识别。这是一个典型的深度学习应用，涵盖了从数据获取到模型训练和评估的完整流程。 首先，我们要理解项目...
深度学习pytorch实战三：VGG16图像分类篇自建数据集图像分类三类
qq_55433305的博客
03-06 5328
VGG16图像分类篇自建数据集图像分类三类1.自建数据集与划分训练集与测试集 2.模型相关知识 3.model.py——定义AlexNet网络模型 4.train.py——加载数据集并训练，训练集计算损失值loss，测试集计算accuracy，保存训练好的网络参数 5.predict.py——利用训练好的网络参数后，用自己找的图像进行分类测试
使用VGG16来训练cifar数据集
yychentracy的博客
05-17 4365
VGG16的特点： VGGNet使用了更深的结构， AlexNet只有8 层网络，而VGGNet 有16 层，不在使用大的卷积核，只使用3*3卷积核和2*2的池化层 之所以使用小的滤波器，是因为层叠很多小的滤波器的感受野和一个大的滤波器的感受野是相同的，还能减少参数，同时有更深的网络结构。其实他只是不断的对网络层进行叠加，并没有太多的创新，而增加深度确实可以一定程度改善模型的效果。 代码如下...
Pytorch之VGG16图像分类
风间琉璃的博客
09-26 4259
VGG是Oxford的VisualGeometryGroup的组提出的。该网络是在ILSVRC 2014上的相关工作，主要工作是证明了增加网络的深度能够在一定程度上影响网络最终的性能。斩获该年ImageNet竞赛中Localization Task（定位任务）第一名和Classification Task（分类任务）第二名。
深度学习与TensorFlow实战（十）卷积神经网络—VGG（16）神经网络
法兰西流浪者博客
08-27 9771
架构： 训练输入：固定尺寸224x224的RGB图像。 预处理：每个像素减去训练集上的RGB均值。 卷积核：一系列3X3卷积核堆叠，步长为1，采用padding保持卷积后图像空间分辨率不变。 空间池化：紧随卷积堆的最大池化，为2x2滑动窗口，步长2. 全连接层：特征提取后，接三个全连接层，前两个为4096，第三个为1000通道，最后是一个softmax层，输出概率。 所有隐藏层都用非线...
VGG-传统神经网络之巅峰
frighting_ing的博客
11-14 5939
1. VGG简介 VGGNet是由牛津大学视觉几何小组（Visual Geometry Group, VGG）提出的一种深层卷积网络结构，他们以7.32%的错误率赢得了2014年ILSVRC分类任务的亚军（冠军由GoogLeNet以6.65%的错误率夺得）和25.32%的错误率夺得定位任务（Localization）的第一名（GoogLeNet错误率为26.44%），网络名称VGGNet取自该小组名缩写。VGGNet是首批把图像分类的错误率降低到10%以内模型，同时该网络所采用的3×33\times33×3
使用pytorch构建基于VGG16的网络实现Cifar10分类
qq_44873474的博客
09-21 2541
pytorch已经包含了诸多的网络结构，可以直接导入来使用。这里来使用torch手工搭建不使用内置模块。定义网络结构主要使用torch的nn，以及nn模块下的functional模块。在搭建之前首先来看一下VGG16的网路结构图，可以看到网络主要包含卷积和全连接，卷积之后跟着池化，每个隐藏层的激活都是用relu，通道数不断增加直到512这样能提取到更多信息，而全连接的数量为经验值可以更改，由此看出VGG16是一种简单的sequence结构。分析完VGG16的结构，下面使用pytorch来搭建网络。
VGG 经典神经网络学习笔记 （附代码）
PLANTTHESON的博客
10-11 2714
VGG 经典神经网络学习笔记 （附代码）
vggnet网络代码进行cifar10数据集的图像分类
11-13
VGGNet是一种深度卷积神经网络，适用于图像分类问题。在我们进行CIFAR-10数据集的图像分类时，可以使用VGGNet网络代码来实现。 首先，我们需要准备CIFAR-10数据集，这个数据集包含了10个不同类别的图像，每个类别有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

青云遮夜雨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值