VGGNet

"""VGGNet是牛津大学计算机视觉组（Visual Geometry Group )与Google DeepMind一起研发的深度卷积神经网络。
结构简洁，整个网络都使用了同样大小的卷积核尺寸（3*3），和最大池化尺寸（2*2）
泛化性好，可用来提取图像特征。VGGNet训练后的模型参数在其官方网址上开源了，可用来在domain specific的图像分类任务上进行再训练,
相当于提供了非常好的初始化权重!
1*1的卷积的意义主要在于线性变换，通道数不变，但大一些的卷积核可以学习更大的空间特征
卷积：计算量 ；全连接层： 参数量
input：224*224 RGB image
VGGNet-16：5段卷积，每段有2~3个卷积层  （64-128-256-512-512）
两个3*3的卷积层串联相当于一个5*5的卷积层，感受野大小为5*5.
而3个3*3的卷积层串联相当于一个7*7的卷积层，拥有比其更少的参数量，只有后者的3*3*3/7*7=55%
更重要的是三个拥有更多的非线性变换，可使用三次RELU激活函数，使得CNN对特征的学习能力更强
这里不直接使用ImageNet数据训练一个VGGNet,而是采用跟AlexNet一样的方式：
构造出VGGNet的网络结构，并评测其forward(inference)耗时和backward（training)耗时
"""

#调用系统库和Tensorflow
from datatime import datatime
import math
import time
import tensorflow as tf

# conv_op函数
# input_op是输入的tensor，name是这一层的名字，n_out是卷积核数量即输出通道数，dh是补偿的高，dw是步长的宽，p是参数列表[]
# get_shape()[-1].value 获取 input_op 的通道数

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())
        #用tf.get_variable创建卷积层的参数，参数维度有四个，然后参数初始化。
        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   #返回relu(z)

#接下来定义全连接层的创建函数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.xvier_initializer())
        biases = tf.Variable(tf.constant(0.1,shape=[n_out],    #不再是0，以避免dead neuron
                                          dtype=tf.float32),name='b')
        activation= tf.nn.relu_layer(input_op, kernel, biases,name=scope)
        p +=[kernel, biases]
        return activation

#再定义最大池化层的创建函数mpool_op,这里直接使用tf.nn.max_pool,
#输入即为input_op,池化尺寸为dh*dw，padding模式设为SAME.
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网络结构的函数inference_op,
输入有input_op和keep_prob（是控制dropout比率的一个placeholder）
step1:先初始化参数列表p
step2:第一段卷积网络，由两个卷积层和一个最大池化层构成
卷积核大小：3*3，卷积核数量：64，步长为1*1，全像素扫描
input_op:224*22*3     224*224*64    224*224*64    112*112*64(标准的2*2的最大池化)
"""

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) #ksize,strides

    #第二段卷积网络与第一段非常类似，但通道数变为128，是以前的两倍，这一段输出尺寸为56*56*128
    conv2_1 =conv_op(pool1,name="conv2_1",kh=3,kw=3,n_out=128,dh=1,dw=1,p=p)
    conv2_2 =vonv_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,dh=2,dw=2)

    #第三段卷积，三个卷积层和一个最大池化层，通道数为256，这一段卷积网络的输出尺寸为28*28*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,dh=2,dw=2)

    #第四段网络也是3个卷积层和一个最大池化层，图像面积缩小到1/4，输出通道数变为2倍，因此输出tensor的总尺寸每次缩小一半，
    #这层就是将卷积输出通道数增加到512，通过最大池化将图片缩小为14*14  *512
    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,dh=2,dw=2)

    #第5段卷积网络通道数不再增加，继续维持在512，池化层尺寸为2*2，步长为2*2，到这里输出的尺寸为7*7*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)

    #将第五段卷积网络的输出结果进行扁平化，将每个样本化为长度为7*7*512=25088的一维向量
    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,然后连接一个Dropout层，在训练时节点保留率为0.5，预测时为1.0
    fc6 = fc_op(resh1,name="fc6", n_out=4096, p=p)
    fc6_drop= tf.nn.dropout(fc6, keep_prob, name="fc6_drop")

    #一样的全连接层，隐含节点数为4096
    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处理得到分类输出概率
    #使用tf.argmax求输出概率最大的类别
    #最后将fc8,softmax,predictions和参数列表p一起返回。
    fc8 =fc_op(fc7_drop,name="fc8",n_out=1000,p=p)
    softmax= tf.nn.softmax(fc8)
    predictions= tf.argmax(softmax,1)
    return predictions, softmax, fc8, p

    #评测函数：time_tensorflow_run()
    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  #一个batch的时间
            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))

    
    #下面定义  评测的主函数  run_benchmark   测forward与backward耗时
    #首先是生成224*224的随机图片
    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))
        #通过tf.random_normal函数生成标准差为0.1的正太分布的随机数
    #接下来，创建keep_prob的placeholder
    keep_prob= tf.placeholder(tf.float32)
    predictions, softmax, fc8, p = inference_op(images,keep_prob)
    #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)
    #fc6_drop/fc7_drop = tf.nn.dropout(fc6, keep_prob, name="fc6_drop")
    #return predictions, softmax, fc8, p

    #然后创建Session并初始化全局参数
    init= tf.global_variables_initializer()
    sess= tf.Session()
    sess.run(init)
     
      ###  time_tensorflow_run(target,feed)函数内有这个：_ = session_run(target, feed_dict=feed)
      ###   predictions, softmax, fc8, p = inference_op(images,keep_prob)
    time_tensorflow_run(sess, predictions, {keep_prob:1.0},"Forward")
    objective = tf.nn.l2_loss(fc8)   #求fc8的l2 loss
    grad = tf.gradients( objective, p)  #并使用tf.gradient求相对于这个loss的所有模型参数p的梯度
    time_tensorflow_run(sess,grad,{keep_prob:0.5},"Forward-backward")


    batch_size= 32
    num_batches= 100
    run_benchmark()


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