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

时间：2022-12-06 19:39:57

一、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倍】

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

代码：

#加载数据

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)

相关文章