TensorFlow之CNN：运用Batch Norm、Dropout和早停优化卷积神经网络

学卷积神经网络的理论的时候，我觉得自己看懂了，可是到了用代码来搭建一个卷积神经网络时，我发现自己有太多模糊的地方。这次还是基于MINIST数据集搭建一个卷积神经网络，首先给出一个基本的模型，然后再用Batch Norm、Dropout和早停对模型进行优化；在此过程中说明我在调试代码过程中遇到的一些问题和解决方法。

一、搭建基本的卷积神经网络

第一步：准备数据

在《Hands on Machine Learning with Scikit-Learn and TensorFlow》这本书上，用的是下面这一段代码来下载MINIST数据集。

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/")

用这种方式下载可能会报一个URLError的错误。大意是SSL证书验证失败，可以在前面加上下面那一段代码来取消SSL证书验证。

URLError: <urlopen error [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:852)>

import ssl
ssl._create_default_https_context = ssl._create_unverified_context

然后运行后会出现一大堆的WARNING，但是不用担心，数据集还是能下载成功，而且还贴心地划分好了训练集、验证集和测试集，生成了batch，并reshape成了恰当的输入格式（比如训练集的维度已经是（55000, 784））。问题是下载太慢了，我失败了很多次，成功全靠运气。

我还是倾向于用tf.keras.datasets.mnist.load_data()来下载野生原始数据，然后自己动手划分数据、生成batch、整理成恰当的输入格式。

import tensorflow as tf
import numpy as np
import time
from datetime import timedelta

# 记录训练花费的时间
def get_time_dif(start_time):
    end_time = time.time()
    time_dif = end_time - start_time
    #timedelta是用于对间隔进行规范化输出，间隔10秒的输出为：00:00:10
    return timedelta(seconds=int(round(time_dif)))

# 准备训练数据集、验证集和测试集，并生成小批量样本
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()

# 对数据进行归一化，把训练集reshape成（60000,784）的维度
X_train = X_train.astype(np.float32).reshape(-1, 28*28) / 255.0
X_test = X_test.astype(np.float32).reshape(-1, 28*28) / 255.0
y_train = y_train.astype(np.int32)
y_test = y_test.astype(np.int32)
# 划分训练集和验证集
X_valid, X_train = X_train[:5000], X_train[5000:]
y_valid, y_train = y_train[:5000], y_train[5000:]

def shuffle_batch(X, y, batch_size):
    rnd_idx = np.random.permutation(len(X))
    n_batches = len(X) // batch_size
    for batch_idx in np.array_split(rnd_idx, n_batches):
        X_batch, y_batch = X[batch_idx], y[batch_idx]
        yield X_batch, y_batch

第二步：配置参数

构建的网络有两个卷积层和一个全连接层，结构是：输入层—卷积层1—卷积层2—最大池化层—全连接层—输出层。卷积层又由卷积核与ReLU激活函数构成。

第一个卷积层有16个卷积核，尺寸为(3, 3)，步幅为1，进行补零操作。第二个卷积层有32个卷积核，尺寸为（3，3），步幅为2，也进行补零。一般而言，越靠后的卷积层，输出的特征图要越多，而每个特征图的尺寸要越小，这就需要增加卷积核、增大卷积核尺寸和增大步幅。这样越往后就能提取到越高级的特征。

每个特征图上的神经元的参数（权重和偏置）是共享的，而不同特征图则有着不同的参数。每一个特征图都能提取出一个图片特征，这意味着特征图越多，提取到的图片特征也越多。

然后我们来看看相关的计算。假设卷积层的输入神经元个数为 n，卷积核大小为 m，步长为 s，输入神经元两端各填补p个零，那么该卷积层的输出神经元的个数为 (n-m+2p)/s + 1。由下面的参数可以知道，第1个卷积层输入神经元的数量为 n=28*28=784，m=3，s=1，由于padding=“SAME”，那么由 (784-3+2p)+1=784可知，p=1，也就是左右各补1个零。

可是在第2个卷积层，我却算出来补零的个数p不是整数，不知道是怎么进行后续操作的。

# 设定输入的高度、宽度、通道数
height = 28
width = 28
channels = 1
n_inputs = height * width

# 设定卷积层特征图（过滤器）的个数，卷积核的尺寸、步幅
conv1_fmaps = 16
conv1_ksize = 3
conv1_stride = 1
conv1_pad = "SAME"

conv2_fmaps = 32
conv2_ksize = 3
conv2_stride = 2
conv2_pad = "SAME"

# 最大池化层的特征图数量（通道数）
pool3_fmaps = conv2_fmaps
# 设定全连接层的神经元数量。
n_fc1 = 32
n_outputs = 10

第三步：构建卷积网络

