手写数字识别TensorFlow

基于TensorFlow的CNN（Convolutional Neural Network）模型通过对MNIST数据集训练，来实现手写数字识别

导入TensorFlow模块

import tensorflow as tf

导入imput_data用于下载和安装MNIST数据集

from tensorflow.examples.tutorials.mnist import input_data

读取数据集相关内容，如果已下载好，直接写入目录

mnist = input_data.read_data_sets("./MNIST_data/", one_hot=True)

创建两个占位符，x为输入网络的图像，y_为输入网络的图像类别

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

初始化权重函数

def weight_variable(shape):
    #输出服从截尾正态分布的随机值，标准差为0.1
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

初始化偏执函数

def bias_variable(shape):
    #输出一个常量0.1
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

创建卷积函数

def conv2d(x, W):
    #x为输入的张量，W为卷积核，padding填充（same考虑边缘，并填充为0，valid则不考虑填充）
    return tf.nn.conv2d(x, W, strides=[1,1,1,1], padding="SAME")

创建池化函数

def max_pool_2x2(x):
    #ksize表示pool窗口大小为2x2,也就是高2，宽2
	#strides，表示在height和width维度上的步长都为2
    return tf.nn.max_pool(x, ksize=[1,2,2,1],strides=[1,2,2,1], padding="SAME")

开始第1层卷积（卷积核为5*5），并池化

#初始化权重W为[5,5,1,32]的张量，表示卷积核大小为5*5，1表示图像通道数，6表示卷积核个数即输出6个特征图
W_conv1 = weight_variable([5,5,1,6])
#初始化偏执b为[6],即输出大小
b_conv1 = bias_variable([6])

#把输入x(二维张量,shape为[batch, 784])变成4d的x_image，x_image的shape应该是[batch,28,28,1]
#-1表示自动推测这个维度的size
#将x变成28*28*（1深度）的张量，并且自动推算个数
x_image = tf.reshape(x, [-1,28,28,1])

#把x_image和权重进行卷积，加上偏置项，然后应用ReLU激活函数tf.nn.relu（小于0输出0，大于0不变），最后进行max_pooling（最大化池化），h_pool1的输出即为第一层网络输出，池化后shape为[batch,14,14,6]
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)

第2层卷积

#卷积核大小依然是5*5，通道数为6，卷积核个数为16
W_conv2 = weight_variable([5,5,6,16])
b_conv2 = weight_variable([16])

#h_pool2即为第二层网络输出，shape为[batch,7,7,16]
#卷积
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
#2*2池化
h_pool2 = max_pool_2x2(h_conv2)

第3层, 全连接层

#这层是拥有1024个神经元的全连接层
#W的第1维size为7*7*16，7*7是h_pool2输出的size，16是第2层输出神经元个数
W_fc1 = weight_variable([7*7*16, 120])
b_fc1 = bias_variable([120])

#计算前需要把第2层的输出reshape成[batch, 7*7*16]的张量
#tf.matmul矩阵相乘      
#tf.nn.relu将大于0的保持不变，小于0的数置为0。
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*16])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

Dropout层

#为了减少过拟合，在输出层前加入dropout
#防止或减轻过拟合（为了得到一致假设而使假设变得过度严格）而使用的函数
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

输出层,第二个全连接层

#添加一个softmax层，使用softmax将网络输出值换成了概率
W_fc2 = weight_variable([120, 10])
b_fc2 = bias_variable([10])

y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

预测值和真实值之间的交叉墒

#tf.log计数自然对数        
#tf.reduce_sum求沿着某一维度的和
cross_entropy = -tf.reduce_sum(y_ * tf.log(y_conv))

使用ADAM优化器来做梯度下降。学习率为0.0001

train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

评估模型

#tf.argmax 按照后面值，axis=0时比较每一列的元素，将每一列最大元素所在的索引记录下来，最后输出每一列最大元素所在的索引数组。axis=1时比较每一行的元素。
#tf.equal 判断两个值是否相等，即判断预测与正确值是否相等
correct_predict = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))

计算正确率

#因为tf.equal返回的是布尔值，使用tf.cast把布尔值转换成浮点数
#然后用tf.reduce_mean求平均值
accuracy = tf.reduce_mean(tf.cast(correct_predict, "float"))

实例化一个saver对象

#tf.train.Saver() 保存和加载模型
saver = tf.train.Saver()

开始训练函数

def cnn_train():
    # 创建一个交互式Session
    sess = tf.InteractiveSession()
    #tf.initialize_all_variables()初始化变量
    sess.run(tf.initialize_all_variables())
    #循环20000次
    for i in range(20000):
        batch = mnist.train.next_batch(50)
        if i%100 == 0:
            #每100次输出一次日志
            train_accuracy = accuracy.eval(feed_dict={
                x:batch[0], y_:batch[1], keep_prob:1.0})
            print ("step %d, training accuracy %g" % (i, train_accuracy))
            #保存模型
            saver.save(sess, './model')
        train_step.run(feed_dict={x:batch[0], y_:batch[1], keep_prob:0.5})

预测函数

def predict():
    sess = tf.InteractiveSession()
    sess.run(tf.global_variables_initializer())
    saver = tf.train.Saver(tf.global_variables())
    saver.restore(sess, 'model')
    print( "test accuracy %g" % accuracy.eval(feed_dict={
        x:mnist.test.images, y_:mnist.test.labels, keep_prob:1.0}))

调用主函数

cnn_train()

predict()