神经网络 + MNIST + Tensorflow + tips

想看神经网络的一些东西，就入了人工智能的坑，看了很多算法之后再回来看神经网络又感觉清晰不少，但求知少不了实践，今晚看了一些Tensorflow，感觉不太友好啊，好不容易看明白了赶紧把一些tips记录下来。

1. 构建神经网络

先用tensorflow导入数据MNIST，结果发现网络不通总是报错。。。
后来直接下载了MNIST的数据搁在运行目录的MNIST_data\下面，直接也就能跑了

然后设置learning_rate, epochs和每批所用的数据集大小batch_size

x和y 作为placeholder，也就是没有初始化等待赋值的变量，代表所有图片和相应的one-hot结果

import tensorflow as tf
import numpy as np

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

# 超参数
learning_rate = 0.5
epochs = 10
batch_size = 100

# placeholder
# 输入图片为28 x 28 像素 = 784
x = tf.placeholder(tf.float32, [None, 784])
# 输出为0-9的one-hot编码
y = tf.placeholder(tf.float32, [None, 10])

2. 构建神经网络

我们要构建的是输入层784 （图片的像素点数目）* 隐层300* 输出层10（one-hot结果）

随机生成相应的weight和bias矩阵

对于隐层，直接用Relu线性修正
对于输出层，用softmax函数把结果变成每个数字结果的概率分布，和为1

# hidden layer => w, b
W1 = tf.Variable(tf.random_normal([784, 300], stddev=0.03), name='W1')
b1 = tf.Variable(tf.random_normal([300]), name='b1')
# output layer => w, b
W2 = tf.Variable(tf.random_normal([300, 10], stddev=0.03), name='W2')
b2 = tf.Variable(tf.random_normal([10]), name='b2')

# hidden layer
hidden_out = tf.add(tf.matmul(x, W1), b1)
#Rectified Linear Unit, ReLU, 线性修正，小于0的把变成0
hidden_out = tf.nn.relu(hidden_out)

# 计算输出
#把结果整理成概率分布，总概率为1
y_ = tf.nn.softmax(tf.add(tf.matmul(hidden_out, W2), b2))
#压缩值域范围，去除1和0点，用0.000000001和0.99999999代替
y_clipped = tf.clip_by_value(y_, 1e-10, 0.9999999)

3. 设定loss函数和回馈方法

这里用交叉熵作为loss函数，关于交叉熵简单来说就是用真实分布*预测分布的log值来看距离真实分布所需要的信息量还差多少
优化器使用梯度下降法GradientDescentOptimizer，梯度下降法去最小化上述交叉熵的信息量差距，目标是接近真实分布

交叉熵也有对应one-hot输出和多类输出两种公式，对于只有一个数字为真的本题情况应该用
y * log（y’)
如果是多分类，比如输出y是（是红色，是男的，是青蛙。。。）每个输出都有可能是0和1，那么应该直接对每个输出用公式： y * log（y’) + (1-y) * log(1-y’)

#计算交叉熵 y * log（y') + (1-y) * log(1-y')
#但这个地方貌似用的不对，这个交叉熵公式应该是每个输出都有0,1的情况，但数字识别应该是只有一个数字是对的
cross_entropy = -tf.reduce_mean(tf.reduce_sum(y * tf.log(y_clipped) + (1 - y) * tf.log(1 - y_clipped), axis=1))
#数据是一个矩阵，n行，10 列，每一列是十个数字的可能概率
#先按列reduce_sum，变成每一行里面每一列计算结果之和，一个数列，再算平均值reduce_sum
#这里用正规的单类交叉熵重新做实验，效果要好不少
cross_entropy = -tf.reduce_mean(tf.reduce_sum(y * tf.log(y_clipped), axis=1))

# 创建优化器，确定优化目标
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cross_entropy)

# 创建准确率节点
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

上面的reduce_sum真是让人头大，看了半天写了几个列子才看明白：
如果是按照axis = 1做，意思就是不管有多少行，每一行都按列去做相应计算，然后加起来，作为结果数组里的一个元素
如果是axis = 0，就是每一列去加各个元素
如果没有axis，就是全部加起来
比如下面代码运行结果是：

Variable a is [24. 28.]
reduce_mean也就可以理解了

y = tf.Variable([[1.0, 2.0, 3.0],
                 [0.0, 3.0, 4.0]])
y_clipped = tf.Variable([[1.0, 2.0, 3.0],
                 [0.0, 3.0, 4.0]])
# cross_entropy = y * tf.log(y_clipped) + (1 - y) * tf.log(1 - y_clipped)
# cross_entropy = -tf.reduce_mean(tf.reduce_sum(y * tf.log(y_clipped) + (1 - y) * tf.log(1 - y_clipped), axis=1))
# cross_entropy = tf.reduce_mean(tf.reduce_sum(y + y_clipped, axis=1))
cross_entropy = tf.reduce_sum(y + y_clipped * 3, axis=1)

4. 最后就是跑结果了

注意这个sess.run(init_op),真没明白是啥意思，只是感觉放的地方挺有讲究，init_op后面定义的操作，变量都用不上的，用上了就会报错

init_op = tf.global_variables_initializer()

# 创建session
with tf.Session() as sess:
    # 变量初始化
    sess.run(init_op)
    total_batch = int(len(mnist.train.labels) / batch_size)
    for epoch in range(epochs):
        avg_cost = 0
        for i in range(total_batch):
            batch_x, batch_y = mnist.train.next_batch(batch_size=batch_size)
            _, c = sess.run([optimizer, cross_entropy], feed_dict={x: batch_x, y: batch_y})
            avg_cost += c / total_batch
        print("Epoch:", (epoch + 1), "cost = ", "{:.3f}".format(avg_cost))
    print(sess.run(accuracy, feed_dict={x: mnist.test.images, y: mnist.test.labels}))