下面的代码正是按照上面所说的网络结构去构建的，需要注意的地方有两点：一是最大池化时不要补零，因为池化的作用就是减少内存占用和参数数量；二是在输入到全连接层之前，要把所有特征图拉平成一个向量。

with tf.name_scope("inputs"):
    X = tf.placeholder(tf.float32, shape=[None, n_inputs], name="X")
    X_reshaped = tf.reshape(X, shape=[-1, height, width, channels])
    y = tf.placeholder(tf.int32, shape=[None], name="y")

conv1 = tf.layers.conv2d(X_reshaped, filters=conv1_fmaps, kernel_size=conv1_ksize,
                         strides=conv1_stride, padding=conv1_pad,
                         activation=tf.nn.relu, name="conv1")
conv2 = tf.layers.conv2d(conv1, filters=conv2_fmaps, kernel_size=conv2_ksize,
                         strides=conv2_stride, padding=conv2_pad,
                         activation=tf.nn.relu, name="conv2")

with tf.name_scope("pool3"):
    pool3 = tf.nn.max_pool(conv2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="VALID")
    # 把所有特征图拉平成一个向量，最大池化后特在图缩小为原来的1/16，所以由28*28变成了7*7
    pool3_flat = tf.reshape(pool3, shape=[-1, pool3_fmaps * 7 * 7])

with tf.name_scope("fc1"):
    fc1 = tf.layers.dense(pool3_flat, n_fc1, activation=tf.nn.relu, name="fc1")

with tf.name_scope("output"):
    logits = tf.layers.dense(fc1, n_outputs, name="output")
    Y_proba = tf.nn.softmax(logits, name="Y_proba")

with tf.name_scope("train"):
    xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y)
    loss = tf.reduce_mean(xentropy)
    optimizer = tf.train.AdamOptimizer()
    training_op = optimizer.minimize(loss)

with tf.name_scope("eval"):
    correct = tf.nn.in_top_k(logits, y, 1)
    accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))

第四步：训练和评估模型

训练和评估阶段最大的问题就是在卷积层可能存在内存溢出，尤其是评估和测试时。训练时batch-size=100，问题不大，而验证集的样本数为5000，测试集的样本数为10000，在计算时是非常消耗内存的。我在测试时，就出现了如下的错误：

ResourceExhaustedError: OOM when allocating tensor with shape[10000,16,29,29]...

OOM意思就是“ Out of Memorry”，这段错误是指在测试阶段内存溢出了。我的GPU是GTX960M，显卡内存是2G，实际训练模型时可用的大概是1.65G，还是比较小。

遇到这种问题，有几种解决办法：一种是让模型简单点，比如减少卷积层的特征图数量，增加步幅，减少卷积层的数量，但是这一般会让模型的性能下降；第二种方法是把32位的浮点数改为16位的；第三种方法是在评估和测试时也进行小批量操作。

让模型变得简单会减低模型的性能，我试了，的确如此，因此我选择了第三种方法，在评估和测试时，把数据按每批次1000个样本输入，然后求平均值。最终的验证精度为98.74%。

with tf.name_scope("init_and_save"):
    init = tf.global_variables_initializer()
    saver = tf.train.Saver()

    n_epochs = 10
    batch_size = 100

