Tensorflow入门五 AlexNet结构

老规矩，上代码，看注释

AlexNet是深度学习鼻祖的弟子的代表作，牛叉牛叉

不过在Tensorflow里看起来不是很麻烦的样子

hhhh

感谢google爸爸

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

batch_size=32
num_batches=100#100个数据

#显示每一层结构，展示每一个卷积层或池化层输出的tensor尺寸
#接收一个tensor作为输入，显示名称和尺寸
#四维tensor
def print_activations(t):
    print (t.op.name,' ',t.get_shape().as_list())

#AlexNet结构，先定义Inference,接收images作为输入
#with tf.name...可以将scope内生成的Variable自动命名为conv1/xxx
#便于区分不同卷积层之间的组件
def inference(images):
    parameters=[]

    with tf.name_scope('conv1') as scope:
        kernel = tf.Variable(tf.truncated_normal([11,11,3,64],dtype=tf.float32,stddev=1e-1),name='weights')
        conv=tf.nn.conv2d(images,kernel,[1,4,4,1],padding='SAME')
        biases=tf.Variable(tf.constant(0.0,shape=[64],dtype=tf.float32),trainable=True,name='biases')
        bias=tf.nn.bias_add(conv,biases)
        conv1=tf.nn.relu(bias,name=scope)
        print_activations(conv1)
        parameters+=[kernel,biases]
        # 在第一个卷积层之后添加LRN层和最大池化层
        # LRN：depth_radius设置为4，bias设置为1...(基本是AlexNet推荐值)
        lrn1 = tf.nn.lrn(conv1, 4, bias=1.0, alpha=0.001 / 9, beta=0.75, name='lrn1')
        # 池化尺寸3*3，，步长2*2,padding意味着取样不能超过边框
        pool1 = tf.nn.max_pool(lrn1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding='VALID', name='pool1')
        print_activations(pool1)

    #第二个卷积层：
    with tf.name_scope('conv2') as scope:
        kernel=tf.Variable(tf.truncated_normal([5,5,64,192],dtype=tf.float32,stddev=1e-1),name='weights')
        conv=tf.nn.conv2d(pool1,kernel,[1,1,1,1],padding='SAME')
        biases=tf.Variable(tf.constant(0.0,shape=[192],dtype=tf.float32),trainable=True,name='biases')
        bias=tf.nn.bias_add(conv,biases)
        conv2=tf.nn.relu(bias,name=scope)
        parameters+=[kernel,biases]
    print_activations(conv2)
    #对第二个卷积层的输出conv2进行处理
    lrn2=tf.nn.lrn(conv2,4,bias=1.0,alpha=0.001/9,beta=0.75,name='lrn2')
    pool2=tf.nn.max_pool(lrn2,ksize=[1,3,3,1],strides=[1,2,2,1],padding='VALID',name='pool2')
    print_activations(pool2)

    #第三个卷积层，结构类似只是参数不同
    with tf.name_scope('conv3') as scope:
        kernel=tf.Variable(tf.truncated_normal([3,3,192,384],dtype=tf.float32,stddev=1e-1),name='weights')
        conv=tf.nn.conv2d(pool2,kernel,[1,1,1,1],padding='SAME')
        biases=tf.Variable(tf.constant(0.0,shape=[384],dtype=tf.float32),trainable=True,name='biases')
        bias=tf.nn.bias_add(conv,biases)
        conv3=tf.nn.relu(bias,name=scope)
        parameters+=[kernel,biases]
        print_activations(conv3)
    #第四层
    with tf.name_scope('conv4') as scope:
        kernel=tf.Variable(tf.truncated_normal([3,3,384,256],dtype=tf.float32,stddev=1e-1),name='weights')
        conv=tf.nn.conv2d(conv3,kernel,[1,1,1,1],padding='SAME')
        biases=tf.Variable(tf.constant(0.0,shape=[256],dtype=tf.float32),trainable=True,name='biases')
        bias=tf.nn.bias_add(conv,biases)
        conv4=tf.nn.relu(bias,name=scope)
        parameters+=[kernel,biases]
        print_activations(conv4)
    #第五层
    with tf.name_scope('conv5') as scope:
        kernel=tf.Variable(tf.truncated_normal([3,3,256,256],dtype=tf.float32,stddev=1e-1),name='weights')
        conv=tf.nn.conv2d(conv4,kernel,[1,1,1,1],padding='SAME')
        biases=tf.Variable(tf.constant(0.0,shape=[256],dtype=tf.float32),trainable=True,name='biases')
        bias=tf.nn.bias_add(conv,biases)
        conv5=tf.nn.relu(bias,name=scope)
        parameters+=[kernel,biases]
        print_activations(conv5)
    #最大池化层,与前两个卷积层之后的池化层一致
    #输出pool5，inference完成,它可以创建AlexNet的卷积部分
    #训练和预测之前还需要添加三个全连接层
    #隐含节点数：4096，4096，1000
    #最后三层的计算量很小，影响小
        pool5=tf.nn.max_pool(conv5,ksize=[1,3,3,1],strides=[1,2,2,1],padding='VALID',name='pool5')
        print_activations(pool5)
    return pool5,parameters

#自行添加三个全连接层

#评估每轮计算时间函数
def time_tensorflow_run(session,target,info_string):#1.Session 2.需要测评的运算算子 3.测试的名称
    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)
        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和标准差sd
    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
        ))#不用数据集，随机生成，用于xunlian
        pool5,parameters=inference(images)
        init=tf.global_variables_initializer()
        sess=tf.Session()
        sess.run(init)


        time_tensorflow_run(sess,pool5,"Forward")#统计运算时间
        objective=tf.nn.l2_loss(pool5)
        grad=tf.gradients(objective,parameters)
        time_tensorflow_run(sess,grad,"Forward-backward")#统计backward的时间
run_benchmark()
#反馈是前馈的3倍，比较耗时