Tensorflow - 训练识别手写体数字的神经网络并进行优化

    在训练手写体识别神经网络之前，先介绍本次使用的训练集： MNIST数据集

它包含了4个部分：

• Training set images: train-images-idx3-ubyte.gz (9.9 MB, 解压后 47 MB, 包含 60,000 个样本)
• Training set labels: train-labels-idx1-ubyte.gz (29 KB, 解压后 60 KB, 包含 60,000 个标签)
• Test set images: t10k-images-idx3-ubyte.gz (1.6 MB, 解压后 7.8 MB, 包含 10,000 个样本)
• Test set labels: t10k-labels-idx1-ubyte.gz (5KB, 解压后 10 KB, 包含 10,000 个标签)

每张图片包含28*28个像素，把这个数组展开成一个向量是28*28=784，所以在MNIST训练集中，mnist.train.images是一个形状为[60000,784]的张量，图片里某个像素的强度值在0-1之间。如图：

MNIST数据集的标签是0-9的数字，我们把它转化成one-hot的形式，比如：数字0表示为([1,0,0,0,0,0,0,0,0,0]) ; 数字5表示为([0,0,0,0,0,1,0,0,0,0]) 。所以mnist.train.labels是一个[6000,10]的像素矩阵。

构建简单的神经网络

    介绍完训练集，接下来构建一个简单的神经网络，该网络只包含了两个层：输入层和输出层。中间没有隐含层，输入层的神经元个数是784，输出层神经元个数是10.

代码如下：

# coding=utf-8

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

#载入数据集，第一个参数为数据集路径
mnist = input_data.read_data_sets(r'C:\Users\Administrator\PycharmProjects\MNIST_data', one_hot=True)

#设定每次训练的批次大小
batch_size = 100
#计算共有多少个批次
n_batch = mnist.train.num_examples // batch_size

#定义输入输出占位符
x = tf.placeholder(tf.float32,[None,784])
y = tf.placeholder(tf.float32,[None,10])

#创建一个简单的神经网络，只含输入层784个神经元和输出层10个神经元
W = tf.Variable(tf.constant(0.1,shape=[784,10]))
b = tf.Variable(tf.zeros([10]))
prediction = tf.nn.softmax(tf.matmul(x,W)+b)


#定义均方误差为代价函数
loss = tf.reduce_mean(tf.square(y-prediction))
#使用梯度下降法
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

#初始化参数
init = tf.global_variables_initializer()

#将结果放入一个布尔型列表中，argmax返回数据中数值最大的索引值，tf.equal比较两个参数是否相等
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))
#将结果转化为准确率，tf.cast将数据转化为float32类型
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

with tf.Session() as sess:
	sess.run(init)
	for epoch in range(201):                                           #训练201次整个训练集
		for batch in range(n_batch):
			batch_xs,batch_ys = mnist.train.next_batch(batch_size)     #每次循环加载一个批次的训练集
			sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys})       #传入数据，开始训练

		acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})  #使用mnist测试集测试最终准确率
		print('epoch' + str(epoch) + ',Text accuracy' + str(acc))

结果如下：

测试集的准确率达到接近93%，（仅仅只用了不含隐含层的最简单的神经网络就达到了如此可观的准确率）

发现问题和总结：

    我曾试图添加一层含20个神经元的隐含层，但发现准确率却只有65% 。可见，并不是网络结构越复杂，准确率越高。网络结构，学习率，**函数，优化器，代价函数，训练次数，初始权值偏置设置等超参的改变都会影响准确率。所以，提高准确率的一个很重要的途径就是调节超参。

优化神经网络，提高准确率：

    上述的简单神经网络对手写体数字识别的准确率基本在93%就达到收敛了，优化网络的选择有很多，下面只选取其中的一种介绍。

过程如下：

• 添加两层隐含层，其中第一层隐含层的神经元个数为500，第二层隐含层神经元的个数为300
• 初始化一个0.001学习率，随着训练次数的增加，学习率越来越小，目的是使代价函数能更好的达到最小值
• 使用的代价函数改为交叉熵代价函数，隐含层的**函数改为tanh，优化器改为AdamOptimizer
• 添加了dropout操作，但在这里并没有使用

代码如下：

# coding=utf-8

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

#载入数据集，第一个参数为数据集路径
mnist = input_data.read_data_sets(r'C:\Users\Administrator\PycharmProjects\MNIST_data', one_hot=True)

#设定每次训练的批次大小
batch_size = 100
#计算共有多少个批次
n_batch = mnist.train.num_examples // batch_size

#定义输入输出占位符
x = tf.placeholder(tf.float32,[None,784])
y = tf.placeholder(tf.float32,[None,10])

#定义一个keep_prob，方便添加dropout
keep_prob = tf.placeholder(tf.float32)
#定义初始值为0.001的学习率
learningrate = tf.Variable(0.001,dtype=tf.float32)


#创建神经网络，网络结构为[784,500,300,10]
W1 = tf.Variable(tf.truncated_normal([784,500],stddev=0.1))
b1 = tf.Variable(tf.zeros([500]) + 0.1)
L1 = tf.nn.tanh(tf.matmul(x,W1)+b1)
L1_drop = tf.nn.dropout(L1,keep_prob)

W2 = tf.Variable(tf.truncated_normal([500,300],stddev=0.1))
b2 = tf.Variable(tf.zeros([300]) + 0.1)
L2 = tf.nn.tanh(tf.matmul(L1_drop,W2)+b2)
L2_drop = tf.nn.dropout(L2,keep_prob)

W3 = tf.Variable(tf.truncated_normal([300,10],stddev=0.1))
b3 = tf.Variable(tf.zeros([10]) + 0.1)
prediction = tf.nn.softmax(tf.matmul(L2_drop,W3)+b3)

#交叉熵代价函数
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction))
#使用AdamOptimizer优化代价函数
train_step = tf.train.AdamOptimizer(learningrate).minimize(loss)

#初始化参数
init = tf.global_variables_initializer()

#将结果放入一个布尔型列表中，argmax返回数据中数值最大的索引值，tf.equal比较两个参数是否相等
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))
#将结果转化为准确率，tf.cast将数据转化为float32类型
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

with tf.Session() as sess:
	sess.run(init)
	for epoch in range(51):                                           #训练51次整个训练集
		sess.run(tf.assign(learningrate,0.001 * (0.95 ** epoch)))      #每次训练，学习率都减小为上一次的0.95
		for batch in range(n_batch):
			batch_xs,batch_ys = mnist.train.next_batch(batch_size)     #每次循环加载一个批次的训练集
			sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys,keep_prob:1.0})   #传入数据，开始训练

		acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels,keep_prob:1.0})
		print('epoch' + str(epoch) + ',Text accuracy' + str(acc))

优化后的结果如下：

    

    可以看到，在对神经网络做了一系列调整后，准确率提升到了98%

    本次的神经网络训练就结束了，在后续，我会用tensorflow构建效果更好的复杂网络。如：CNN，RNN，LSTM