卷积神经网络（二）：应用简单卷积网络实现MNIST数字识别

墨蓝 2022-04-15 02:45 335阅读 0赞

## 卷积神经网络简单实现MNIST数字识别 ##

本篇的主要内容：

*  一个两层卷积层的简单卷积网络的TensorFlow的实现

### 网络的结构 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM0MzI4NzY0_size_16_color_FFFFFF_t_70]

在这张图里，我把每一层的输入以及输出的结构都标注了，结合阅读代码食用效果更佳。

### 具体代码 ###

具体的内容，都写在相应位置的注释中了,可能一下子全部代码都贴出来不太好看，所以我非常贴心的分成了好几个部分：

导入包

import tensorflow as tf
    from tensorflow.examples.tutorials.mnist import input_data
    
    mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

数据准备：

# 准备数据
    trainimg = mnist.train.images
    trainlabel = mnist.train.labels
    testimg = mnist.test.images
    testlabel = mnist.test.labels
    print('MNIST ready')

定义不同层的参数与偏置：

# 定义不同层的权重 与 偏置
    # 使用 字典的形式方便使用
    n_input = 784
    n_output = 10
    weights = {
        'wc1': tf.Variable(tf.random_normal([3, 3, 1, 64],  stddev=0.1)),  # 第一层卷积层
        'wc2': tf.Variable(tf.random_normal([3, 3, 64, 128], stddev=0.1)), # 第二层卷积层
        'wd1': tf.Variable(tf.random_normal([7*7*128, 1024], stddev=0.1)),  #第一层全连接层
        'wd2': tf.Variable(tf.random_normal([1024, n_output], stddev=0.1))  #第二层全连接层
    }
    biases = {
        'bc1': tf.Variable(tf.random_normal([64], stddev=0.1)),         # 分别是上面四层的偏置
        'bc2': tf.Variable(tf.random_normal([128], stddev=0.1)),
        'bd1': tf.Variable(tf.random_normal([1024], stddev=0.1)),
        'bd2': tf.Variable(tf.random_normal([n_output], stddev=0.1))
    }

定义整个网络的结构：

