VGGNet网络结构
下面代码基于VGG-16
from datetime import datetime
import math
import time
import tensorflow as tf
# 定义参数初始化函数Xavier初始化方法在4.1自编码器有讲过
# 参考：https://blog.csdn.net/li_haiyu/article/details/80009430
# def xavier_init( fan_in, fan_out, constant = 1 ):
# low = -constant * np.sqrt( 6.0 / ( fan_in + fan_out ) )
# high = constant * np.sqrt( 6.0 / ( fan_in + fan_out ) )
# return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high, dtype=tf.float32 )
# 创建函数conv_op来创建卷积层并将本层参数存入参数列表中
# input_op 输入tensor，kh：kernel hight,kw:kernel width,n_out:卷积核数量，dh步长的高，dw步长的宽，p是参数列表
def conv_op(input_op,name,kh,kw,n_out,dh,dw,p):
# a.get_shape()获取tensor的维度，此函数维度以元组返回，list/tuple.[-1]表示获取最后一个数，本处获图像通道数
# 参考：https://blog.csdn.net/li_haiyu/article/details/80063842
n_in = input_op.get_shape()[-1].value
# tf.name_scope主要实现参数命名管理
# 参考：https://blog.csdn.net/Li_haiyu/article/details/80119340
with tf.name_scope(name) as scope:
# shape = [高，宽，输入通道数，输出通道数]
kernel = tf.get_variable(scope+"W",shape=[kh,kw,n_in,n_out],dtype=tf.float32,
initializer=tf.contrib.layers.xavier_initializer_conv2d())
# 对input_op进行卷积操作
conv = tf.nn.conv2d(input_op,kernel,(1,dh,dw,1),padding = "SAME")
# biases使用tf.constant赋值0，再使用tf。Variable将其转化成可训练的参数
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:
# 全链接层的参数维度只有两个，第一个数输入通道数n_in，第二是输出通道数n_out
kernel = tf.get_variable(scope+"w",shape=[n_in,n_out],dtype=tf.float32,
initializer=tf.contrib.layers.xavier_initializer())
# baises 不再初始化为0，而是赋予一个较小的值0.1，为了避免dead neuron
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,池化尺寸为kh*kw 步长尺寸为dh*dw
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部分，前五部分为卷积网络，最后一个部分为全链接网络
我们定义的inference有两个输入input_op和keep_prob,keep_prob用来控制droput的对神经元的保留率
第一个卷积层的输入为input_op的尺寸为224*224*3，输出尺寸为224*224*64
而第二个卷积层的输入输出尺寸均为224*224*64，卷积层的最大池化层则是一个标准的2*2最大池化，输出为112*112*64"""
def inference_op(input_op,keep_prob):
p = []
'''第一部分卷积输入为224*224*3'''
# 第一部分卷积
# 一共有两个层卷积层，都是64个卷积核，尺寸都是3*3，步长为1*1
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)
# 第一部分卷积之后进行maxpooling,步长为2*2
pool1 = mpool_op(conv1_2,name = 'pool1',kh=2,kw=2,dh=2,dw=2)
'''第一部分卷积输出为112*112*64'''
# 第二部分卷积
# 一共有两个卷积层，都是128个卷积核，尺寸都是3*3，步长为1*1
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)
# 第二部分卷积之后进行maxpooling,步长为2*2
pool2 = mpool_op(conv2_2, name='pool2', kh=2, kw=2,dh=2,dw=2)
'''最大池化后输出56*56*128'''
# 第三部分卷积
# 一共有三个卷积层，都是256个卷积核，尺寸都是3*3，步长为1*1
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)
# 第三部分卷积之后进行maxpooling,步长为2*2
pool3 = mpool_op(conv3_3, name='pool3', kh=2, kw=2,dh=2,dw=2 )
'''最大池化后输出28*28*256'''
# 第四部分卷积
# 一共有三个卷积层，都是512个卷积核，尺寸都是3*3，步长为1*1
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)
# 第三部分卷积之后进行maxpooling,步长为2*2
pool4 = mpool_op(conv4_3, name='pool4', kh=2, kw=2, dh=2, dw=2)
'''最大池化后输出14*14*512'''
# 第五部分卷积
# 一共有三个卷积层，还是512个卷积核，尺寸都是3*3，步长为1*1
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)
# 第三部分卷积之后进行maxpooling,步长为2*2
pool5 = mpool_op(conv5_3, name='pool5', kh=2, kw=2, dh=2, dw=2)
'''最大池化后输出7*7*512'''
'''也许你已经发现了VGG—16的每一段卷积网络都会将图像的边长缩小一半，但是卷积输出通道数翻倍，
这样图像面积缩小到1/4，输出通道变为2倍，因此输出通道数增加到152，但是通过最大池化将图像缩小片缩小为7*7'''
'''全链接层走起'''
'''我们将第五段卷积的输出结果进行扁平化，使用tf.reshape函数将样本华为长度为7*7*512 = 25088的一维向量'''
shp = pool5.get_shape()
# 对三个维度分别取值相乘
flattened_shape = shp[1].value*shp[2].value*shp[3].value
# 最后整形成一行，一共有25088个元素
resh1 = tf.reshape(pool5,[-1,flattened_shape],name='resh1')
# 然后链接一个隐含层节点数为4096的全连接层，激活函数为ReLu，然后链接一个dropout层，在节点训练时保留率为0.5，预测时为1.0
'''keep_prob在训练时应该是小于1的，用于制造随机性，防止过拟合，在测试时keep_prob应该是等于1的，即使用全部特征来预测样本的类别'''
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进行处理得到输出分类概率，
# 这里使用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()和前面Alexnet中的十分相似，只有一点区别：
我们在session.run()方法中加入了fee_dict,方便后面传入keep_drop来控制Dropout层的保留比率'''
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 = match.sqrt(vr)
print('%s: %s across %d steps,%.3f +/- %.3f sec/batch'%(datetime.now(),info_string,num_batches,mn,sd))
'''下面定义测评主函数run_benchmark,我们的目标依然是测评forward和backward的运算性能'''
def run_benchmark():
with tf.Graph().as_default():
image_size = 224
images = tf.Variable(tf.truncated_normal([batch_size,image_size,image_size,3],dtype=tf.float32,stddev=1e-1))
# 接下来创建keep_prob的placeholder，并调用inference_op函数构建VGG—16的网络结构，获得fc8，predictions，softmax和参数列表p
keep_prob = tf.placeholder(tf.float32)
predictions,softmax,fc8,p = inference_op(images,keep_prob)
# 然后创建Session并初始化全局参数
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
# keep_prob设置为1.0，使用time_tensorflow_run()进行测评forward运算时间，再计算VGG-16最后的全连接层输出fc8的l2 loss,
# 并使用tf.gradients求相对于这个loss的所有模型参数的梯度，最后使用time_tenssorflow_run评测backward的运算时间，这里target
# 为求梯度的操作grad，keep_prob为0.5
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()