这段时间学习了yolo v3的源代码，作一下笔记。这个tensorflow版本的yolo v3源码出自这里malin9402

yolo v3中首先使用的是一个darknet53的模块来提取输入图片的特征，这个darknet53的模块比较特别，全部使用的是卷积神经网络，没有使用池化层，全连接层，下面来分析一下它的代码。

1. darknet53模型

import tensorflow as tf #导入库
import core.common as common #导入所需要的文件


def darknet53(input_data):

    #[bs,416,416,3] => [bs,416,416,32]
    input_data = common.convolutional(input_data, (3, 3,  3,  32))
    #[bs,416,416,32] => [bs,208,208,64]
    input_data = common.convolutional(input_data, (3, 3, 32,  64), downsample=True)

    for i in range(1):
        #[bs,208,208,64] => [bs,208,208,64]
        input_data = common.residual_block(input_data,  64,  32, 64)

    #[bs,208,208,64] => [bs,104,104,128]
    input_data = common.convolutional(input_data, (3, 3,  64, 128), downsample=True)

    for i in range(2):
        #[bs,104,104,128] => [bs,104,104,128]
        input_data = common.residual_block(input_data, 128,  64, 128)

    #[bs,104,104,128] => [bs,52,52,256]
    input_data = common.convolutional(input_data, (3, 3, 128, 256), downsample=True)

    for i in range(8):
        #[bs,52,52,256] => [bs,52,52,256]
        input_data = common.residual_block(input_data, 256, 128, 256)

    route_1 = input_data#[bs,52,52,256]
    #[bs,52,52,256] => [bs,26,26,512]
    input_data = common.convolutional(input_data, (3, 3, 256, 512), downsample=True)

    for i in range(8):
        #[bs,26,26,512] => [bs,26,26,512]
        input_data = common.residual_block(input_data, 512, 256, 512)

    route_2 = input_data#[bs,26,26,512]
    #[bs,26,26,512] => [bs,13,13,1024]
    input_data = common.convolutional(input_data, (3, 3, 512, 1024), downsample=True)

    for i in range(4):
        #[bs,13,13,1024] => [bs,13,13,1024]
        input_data = common.residual_block(input_data, 1024, 512, 1024)

    return route_1, route_2, input_data

最后darknet53返回三个尺度的特征，

route_1: [bs,52,52,256]
route_2: [bs,26,26,512]
input_data: [bs,13,13,1024]

另外还要说明的是，我计算了一下darknet53模型的网络层，发现只有52层网络(1+2+8+8+4)*2 = 46个卷积层
1+1+1+1+1+1 = 6个卷积层
6+46 = 52个卷积层

后来才了解到，darknet53是在ImageNet上的经典分类模型，后来被yolo v3的作者移植到了yolo v3中，但是去掉了最后的池化层和全连接层，所以只剩52层了。

2. darknet53模型中用到的卷积层和残差网络

先看代码，此代码位于core/common.py文件中。
从上面darknet53的代码中可以看到，其中用到了common.convolutional卷积层和common.residual_block残差模块。下面我们来分析分析。

import tensorflow as tf

#这个就是我们常说的bn层了
class BatchNormalization(tf.keras.layers.BatchNormalization):
    """
    "Frozen state" and "inference mode" are two separate concepts.
    `layer.trainable = False` is to freeze the layer, so the layer will use
    stored moving `var` and `mean` in the "inference mode", and both `gama`
    and `beta` will not be updated !
    """
    def call(self, x, training=False):
        if not training:
            training = tf.constant(False)
        training = tf.logical_and(training, self.trainable)
        return super().call(x, training)

下面来看一下卷积层的实现

#卷积层
def convolutional(input_layer, filters_shape, downsample=False, activate=True, bn=True):
    if downsample:
        #下采样，主要功能是将输入的高宽缩小2倍，比如高宽[416,416] => 高宽[208,208]
        input_layer = tf.keras.layers.ZeroPadding2D(((1, 0), (1, 0)))(input_layer)
        padding = 'valid'
        strides = 2
    else:
      #不是下采样的话，高宽保持不变，[416,416] => [416,416]
        strides = 1
        padding = 'same'

    conv = tf.keras.layers.Conv2D(filters=filters_shape[-1], kernel_size = filters_shape[0], strides=strides, padding=padding,
                                  use_bias=not bn, kernel_regularizer=tf.keras.regularizers.l2(0.0005),
                                  kernel_initializer=tf.random_normal_initializer(stddev=0.01),
                                  bias_initializer=tf.constant_initializer(0.))(input_layer)

    if bn: conv = BatchNormalization()(conv)
    if activate == True: conv = tf.nn.leaky_relu(conv, alpha=0.1)

    return conv

说明一下，tf.keras.layers.ZeroPadding2D是给输入的高宽上下左右填充0，padding=((top_pad, bottom_pad), (left_pad, right_pad))。

卷积层有一个特性：strides = 1并且padding = 'same'的时候，输入的高宽和输出的高宽相同。如果padding = 'valid'的时候，输出的高宽 = （输入的高宽+填充的数目-卷积核的大小）/ 卷积核的步长 + 1。

比如上面的代码中downsample=True的时候，假设输入的图片为[bs,416,416,3],卷积核的数目为32，那么根据公式，输出的图片高宽为(416 + 1 - 3) /2 + 1 = 208，那么输出的图片为[bs,208,208,32]。

下面看一下残差网络的代码，残差网络的功能主要是能够防止梯度弥散现象的出现，使用了残差网络，就可以训练比较深的神经网络。

# 残差网络
def residual_block(input_layer, input_channel, filter_num1, filter_num2):
    short_cut = input_layer
    conv = convolutional(input_layer, filters_shape=(1, 1, input_channel, filter_num1))
    conv = convolutional(conv       , filters_shape=(3, 3, filter_num1,   filter_num2))

    residual_output = short_cut + conv
    return residual_output

通过上面的代码可以看出，残差网络中包含了2个卷积层，并且这2个卷积层并不改变输入图片的大小，所以代码中short_cut和conv的shape是一样的，shape相同的两个张量是可以直接相加的，于是就可以得到残差网络的输出residual_output。

下面看一下上采样操作，在tensorflow中，上采样操作可以通过转置卷积来实现，但是那样会引入训练参数。这里采用的方法比较简单，直接使用tf.image.resize方法将输入图片的尺寸放大2倍。

def upsample(input_layer):
    return tf.image.resize(input_layer, (input_layer.shape[1] * 2, input_layer.shape[2] * 2), method='nearest')

darknet53和卷积网络、残差模块的代码解读到这里就结束了，在下一篇中，我们接着来分析yolo v3的代码。