# 定义神经网络结构
    def conv_basic(_input, _w, _b, _keepratio):
        # 首先对输入数据进行预处理
        # 一开始 图像是以 784 长度的向量保存
        # tf 中要求的输入格式是 四维 向量的形式 所以首先进行数据的预处理
        # [a, b, c, d] 中 四个维度 分别是指 batch_size、 height、 width、deepth(channels)
        # 关于reshape函数，稍后解释
        _input_r = tf.reshape(_input, shape=[-1, 28, 28, 1])
    
        # 创建第一层 是卷积层 conv1
        # 这个创建的函数 后面详细介绍
        _conv1 = tf.nn.conv2d(_input_r, _w['wc1'], strides=[1,1,1,1], padding='SAME')
        # 这里 也可以合在一起写 因为一般卷积操作之后会跟一个激活函数 进行去线性化 这里使用的 ReLU（）函数
        _conv1 = tf.nn.relu(tf.nn.bias_add(_conv1, _b['bc1']))
    
        # 创建第二层 是池化层 pool1
        _pool1 = tf.nn.max_pool(_conv1, ksize=[1, 2, 2, 1] ,strides=[1, 2, 2, 1], padding='SAME')
        # 这个函数稍后详细介绍
        _pool_dr1 = tf.nn.dropout(_pool1, _keepratio)
    
        # 创建第三层 是卷积层  conv2  （接下来与前面的创建过程是一样的）
        _conv2 = tf.nn.conv2d(_pool_dr1, _w['wc2'], strides=[1,1,1,1], padding='SAME')
        _conv2 = tf.nn.relu(tf.nn.bias_add(_conv2, _b['bc2']))
        # 创建第四层 是池化层 pool2
        _pool2 = tf.nn.max_pool(_conv2, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
        _pool_dr2 = tf.nn.dropout(_pool2, _keepratio)
    
        # 向量化处理 因为接下来要创建 全连接层 就像之前一样 全连接层要进行的处理时向量形式的
        _dense1 = tf.reshape(_pool_dr2, [-1, _w['wd1'].get_shape().as_list()[0]])
    
        # 创建第五层 是全连接层 fc1
        _fc1 = tf.nn.relu(tf.add(tf.matmul(_dense1, _w['wd1']), _b['bd1']))
        _fc_dr1 = tf.nn.dropout(_fc1, _keepratio)
    
        # 创建第六层 是全连接层 fc2
        _out = tf.add(tf.matmul(_fc_dr1, _w['wd2']), _b['bd2'])
    
        # 对上面所有的计算 创建字典形式来返回多个内容
        out = {
            'input_r': _input_r, 'conv1':_conv1, 'pool1': _pool1, 'pool1_dr1':_pool_dr1,
            'conv2': _conv2, 'pool2': _pool2, 'pool_dr2': _pool_dr2, 'dense1': _dense1,
            'fc1' : _fc1, 'fc1_dr1': _fc_dr1, 'out': _out
        }
        return out
    print("CNN READY")

定义优化器以及损失函数、正确率等计算方法：

# 创建几个占位符 用来输入数据
    x = tf.placeholder(tf.float32, [None, n_input])
    y = tf.placeholder(tf.float32, [None, n_output])
    keepratio = tf.placeholder(tf.float32)
    
    
    # 定义损失函数 使用的是交叉熵函数
    # 定义优化器 优化方式是 随机梯度下降
    
    _pred = conv_basic(x, weights, biases, keepratio)['out']
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=_pred, labels=y))
    optm = tf.train.AdamOptimizer(learning_rate=0.001).minimize(cost)
    
    # 定义正确率计算函数
    _corr = tf.equal(tf.argmax(_pred, 1), tf.argmax(y, 1))
    accr = tf.reduce_mean(tf.cast(_corr, tf.float32))
    
    
    init_op = tf.global_variables_initializer()
    
    print("GRAPH READY")

运行部分：

sess = tf.Session()
    sess.run(init_op)
    
    training_epoches = 15      # 训练轮数
    batch_size = 16            # 每一批次数量
    display_step = 1           # 用于一定步数之后 输出中间结果
    
    for epoch in range(training_epoches):
        avg_cost = 0
        # total_batch = int(mnist.train.num_examples/batch_size)   本来应该是这样定义 total_batch 的
        total_batch = 100           # 个人硬件条件有限。。 所以直接指定 total_batch
        batch_xs, batch_ys = None, None
        for i in range(total_batch):
            batch_xs, batch_ys = mnist.train.next_batch(batch_size)
            sess.run(optm, feed_dict={x: batch_xs, y:batch_ys, keepratio:0.7})
            avg_cost += sess.run(cost, feed_dict={x: batch_xs, y:batch_ys, keepratio:1.})/total_batch
    
        if epoch % display_step == 0:
            print('Epoch: %03d/%03d cost: %.9f'%(epoch, training_epoches, avg_cost))
            #train_acc = sess.run(accr, feed_dict={x:batch_xs, y:batch_ys, keepratio:1.})   # 这里可以输出训练集的正确率
            test_acc = sess.run(accr, feed_dict={x:testimg, y:testlabel, keepratio:1.})     # 测试集的正确率
            #print("Training accuracy: %.03f" % train_acc)
            print("Test accuracy: %.03f" % test_acc)
    sess.close()
    print("OPTIMIZATION FINISHED")

受限于机器。。。我设置的训练轮数只有 15 次（也很吃力），最后在 Test 数据集上的识别率大概是在 97.5% 以上 ，在中介结果来看，应该随着训练的增加，识别率将会继续增加。

