CNN（卷积神经网络）实现手写数字识别并与django集成

任务

设计一个卷积神经网络来实现对MNIST手写数字集的识别任务。
为了增加模型复杂度并进一步练习tensorflow的使用方法，所以模型设计的稍微复杂一些。网路结构总共包括五个层级，包括四个隐藏单元、一个输出单元。 层级结构如下图所示

包、数据集载入

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

# 载入数据集
data = input_data.read_data_sets('MNIST_data/', one_hot=True)

层级结构设计

输入层中输入的张量设为x，类型为32位浮点型，x以占位符形式定义，并且其维度为784。并且每次迭代样本个数并不确定，主要由迭代batch的大小决定。由于我们设计的是卷积神经网络，跟bp神经网络不同的地方在于增加了卷积操作、池化操作等。故输入进去的图像数据需要从原来的1*784的行向量变为28*28*1的张量（tensor）。

x = tf.placeholder(dtype=tf.float32, shape=[None, 784])
x_in = tf.reshape(x, [-1, 28, 28, 1])

隐层牵涉到权值参数与偏置项的设定。在未运行算法之前，需要对权重参数与偏置项进行初始化。
为防止权重参数恒为0，我们采用tensorflow的内置方法，将权重参数初始化为拥有固定标准差的高斯分布的张量，方法如下：

def weight_variable(shape):
    #权重的初始化
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

对于偏置项，我们可以直接将其初始化为某一固定常量，方法如下：

def bias_variable(shape):
    #偏置项的初始化
    initial = tf.constant(0.5, shape=shape)
    return tf.Variable(initial)

为了简化定义，我们将最大池化操作、2d卷积操作封装在函数里。

def conv2d(x, w):
    # 定义卷积的函数
    return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME')

def max_pooling(x):
    # 定义池化操作的函数
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

四个隐层都在内部定义并实现卷积层，包括卷积运算、非线性转换（relu函数）、最大池化操作。卷积操作步长设置为1，池化操作步长设定为2，且池化层核函数设定为2*2。并且每个隐层最后将附带dropout功能结构防止模型过拟合。

隐层1中定义的卷积核大小为3*3*1，卷积核（filter）个数设定为32个，则经过非线性映射后输出32个大小为28*28的feature map，经过池化操作后feature map大小变为14*14。

隐层2中定义的卷积核大小为3*3*32，卷积核设定为64个，则经过非线性映射后输出64个大小为14*14的feature map，经过池化操作后feature map的大小变为7*7。

隐层3中定义卷积核大小为3*3*64，卷积核设定为128个，则经过非线性映射后输出128个大小为7*7的feature map，经过池化操作后feature map的大小变为4*4。

隐层4是全连接层，参数进行类似的定义，不过此处的权值参数恢复到了向量形式，形状为625*625，并将由隐层3传来的feature map转换为形状为n*625（n代表样本数，取决于batch的值，代码中以-1代表不确定）的向量形式，经过全连接操作到达输出层。

最后在输出层定义权重参数形状为625*10，经过softmax激活，得到n*10（n代表迭代的样本数）的输出，表示对n个样本的预测概率。

通过以上分析可以看出，在通过隐层1之后，输入隐层2的feature map比一开始输入隐层1的原始图像尺寸减少了一半，但深度增加到32，隐层3的输入情况与此相类似。可以得出结论，该模型卷积层的参数设置较为合理，能够分别发挥卷积层有效提取特征、池化层有效压缩输出参数的优势特点。
结构实现代码如下：

