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

绝地灬酷狼 2021-12-09 07:07 347阅读 0赞

## 任务 ##

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

## 包、数据集载入 ##

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函数得变化展现如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdib3dqMTIz_size_16_color_FFFFFF_t_70 1]  
打个小广告：我最终将该项目和django联系在一起的，系统中的模型拟合程度更好一些。实现界面如图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdib3dqMTIz_size_16_color_FFFFFF_t_70 2]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdib3dqMTIz_size_16_color_FFFFFF_t_70]: /images/20211208/2afa794ee1314b96998dc0ee005bbc81.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdib3dqMTIz_size_16_color_FFFFFF_t_70 1]: /images/20211208/f062f33138184d5fbc78f5ceefa43b22.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdib3dqMTIz_size_16_color_FFFFFF_t_70 2]: /images/20211208/981eb8c91a8340d28367446b47032f55.png