手写数字识别

# -*- coding: utf-8 -*-
"""
Created on Sat Mar 23 19:11:23 2019

@author: Admin
"""


import tensorflow as tf 
 
#定义输入，输出，隐藏层1的节点个数
INPUT_NODE = 784 #28*28
OUTPUT_NODE = 10 #输出10个结点，十种分类结果，对应0-9数字
LAYER1_NODE = 500 #隐藏层有500个结点
 
def get_weight_variable(shape, regularizer): #regularizer正则化矩阵，变量属性：维度，shape；truncated缩短了的；被删节的；切去顶端的
	weights = tf.get_variable('weights',shape, initializer = tf.truncated_normal_initializer(stddev=0.1))
	#张量加入集合losses
	if regularizer != None:
		tf.add_to_collection('losses', regularizer(weights))
	return weights
 
#定义前向传播过程
def inference(input_tensor, regularizer):
	#声明第一层神经网络的过程并完成前向传播的过程
	with tf.variable_scope('layer1'):
		weights = get_weight_variable([INPUT_NODE, LAYER1_NODE], regularizer) #[INPUT_NODE, LAYER1_NODE]之间的权重
		biases = tf.get_variable('biases', [LAYER1_NODE], initializer = tf.constant_initializer(0.0))
		layer1 = tf.nn.relu(tf.matmul(input_tensor, weights) + biases)
 
	#声明第2层神经网络的过程并完成前向传播的过程
	with tf.variable_scope('layer2'):
		weights = get_weight_variable([LAYER1_NODE, OUTPUT_NODE], regularizer) #[LAYER1_NODE, OUTPUT_NODE]之间的权重
		biases = tf.get_variable('biases', [OUTPUT_NODE], initializer = tf.constant_initializer(0.0))
		layer2 = tf.matmul(layer1, weights) + biases
	#返回前向传播结果
	return layer2
 
 

 

# -*- coding: utf-8 -*-
"""
Created on Sat Mar 23 19:12:38 2019

@author: Admin
"""

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_inference
import os
 
BATCH_SIZE = 100  #每批次取100个；一个批次中训练个数。
LEARNING_RATE_BASE = 0.8 #学习率初始值
LEARNING_RATE_DECAY = 0.99 #学习率衰减率
REGULARIZATION_RATE = 0.0001 #正则化系数
TRAINING_STEPS = 30000 #训练轮数
MOVING_AVERAGE_DECAY = 0.99 #滑动平均衰减率，控制模型更新的速度，让模型在测试数据上更健壮
MODEL_SAVE_PATH = 'MNIST_data/'
MODEL_NAME = "mnist_model"
 
def train(mnist):
    # 定义输入输出placeholder。placeholder定义了一个位置，程序运行时候给这个位置提供数据。这个机制提供输入数据
    x = tf.placeholder(tf.float32, [None, mnist_inference.INPUT_NODE], name='x-input')
    y_ = tf.placeholder(tf.float32, [None, mnist_inference.OUTPUT_NODE], name='y-input')
 
    regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE) #L2范数正则化
    y = mnist_inference.inference(x, regularizer) #预测值
    global_step = tf.Variable(0, trainable=False) #定义存储训练轮数的变量
    
    # 定义损失函数、学习率、滑动平均操作以及训练过程。
    variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
    variables_averages_op = variable_averages.apply(tf.trainable_variables())
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    loss = cross_entropy_mean + tf.add_n(tf.get_collection('losses')) #总损失=交叉熵损失和正则化损失
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE, #基础学习率
        global_step,		#当前迭代轮数
        mnist.train.num_examples / BATCH_SIZE, #过完所有训练数据需要的迭代次数
        LEARNING_RATE_DECAY, 					#学习率衰减速度
        staircase=True)
    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')
        
    # 初始化TensorFlow持久化类。
    saver = tf.train.Saver()
    #初始化会话，开始训练过程
    with tf.Session() as sess:
        tf.global_variables_initializer().run()
 
        for i in range(TRAINING_STEPS):
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            _, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: xs, y_: ys})
            if i % 1000 == 0: #每1000轮输出一次损失，保存模型，实现持久化
                print("After %d training step(s), loss on training batch is %g." % (step, loss_value))
                saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step) #
 
 
def main(argv=None):
    mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)
    train(mnist)
 
if __name__ == '__main__':
    main()