Tensorflow_MNIST数据测试

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
"""
#载入MNIST数据集，如果指定地址 “/”下没有已经下载好的数据，
#那么Tensorflow 会制动下载数据
mnist = input_data.read_data_sets(u"H:\\tensorflow\\MNIST\\",one_hot = True)
print ("Training data size:",mnist.train.num_examples)
print ("Validating data size:",mnist.validation.num_examples)
print ("Example Training data:",mnist.train.[0])
print ("Example Training data lable:",mnist.train.labels[0])
"""
# MNIST 数据集相关的常数
INPUT_NODE          = 784          # 输入层的节点数，对于MNIST数据集，这个就等于图片的像素。
OUTPUT_NODE         = 10           # 输出层的节点数，这个等于类别的数目（0~9）。
# 配置神经网络的参数

LAYER1_NODE         = 500          # 隐藏层的节点数

BATCH_SIZE          = 100          # 一个训练batch中的训练数据个数，数字越小时，训练过程越接近，
                                   # 随机梯度下降;数字越大时，训练越接近梯度下降(这句话没懂)
LEARNING_RATE_BASE  = 0.8          # 基础的学习率。
LEARNING_RATE_DECAY = 0.99         # 学习率的衰减。

REGULARIZATION_RATE = 0.0001       # 描述模型复杂度的正则化项在损失函数中的系数。
TRAINING_STEPS      = 30000        # 训练轮数。
MOVING_AVERAGE_DECAY= 0.99         # 滑动平均衰减率。 

def inference(input_tensor,avg_class,weights1,biases1,weights2,biases2):
    if avg_class == None:
        layer1 = tf.nn.relu(tf.matmul(input_tensor,weights1)+biases1)
        return tf.matmul(layer1,weights2) + biases2
    else:
        layer1 = tf.nn.relu(tf.matmul(input_tensor,avg_class.average(weights1)) + avg_class.average(biases1))
        return tf.matmul(layer1,avg_class.average(weights2)) + avg_class.average(biases2)
    
# 训练模型的过程。
def train(mnist):
    # 输入
    x  = tf.placeholder(tf.float32,[None,INPUT_NODE],name = 'x-input')
    # 输出
    y_ = tf.placeholder(tf.float32,[None,OUTPUT_NODE],name = 'y-input')
    """
                   Tensorflow 随机数生成函数
    —————————————————————————————————————————————————————————————————
     函数名称              随机数分布                          主要参数                
     tf.random_norma      正太分布                            平均值、标准差、取值类型  
     tf.truncated_normal  正太分布，但是如果随机出来的值偏离     平均值、标准差、取值类型 
                          平均值超过2个标准差，那么这个数将
                          会被重新随机。                        
     tf.random_unform     平均分布                            平均值、标准差、取值类型
     tf.random_gamma      Gamma分布                          形状参数alpha,尺度参数beta 取值类型
     ————————————————————————————————————————————————————————————————
    """
    """
                    Tensorflow 常数生成函数
     tf.zeros        产生全0数组                tf.zeros([2,3],int32) [[0,0,0],[0,0,0]]
     tf.ones         产生全1数据                tf.zeros([2,3],int32) [[1,1,1],[1,1,1]]
     tf.fill         产生一个全部为给定数字的数字 tf.fill([2,3],9)      [[9,9,9],[9,9,9]]
     tf.constant     产生一个给定值得常量        tf.constant([1,2,3])  [1,2,3]
    """
    # 生成隐藏层的参数。
    # 权重
    weights1 = tf.Variable(tf.truncated_normal([INPUT_NODE,LAYER1_NODE],stddev = 0.1))
    # 偏置因子
    biases1  = tf.Variable(tf.constant(0.1,shape = [LAYER1_NODE]))
    # 隐藏层只有一层  
    # 生成输出层的参数
    # 权重
    weights2 = tf.Variable(tf.truncated_normal([LAYER1_NODE,OUTPUT_NODE],stddev = 0.1))
    # 偏置因子
    biases2  = tf.Variable(tf.constant(0.1,shape = [OUTPUT_NODE]))

    y = inference(x,None,weights1,biases1,weights2,biases2)
    # 模拟神经网络中迭代的轮数，可以用于动态控制衰减率。
    global_step = tf.Variable( 0, trainable = False)
    # 定义一个滑动平均的类，
    variable_vaerages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
    # 定义一个更新变量滑动平均的操作，这里需要给定一个列表，每次执行这个操作时，这个列表中的变量都会更新。
    Variables_averages_op = variable_vaerages.apply(tf.trainable_variables())

    average_y = inference(x,variable_vaerages,weights1,biases1,weights2,biases2)
    # 现在语法
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits( logits = y , labels = tf.argmax( y_ , 1 ) )
    # 原书代码
    #cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits( y , ytf.argmax( y_ , 1 )_ )
    cross_entropy_mean = tf.reduce_mean(cross_entropy)

    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)

    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')

    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_acc = sess.run(accuracy,feed_dict = test_feed)
        print("After %d training step(s) ,validation accuracy"
                "using average model is %g " % (TRAINING_STEPS,test_acc))

# 主程序的入口;
def main(argv = None):
    # 加载数据;
    mnist = input_data.read_data_sets(u"H:\\tensorflow\\MNIST\\",one_hot = True)
    train(mnist)
# Tensorflow 提供一个主程序入口，tf.app.run会调用上面定义的main函数。
if __name__ == '__main__':
    tf.app.run()