Tensorflow实现VGGNet及其原理

    VGGNet探索了卷积神经网络与其性能之间的关系，通过反复叠堆3*3的小型卷积核和2*2的最大池化层，VGGNet成功构造了16~19层深的卷积神经网络。目前，VGGNet依然经常用于提取图像特征。

VGGNet各级别的网络结构图：

   从11层的网络一直到19层的网络都有详细的性能测试，虽然从A到E级网络逐渐变深，但网络的参数量便没有增加很大，如图2，这是因为参数主要消耗在后面的三个全连接层。不过训练比较耗时的还是卷积，其中D和E是我们常说的VGGNet-16和VGGNet-19，C很有意思，相比B多了几个1*1的卷积层，1*1的卷积层意义在于线性变换，而输入通道数和输出通道数不变，没有发生降维。

图1：VGGNet各级别的网络结构

图2VGGNet各级别网络参数量： 

VGGNet拥有5段卷积，每一段内有2~3个卷积层，每段尾部连接一个最大池化层来缩小图片尺寸，每段内的卷积核数量一样。图3中，两个3*3的卷积层串联相当于1个5*5的卷积层，即一个 像素会和周围5*5的像素产生关联，可以说感受视野为5*5。而三个3*3的卷积层串联相当于1个7*7的卷积层，三个3*3的串联的卷积层比1个7*7的卷积层更少的参数量，而且有更多的非线性变换。使CNN对特征的学习能力更强。

图3：

VGGNet在训练时有一个技巧，先训练级别低的A的简单网络，再复用A网络的权重来初始化后面的几个复杂模型，这样训练收敛的速度更快。在预测时，VGG采用Multi-Scale的方法，将图像Scale到一个尺寸Q，并将图片输入卷积网络计算。然后再最后一个卷积层使用滑窗的方式进行分类预测，将不同窗口的分类结果平均，再将不同尺寸Q的结果平均得到最后结果，这样可提高图片数据的利用率并提升预测准确率。VGGNet还使用了Multi-Scale的方法做数据增强，将原始图像缩放到不同尺寸的S，然后再随机裁切224*224的图片，这样能增加很多数据量，可以防止模型过拟合。

有以下几个观点：

（1）LRN层的作用不大

（2）越深的网络效果越好

（3）1*1的卷积也很有效，但没有3*3的卷积好，大一些的卷积核可以学习更大的空间特性。

图4各级别VGGNet在使用Multi-Scale训练时的top-5错误率：

 VGGNet训练时使用了4块Geforce GTX Titan GPU并行计算，比单块GPU快3.75倍，几乎没有太多的性能损耗。下面的实现中不直接使用ImageNet数据训练一个VGGNet，和AlexNet一样构造VGGNet网络结构，并测评forward和backwars耗时。

实现VGGNet-16： 即版本D

from datetime import datetime
import math 
import time
import tensorflow as tf

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:
        #使用tf.get_variable创建卷积核参数kernel
        kernel=tf.get_variable(scope+"w",
                               shape=[kh,kw,n_in,n_out],dtype=tf.float32,
                               initializer=tf.contrib.layers.xavier_initializer_conv2d())
        #使用tf.nn.conv2d对input_op进行卷积处理
        conv=tf.nn.conv2d(input_op,kernel,(1,dh,dw,1),
                          padding='SAME')
        bias_init_val=tf.constant(0.0,shape=[n_out],dtype=tf.float32)
        biases=tf.Variable(bias_init_val,trainable=True,name='b')
        z=tf.nn.bias_add(conv,biases)
        activation=tf.nn.relu(z,name=scope)
        p+=[kernel,biases]
        return activation

#定义全连层的创建函数fc_op
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),name='b')
        activation=tf.nn.relu_layer(input_op,kernel,biases,name=scope)
        p+=[kernel,biases]
        return activation

#定义最大池化层的创建函数mpool_op
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)

#创建VGGNet-16的网络结构，分为6个部分，前5段为卷积层，最后一段为全连接网络
#第一段卷积网络,包括两个卷积层和一个最大池化层
def inference_op(input_op,keep_prob):
    p=[]
    conv1_1=conv_op(input_op,name="conv1_1",kh=3,kw=3,n_out=64,dh=1,dw=1,p=p)
    conv1_2=conv_op(conv1_1,name="conv1_2",kh=3,kw=3,n_out=64,dh=1,dw=1,p=p)
    pool1=mpool_op(conv1_2,name="pool1",kh=2,kw=2,dw=2,dh=2)

#第二段卷积网络，输出通道变为128,其他和第一段类似
    conv2_1=conv_op(pool1,name="conv2_1",kh=3,kw=3,n_out=128,dh=1,dw=1,p=p)
    conv2_2=conv_op(conv2_1,name="conv2_2",kh=3,kw=3,n_out=128,dh=1,dw=1,p=p)
    pool2=mpool_op(conv2_2,name="pool2",kh=2,kw=2,dw=2,dh=2)

