TensorFlow实现神经网络算法（三）全连接网络实现MNIST手写识别

1、模型结构：两个隐藏层，每层256个节点，隐藏层的激活函数为Relu，输出层的激活函数为softmax。批大小100，迭代次数7000磁，学习率0.01

2、总结一下实现神经网络的步骤（以这次实验代码为例）：

①定义模型结构参数，定义超参数：

#定义参数
learning_rate=0.01
train_epochs=7000
batch_size=100
display_step=1

#设置网络模型参数
n_hidden_1=256 #第一个隐藏层节点数
n_hidden_2=256 #第二个隐藏层节点数
n_input=784 #输入特征维数
n_classes=10 #类别数

②给特征和标签创建占位符：

x=tf.placeholder("float",[None,784])
y=tf.placeholder("float",[None,10])

③实现正向预测，也就是根据w和b确定预测值，在多层网络结构中，这部分要定义一个函数，因为涉及很多层的很多参数：

def multilayer_perceptron(x,weights,biases):
    #第一层隐藏层
    layer_1=tf.add(tf.matmul(x,weights['h1']),biases['b1'])
    layer_1=tf.nn.relu(layer_1)
    #第二层隐藏层
    layer_2=tf.add(tf.matmul(layer_1,weights['h2']),biases['b2'])
    layer_2=tf.nn.relu(layer_2)
    #输出层
    out_layer=tf.matmul(layer_2,weights['out'])+biases['out']
    return out_layer

这里要注意一些问题，上一层的输出经过激活函数作为下一层的输入，可以看出这个传进来的参数weights和biases是字典，字典的值是二维列表，用来存储对应层的参数。这个函数的计算过程就是根据传过来的参数计算预测结果后返回，要注意这个返回的值没有经过激活函数，这一点决定之后用什么类型的交叉熵。

④学习参数

#学习参数
weights={
    'h1':tf.Variable(tf.random_normal([n_input,n_hidden_1])), #特征输入时5500*784，第一层的w矩阵的行就应该是784，列等于输出维数，即第二层的输入，总结w=784*256
    'h2':tf.Variable(tf.random_normal([n_hidden_1,n_hidden_2])), #第二层w的行是第一层的输出即256，第二层的输出是256，第二层的w=256*256
    'out':tf.Variable(tf.random_normal([n_hidden_2,n_classes]))
}
biases={
    'b1':tf.Variable(tf.random_normal([n_hidden_1])),
    'b2':tf.Variable(tf.random_normal([n_hidden_2])),
    'out':tf.Variable(tf.random_normal([n_classes]))
}

参数已经随机初始化了，形状设置注释已经说清楚了，定义的参数包括所有层次的参数，存放在字典中。

⑤预测值、损失函数和优化函数

#预测值
pred=multilayer_perceptron(x,weights,biases)

#代价函数
cost=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred,labels=y)) #注意这个交叉熵的 乘法是点乘

#优化函数
Optimizer=tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

之前说过预测值有没有经过激活函数决定了代价函数的写法，没有经过softmax的预测值可以通过TensorFlow封装好的函数tf.nn.softmax_cross_entropy_with_logits()，然后再对结果求平均值就是交叉熵。对于经过了softmax的预测值可以自己写cost函数如cost=-tf.reduce_mean(tf.reduce_sum(y*tf.log(pred)))来实现。

⑥开始训练，训练的过程中要注意，在进行优化函数的时候不要忘记写第二个参数传递数据即feed_dict

⑦关于可视化，目前只会把迭代次数和损失函数值的关系以点图的形式画出来，虽然不怎么好看，但是可以简单判断算法有没有正常工作。思路是先创建一个字典，字典里面有两个键值，一个是loss，一个是epoch。他们分别对应一个列表，在迭代的过程中，把迭代轮次数和当前Loss值放进对应列表中。训练结束后利用这个字典画图。

⑧测试模型

3、试验结果

查看每轮迭代的当前代价值可以看出，代价值总体来说在减小，但是有波动。可能是因为采用小批次梯度下降算法有关，多次实验，模型精度在0.965左右。

4、实验完整代码：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt


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

#定义参数
learning_rate=0.01
train_epochs=7000
batch_size=100
display_step=1

#设置网络模型参数
n_hidden_1=256 #第一个隐藏层节点数
n_hidden_2=256 #第二个隐藏层节点数
n_input=784 #输入特征维数
n_classes=10 #类别数

#迭代次数和代价值的关系
Loss_epoch={'epoch':[],'loss':[]}

#定义占位符
x=tf.placeholder("float",[None,784])
y=tf.placeholder("float",[None,10])

#创建model
def multilayer_perceptron(x,weights,biases):
    #第一层隐藏层
    layer_1=tf.add(tf.matmul(x,weights['h1']),biases['b1'])
    layer_1=tf.nn.relu(layer_1)
    #第二层隐藏层
    layer_2=tf.add(tf.matmul(layer_1,weights['h2']),biases['b2'])
    layer_2=tf.nn.relu(layer_2)
    #输出层
    out_layer=tf.matmul(layer_2,weights['out'])+biases['out']
    return out_layer

#学习参数
weights={
    'h1':tf.Variable(tf.random_normal([n_input,n_hidden_1])), #特征输入时5500*784，第一层的w矩阵的行就应该是784，列等于输出维数，即第二层的输入，总结w=784*256
    'h2':tf.Variable(tf.random_normal([n_hidden_1,n_hidden_2])), #第二层w的行是第一层的输出即256，第二层的输出是256，第二层的w=256*256
    'out':tf.Variable(tf.random_normal([n_hidden_2,n_classes]))
}
biases={
    'b1':tf.Variable(tf.random_normal([n_hidden_1])),
    'b2':tf.Variable(tf.random_normal([n_hidden_2])),
    'out':tf.Variable(tf.random_normal([n_classes]))
}

#预测值
pred=multilayer_perceptron(x,weights,biases)

#代价函数
cost=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred,labels=y)) #注意这个交叉熵的 乘法是点乘

#优化函数
Optimizer=tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

#初始化函数
init=tf.initialize_all_variables() #不知道作用，但是应该要写

#启动训练
with tf.Session() as sess:
    sess.run(init) #初始化
    for i in range(train_epochs):
        batch_x, batch_y = mnist.train.next_batch(batch_size)  # 批次大小为100，注意这部分要放在for循环里面，因为每次迭代都要再重新抓取数据
        sess.run(Optimizer,feed_dict={x:batch_x,y:batch_y})
        loss=sess.run(cost,feed_dict={x:batch_x,y:batch_y})
        Loss_epoch['loss'].append(loss)
        Loss_epoch['epoch'].append(i+1)
        print("迭代次数：",i+1,"代价值：",loss)

    #画图
    plt.plot(Loss_epoch['epoch'],Loss_epoch['loss'],'ro',label="loss-epoch")
    plt.legend()
    plt.show()

    #预测进度
    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(pred, 1))
    accuary = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    print(sess.run(accuary, feed_dict={x: mnist.test.images, y: mnist.test.labels}))