从0到1搭建简单深度神经网络

深度学习在最近几年越来越热门。今天在这里使用python，基于 tensorflow框架搭建一个简单深度神经网络，并且应用在mnist数据集上。与大家分享如何搭建一个神经网络，并且完成训练的过程。

首先是输入数据部分：

import tensorflow.examples.tutorials.mnist.input_data as input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
from sklearn.metrics import confusion_matrix,classification_report #分类报告函数
import numpy as np  
import tensorflow as tf  
train_data=mnist.train.images
train_tag=mnist.train.labels
test_data=mnist.test.images
test_tag=mnist.test.labels

new_train_tag=[]  # 标签转换，方便查看分类报告与分类混淆矩阵
for i in range(train_tag.shape[0]):
    new_train_tag.append(np.argmax(train_tag[i]))
new_test_tag=[]
for i in range(test_tag.shape[0]):
    new_test_tag.append(np.argmax(test_tag[i]))

神经网络搭建部分：因为mnist数据集的每个样本的维度为784，因此网络的输入节点个数为784。

batch_size=1024
##############
#定义网络结构，和网络参数
learning_rate = 0.1  # 学习率 
training_epochs = 1000
data_size=train_data.shape[0]
n_input = 784  # 输入节点数
n_hidden_1 = 400  #隐层1的节点数

n_hidden_2 = 100   #隐层2的节点数

n_output = 10  # 输出层节点数
x = tf.placeholder("float", [None, n_input])  #占位符
y = tf.placeholder("float", [None, n_output])

weights = { 'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),
            'h2': tf.Variable(tf.random_normal([n_hidden_1,n_hidden_2])),
            'h3': tf.Variable(tf.random_normal([n_hidden_2,n_output])),
                                      } # 定义每一层权重

   
                            
biases = {
    'b1': tf.Variable(tf.random_normal([n_hidden_1])),
    'b2': tf.Variable(tf.random_normal([n_hidden_2])),
    'b3': tf.Variable(tf.random_normal([n_output])), 
   
}  #  定义每一层的偏置  


def y_predict(x):  # 定义前向传播过程，添加softmax层进行分类预测，激活函数为sigmoid
    layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['h1']),
                                   biases['b1']))
    layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['h2']),
                                   biases['b2']))
    layer_3 = tf.add(tf.matmul(layer_2, weights['h3']),
                                    biases['b3'])
    y_predict=tf.nn.softmax(layer_3)
    return y_predict


y_predict=y_predict(x)

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y * tf.log(y_predict), reduction_indices=[1])) # 损失函数为交叉熵

optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cross_entropy)#采用梯度下降法优化损失函数，学习率为0.1


correct_prediction = tf.equal(tf.argmax(y_predict, 1), tf.argmax(y, 1))  #判断正确预测的个数
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))      #计算分类正确率

with tf.Session() as sess:
    if int((tf.__version__).split('.')[1]) < 12 and int((tf.__version__).split('.')[0]) < 1:
        init = tf.initialize_all_variables()
    else:
        init = tf.global_variables_initializer()
    sess.run(init)
    for epoch in range(training_epochs):
        total_batch = int(train_data.shape[0] / batch_size)  #把所有的数据分成大小相等的批次进行训练
        for i in range(total_batch): 
            start=(i*batch_size)%data_size
            end=min(start+batch_size,data_size)
            sess.run(optimizer,feed_dict={x:train_data[start:end],y:train_tag[start:end]})
        if(epoch%100==0):#每训练100轮，输出一下训练正确率
            print("训练准确率为：",sess.run(accuracy,feed_dict={x:train_data,y:train_tag}))
    print("测试准确率为：",sess.run(accuracy,feed_dict={x:test_data,y:test_tag}))           
    y_pre=sess.run(y_predict,feed_dict={x:test_data})  #训练数据集的类别预测

输出结果如下：

训练准确率为： 0.258945
训练准确率为： 0.889455
训练准确率为： 0.923455
训练准确率为： 0.940618
训练准确率为： 0.952109
训练准确率为： 0.960745
训练准确率为： 0.967091
训练准确率为： 0.972582
训练准确率为： 0.976927
训练准确率为： 0.980364
测试准确率为： 0.9308

查看分类正确率与混淆矩阵：

pre_testtag=[]
for i in range(test_tag.shape[0]):
    pre_testtag.append(np.argmax(y_pre[i]))
print(confusion_matrix(new_test_tag,pre_testtag))
print(classification_report(new_test_tag,pre_testtag))

输出混淆矩阵和分类报告如下：

[[ 945    0    3    1    2   11   10    2    6    0]
[   0 1117    3    2    0    0    2    3    8    0]
[  10    2  944   22   10    4   10   13   16    1]
[   0    4   10  936    2   22    0    9   24    3]
[   3    1    6    1  915    1    8    8    5   34]
[  11    1    6   24    8  809    7    7   11    8]
[   7    2    8    1    8   15  909    2    6    0]
[   4   10   25    4    7    1    1  943    8   25]
[   5    2    6   18   12   19    9    8  886    9]
[   8    5    2    7   36   14    1   25    7  904]]
             precision    recall  f1-score   support

          0       0.95      0.96      0.96       980
          1       0.98      0.98      0.98      1135
          2       0.93      0.91      0.92      1032
          3       0.92      0.93      0.92      1010
          4       0.92      0.93      0.92       982
          5       0.90      0.91      0.90       892
          6       0.95      0.95      0.95       958
          7       0.92      0.92      0.92      1028
          8       0.91      0.91      0.91       974
          9       0.92      0.90      0.91      1009

avg / total       0.93      0.93      0.93     10000


至此，便完成了一个简单深度神经网络的搭建。后续我们可以根据分类正确率对参数进行调整，例如学习率，以及隐层神经元个数。达到一个比较好的分类正确率。

由于此网络没有加任何的正则化项，导致神经网络对训练数据拟合过度，在测试数据集上分类正确率相比较与训练数据集上的分类正确率有所下降。所以我们可以在损失函数上加上正则化项，可以得到更好的泛化性能。