#第三段卷积网络，三个卷积层和一个最大池化层，输出通道为256
    conv3_1=conv_op(pool2,name="conv3_1",kh=3,kw=3,n_out=256,dh=1,dw=1,p=p)
    conv3_2=conv_op(conv3_1,name="conv3_2",kh=3,kw=3,n_out=256,dh=1,dw=1,p=p)
    conv3_3=conv_op(conv3_2,name="conv3_3",kh=3,kw=3,n_out=256,dh=1,dw=1,p=p)
    pool3=mpool_op(conv3_3,name="pool3",kh=2,kw=2,dw=2,dh=2)

#第四三段卷积网络，三个卷积层和一个最大池化层
    conv4_1=conv_op(pool3,name="conv4_1",kh=3,kw=3,n_out=512,dh=1,dw=1,p=p)
    conv4_2=conv_op(conv4_1,name="conv4_2",kh=3,kw=3,n_out=512,dh=1,dw=1,p=p)
    conv4_3=conv_op(conv4_2,name="conv4_3",kh=3,kw=3,n_out=512,dh=1,dw=1,p=p)
    pool4=mpool_op(conv4_3,name="pool4",kh=2,kw=2,dw=2,dh=2)

#第五三段卷积网络，三个卷积层和一个最大池化层，输出通道维持512
    conv5_1=conv_op(pool4,name="conv5_1",kh=3,kw=3,n_out=512,dh=1,dw=1,p=p)
    conv5_2=conv_op(conv5_1,name="conv5_2",kh=3,kw=3,n_out=512,dh=1,dw=1,p=p)
    conv5_3=conv_op(conv5_2,name="conv5_3",kh=3,kw=3,n_out=512,dh=1,dw=1,p=p)
    pool5=mpool_op(conv5_3,name="pool5",kh=2,kw=2,dw=2,dh=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")

    #连接一个隐含节点数为4096的全连接层，激活函数为ReLU
    fc6=fc_op(resh1,name="fc6",n_out=4096,p=p)
    fc6_drop=tf.nn.dropout(fc6,keep_prob,name="fc6_drop")

    #与前面一样的全连层
    fc7=fc_op(fc6_drop,name="fc7",n_out=4096,p=p)
    fc7_drop=tf.nn.dropout(fc7,keep_prob,name="fc7_drop")

    #连接一个有1000个输出节点的全连接层，并使用SoftMax进行分类处理
    fc8=fc_op(fc7_drop,name="fc8",n_out=1000,p=p)
    softmax=tf.nn.softmax(fc8)
    predicitions=tf.argmax(softmax,1)
    return predicitions,softmax,fc8,p


#评测函数，与AlexNet类似
def time_tensorflow_run(session,target,feed,info_string):
    num_steps_burn_in=10
    total_duration=0.0
    total_duration_squared=0.0
    for i in range(num_batches+num_steps_burn_in):
        start_time=time.time()
        _=session.run(target,feed_dict=feed)
        duration=time.time() - start_time
        if i>=num_steps_burn_in:
            if not i % 10:
                print('%s:step %d,duration=%.3f'%
                      (datetime.now(),i-num_steps_burn_in,duration))
                total_duration+=duration
                total_duration_squared+=duration*duration
    mn=total_duration/num_batches
    vr=total_duration_squared/num_batches-mn*mn
    sd=math.sqrt(vr)
    print('%s:%s across %d steps,%.3f +/- %.3f sec /batch'%
          (datetime.now(),info_string,num_batches,mn,sd))


#评测的主函数
def run_benchmark():
    with tf.Graph().as_default():
        image_size=224
        images=tf.Variable(tf.random_normal([batch_size,
                                             image_size,
                                             image_size,3],
        dtype=tf.float32,
        stddev=1e-1))
        keep_prob=tf.placeholder(tf.float32)
        predictions,softmax,fc8,p=inference_op(images,keep_prob)
        init=tf.global_variables_initializer()
        sess=tf.Session()
        sess.run(init)
        time_tensorflow_run(sess,predictions,{keep_prob:1.0},"Forward")
        objective=tf.nn.l2_loss(fc8)
        grad=tf.gradients(objective,p)
        time_tensorflow_run(sess,grad,{keep_prob:0.5},"Forward-backward")

batch_size=32
num_batches=100
run_benchmark()

（我用的cpu,,,,太慢。 我就不跑了）

VGGNet的模型参数虽然比AlexNet是多，但需要的迭代次数少就可以收敛， 主要原因是更深的网络和更小的卷积核带来的隐式的正则化效果，VGGNet凭借其相对不算很高的复杂度和优秀的分类性能， 成为一代经典的卷积神经网络。

参考文献：

Tensorflow实战（ 黄文坚）