TensorFlow技术解析与实战学习笔记（13）------Mnist识别和卷积神经网络AlexNet - 吱吱了了

TensorFlow技术解析与实战学习笔记（13）------Mnist识别和卷积神经网络AlexNet

一、AlexNet：共8层：5个卷积层（卷积+池化）、3个全连接层，输出到softmax层，产生分类。

 论文中lrn层推荐的参数：depth_radius = 4，bias = 1.0 , alpha = 0.001 / 9.0 , beta = 0.75

lrn现在仅在AlexNet中使用，主要是别的卷积神经网络模型效果不明显。而LRN在AlexNet中会让前向和后向速度下降，（下降1/3）。

【训练时耗时是预测的3倍】

代码：

#加载数据
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/",one_hot = True)

#定义卷积操作
def conv2d(name , input_x , w , b , stride = 1,padding = \'SAME\'):
    conv = tf.nn.conv2d(input_x,w,strides = [1,stride,stride,1],padding = padding , name = name)
    return tf.nn.relu(tf.nn.bias_add(conv,b))
def max_pool(name , input_x , k=2):
    return tf.nn.max_pool(input_x,ksize = [1,k,k,1],strides = [1,k,k,1],padding = \'SAME\' , name = name)
def norm(name , input_x , lsize = 4):
    return tf.nn.lrn(input_x , lsize , bias = 1.0 , alpha = 0.001 / 9.0 , beta = 0.75 , name = name)

def buildGraph(x,learning_rate,weight,bias,dropout):

#############前向传播##################
    #定义网络
    x = tf.reshape(x , [-1,28,28,1])
    #第一层卷积
    with tf.variable_scope(\'layer1\'):
        conv1 = conv2d(\'conv1\',x,weight[\'wc1\'],bias[\'bc1\'])
        pool1 = max_pool(\'pool1\',conv1)
        norm1 = norm(\'norm1\',pool1)
    with tf.variable_scope(\'layer2\'):
        conv2 = conv2d(\'conv2\',norm1,weight[\'wc2\'],bias[\'bc2\'])
        pool2 = max_pool(\'pool2\',conv2)
        norm2 = norm(\'norm2\',pool2)
    with tf.variable_scope(\'layer3\'):
        conv3 = conv2d(\'conv3\',norm2,weight[\'wc3\'],bias[\'bc3\'])
        pool3 = max_pool(\'pool3\',conv3)
        norm3 = norm(\'norm3\',pool3)
    with tf.variable_scope(\'layer4\'):
        conv4 = conv2d(\'conv4\',norm3,weight[\'wc4\'],bias[\'bc4\'])
    with tf.variable_scope(\'layer5\'):
        conv5 = conv2d(\'conv5\',conv4,weight[\'wc5\'],bias[\'bc5\'])
        pool5 = max_pool(\'pool5\',conv5)
        norm5 = norm(\'norm5\',pool5)
    with tf.variable_scope(\'func1\'):
        norm5 = tf.reshape(norm5,[-1,4*4*256])
        fc1 = tf.add(tf.matmul(norm5,weight[\'wf1\']) , bias[\'bf1\'])
        fc1 = tf.nn.relu(fc1)
        #dropout
        fc1 = tf.nn.dropout(fc1,dropout)
    with tf.variable_scope(\'func2\'):
        fc2 = tf.reshape(fc1,[-1,weight[\'wf1\'].get_shape().as_list()[0]])
        fc2 = tf.add(tf.matmul(fc1,weight[\'wf2\']),bias[\'bf2\'])
        fc2 = tf.nn.relu(fc2)
        #dropout
        fc2 = tf.nn.dropout(fc2,dropout)
    with tf.variable_scope(\'outlayer\'):
        out = tf.add(tf.matmul(fc2,weight[\'w_out\']),bias[\'b_out\'])
    return out

def train(mnist):
        #定义网络的超参数
    learning_rate = 0.001
    training_step = 20000
    batch_size = 128
    
    #定义网络的参数
    n_input = 784
    n_output = 10
    dropout = 0.75

    #x、y的占位
    x = tf.placeholder(tf.float32,[None,784])
    y = tf.placeholder(tf.float32,[None,10])
    keep_prob = tf.placeholder(tf.float32)
    
    #权重和偏置的设置
    weight = {
        \'wc1\':tf.Variable(tf.truncated_normal([11,11,1,96],stddev = 0.1)),
        \'wc2\':tf.Variable(tf.truncated_normal([5,5,96,256],stddev = 0.1)),
        \'wc3\':tf.Variable(tf.truncated_normal([3,3,256,384],stddev = 0.1)),
        \'wc4\':tf.Variable(tf.truncated_normal([3,3,384,384],stddev = 0.1)),
        \'wc5\':tf.Variable(tf.truncated_normal([3,3,384,256],stddev = 0.1)),
        \'wf1\':tf.Variable(tf.truncated_normal([4*4*256,4096])),
        \'wf2\':tf.Variable(tf.truncated_normal([4096,4096])),
        \'w_out\':tf.Variable(tf.truncated_normal([4096,10]))
    }
    bias = {
        \'bc1\':tf.Variable(tf.constant(0.1,shape = [96])),
        \'bc2\':tf.Variable(tf.constant(0.1,shape =[256])),
        \'bc3\':tf.Variable(tf.constant(0.1,shape =[384])),
        \'bc4\':tf.Variable(tf.constant(0.1,shape =[384])),
        \'bc5\':tf.Variable(tf.constant(0.1,shape =[256])),
        \'bf1\':tf.Variable(tf.constant(0.1,shape =[4096])),
        \'bf2\':tf.Variable(tf.constant(0.1,shape =[4096])),
        \'b_out\':tf.Variable(tf.constant(0.1,shape =[10]))
    }
    
    out = buildGraph(x,learning_rate,weight,bias,keep_prob)
    ####################后向传播####################
    #定义损失函数
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=out))
    optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss)
    
    #评估函数
    correction = tf.equal(tf.argmax(out,1),tf.argmax(y,1))
    acc = tf.reduce_mean(tf.cast(correction,tf.float32))
#####################################开始训练##############################

    init = tf.global_variables_initializer()
    
    with tf.Session() as sess:
        sess.run(init)
        step = 1
        while step <= training_step:
            batch_x , batch_y = mnist.train.next_batch(batch_size)
            sess.run(out,feed_dict = {x:batch_x,y:batch_y,keep_prob:dropout})
            print(out.shape)
            sess.run(optimizer,feed_dict = {x:batch_x,y:batch_y,keep_prob:dropout})
            if step % 500 == 0:
                loss , acc = sess.run([loss,acc],feed_dict = {x:batch_x,y:batch_y,keep_prob:1})
                print(step,loss,acc)
            step += 1
    print(sess.run(acc,feed_dict = {x:mnist.test.images[:256],y:mnist.test.images[:256],keep_prob:1}))


if __name__==\'__main__\':
    train(mnist)