Batch Normalization 的实战使用

朱雀 2022-09-10 00:25 141阅读 0赞

## 1. 前言 ##

Batch normalization 有多好用我就不多说了，一般来说，做卷积神经网络加上batch normalization，效果会得到一定的**提升**的。具体的batch normalization的原理可以参照(https://zhuanlan.zhihu.com/p/34879333)

我在他的基础上补充关于**卷积神经网络**使用Batch normalization的一些代码实现。以下的Batch normalization简称**BN**。

## 2. contrib.slim中使用BN ##

使用Tensorflow搭建Inception v3模型的时候,是我第一次接触BN，了解了BN的那么多好处后，开始上手。实战的过程中，最大的感受就是：**训练速度加快**了很多，而且模型对**学习率这种超参数不是很敏感**。

我们接下来在VGG16模型中引入BN,看看我们如何使用contrib.slim中自带的BN来搭建卷积神经网络。

接下来我们搭建VGG16的卷积基：

def VGG16_base(inputs,scope=None):
        with tf.variable_scope(scope,'VGG16',[inputs]):
            with slim.arg_scope([slim.conv2d],padding='SAME',stride=1,kernel_size=[3,3]):
                with slim.arg_scope([slim.max_pool2d],padding='SAME',stride=2,kernel_size=[2,2]):
                    layer1=slim.conv2d(inputs,64,scope='conv_layer1')
                    layer2=slim.conv2d(layer1,64,scope='conv_layer2')
                    mp_layer1=slim.max_pool2d(layer2,scope='max_pool_layer1')
                    layer3=slim.conv2d(mp_layer1,128,scope='conv_layer3')
                    layerx4 = slim.conv2d(layer3, 128, scope='conv_layerx4')
                    mp_layer2=slim.max_pool2d(layerx4,scope='max_pool_layer2')
                    layer4=slim.conv2d(mp_layer2,256,scope='conv_layer4')
                    layer5=slim.conv2d(layer4,256,scope='conv_layer5')
                    layer6=slim.conv2d(layer5,256,scope='conv_layer6')
                    mp_layer3=slim.max_pool2d(layer6,scope='max_pool_layer3')
                    layer7=slim.conv2d(mp_layer3,512,scope='conv_layer7')
                    layer8=slim.conv2d(layer7,512,scope='conv_layer8')
                    layer9 = slim.conv2d(layer8, 512, scope='conv_layer9')
                    mp_layer4= slim.max_pool2d(layer9, scope='max_pool_layer4')
                    layer10 = slim.conv2d(mp_layer4, 512, scope='conv_layer10')
                    layer11 = slim.conv2d(layer10, 512, scope='conv_layer11')
                    layer12 = slim.conv2d(layer11, 512, scope='conv_layer12')
                    mp_layer5= slim.max_pool2d(layer12, scope='max_pool_layer5')
        return  mp_layer5

我们这里使用了tensorflow中的**contrib.slim**包中的slim来**搭建卷积层和池化层**。

嗯？不是说要在slim.conv2d中引入BN的嘛？BN呢？

别急嘛，我们知道tensorlfow中有个好东西，叫做**slim.arg\_scope**。我们的BN是使用到所有的slim.conv2d中，如果我们在每个**slim.conv2d中都加BN**，就重复操作了，接下来我们使用slim.arg\_scope来对上述所有定义的slim.conv2d中加入BN。

def VGG16_arg_scope(weight_decay=0.00004,
                               stddev=0.1,
                               batch_norm_var_collection='moving_vars'
    
                               ):
        batch_norm_params={
            'decay':0.9997,
            'epsilon':0.001,
            'updates_collections':tf.GraphKeys.UPDATE_OPS,
            'variables_collections':{
                'beta':None,
                'gamma':None,
                'moving_mean':[batch_norm_var_collection],
                'moving_variance':[batch_norm_var_collection],
            }
        }
        with slim.arg_scope([slim.conv2d,slim.fully_connected],
            weights_regularizer=slim.l2_regularizer(weight_decay)):
            with slim.arg_scope(
                [slim.conv2d],
                weights_initializer=tf.truncated_normal_initializer(stddev=stddev),
                activation_fn=tf.nn.relu,
                normalizer_fn=slim.batch_norm,
                normalizer_params=batch_norm_params)as sc:
                return sc

上述代码中的：

with slim.arg_scope(
        [slim.conv2d],
        weights_initializer=tf.truncated_normal_initializer(stddev=stddev),
        activation_fn=tf.nn.relu,
        normalizer_fn=slim.batch_norm,
        normalizer_params= batch_norm_params)as sc:
        return sc

这段代码就是对所有的slim.conv2d引入了BN，当然了，其中的**batch\_norm\_params**上面定义了，如下：

batch_norm_params={
        'decay':0.9997,
        'epsilon':0.001,
        'updates_collections':tf.GraphKeys.UPDATE_OPS,
        'variables_collections':{
            'beta':None,
            'gamma':None,
            'moving_mean':[batch_norm_var_collection],
            'moving_variance':[batch_norm_var_collection],
        }

既然使用BN，我们就一定要分清：**is\_training=True** 或者**is\_training=False**。

**训练**的时候，一定要加slim.conv2d中的**is\_training**设为**True**，而且我们刚刚只是设置了卷积基，我们还要后面接上全连接层嘞。

def VGG16(inputs,
              num_classes=config.NUM_CLASSES,
              is_training=True,
              reuse=None,
              scope='VGG16'):
        with tf.variable_scope(scope, 'VGG16', [inputs, num_classes], reuse=reuse) as scope:
            with slim.arg_scope([slim.batch_norm, slim.dropout],
                                is_training=is_training):  # is_training 只会对batch_norm和dropout影响
                net = VGG16_base(inputs, scope=scope)
    
                reshape = tf.layers.flatten(net)
                # print(type(reshape))
                dim = reshape.get_shape()[1].value
                print(dim)
            with slim.arg_scope([slim.fully_connected],activation_fn=tf.nn.relu):
                fc_layer1=slim.fully_connected(reshape,2048,scope='fc_layer1')
                fc_layer2=slim.fully_connected(fc_layer1,512,scope='fc_layer2')
                logit=slim.fully_connected(fc_layer2,num_classes,scope='logit',activation_fn=None)
    
        return logit

这里我们设置了slim.batch\_norm的is\_training。这个slim. batch\_norm是在slim.conv2d中设置的。

我们定义完了网络的结构的时候，现在我们在train和test要注意以下几点。

Train的时候，我们需要注意以下三点：

(1) 前向logit需要将上面定义的\*\*VGG16\_arg\_scope()**放在**slim.arg\_scope()\*\*中，对所有的slim.conv2d采用BN。

with slim.arg_scope(VGG16_arg_scope()):
        logit=VGG16(image,num_classes=config.NUM_CLASSES,is_training=is_training)

（2）获取集合**tf.GraphKeys.UPDATE\_OPS** ，并将update\_op和train\_op

同时进行。

update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
    with tf.control_dependencies(update_ops):
        train_op=tf.train.AdamOptimizer(config.learning_rate).minimize(losses)

（3）**保存变量**（主要保存**moving\_mean**和**moving\_variance**）

var_list = tf.trainable_variables()
    # print('trainable variables',tf.trainable_variables)
    g_list = tf.global_variables()
    bn_moving_vars = [g for g in g_list if 'moving_mean' in g.name]
    bn_moving_vars += [g for g in g_list if 'moving_variance' in g.name]
    var_list += bn_moving_vars
    saver = tf.train.Saver(var_list=var_list,max_to_keep=5)

测试的时候，**is\_training=False**别忘了

with slim.arg_scope(VGG16_arg_scope()):
        logit = VGG16(image_batch, num_classes=config.NUM_CLASSES, is_training=False)

我在猫狗数据集上进行分类训练。最终在测试集上，不加BN的精度为89%，加了BN的精度为95%，而且训练速度提升，所有BN有多好，就不用多说了。

后面，我们来说第二种使用BN的方法。

## 3. tf.nn.batch\_normalization的使用 ##

tf.nn.batch\_normalization的使用是在我阅读YOLO V2代码时遇到的。作者通过对yolo v1中加入BN,提升了mAP。

他是这样实现的，

首先代码中按照原始的tensorflow 的方法定义了卷积层：

def conv_layer(self, inputs, shape, batch_norm = True, name = '0_conv'):
        weight = tf.Variable(tf.truncated_normal(shape, stddev=0.1), name='weight')
        biases = tf.Variable(tf.constant(0.1, shape=[shape[3]]), name='biases')
    
        conv = tf.nn.conv2d(inputs, weight, strides=[1, 1, 1, 1], padding='SAME', name=name)
    
        if batch_norm:
            depth = shape[3]
            scale = tf.Variable(tf.ones([depth, ], dtype='float32'), name='scale')
            shift = tf.Variable(tf.zeros([depth, ], dtype='float32'), name='shift')
            mean = tf.Variable(tf.ones([depth, ], dtype='float32'), name='rolling_mean')
            variance = tf.Variable(tf.ones([depth, ], dtype='float32'), name='rolling_variance')
    
            conv_bn = tf.nn.batch_normalization(conv, mean, variance, shift, scale, 1e-05)
            conv = tf.add(conv_bn, biases)
            conv = tf.maximum(self.alpha * conv, conv)
        else:
            conv = tf.add(conv, biases)
    
        return conv

先定义权重，再定义偏置。

使用上一层的输入和定义的权重进行卷积运算，再将结果输入到tf.nn.batch\_normalization中，这里我们需要好好品味下，它定义的几个变量，平均值、方差、scale和shift都是和**输出维度相同的维度**。这个是什么意思呢？很显然，我们在学习BN的时候，说过我们的均值和方差是求**batch个神经元**的平均值和方差，这里的维度说明了在卷积神经网络中，每一层（不是每层的每个格子）才是一个神经元。这里的均值和方差的计算，应该是对**batch个特征图**，**逐层**进行求平均和求方差。

好了，定义了卷积函数后，我们引入darknet-19中的每个卷积层就好了。

def build_networks(self, inputs):
        net = self.conv_layer(inputs, [3, 3, 3, 32], name = '0_conv')
        net = self.pooling_layer(net, name = '1_pool')
    
        net = self.conv_layer(net, [3, 3, 32, 64], name = '2_conv')
        net = self.pooling_layer(net, name = '3_pool')
    
        net = self.conv_layer(net, [3, 3, 64, 128], name = '4_conv')
        net = self.conv_layer(net, [1, 1, 128, 64], name = '5_conv')
        net = self.conv_layer(net, [3, 3, 64, 128], name = '6_conv')
        net = self.pooling_layer(net, name = '7_pool')
    
        net = self.conv_layer(net, [3, 3, 128, 256], name = '8_conv')
        net = self.conv_layer(net, [1, 1, 256, 128], name = '9_conv')
        net = self.conv_layer(net, [3, 3, 128, 256], name = '10_conv')
        net = self.pooling_layer(net, name = '11_pool')
    
        net = self.conv_layer(net, [3, 3, 256, 512], name = '12_conv')
        net = self.conv_layer(net, [1, 1, 512, 256], name = '13_conv')
        net = self.conv_layer(net, [3, 3, 256, 512], name = '14_conv')
        net = self.conv_layer(net, [1, 1, 512, 256], name = '15_conv')
        net16 = self.conv_layer(net, [3, 3, 256, 512], name = '16_conv')
        net = self.pooling_layer(net16, name = '17_pool')
    
        net = self.conv_layer(net, [3, 3, 512, 1024], name = '18_conv')
        net = self.conv_layer(net, [1, 1, 1024, 512], name = '19_conv')
        net = self.conv_layer(net, [3, 3, 512, 1024], name = '20_conv')
        net = self.conv_layer(net, [1, 1, 1024, 512], name = '21_conv')
        net = self.conv_layer(net, [3, 3, 512, 1024], name = '22_conv')
    
        net = self.conv_layer(net, [3, 3, 1024, 1024], name = '23_conv')
        net24 = self.conv_layer(net, [3, 3, 1024, 1024], name = '24_conv') #这里输出为（h/32，w/32,1024)
    
        net = self.conv_layer(net16, [1, 1, 512, 64], name = '26_conv')
        net = self.reorg(net)  #输出shape为（h/32,w/32,64*4)
    
        net = tf.concat([net, net24], 3) #拼接，shape为（bz，h/32，w/32，1024+256）
    
        net = self.conv_layer(net, [3, 3, int(net.get_shape()[3]), 1024], name = '29_conv')  #转（bz，h/32，w/32，1024）
        net = self.conv_layer(net, [1, 1, 1024, self.box_per_cell * (self.num_class + 5)], batch_norm=False, name = '30_conv') #转（bz，h/32，w/32，5*(num_classes+5）)
    
        return net

## 4. 小结 ##

我们讲完了BN后，读者可以自行尝试他的效果，虽然听说**GN,即group normalization**也出了，但是我还没有试过，以后尝试了再做个总结吧。

**建议阅读：**

**[高考失利之后，属于我的大学本科四年][Link 1]**

[**【资源分享】对于时间序列，你所能做的一切.**][.]

[**【时空序列预测第一篇】什么是时空序列问题？这类问题主要应用了哪些模型？主要应用在哪些领域？**][Link 2]

[**【AI蜗牛车出品】手把手AI项目、时空序列、时间序列、白话机器学习、pytorch修炼**][AI_AI_pytorch]

**公众号：****AI蜗牛车**

保持谦逊、保持自律、保持进步

![e22b00c314eb029dc61c78abea283510.png][]

个人微信

备注：昵称+学校/公司+方向

如果没有备注不拉群！

拉你进AI蜗牛车交流群

![a8bd95eb7c3c7d6a89295d58a813b140.png][]

[Link 1]: http://mp.weixin.qq.com/s?__biz=MzA4ODUxNjUzMQ%3D%3D&chksm=9029a749a75e2e5fde587cf68ab729deaa3a6c2ec952e288af747c1591df1416c24c9a9bcd1a&idx=1&mid=2247488917&scene=21&sn=6b0a24a219f861bd146366b25f710beb#wechat_redirect
[.]: http://mp.weixin.qq.com/s?__biz=MzA4ODUxNjUzMQ%3D%3D&chksm=9029b4cda75e3ddb7cb31a55ed528f386b3adcba3a077d6344f4c868f19bac1185a58cb262f8&idx=1&mid=2247484945&scene=21&sn=d3b302099848ad3549a395750b9da2bf#wechat_redirect
[Link 2]: http://mp.weixin.qq.com/s?__biz=MzA4ODUxNjUzMQ%3D%3D&chksm=9029b7fba75e3eed7d9e647994cae086ee483c1e55d386a92d385e3648f0ce715097f2c33a62&idx=1&mid=2247484711&scene=21&sn=c4187946d58e277a45512d3146d4f062#wechat_redirect
[AI_AI_pytorch]: http://mp.weixin.qq.com/s?__biz=MzA4ODUxNjUzMQ%3D%3D&chksm=9029afcba75e26dd76bd9263b4cf22a9ef3e1538f90008bc64867f52a7b2705bdeaf526d4b37&idx=1&mid=2247490839&scene=21&sn=d9d0a9fad6efb225a92deafd80a2838d#wechat_redirect
[e22b00c314eb029dc61c78abea283510.png]: /images/20220829/13a56464ec0144338d23dfa691aea775.png
[a8bd95eb7c3c7d6a89295d58a813b140.png]: /images/20220829/e6cfe8374652463bab40c30d80d89c43.png