VGGNet-16 解析 + TensorFlow实现

以你之姓@ 2022-03-17 05:26 272阅读 0赞

VGGNet通过反复堆叠3x3的小型卷积核和2x2的最大池化层，构筑了16~19层深的神经网络。在错误率大大降低的同时扩展性很强，迁移到其它图片数据上的泛化能力很好，而且结构简单。

VGGNet拥有从A到E的五个级别，每一级网络都比前一级根深，但是参数并没有增加很多，因为卷积部分消耗参量不大，主要在全连接层。D和E就是常说的VGGNet-16和VGGNet-19。

VGGNet拥有5段卷积，每一段卷积内有2~3个卷积层，同时每段尾部都会连接一个最大池化层用来缩小图片尺寸，5段卷积后有3个全连接层，然后通过softmax(）来预测结果。

--------------------

总结一些关键点：

1.  在级别C中有几个1x1的卷积层，1x1的卷积的意义主要在于线性变换，因为输入通道数和输出通道数不变，没有发生降维。
2.  VGGNet中经常出现多个完全一样的3x3的卷积层堆叠在一起的情况，因为两个3x3的卷积层串联相当于1个5x5的卷积层，即一个像素会跟周围5x5的像素产生联系，可以说感受视野大小为5x5。  
    首先，2个串联的3x3卷积层（2x9个参数）拥有比1个5x5的卷积层(25个参数）更少的参数量；其次，2个串联的3x3卷积层（使用2次ReLU激活函数）拥有比1个5x5的卷积层（使用1次ReLU激活函数）更多的非线性变换，使得学习能力更强。
3.  使用Mutlti-Scale的方法做数据增强，将原始图像缩放到不同的尺寸S然后随机剪裁程224x224的图片，这样可以增加更多的数据量，对防止模型过拟合有很不错的效果。  
    同时作者另S的取值在\[256, 512\]这个区间内取值，可以获得更多版本的数据，然后一起训练。
4.  VGGNet的模型参数虽然比AlexNet多，但反而只需要较少的迭代次数就可以收敛，主要原因是更深的网络和更小的卷积核带来的隐式的正则化效果。

作者提出了以下几个观点：
    1. LRN层作用不大
    2. 越深的网络效果越好
    3. 1x1的卷积也是很有效的， 但没有3x3的卷积好，大一些的卷积核可以学习更大的空间特征。

--------------------

输入是224x224x3的图像，下面是每一层的大小：  
conv1\_1 \[32, 224, 224, 64\]  
conv1\_2 \[32, 224, 224, 64\]  
pool1 \[32, 112, 112, 64\]  
conv2\_1 \[32, 112, 112, 128\]  
conv2\_2 \[32, 112, 112, 128\]  
pool2 \[32, 56, 56, 128\]  
conv3\_1 \[32, 56, 56, 256\]  
conv3\_2 \[32, 56, 56, 256\]  
conv3\_3 \[32, 56, 56, 256\]  
pool3 \[32, 28, 28, 256\]  
conv4\_1 \[32, 28, 28, 512\]  
conv4\_2 \[32, 28, 28, 512\]  
conv4\_3 \[32, 28, 28, 512\]  
pool4 \[32, 14, 14, 512\]  
conv5\_1 \[32, 14, 14, 512\]  
conv5\_2 \[32, 14, 14, 512\]  
conv5\_3 \[32, 14, 14, 512\]  
pool5 \[32, 7, 7, 512\]  
fc6 \[32, 4096\]  
fc7 \[32, 4096\]  
fc8 \[32, 1000\]

--------------------

下面是使用Tensorflow的实现：

# _*_ coding:utf-8 _*_
    
    import math
    import time
    import tensorflow as tf
    from datetime import datetime
    
    batch_size = 32
    num_batches = 100
    
    # 卷积层
    '''
        input_op输入的tensor
        kh, kw是卷积核的高和宽
        dh, w是步长到的高和宽
        p参数列表
    '''
    def conv_op(input_op, name, kh, kw, n_out, dh, dw, p):
        n_in = input_op.get_shape()[-1].value
    
        with tf.name_scope(name) as scope:
            kernel = tf.get_variable(scope+'w',
                                     shape=[kh, kw, n_in, n_out], dtype=tf.float32,
                                     initializer=tf.contrib.layers.xavier_initializer_conv2d())
            conv = tf.nn.conv2d(input_op, kernel, strides=[1, dh, dw, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[n_out], dtype=tf.float32), trainable=True, name='biases')
            z = tf.nn.bias_add(conv, biases)
            activation = tf.nn.relu(z, name=scope)
            p += [kernel, biases]
    
        return activation
    
    # 全连接层
    def fc_op(input_op, name, n_out, p):
        n_in = input_op.get_shape()[-1].value
    
        with tf.name_scope(name) as scope:
            kernel = tf.get_variable(scope+'w',
                                     shape=[n_in, n_out], dtype=tf.float32,
                                     initializer=tf.contrib.layers.xavier_initializer())
            biases = tf.Variable(tf.constant(0.1, shape=[n_out], dtype=tf.float32), trainable=True, name='biases')
            activation = tf.nn.relu_layer(input_op, kernel, biases, name=scope)
            p += [kernel, biases]
    
        return activation
    
    # 最大池化层
    def mpool_op(input_op, name, kh, kw, dh, dw):
        return tf.nn.max_pool(input_op,
                              ksize=[1, kh, kw, 1],
                              strides=[1, dh, dw, 1],
                              padding='SAME',
                              name=name)
    
    # 网络结构
    def inference_op(input_op, keep_prob):
        parameters = []
    
        # 第一段卷积网络
        conv1_1 = conv_op(input_op, name='conv1_1', kh=3, kw=3, n_out=64, dh=1, dw=1, p=parameters)
        conv1_2 = conv_op(conv1_1, name='conv1_2', kh=3, kw=3, n_out=64, dh=1, dw=1, p=parameters)
        pool1 = mpool_op(conv1_2, name='pool1', kh=2, kw=2, dw=2, dh=2)
    
        # 第二段卷积网络
        conv2_1 = conv_op(pool1, name='conv2_1', kh=3, kw=3, n_out=128, dh=1, dw=1, p=parameters)
        conv2_2 = conv_op(conv2_1, name='conv2_2', kh=3, kw=3, n_out=128, dh=1, dw=1, p=parameters)
        pool2 = mpool_op(conv2_2, name='pool2', kh=2, kw=2, dh=2, dw=2)
    
        # 第三段卷积网络
        conv3_1 = conv_op(pool2, name='conv3_1', kh=3, kw=3, n_out=256, dh=1, dw=1, p=parameters)
        conv3_2 = conv_op(conv3_1, name='conv3_2', kh=3, kw=3, n_out=256, dh=1, dw=1, p=parameters)
        conv3_3 = conv_op(conv3_2, name='conv3_3', kh=3, kw=3, n_out=256, dh=1, dw=1, p=parameters)
        pool3 = mpool_op(conv3_3, name='pool3', kh=2, kw=2, dh=2, dw=2)
    
        # 第四段卷积网络
        conv4_1 = conv_op(pool3, name='conv4_1', kh=3, kw=3, n_out=512, dh=1, dw=1, p=parameters)
        conv4_2 = conv_op(conv4_1, name='conv4_2', kh=3, kw=3, n_out=512, dh=1, dw=1, p=parameters)
        conv4_3 = conv_op(conv4_2, name='conv4_3', kh=3, kw=3, n_out=512, dh=1, dw=1, p=parameters)
        pool4 = mpool_op(conv4_3, name='pool4', kh=2, kw=2, dh=2, dw=2)
    
        # 第五段卷积网络
        conv5_1 = conv_op(pool4, name='conv5_1', kh=3, kw=3, n_out=512, dh=1, dw=1, p=parameters)
        conv5_2 = conv_op(conv5_1, name='conv5_1', kh=3, kw=3, n_out=512, dh=1, dw=1, p=parameters)
        conv5_3 = conv_op(conv5_2, name='conv5_3', kh=3, kw=3, n_out=512, dh=1, dw=1, p=parameters)
        pool5 = mpool_op(conv5_3, name='conv5_3', kh=2, kw=2, dh=2, dw=2)
    
        # 扁平化
        shp = pool5.get_shape()
        flattened_shape = shp[1].value * shp[2].value * shp[3].value
        resh1 = tf.reshape(pool5, [-1, flattened_shape], name='resh1')
    
        # 全连接层
        fc6 = fc_op(resh1, name='fc6', n_out=4096, p=parameters)
        fc6_drop = tf.nn.dropout(fc6, keep_prob, name='fc6_drop')
        fc7 = fc_op(fc6_drop, name='fc7', n_out=4096, p=parameters)
        fc7_drop = tf.nn.dropout(fc7, keep_prob, name='fc7_drop')
        fc8 = fc_op(fc7_drop, name='fc8', n_out=1000, p=parameters)
        softmax = tf.nn.softmax(fc8)
        predictions = tf.argmax(softmax, 1)
    
        return predictions, softmax, fc8, parameters

作者：Manfestain  
链接：https://www.jianshu.com/p/fcb2ff59f7e6  
來源：简书  
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

发表评论取消回复

表情：

评论列表（有 0 条评论，272人围观）

还没有评论，来说两句吧...

相关阅读

相关经典网络VGGNet介绍

经典网络VGGNet(其中VGG为Visual Geometry Group)由Karen Simonyan等于2014年提出，论文名为《Very Deep Convoluti

我会带着你远行/ 2023年01月10日 10:17/ 0 赞/ 240 阅读

相关【北京大学】12 TensorFlow1.x的卷积神经网络模型VGGNet实现

目录 1 简介 2 基本方法 3 实现 app.py文件 vgg16.py文件 utils.py文件

叁歲伎倆/ 2022年12月29日 11:20/ 0 赞/ 195 阅读

相关 uint16 java_java解析UINT16

JAVA解释UINT16文件，首先将UINT16文件用byte来读取 try \{ File file = new File(filePath); FileInputSt

Bertha 。/ 2022年11月02日 13:23/ 0 赞/ 452 阅读

相关【Tensorflow】深度学习实战04——Tensorflow实现VGGNet

【[fishing-pan][]：[https://blog.csdn.net/u013921430][https_blog.csdn.net_u013921430]

川长思鸟来/ 2022年05月23日 23:35/ 0 赞/ 347 阅读

相关【深度学习】GoogleNet原理解析与tensorflow实现

【深度学习】GoogleNet原理解析与tensorflow实现 1.googleNet系列介绍 2.googlenet思想 3.googleNet实现 Googe

ゞ浴缸里的玫瑰/ 2022年05月21日 01:06/ 0 赞/ 262 阅读

相关【深度学习】VGGNet原理解析及实现

【深度学习】VGGNet原理解析及实现 VGGNet由牛津大学的视觉几何组（Visual Geometry Group）和Google DeepMind公司的研究员共同

亦凉/ 2022年05月20日 22:39/ 0 赞/ 623 阅读

相关大话CNN经典模型：VGGNet

— 原文发布于本人的微信公众号“大数据与人工智能Lab”（BigdataAILab），欢迎关注。 ![022831_wOGN_876354.png][] 2014年，牛津

偏执的太偏执、/ 2022年05月19日 11:49/ 0 赞/ 265 阅读

相关 ubuntu16.04下安装tensorflow

输入命令： pip install tensorflow-gpu==1.4.1 ps:cuda:8.0 cudnn:6.0 cuda版本查看： cat /us

╰半夏微凉°/ 2022年05月11日 06:20/ 0 赞/ 339 阅读

相关 TensorFlow学习（五）之Ubuntu16.04安装TensorFlow———GPU版本（gtx1070+ubuntu16.04）

Ubuntu16.04系统安装系列： [Ubuntu系统安装QQ+百度云盘+微信+迅雷下载等][Ubuntu_QQ] [Ubuntu系统安

超、凢脫俗/ 2022年04月06日 04:52/ 0 赞/ 249 阅读

相关 VGGNet-16 解析 + TensorFlow实现

VGGNet通过反复堆叠3x3的小型卷积核和2x2的最大池化层，构筑了16~19层深的神经网络。在错误率大大降低的同时扩展性很强，迁移到其它图片数据上的泛化能力很好，而且结构简

以你之姓@/ 2022年03月17日 05:26/ 0 赞/ 273 阅读