with tf.Session() as sess:
    init.run()
    start_time = time.time()

    for epoch in range(n_epochs):
        for X_batch, y_batch in shuffle_batch(X_train,y_train,batch_size):

            sess.run(training_op, feed_dict={X: X_batch, y: y_batch})
            acc_train = accuracy.eval(feed_dict={X: X_batch, y: y_batch})

        if epoch % 2 == 0 or epoch == 9:
            # 每次输入1000个样本进行评估，然后求平均值
            acc_val = []
            for i in range(len(X_valid)//1000):
                acc_val.append(accuracy.eval(feed_dict={X: X_valid[i*1000:(i+1)*1000], y: y_valid[i*1000:(i+1)*1000]}))
            acc_val = np.mean(acc_val)
            print('Epoch:{0:>4}, Train accuracy:{1:>7.2%},Validate accuracy:{2:7.2%}'.format(epoch,acc_train, acc_val))

    time_dif = get_time_dif(start_time)
    print("\nTime usage:", time_dif)
    acc_test = []
    # 每次输入1000个样本进行测试，再求平均值
    for i in range(len(X_test)//1000):
        acc_test.append(accuracy.eval(feed_dict={X: X_test[i*1000:(i+1)*1000], y: y_test[i*1000:(i+1)*1000]}))
    acc_test = np.mean(acc_test)
    print("\nTest_accuracy:{0:>7.2%}".format(acc_test))

Epoch:   0, Train accuracy: 98.00%,Validate accuracy: 97.12%
Epoch:   2, Train accuracy: 97.00%,Validate accuracy: 98.34%
Epoch:   4, Train accuracy:100.00%,Validate accuracy: 98.62%
Epoch:   6, Train accuracy:100.00%,Validate accuracy: 98.84%
Epoch:   8, Train accuracy: 99.00%,Validate accuracy: 98.68%
Epoch:   9, Train accuracy:100.00%,Validate accuracy: 98.86%

Time usage: 0:01:02

Test_accuracy: 98.68%

二、用Batch Norm、Dropout和早停优化卷积神经网络

参考的这本书里用Dropout和早停来优化卷积神经网络的基本模型，没有用Batch Norm来优化。我觉得作者实现早停的代码太复杂了，推荐用我的这个代码来实现，清晰明了。

关于在卷积神经网络中运用Batch Norm的代码我暂时没找到，只能凭自己的理解来实现。Batch Norm在哪些层用呢？我觉得在卷积层和全连接层（包括输出层）用，在池化层就不用了，因为内部协变量偏移问题应该主要源自于层与层之间的非线性变换，而池化层的输出值并没有做非线性激活，因此在之后的全连接层做Batch Norm就行。

Dropout运用在池化层和全连接层，丢弃率分别为0.25和0.5，注意是按照Batch Norm—SELU函数激活—Dropout的顺序来进行。

同时将第2个卷积层的卷积步幅设置为1，以获得尺寸更大的特征图和更多参数。

设置迭代轮次为20，batch size = 100，做Batch Norm 时因为要求每个小批量的均值和方差，因此batch size 可以稍微设置得大一些。如果2000步以后验证精度仍然没有提升，那就中止训练。

结果，模型在第18轮、第9921步中止了训练，最好的验证精度为99.22%，测试精度为98.94%。

import tensorflow as tf
import numpy as np
import time
from datetime import timedelta
from functools import partial

# 记录训练花费的时间
def get_time_dif(start_time):
    end_time = time.time()
    time_dif = end_time - start_time
    #timedelta是用于对间隔进行规范化输出，间隔10秒的输出为：00:00:10
    return timedelta(seconds=int(round(time_dif)))

# 准备训练数据集、验证集和测试集，并生成小批量样本
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()

X_train = X_train.astype(np.float32).reshape(-1, 28*28) / 255.0
X_test = X_test.astype(np.float32).reshape(-1, 28*28) / 255.0
y_train = y_train.astype(np.int32)
y_test = y_test.astype(np.int32)
X_valid, X_train = X_train[:5000], X_train[5000:]
y_valid, y_train = y_train[:5000], y_train[5000:]

def shuffle_batch(X, y, batch_size):
    rnd_idx = np.random.permutation(len(X))
    n_batches = len(X) // batch_size
    for batch_idx in np.array_split(rnd_idx, n_batches):
        X_batch, y_batch = X[batch_idx], y[batch_idx]
        yield X_batch, y_batch

height = 28
width = 28
channels = 1
n_inputs = height * width

# 第一个卷积层有16个卷积核
# 卷积核的大小为（3,3）
# 步幅为1
# 通过补零让输入与输出的维度相同
conv1_fmaps = 16
conv1_ksize = 3
conv1_stride = 1
conv1_pad = "SAME"

conv2_fmaps = 32
conv2_ksize = 3
conv2_stride = 1
conv2_pad = "SAME"
# 在池化层丢弃25%的神经元
conv2_dropout_rate = 0.25

pool3_fmaps = conv2_fmaps

n_fc1 = 32
# 在全连接层丢弃50%的神经元
fc1_dropout_rate = 0.5

n_outputs = 10

with tf.name_scope("inputs"):
    X = tf.placeholder(tf.float32, shape=[None, n_inputs], name="X")
    X_reshaped = tf.reshape(X, shape=[-1, height, width, channels])
    y = tf.placeholder(tf.int32, shape=[None], name="y")

training = tf.placeholder_with_default(False, shape=[], name='training')
# 构建一个batch norm层，便于复用。用移动平均求全局的样本均值和方差，动量参数取0.9
my_batch_norm_layer = partial(tf.layers.batch_normalization,
                              training=training, momentum=0.9)

with tf.name_scope("conv"):
    # batch norm之后在激活，所以这里不设定激活函数
    conv1 = tf.layers.conv2d(X_reshaped, filters=conv1_fmaps, kernel_size=conv1_ksize,
                         strides=conv1_stride, padding=conv1_pad,
                         activation=None, name="conv1")
    # 进行batch norm之后，再激活
    batch_norm1 = tf.nn.selu(my_batch_norm_layer(conv1))
    conv2 = tf.layers.conv2d(batch_norm1, filters=conv2_fmaps, kernel_size=conv2_ksize,
                         strides=conv2_stride, padding=conv2_pad,
                         activation=None, name="conv2")
    batch_norm2 = tf.nn.selu(my_batch_norm_layer(conv2))

with tf.name_scope("pool3"):
    pool3 = tf.nn.max_pool(batch_norm2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="VALID")
    # 把特征图拉平成一个向量
    pool3_flat = tf.reshape(pool3, shape=[-1, pool3_fmaps * 14 * 14])
    # 丢弃25%的神经元
    pool3_flat_drop = tf.layers.dropout(pool3_flat, conv2_dropout_rate, training=training)

with tf.name_scope("fc1"):
    fc1 = tf.layers.dense(pool3_flat_drop, n_fc1, activation=None, name="fc1")
    # 在全连接层进行batch norm，然后激活
    batch_norm4 = tf.nn.selu(my_batch_norm_layer(fc1))
    # 丢弃50%的神经元
    fc1_drop = tf.layers.dropout(batch_norm4, fc1_dropout_rate, training=training)

with tf.name_scope("output"):
    logits = tf.layers.dense(fc1_drop, n_outputs, name="output")
    logits_batch_norm = my_batch_norm_layer(logits)
    Y_proba = tf.nn.softmax(logits_batch_norm, name="Y_proba")

with tf.name_scope("loss_and_train"):
    learning_rate = 0.01
    xentropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits_batch_norm, labels=y)
    loss = tf.reduce_mean(xentropy)

    optimizer = tf.train.AdamOptimizer(learning_rate)
    # 这是需要额外更新batch norm的参数
    extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
    # 模型参数的优化依赖与batch norm参数的更新
    with tf.control_dependencies(extra_update_ops):
        training_op = optimizer.minimize(loss)

with tf.name_scope("eval"):
    correct = tf.nn.in_top_k(logits, y, 1)
    accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))

