看了几天的Deep Learnning的书，全是高数公式，看得一脸懵逼， 所以找了个tensorflow的例子看看这个些矩阵变化的意义。机器学习交流可访问
http://www.jokls.com

这里是tensorflow 书上的一个列子MNIST，数据来源 http://yann.lecun.com/exdb/mnist/
就是一个手写体阿拉伯数字的图像识别的程序。

训练集有55000张图片， 检验集中有5000张图片，处理后的每张图片都是784像素的一维数组，数组中的数字对应了 （28*28=784） 像素矩阵中的每一个数字

我安装的tensorflow版本是 1.2 whl.
书上的例子在tensorflow1.2上运行不了， 会报错， 看了tensorflow的这个sparse_softmax_cross_entropy_with_logits函数的源码，发现调用方式有变化，改成这样即可:
tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))

程序代码如下：

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


INPUT_NODE= 784  #输入层的节点数,即为图片的像素
OUTPUT_NODE = 10 #输出的节点数,在MINST中需要区分的是0-9,所以输出节点数是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     #滑动平均衰减率

#计算神经网络的前向传播结果
# 在这里定义了一个使用ReLU激活函数的三层全连接神经网络，通过加入隐藏层实现了多层网络结构
#通过ReLu激活函数实现了去线性化，这个函数也支持滑动平均计算mean(股票的MACD就是用这个滑动平均算的)
def inference(input_tensor, avg_class, weight1,biases1, weight2, biases2):
    #如果没有提供滑动平均函数，则直接使用参数当前值
    if avg_class == None:
        #计算隐藏层的前向传播结果,这里使用ReLU作为激活函数
        layer1 = tf.nn.relu(tf.matmul(input_tensor,weight1) + biases1)

        #计算输出层前向传播的结果，因为在计算损失函数时会一并计算softmax 函数
        #所以这里不需要加入激活函数，而且不加入softmax函数也不会影响结果，因为预测时使用的是
        #不同类别对应节点输出值的大小，有没有softmax层对最后分类结果的计算没有影响，于是在计算整个神经
        #网络的前向传播时可以不加入最后的softmax层
        return tf.matmul(layer1, weight2) + biases2
    else:
        #先使用avg_class计算变量的滑动平均值，然后再计算神经网络前向传播结果
        layer1 = tf.nn.relu(tf.matmul(input_tensor, avg_class.average(weight1)) + avg_class.average(biases1))

        return tf.matmul(layer1, avg_class.average(weight2)) + avg_class.average(biases2)

#神经网络训练函数
def train(minst):
    x = tf.placeholder(tf.float32, [None, INPUT_NODE], name="x_input")
    y_ = tf.placeholder(tf.float32, [None, OUTPUT_NODE], name="y_input")


    #生成隐藏层的参数
    weight1= tf.Variable(tf.truncated_normal([INPUT_NODE, LAYER1_NODE], stddev= 0.1))
    biases1= tf.Variable(tf.constant(0.1, shape=[LAYER1_NODE]))

    #生成输出层的参数
    weight2= 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, weight1, biases1, weight2, biases2)

    #定义存储训练轮数的变量，这个变量不需要计算滑动平均值，所以这里指定这个变量为不可训练的变量(trainable=False)
    #在使用Tensorflow训练神经网络时，一般将代表训练轮数的变量指定为不可训练的参数
    global_step= tf.Variable(0, trainable=False)

    #给定滑动平均衰减率和训练轮数的变量，初始化滑动平均类
    variable_avg= tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)


    variable_avg_op= variable_avg.apply(tf.trainable_variables())

    avg_y= inference(x, variable_avg, weight1, biases1, weight2, biases2)


    #计算交叉熵作为刻画预测值与真实值之间差距的损失函数，这里使用了Tensorflow的sparse_softmax_cross_entropy_with_logits函数来计算交叉熵
    #当分类问题只有一个正确答案是，这个函数可以加速交叉熵的计算。MNIS

    #cross_entopy= tf.nn.sparse_softmax_cross_entropy_with_logits(y, tf.argmax(y_, 1))
    cross_entopy= tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))



    print("cross_entopy = ",cross_entopy)
    #这里是计算使用reduce_mean求向量的均值,也就是Loss函数的值，如果要求代价函数H的值，则需要使用tf.reduce_sum
    cross_entopy_mean= tf.reduce_mean(cross_entopy)

    #计算L2的正则化损失函数
    regularizer= tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)

    #计算模型的正则化损失，一般只计算神经网络边上权重的正则化损失，而不使用偏置项
    regularization= regularizer(weight1) + regularizer(weight2)

    #总得损失函数的值等于交叉熵的值和正则化损失之和
    loss= cross_entopy_mean + regularization


    #设置指数衰减的学习率
    learning_rate= tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, minst.train.num_examples, LEARNING_RATE_DECAY)

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


    #在神经网络中，每循环一遍，就需要更新通过反向传播来更新参数的值，并且更新参数的滑动平均值
    #为了一次完成这两个操作，Tensorflow提供了 control_dependencies 和group两种机制,结果是等价的
    with tf.control_dependencies([train_step,variable_avg_op]):
        train_op= tf.no_op(name='train')

    #检查使用了滑动平均模型的神经网络前向传播结果是否正确
    #tf.argmax()用来获取每一个样例的预测结果, argmax 的第二个参数"1"表示选取最大值得操作仅在第一个维度中进行,也就是只在第一行选取最大值得下标
    #于是就得到一个长度为batch的一维数组，这个一维数组中的值就表示了每一个样例对应数字的识别结果, tf.equal用来判断两个张量的每一维是否相等
    correct_prediction = tf.equal(tf.argmax(avg_y,1),tf.argmax(y_,1))

    #这里是将一个布尔类型的值转换成实数类型的值，然后计算平均值，这个平均值就是模型在这一组数据上的正确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

    with tf.Session() as sess:
        tf.global_variables_initializer().run()

        #准备验证数据.一般在神经网络的训练过程中会通过验证数据来大致判断停止的条件和评判训练的效果
        validate_feed = {x: minst.validation.images, y_: minst.validation.labels}

        #准备测试数据，在真是的应用中，这部分数据在训练时是不可见的，这个数据是模型的优劣的最后评价标准
        test_feed= {x:minst.test.images, y_:minst.test.labels}

        for i in range(TRAINING_STEPS):
            if i % 1000 == 0:
                #计算滑动平均模型在验证数据上的结果
                validate_acc = sess.run(accuracy, feed_dict=validate_feed)
                print("After %d traing step(s), validation accuracy use average model is %g" % (i, validate_acc))
            xs, ys = minst.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 traing step(s), validation accuracy use average model is %g" % (TRAINING_STEPS, test_acc))

def main(argv=None):
    minst = input_data.read_data_sets("/path/to/Minst_Data", one_hot=True)

    print("trainning dataset ", minst.train.num_examples)
    print("trainning data label  ", minst.train.labels[0])
    train(minst)

if __name__ == '__main__':
    tf.app.run()

识别的准确率能达到 98.5%

Paste_Image.png