TensorFlow的helloworld（MNIST数字识别问题）代码手把手解读

代码来源是《TensorFlow实战Google深度学习框架第2版》
因为是“helloworld”级别，所以是针对每一行代码进行解析。
训练神经网络的全部过程，总结为三个步骤：
步骤1，定义神经网络结构和前向传播的输出结果。
步骤2，定义损失函数以及选择反向传播优化的算法。
步骤3，生成会话（tf.Session）并且在训练数据上反复运行反向传播优化算法。

一、引入官方写的类，这个类主要是调用官方的函数，用来解析文件中的4个文件生成为代码可执行格式。网站为 http://yann.lecun.com/exdb/mnist

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

二、定义一些变量，分别为输入层节点数、输出层节点数、隐藏层节点数等

INPUT_NODE  = 784
OUTPUT_NODE = 10
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#滑动平均衰减率

三、辅助函数，这个可自己更改，通过改第二个参数avg_class，选择是否用滑动平均模型，比较简单。

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)

四、训练模型，

（1）首先是利用placeholder机制
tf中有一个常量定义：tf.constant
两个变量定义：
tf.Variable：主要在于一些可训练变量（trainable variables），比如模型的权重（weights，W）或者偏执值（bias）；《TensorFlow实战Google深度学习框架第2版》：“在Tensorflow中，变量（tf.Variable）的作用就是保存和更新神经网络中的参数。TensorFlow还提出了一些其他的随机数生成器，

tf.placeholder：用于得到传递进来的真实的训练样本，tf提供了placeholder用于输入数据，而且也可以不定义维度，但是tf.Variable必须初始化，placeholder中数据的维度信息可以根据提供的数据推导得出，中文注释为“占位符”，意思是定义了一个位置，这个位置中的数据在程序运行时再指定

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

（2）
步骤2，定义损失函数以及选择反向传播优化的算法。
首先是求loss，
首先:用前行传播算法求出y，根据交叉熵平均值和正则化算出loss
其次给定滑动平均衰减率和训练轮数的变量，初始化滑动平均类，
variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
其中global_step的作用就是加快训练早期变量的更新速度
在所有代表神经网络参数的变量上使用滑动平均variables_averages_op = variable_averages.apply(tf.trainable_variables())，
因为global_step不需要训练，所以之前定义时候是 global_step = tf.Variable(0, trainable=False)，第二个参数trainable=False则代表不可训练的参数。
最后求反向传播算法 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’)
求出train_op,用于步骤3
主要是用train_step和variables_averages_op求得train_op，

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

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

（3）创建一个会话
这个是最开始所说的步骤3
基本的常量与变量设置完，我习惯先从创建会话处入手，这样更容易从整体看到局部（因为之前在做嵌入式就是这么干的，从main函数入手，习惯没改过来）
如下代码、
第一行：创建一个会话，并通过Python中的上下文管理器来管理这个会话。
第二行：通过tf.global_variables_initializer().run()函数实现初始化所有变量的过程。这个函数不需要将变量一个一个初始化，并且会自动处理变量之间的依赖关系。
第三行：创建验证字典
第四行：创建训练字典
第五行：轮询，就是迭代地训练神经网络
第六行~第十行：判断是否为第1000个训练数据，如果是则，用验证集来看准确率，一般的神经网络训练过程都需要一个验证集来观察训练过程中准确率是否增加，这么做的目的是防止准确度越来越小，那么训练的模型就是错误的了，直接终止即可，毕竟一些大的模型需要花很长时间来训练。
第十一行：这里采用了mnist.train.next_batch函数，这个我猜测就是官方给的一个查找下一个BATCH的函数，找出下一个XS和YS即可
第十二行：sess.run（）函数作用是通过选取的样本训练神经网络并更新参数。这里主要是更新train_op，这个参数上一步求出的。这么做的目的就是步骤三所说的生成会话（tf.Session）并且在训练数据上反复运行反向传播优化算法。
第十三行：在训练结束之后，在测试数据上检测神经网络模型的最终正确率。

    with tf.Session() as sess:
        tf.global_variables_initializer().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), test accuracy using average" "model is %g"%(TRAINING_STEPS,test_acc) )

TensorFlow的helloworld（MNIST数字识别问题）代码手把手解读

猜你喜欢