VGG网络

1、VGG模型介绍

VGGNet是牛津大学VGG（Visual Geometry Group）视觉几何组于2014年撰写的论文中提出的卷积神经网络结构，VGGNet建立了一个19层的神经网络，在ILSVRC取得了定位第一、分类第二的成绩。VGGNet网络模型与AlexNet框架有很多相似之处，有5个Group的卷积，2层FC图像特征，1层FC分类特征。

VGGNet是从AlexNet发展而来，主要进行了两方面的改进：（1）在第一卷积层使用更小的filter尺寸和间隔。（2）在整个图片和multi-scale上训练和测试图片。

2、VGGNet模型特点

VGGNet与AlexNet相比，除了使用更多的层之外，

VGGNet所有的卷积层都是同样大小的filter，尺寸为3×3，卷积间隔S=1，并且3×3的卷积层有一个像素的填充。VGGNet网络模型的特点如下：

（1）3×3是最小的能够捕捉上下左右和中心概念的尺寸。

（2）两个3×3的卷积层是5×5，三个3×3是7×7，可以替代大的filter尺寸。

（3）多个3×3的卷积层比一个大的尺寸filter卷积层具有更对的非线性，使得判决函数更加具有判决性。

（4）多个3×3的卷积层比一个大尺寸的filter有更少的参数。

 

《Very Deep Convolutional Networks for Large-Scale Image Recognition》

• arXiv：[1409.1556] Very Deep Convolutional Networks for Large-Scale Image Recognition
• intro：ICLR 2015
• homepage：Visual Geometry Group Home Page

 

 

3、VGG优缺点

VGG优点

• VGGNet的结构非常简洁，整个网络都使用了同样大小的卷积核尺寸（3x3）和最大池化尺寸（2x2）。
• 几个小滤波器（3x3）卷积层的组合比一个大滤波器（5x5或7x7）卷积层好（具有更多的非线性、更少的参数）：
• 验证了通过不断加深网络结构可以提升性能。

 

VGG缺点

• VGG耗费更多计算资源，并且使用了更多的参数（这里不是3x3卷积的锅），导致更多的内存占用（140M）。其中绝大多数的参数都是来自于第一个全连接层。VGG可是有3个全连接层啊！

PS：有的文章称：发现这些全连接层即使被去除，对于性能也没有什么影响，这样就显著降低了参数数量。

 

注：很多pretrained的方法就是使用VGG的model（主要是16和19），VGG相对其他的方法，参数空间很大，最终的model有500多m，AlexNet只有200m，GoogLeNet更少，所以train一个vgg模型通常要花费更长的时间，所幸有公开的pretrained model让我们很方便的使用。

4、VGGNet的pytorch实现

实现一

# -*- coding : UTF-8 -*-
# @file   : vgg_practice.py
# @Time   : 2021/5/9 11:15
# @Author : wmz

# VGGNet16 的pytorch代码实现

import torch.nn as nn
import math


class VGG(nn.Module):
    def __init__(self, num_classes=1000):
        super(VGG, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, padding=1),
            nn.ReLU(True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(True),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.ReLU(True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.ReLU(True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )
        self.classifier = nn.Sequential(
            nn.Linear(512*7*7, 4096),
            nn.ReLU(True),
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Dropout(),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x


VggNet = VGG(10)

参考：简介VggNet与其pytorch实现

实现二

#model.py

import torch.nn as nn
import torch

#分类网络
class VGG(nn.Module):
    def __init__(self, features, num_classes=1000, init_weights=False):
        super(VGG, self).__init__()
        self.features = features
        #先会进行一个展平处理
        self.classifier = nn.Sequential( #定义分类网络结构
            nn.Dropout(p=0.5), #减少过拟合
            nn.Linear(512*7*7, 2048),
            nn.ReLU(True),
            nn.Dropout(p=0.5),
            nn.Linear(2048, 2048),
            nn.ReLU(True),
            nn.Linear(2048, num_classes)
        )
        if init_weights:
            self._initialize_weights()

    def forward(self, x):
        # N x 3 x 224 x 224
        x = self.features(x)
        # N x 512 x 7 x 7
        x = torch.flatten(x, start_dim=1)#展平处理
        # N x 512*7*7
        x = self.classifier(x)
        return x

    def _initialize_weights(self): #初始化权重函数
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                nn.init.xavier_uniform_(m.weight)
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)#初始化偏置为0
            elif isinstance(m, nn.Linear):
                nn.init.xavier_uniform_(m.weight)
                # nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)


def make_features(cfg: list):#提取特征函数
    layers = [] #存放创建每一层结构
    in_channels = 3 #RGB
    for v in cfg:
        if v == "M":
            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
        else:
            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
            layers += [conv2d, nn.ReLU(True)]
            in_channels = v
    return nn.Sequential(*layers)   #通过非关键字参数传入


cfgs = {
    'vgg11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'], #数字为卷积层个数，M为池化层结构
    'vgg13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
    'vgg16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
    'vgg19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
}

#实例化VGG网络
def vgg(model_name="vgg16", **kwargs): #**字典
    try:
        cfg = cfgs[model_name]
    except:
        print("Warning: model number {} not in cfgs dict!".format(model_name))
        exit(-1)
    model = VGG(make_features(cfg), **kwargs) #
    return model


#vgg_model = vgg(model_name='vgg13')

参考：VGG——CNN经典网络模型（pytorch实现）

 

vgg16查看：vgg16

参考：《深度学习——Caffe之经典模型详解与实战》--第8章 VGGNet模型

参考：一文读懂VGG网络