前言

上一次我们展示了如果使用 tf 来实现 cnn 中卷积层和池化层的实现。 今天我们来继续完善他。

方法封装

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

# 加载数据
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
with tf.device('/GPU:0'):
    # 设置占位符
    x = tf.placeholder(tf.float32, shape=[None, 784])
    y_ = tf.placeholder(tf.float32, shape=[None, 10])

    # 创建w参数
    def weight_variable(shape):
      initial = tf.truncated_normal(shape, stddev=0.1)
      return tf.Variable(initial)

    # 创建b参数
    def bias_variable(shape):
      initial = tf.constant(0.1, shape=shape)
      return tf.Variable(initial)

    # 创建卷积层，步长为1,周围补0，输入与输出的数据大小一样（可得到补全的圈数）
    def conv2d(x, W):
      return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

    # 创建池化层，kernel大小为2,步长为2,周围补0，输入与输出的数据大小一样（可得到补全的圈数）
    def max_pool_2x2(x):
      return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                            strides=[1, 2, 2, 1], padding='SAME')

我们来一步一步的再解释一下上面的代码， 虽然都有注释了，但我们还是一步一步的说明一下。 其中包括了我们上一次写过的池化层和卷积层。

• 首先加载数据
• with tf.device('/GPU:0'): 是在声明这段计算要运行在 GPU 上。 关于 GPU 的东西我们下一次再讲，这里先略过
• 紧接着下面我们声明样本 x 和 label 的占位符，以免后面执行多次迭代的时候重新声明变量会在计算图中产生大量节点
• 接着封装创建参数还有卷积层，池化层的方法以便之后定义多层网络的时候调用。 这部分的说明在上一节中也介绍过，这里略过。

第一层卷积层

# 第一层卷积，这里使用5*5的过滤器，因为是灰度图片，所以只有一个颜色通道，使用32个过滤器来建立卷积层，所以
    # 我们一共是有5*5*32个参数
    W_conv1 = weight_variable([5, 5, 1, 32])
    b_conv1 = bias_variable([32])
    # 数据加载出来以后是一个n*784的矩阵，每一行是一个样本。784是灰度图片的所有的像素点。实际上应该是28*28的矩阵
    # 平铺开之后的结果，但在cnn中我们需要把他还原成28*28的矩阵，所以要reshape
    x_image = tf.reshape(x, [-1,28,28,1])
    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
    h_pool1 = max_pool_2x2(h_conv1)

• 这是我们的第一层卷积层 (由于现在卷积层后一般都要跟着一个池化层，所以现在都把一个卷积 + 一个池化归为一层)。 我们使用 5*5 的过滤器，由于是灰度图片所以第三个维度的参数是 1， 我们要使用 32 个过滤器。所以第四个参数是 32.
• 上一节说过，卷积层需要一个矩阵，所以要把一维的数据 reshape 成 28*28 的矩阵。
• 然后经过卷积层和池化层。

第二层卷积层

# 第二层卷积，同样使用5*5的过滤器，因为上一层使用32个过滤器所以相当于有32个颜色通道一样。 而这一层我们使用64
    # 个过滤器
    W_conv2 = weight_variable([5, 5, 32, 64])
    b_conv2 = bias_variable([64])

    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
    h_pool2 = max_pool_2x2(h_conv2)

• 第二层首先同样初始化参数，同样用 5*5 的过滤器。 但是由于上一个卷积层我们使用了 32 个过滤器。所以我们第三个参数要设置成 32. 然后这一层我们使用 64 个过滤器。 一般对 CNN 来说随着层数的增加，过滤器的数量也要增加的
• 同样经过卷积层和池化层。

全连接层和输出层