with tf.name_scope("init_and_save"):
    init = tf.global_variables_initializer()
    saver = tf.train.Saver()

n_epochs = 20
batch_size = 100

with tf.Session() as sess:
    init.run()
    start_time = time.time()

    # 记录总迭代步数，一个batch算一步
    # 记录最好的验证精度
    # 记录上一次验证结果提升时是第几步。
    # 如果迭代2000步后结果还没有提升就中止训练。
    total_batch = 0
    best_acc_val = 0.0
    last_improved = 0
    require_improvement = 2000

    flag = False
    for epoch in range(n_epochs):
        for X_batch, y_batch in shuffle_batch(X_train, y_train, batch_size):

            sess.run(training_op, feed_dict={training:True, X: X_batch, y: y_batch})

            # 每次迭代10步就验证一次
            if total_batch % 10 == 0:
                acc_batch = accuracy.eval(feed_dict={X: X_batch, y: y_batch})
                            # 每次输入1000个样本进行评估，然后求平均值
                acc_val = []
                for i in range(len(X_valid)//1000):
                    acc_val.append(accuracy.eval(feed_dict={X: X_valid[i*1000:(i+1)*1000], y: y_valid[i*1000:(i+1)*1000]}))
                acc_val = np.mean(acc_val)

                # 如果验证精度提升了，就替换为最好的结果，并保存模型
                if acc_val > best_acc_val:
                    best_acc_val = acc_val
                    last_improved = total_batch
                    save_path = saver.save(sess, "./my_model_CNN_stop.ckpt")
                    improved_str = 'improved!'
                else:
                    improved_str = ''

                # 记录训练时间，并格式化输出验证结果，如果提升了，会在后面提示：improved！
                time_dif = get_time_dif(start_time)
                msg = 'Epoch:{0:>4}, Iter: {1:>6}, Acc_Train: {2:>7.2%}, Acc_Val: {3:>7.2%}, Time: {4} {5}'
                print(msg.format(epoch, total_batch, acc_batch, acc_val, time_dif, improved_str))

            # 记录总迭代步数
            total_batch += 1

            # 如果2000步以后还没提升，就中止训练。
            if total_batch - last_improved > require_improvement:
                print("Early stopping in  ",total_batch," step! And the best validation accuracy is ",best_acc_val, '.')
                # 跳出这个轮次的循环
                flag = True
                break
        # 跳出所有训练轮次的循环
        if flag:
            break        

with tf.Session() as sess:
    saver.restore(sess, "./my_model_CNN_stop.ckpt")
    # 每次输入1000个样本进行测试，再求平均值
    acc_test = []
    for i in range(len(X_test)//1000):
        acc_test.append(accuracy.eval(feed_dict={X: X_test[i*1000:(i+1)*1000], y: y_test[i*1000:(i+1)*1000]}))
    acc_test = np.mean(acc_test)
    print("\nTest_accuracy:{0:>7.2%}".format(acc_test))

Early stopping in   9921  step! And the best validation accuracy is  0.9922 .
INFO:tensorflow:Restoring parameters from ./my_model_CNN_stop.ckpt

Test_accuracy: 98.94%

参考资料：

《Hands on Machine Learning with Scikit-Learn and TensorFlow》