def convlutional(x, keep_prob):
    
    with tf.name_scope('first_layer'):
        
        w1 = weight_variable([3, 3, 1, 32])
        b1 = bias_variable([32])
        h1 = tf.nn.relu(conv2d(x, w1) + b1)
        p1 = max_pooling(h1)
        L1 = tf.nn.dropout(p1, keep_prob=keep_prob)
        # op -> image
        # input -> [?, 28, 28, 1]
        # conv -> [?, 28, 28, 32]
        # pool -> [?, 14, 14, 32]
    
    with tf.name_scope('second_layer'):
        
        w2 = weight_variable([3, 3, 32, 64])
        b2 = bias_variable([64])
        h2 = tf.nn.relu(conv2d(L1, w2) + b2)
        p2 = max_pooling(h2)
        L2 = tf.nn.dropout(p2, keep_prob=keep_prob)
        # input -> [?, 14, 14, 32]
        # conv -> [?, 14, 14, 64]
        # pool -> [?, 7, 7, 64]
    
    with tf.name_scope('third_layer'):
        
        w3 = weight_variable([3, 3, 64, 128])
        b3 = bias_variable([128])
        h3 = tf.nn.relu(conv2d(L2, w3) + b3)
        p3 = max_pooling(h3)
        L3 = tf.nn.dropout(p3, keep_prob=keep_prob)
        # input -> [?, 7, 7, 64]
        # conv -> [?, 7, 7, 128]
        # pool -> [?, 4, 4, 128]
    
    with tf.name_scope('firth_layer'):
        
        L3_ = tf.reshape(L3, [-1, 128 * 4 * 4])
        w4 = weight_variable([128 * 4 * 4, 625])
        b4 = bias_variable([625])
        h4 = tf.nn.relu(tf.matmul(L3_, w4) + b4)
        L4 = tf.nn.dropout(h4, keep_prob=keep_prob)
        # input -> [?, 128*4*4]
        # line -> [?, 625]
    
    with tf.name_scope('output_layer'):
        
        w5 = weight_variable([625, 10])
        b5 = bias_variable([10])
        h5 = tf.nn.softmax(tf.matmul(L4, w5) + b5)
        
        output = h5
        # input -> [?, 625]
        # output -> [?, 10]
    return output

实现过程

在定义好了层级结构之后，我们还需要定义超参数、标签、梯度下降优化器、损失函数等。
代码如下：

# 超参数定义
keep_prob = tf.placeholder(tf.float32)

learning_rate = 0.0001

max_step = 10000

# 输入数据
x = tf.placeholder(tf.float32, [None, 784])

x_in = tf.reshape(x, [-1, 28, 28, 1])

# 标签
y_ = tf.placeholder(tf.float32, [None, 10])

y = convlutional(x_in, keep_prob)

# 损失函数
cross_entropy = - tf.reduce_sum(y_ * tf.log(y))

train_step = tf.train.GradientDescentOptimizer(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))

我们定义为占位符的数据就是需要在会话执行时喂食的数据。 如x、y_、keep_prob。

要知道tensorflow是基于运算图的框架，所以我们在定义了一系列占位符、操作、变量等tensor后，需要在会话里跑起来，不断地迭代！
迭代代码如下：

with tf.Session() as sess:
    
    sess.run(tf.global_variables_initializer())
    
    print('--------------------载入训练集-------------------')
    
    for i in range(max_step):
        
        batch = data.train.next_batch(50)
        
        sess.run(train_step, feed_dict={x : batch[0], y_ : batch[1], keep_prob:0.7})
        
        if i % 100 == 0:
            acc = sess.run(accuracy, feed_dict={x : batch[0], y_ : batch[1], keep_prob:1.0})
            print('准确率：'+str(acc))
            
    print('--------------------载入训练集-------------------')
    
    acc = []
    
    for i in range(max_step):
        
        batch = data.test.next_batch(50)
        
        a = sess.run(accuracy, feed_dict={x : batch[0], y_ : batch[1], keep_prob : 1.0})
        acc.append(a)
    
    mean_acc = np.mean(acc)
    print('平均精度为：' + str(mean_acc))

选择部分项输出展示如下：

--------------------载入训练集-------------------
准确率：0.14
准确率：0.26
准确率：0.54
准确率：0.66
准确率：0.64
准确率：0.62
准确率：0.64
准确率：0.76
准确率：0.82
准确率：0.78
准确率：0.86
准确率：0.88
准确率：0.88
准确率：0.88
准确率：0.9
准确率：0.88
准确率：0.86
准确率：0.9
准确率：0.9
准确率：0.94
准确率：0.98
… …
--------------------载入训练集-------------------
平均精度为：0.9734

嘛… …最终测试机上表现得不是很好，结构、参数等还有待优化。

loss函数得变化展现如下：

打个小广告：我最终将该项目和django联系在一起的，系统中的模型拟合程度更好一些。实现界面如图：