# 全连接层，经过上面2层以后，图片大小变成了7*7
    # 初始化权重，全连接层我们使用1024个神经元
    W_fc1 = weight_variable([7 * 7 * 64, 1024])
    b_fc1 = bias_variable([1024])

    # 铺平图像数据。因为这里不再是卷积计算了，需要把矩阵冲洗reshape成一个一维的向量
    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])

    # 全连接层计算
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

    # keep_prob表示保留不关闭的神经元的比例。为了避免过拟合，这里在全连接层使用dropout方法，
    # 就是随机地关闭掉一些神经元使模型不要与原始数据拟合得辣么准确。
    keep_prob = tf.placeholder(tf.float32)
    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)


    # 创建输出层
    W_fc2 = weight_variable([1024, 10])
    b_fc2 = bias_variable([10])

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

• 现在到了我们的全连接层， 我们的 28*28 的图片已经产生了变化。 还记得我们在讲卷积神经网络的时候讲的，不同的 padding 和步长会影响最后图片输出的大小。 我们在这里卷积层统一是使用 SAME 的方式，用全 0 去补全。所以 padding 会保证卷积操作不会影响图片大小。而我们的步长又设置成了 1.所以在卷积层中，我们的图片并没有减少。 但是到了池化层，我们发现步长变成了 2. 现在我们来解释一下这里面的计算过程， 首先 padding 是 SAME。 我们以前学到如果想要卷积层的图片大小不变，padding 的值 (p) 必须要满足 p = (f-1)/2 。其中 f 是过滤器的大小。 那么在我们这里就是 padding 的值就是 2. 而图片的大小可以用这个公式计算：n = (n + 2p -f)/s +1 其中 s 是步长，n 是图片大小。 我们的原始图片是 28*28，那么刚才的公式就是（28 + 2*2 -5）/2 +1 = 14 。 这样经过第一个卷积 + 池化的时候，图片就变成了 14*14. 同理经过第二个时候变成了 7*7. 理解起来有点绕，大家可以就是认为在 padding 为 SAME 的情况下，图片大小就是原始图片大小除以步长吧。
• 既然图片变成了 7*7，并且有 64 个过滤器。 那么我们的数据就是一个 7*7*64 大小的矩阵，其中每一个数据都是一个特征。 那么我们就需要 7*7*64 个权重参数 W。 那么我们设置参数的时候前两个维度就是 7，7 由于上一层我们使用了 64 个过滤器，所以第三个维度是 64. 而在全连接层中，我们希望使用 1024 个神经元节点， 所以最后一个维度是 1024
• 然后由于我们现在不是在做卷积运算，所以要把数据平铺成一个一维数组。
• 全连接层计算，使用 relu 作为激活函数
• 加入 dropout
• 计算输出层

反向传播，损失函数和计算准确率

# 训练过程
    # # 1.计算交叉熵损失
    cross_entropy = tf.reduce_mean(
        tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))

    # # 2.创建优化器（注意这里用  AdamOptimizer代替了梯度下降法）
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

    # # 3. 计算准确率
    correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

• 第一步定义损失函数， 由于我们是多分类场景。所以使用的是 softmax 的损失函数
• 然后是反性传播算法，之前写神经网络的时候用的是梯度下降， 这里用 Adam。但基本使用方式都一样的
• 然后就是计算准确率。 这个计算方式其实也简单。 首先我们我们的 label 是一个有 10 个数字的数组。 要么是 0 要么是 1，而且只有一个是 1. 因为我们是多分类场景么。 这个在上一节的数据介绍里讲过。 tf.argmax 的意思就是在这些 label 中找数值最大的那个的下标。然后用 tf.equal 比较预测的和真实的是不是相等的。 这样就能比较出本次预测是否正确。 然后再使用 tf.reduce_mean 求平均值。 这样我们就得出了正确率

训练过程

import time
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))
with tf.Session() as sess:
    # # 4.初始化所有变量
    sess.run(tf.global_variables_initializer())

    # # 5. 执行循环
    for i in range(2000):
        # 每批取出50个训练样本
        batch = mnist.train.next_batch(64)
        # 循环次数是100的倍数的时候，打印准确率信息
        if i % 100 == 0:
            # 计算正确率，
            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))
        # 执行训练模型
        train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
    # 打印测试集正确率
    print("test accuracy %g" % accuracy.eval(feed_dict={
            x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0
        }))
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))

