MNIST character judgement demo code

mnist judgement demo code

from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
#获取mnist数据集
mnist = input_data.read_data_sets("/path/to/MNIST_data/",one_hot = True)
print("Training data size:",mnist.train.num_examples)
print("Validating data size:",mnist.validation.num_examples)
print("Testing data size:",mnist.test.num_examples)

print("Example training data",mnist.train.images[0])
print("Example training data label:",mnist.train.labels[0])

BATCH_SIZE = 100
xs,ys = mnist.train.next_batch(BATCH_SIZE)
#输入层的数据
print("X shape:",xs.shape)
#对应输入层各个数据的label
print("Y shape:",ys.shape)


#MNIST数据集相关constant
INPUT_NODE = 784
OUTPUT_NODE = 10
#神经网络相关参数
LAYER1_NODE = 500
#初始学习率和衰减系数
LEARNING_RATE_BASE = 0.8
LEARNING_RATE_DECAY = 0.99
#损失函数中正则化项的系数
REGULARIZATION_RATE = 0.0001
TRAINING_STEPS = 30000
#滑动平均衰减率
MOVING_AVERAGE_DECAY = 0.99
#给定网络的输入和所有参数，计算前向传播结果,3层
def inference(input_tensor,avy_class,weights1,biases1,weights2,biases2):
    #没有平滑类的场景，直接使用参数的当前取值
    if avy_class == None:
        #计算隐藏层的前向传播结果，**函数为relu
        layer1 = tf.nn.relu(tf.matmul(input_tensor,weights1) + biases1)
        #计算输出层的前向传播结果，这里不需要加入**，因为在计算输出层的损失函数时会一并计算softmax函数
        return tf.matmul(layer1,weights2) + biases2
    else:
        #有平滑类
        layer1 = tf.nn.relu(tf.matmul(input_tensor,avy_class.average(weights1)) + avy_class.average(biases1))
        return tf.matmul(layer1,avy_class.average(weights2)) + avy_class.average(biases2)

#train 函数
def train(mnist):
    #输入层占位符
    x = tf.placeholder(tf.float32,[None,INPUT_NODE],name = "x-input")
    #输出层label占位符
    y_ = tf.placeholder(tf.float32,[None,OUTPUT_NODE],name = "y-input")
    
    #生成隐藏层参数
    weights1 = tf.Variable(tf.truncated_normal([INPUT_NODE,LAYER1_NODE],stddev=0.1))
    biases1 = tf.Variable(tf.truncated_normal([LAYER1_NODE],stddev=0.1))
    #生成输出层参数
    weights2 = tf.Variable(tf.truncated_normal([LAYER1_NODE,OUTPUT_NODE],stddev=0.1))
    biases2 = tf.Variable(tf.truncated_normal([OUTPUT_NODE],stddev=0.1))
    #计算整个网络的前向传播结果,当前不用参数的滑动平均值
    y = inference(x,None,weights1,biases1,weights2,biases2)
    #定义存储当前训练轮数的变量，此变量不需要计算滑动平均值，所以应该是不可训练的
    global_step = tf.Variable(0,trainable=False)
    #初始化滑动平均类
    variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
    #在所有代表神经网络参数的变量上使用滑动平均，其他辅助变量不使用(trainable为false的变量)
    variables_averages_op = variable_averages.apply(tf.trainable_variables())
    #计算整个网络的前向传播结果，使用滑动平均参数
    average_y = inference(x,variable_averages,weights1,biases1,weights2,biases2)
    #用交叉熵做损失函数,计算非滑动平均值下的损失值
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))
    #计算当前batch的交叉熵平均值
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    
    #计算L2正则化损失函数，防止过度拟合，过度复杂化
    regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
    #计算模型的正则化损失，不考虑偏置项
    regularization = regularizer(weights1) + regularizer(weights2)
    #总损失为交叉熵损失加正则化损失
    loss = cross_entropy_mean + regularization
    #设置指数衰减的学习率
    learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE,global_step,
                                               mnist.train.num_examples/BATCH_SIZE,LEARNING_RATE_DECAY)



    #优化算法优化损失函数，这里的损失函数包含了交叉熵损失和L2正则化损失
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)

    #每过一遍数据都要通过反向传播来更新网络参数，而且要更新每个参数的滑动平均值
    with tf.control_dependencies([train_step,variables_averages_op]):
        train_op = tf.no_op(name='train')

    #判断使用滑动平均类的预测结果和label值的比较,返回bool型
    correct_prediction = tf.equal(tf.argmax(average_y,1),tf.argmax(y_,1))
    #将预测结果转换为实数型，再计算平均值，这个平均值就是这个模型在这一组数据上的正确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

    #初始化会话并开始训练过程
    with tf.Session() as sess:
        tf.initialize_all_variables().run()
        #准备验证数据
        validate_feed = {x:mnist.validation.images,
                        y_:mnist.validation.labels}
        #准备测试数据
        test_feed = {x:mnist.test.images,
                    y_:mnist.test.labels}
        #开始迭代训练网络
        for i in range(TRAINING_STEPS):
            if i % 1000 == 0:
                validate_acc = sess.run(accuracy,feed_dict=validate_feed)
                print('After %d training step(s),validation accuracy using average model is %g' %(i,validate_acc))

            xs,ys = mnist.train.next_batch(BATCH_SIZE)
            sess.run(train_op,feed_dict={x:xs,y_:ys})
        #训练结束后，在test数据上验证模型的最终正确率
        test_acc = sess.run(accuracy,feed_dict=test_feed)
        print('After %d training step(s),test accuracy using average model is %g' %(TRAINING_STEPS,test_acc))
            
    

def main(argv=None):
    train(mnist)

#tf提供的主程序入口，tf.app.run会调用上面定义的main
if __name__ == '__main__':
    tf.app.run()

Result

Reference

一文搞懂交叉熵在机器学习中的使用，透彻理解交叉熵背后的直觉