MNIST ready
    CNN READY
    GRAPH READY
    Epoch: 000/015 cost: 2.028865358
    Test accuracy: 0.805
    Epoch: 001/015 cost: 0.471636516
    Test accuracy: 0.907
    Epoch: 002/015 cost: 0.289570311
    Test accuracy: 0.936
    Epoch: 003/015 cost: 0.197701737
    Test accuracy: 0.950
    Epoch: 004/015 cost: 0.200011803
    Test accuracy: 0.955
    Epoch: 005/015 cost: 0.173358922
    Test accuracy: 0.961
    Epoch: 006/015 cost: 0.129958615
    Test accuracy: 0.967
    Epoch: 007/015 cost: 0.119177620
    Test accuracy: 0.969
    Epoch: 008/015 cost: 0.099255772
    Test accuracy: 0.970
    Epoch: 009/015 cost: 0.102970457
    Test accuracy: 0.973
    Epoch: 010/015 cost: 0.093222790
    Test accuracy: 0.970
    Epoch: 011/015 cost: 0.100271105
    Test accuracy: 0.975
    Epoch: 012/015 cost: 0.081711438
    Test accuracy: 0.978
    Epoch: 013/015 cost: 0.074602938
    Test accuracy: 0.979
    Epoch: 014/015 cost: 0.090728084
    Test accuracy: 0.978
    OPTIMIZATION FINISHED

### 几个说明点 ###

*  输入数据格式调整

在TensorFlow中，卷积的输入要求是四维数组的形式，所以我们直接获得的mnist数据集不能直接使用，使用reshape可以得到符合规定的输入。  
标准的输入格式：

[batch_size, height, width, deepth]

batch\_size就是每一批要进行处理的数据数量  
height 是输入图片的高度  
width 是输入图片的宽度  
deepth 也可以说是 channel，也就是通道数，例如输入的图像是RGB格式的话，通道数就是3

*  help函数

如果对 TensorFlow 的某些函数不了解，在IPython 或者Jupyter notebook中可以使用：

print(help(tf.nn.conv2d))

获得函数的说明。  
当然，如果使用Pycharm的话，可以直接点击函数，在右侧的 Documentation 内就会出现函数的介绍。

*  reshape（）函数

之前提到过这个函数：  
[Python numpy.ndim 和 numpy.shape][Python numpy.ndim _ numpy.shape]

*  conv2d()函数

conv = tf.nn.conv2d()  # 创建卷积层
    
    # 定义
    def conv2d(input: Any,    # 输入数据
               filter: Any,   # 卷积核权重矩阵
               strides: Any,  # 一般使用四维的输入形式 
               padding: Any,  # 取值有 SAME 和 VALID
               use_cudnn_on_gpu: bool = True,
               data_format: str = "NHWC",
               dilations: List[int] = [1, 1, 1, 1],
               name: Any = None) -> Any
               
    # 定义例子
    
    _conv1 = tf.nn.conv2d(_input_r, _w['wc1'], strides=[1,1,1,1], padding='SAME')

更加具体的说明，我在另一篇记录中提到了，可以移步这里：  
[tf.nn.conv2d()函数以及padding填充方式介绍][tf.nn.conv2d_padding]

*  dropout()函数

这个函数的作用就是在训练过程中随机 “杀死” 一些神经元，也就是说为模型的收敛做了一点贡献，还可以防止过拟合，在TensorFlow中一般是会使用在全连接层上，上面的代码中，放在了卷积层附近，当然，对于这样小型的网络，其实并不会有什么区别。具体的解释可以看这篇博客：  
[谈谈TensorFlow的dropout][TensorFlow_dropout]

以上~

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM0MzI4NzY0_size_16_color_FFFFFF_t_70]: /images/20220415/01a16f58160b49f7b91d6d07d69ec237.png
[Python numpy.ndim _ numpy.shape]: https://blog.csdn.net/sinat_34328764/article/details/80481636
[tf.nn.conv2d_padding]: https://blog.csdn.net/sinat_34328764/article/details/84303919
[TensorFlow_dropout]: https://www.jianshu.com/p/c9f66bc8f96c