这就是一个简单的训练过程了， for 循环 2000 次，每次取 64 个样本进行测试。 这也是走 mini batch。 设置 block size 为 64 的意思。 然后每 100 轮打印出正确率。

这个 CNN 的完整代码

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

# 加载数据
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
with tf.device('/GPU:0'):
    # 设置占位符
    x = tf.placeholder(tf.float32, shape=[None, 784])
    y_ = tf.placeholder(tf.float32, shape=[None, 10])

    # 创建w参数
    def weight_variable(shape):
      initial = tf.truncated_normal(shape, stddev=0.1)
      return tf.Variable(initial)

    # 创建b参数
    def bias_variable(shape):
      initial = tf.constant(0.1, shape=shape)
      return tf.Variable(initial)

    # 创建卷积层，步长为1,周围补0，输入与输出的数据大小一样（可得到补全的圈数）
    def conv2d(x, W):
      return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

    # 创建池化层，kernel大小为2,步长为2,周围补0，输入与输出的数据大小一样（可得到补全的圈数）
    def max_pool_2x2(x):
      return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                            strides=[1, 2, 2, 1], padding='SAME')


    # 第一层卷积，这里使用5*5的过滤器，因为是灰度图片，所以只有一个颜色通道，使用32个过滤器来建立卷积层，所以
    # 我们一共是有5*5*32个参数
    W_conv1 = weight_variable([5, 5, 1, 32])
    b_conv1 = bias_variable([32])
    # 数据加载出来以后是一个n*784的矩阵，每一行是一个样本。784是灰度图片的所有的像素点。实际上应该是28*28的矩阵
    # 平铺开之后的结果，但在cnn中我们需要把他还原成28*28的矩阵，所以要reshape
    x_image = tf.reshape(x, [-1,28,28,1])
    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
    h_pool1 = max_pool_2x2(h_conv1)

    # 第二层卷积，同样使用5*5的过滤器，因为上一层使用32个过滤器所以相当于有32个颜色通道一样。 而这一层我们使用64
    # 个过滤器
    W_conv2 = weight_variable([5, 5, 32, 64])
    b_conv2 = bias_variable([64])

    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
    h_pool2 = max_pool_2x2(h_conv2)

    # 全连接层，经过上面2层以后，图片大小变成了7*7
    # 初始化权重，全连接层我们使用1024个神经元
    W_fc1 = weight_variable([7 * 7 * 64, 1024])
    b_fc1 = bias_variable([1024])

    # 铺平图像数据。因为这里不再是卷积计算了，需要把矩阵冲洗reshape成一个一维的向量
    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])

    # 全连接层计算
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

    # keep_prob表示保留不关闭的神经元的比例。为了避免过拟合，这里在全连接层使用dropout方法，
    # 就是随机地关闭掉一些神经元使模型不要与原始数据拟合得辣么准确。
    keep_prob = tf.placeholder(tf.float32)
    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)


    # 创建输出层
    W_fc2 = weight_variable([1024, 10])
    b_fc2 = bias_variable([10])

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



    # 训练过程
    # # 1.计算交叉熵损失
    cross_entropy = tf.reduce_mean(
        tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))

    # # 2.创建优化器（注意这里用  AdamOptimizer代替了梯度下降法）
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

    # # 3. 计算准确率
    correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
import time
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))
with tf.Session() as sess:
    # # 4.初始化所有变量
    sess.run(tf.global_variables_initializer())

    # # 5. 执行循环
    for i in range(2000):
        # 每批取出50个训练样本
        batch = mnist.train.next_batch(50)
        # 循环次数是100的倍数的时候，打印准确率信息
        if i % 100 == 0:
            # 计算正确率，
            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))
        # 执行训练模型
        train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
    # 打印测试集正确率
    print("test accuracy %g" % accuracy.eval(feed_dict={
            x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0
        }))
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))