ResNet 网络详解与 keras 实现

本博客旨在给经典的 ResNet 网络进行详解与代码实现，如有不足或者其他的见解，请在本博客下面留言。

Resnet 网络的概览

1. 为了解决训练很深的网络时候出现的梯度退化 (gradient degradation) 的问题, Kaiming He 提出了 Resnet 结构。由于使用了残差学习的方法 (Resuidal learning)，使得网络的层数得到了大大的提升。
2. ResNet 由于使用了 shortcut, 把原来需要学习逼近的未知函数 H(x) 恒等映射 (Identity mapping), 变成了逼近 F(x)=H(x)-x 的一个函数。作者认为这两种表达的效果相同，但是优化的难度却并不相同，作者假设 F(x) 的优化会比 H(x) 简单的多。这一想法也是源于图像处理中的残差向量编码，通过一个 reformulation，将一个问题分解成多个尺度直接的残差问题，能够很好的起到优化训练的效果。
3. ResNet 针对较深 (层数大于等于 50) 的网络提出了 BottleNeck 的结构，这个结构可以减少运算的时间复杂度。
4. ResNet 里存在两种 shortcut,Identity shortcut & Projection shortcut。Identity shortcut 使用零填充的方式保证其纬度不变，而 Projection shortcut 则具有下面的形式y=F(x,Wi)+Wsxy=F(x,Wi)+Wsx来匹配纬度的变换。
5. ResNet 这个模型在图像处理的相关任务中具有很好的泛化性，在 2015 年的 ImageNet Recognization,ImageNet detection,ImageNet localization,COCO detection,COCO segmentation 等等任务上取得第一的成绩。

在本篇博客中，将对 Resnet 的结构进行详细的解释，并用代码实现 ResNet 的网络结构。同时，本文还将引入另一篇论文 <>，来更加深入的理解 Resnet。本文使用 VOC2012 的数据集进行网络的训练，验证，与测试。为了快速开发，本次我们把 Keras 作为代码的框架。

Pascal_VOC 数据集

Pascal VOC 为图像识别，检测与分割提供了一整套标准化的优秀的数据集，每一年都会举办一次图像识别竞赛。下面是 VOC2012，训练集 (包括验证集) 的下载地址。

VOC2012 里面有 20 类物体的图片，图片总共有 1.7 万张。我把数据集分成了 3 个部分，训练集，验证集，测试集，比例为 8:1:1。
下面是部分截图：

第一层目录

 

 

第二层目录

 

 

第三层目录

 

 

接着我们使用 keras 代码来使用这个数据集，代码如下：

IM_WIDTH=224 #图片宽度
IM_HEIGHT=224 #图片高度
batch_size=32 #批的大小

# train data
train_datagen = ImageDataGenerator(
    width_shift_range=0.1,
    height_shift_range=0.1,
    shear_range=0.1,
    zoom_range=0.1,
    horizontal_flip=True,
    rescale=1./255
)
train_generator = train_datagen.flow_from_directory(
    train_root,
    target_size=(IM_WIDTH, IM_HEIGHT),
    batch_size=batch_size,
    shuffle=True
)

# vaild data
vaild_datagen = ImageDataGenerator(
    width_shift_range=0.1,
    height_shift_range=0.1,
    shear_range=0.1,
    zoom_range=0.1,
    horizontal_flip=True,
    rescale=1./255
)
vaild_generator = train_datagen.flow_from_directory(
    vaildation_root,
    target_size=(IM_WIDTH, IM_HEIGHT),
    batch_size=batch_size,
)

# test data
test_datagen = ImageDataGenerator(
    rescale=1./255
)
test_generator = train_datagen.flow_from_directory(
    test_root,
    target_size=(IM_WIDTH, IM_HEIGHT),
    batch_size=batch_size,
)

我使用了 3 个 ImageDataGenerator，分别来使用训练集，验证集与测试集的数据。使用 ImageDataGenerator 需要导入相应的模块，==from keras.preprocessing.image import ImageDataGenerator==。ImageDataGenrator 可以用来做数据增强，提高模型的鲁棒性. 它里面提供了许多变换，包括图片旋转，对称，平移等等操作。里面的 flow_from_directory 方法可以从相应的目录里面批量获取图片，这样就可以不用一次性读取所有图片 (防止内存不足)。

梯度退化

按照我们的惯性思维，一个网络越深则这个网络就应该具有更好的学习能力，而梯度退化是指下面一种现象：随着网络层数的增加，网络的效果先是变好到饱和，然后立即下降的一个现象。在这里，我们引用一幅来自 Resnet 里面的图片，更加直观的理解这个现象：

从上图我们可以看出，一个 56 层的网络的训练误差和测试误差都大于一个 20 层的网络。

 

Residual Learning

 

 

为了解决梯度退化的问题，论文中提出了 Residual learning 这个方法，它通过构造一个 Residual block 来完成。如图 Figure 2 所示，引入残差结构以后，把原来需要学习逼近的未知函数 H(x) 恒等映射 (Identity mapping), 变成了逼近 F(x)=H(x)-x 的一个函数。作者认为这两种表达的效果相同，但是优化的难度却并不相同，作者假设 F(x) 的优化会比 H(x) 简单的多。这一想法也是源于图像处理中的残差向量编码，通过一个 reformulation，将一个问题分解成多个尺度直接的残差问题，能够很好的起到优化训练的效果。

上图的恒等映射，是把一个输入 x 和其堆叠了 2 次后的输出 F(x) 的进行元素级和作为总的输出。因此它没有增加网络的运算复杂度，而且这个操作很容易被现在的一些常用库执行 (e.g.,Caffe,tensorflow)。

下面是一张没有使用普通图 (plain, 即没有加入恒等映射的图)，与一张有 shortcut 图的对比：

最左边的图为经典的 VGG-19 图的网络结构，中间的图是一个类似于 VGG-19 的 34 层的普通图，最右边的图是 34 层的带有恒等映射的 Resnet 网络图。其中黑色的实线代表的是同一纬度 (即卷积核的个数相同) 下的恒等映射。而虚线指的是不同维度间 (卷积核的个数不同) 的恒等映射。

 

Identity vs Projection Shortcuts

除了最简单的 Identity shortcuts(直接进行同纬度的元素级相加)，论文还研究了 Projection shortcuts($ y=F(x,{W_i})+W_sx$). 论文研究了以下 3 种情况：

i. 对于纬度没有变化的连接进行直接相连，对于纬度增加的连接则通过补零填充后进行连接。由于 shortcuts 是恒等的，因此这个连接本身不会带来额外的参数。

ii. 对于纬度没有变化的连接进行直接相连，对于纬度增加的连接则通过投影相连，投影相连会增加参数。

iii. 对于所有的连接都采取投影相连。

作者对以上三种情况都进行了研究，发现 iii 的效果比 ii 好一点点点 (marginly better)，发现 ii 的效果比 i 的效果好一点。这是因为$W_s$中带来的额外参数所带来的效果。

Bottleneck architecture

 

如上图右边所示，作者在研究更深层次 (层数大于 50) 的网络的时候，使用了 Bottleneck 这个网络结构。我觉得作者可能是参考了 goolenet 里面的 Inception 结构。我们可以看到在 Bottleneck 中，第一个 1x1 的卷积层用来在降低纬度 (用来降低运算复杂度)，而后一个的 1x1 的卷积层则用来增加纬度，使其保持与原来的输入具有相同的纬度。(从而可以进行恒等映射)。

 

Resnet 网络构建表

 

 

Tabel 1

上图是一个 Resnet 的网络构建表，它显示了 resnet 是怎么构成的。同时这个表还提供了各个网络的运算浮点数，虽然 resnet 的层数比较深，但是它的运算量都小于 VGG-19（19.6x10 的 9 次方)。

ResNet 论文结果:

 

 

上图左边是普通的网络，右边是残差网络，较细的线代表验证误差，较粗的线则代表训练误差。我们可以看到普通的网络存在梯度退化的现象，即 34 层网络的训练和验证误差都大于 18 层的网络，而残差网络中则不存在这个现象。可见残差网络解决了梯度退化的问题。

为了搭建 Resnet 网络，我们使用了以下策略：

• 使用 identity_block 这个函数来搭建 Resnet34, 使用 bottleneck 这个函数来搭建 Resnet50。
• 每个卷积层后都使用 BatchNormalization，来防止模型过拟合，并且使输出满足高斯分布。
• 具体网络搭建可以参考 Tabel.1，可以边看表里面的具体参数边搭网络。

整个代码的流程如下：

graph TD
A(导入相应库) --> Z[模型参数设置以及其它配置]
Z --> B[生成训练集,测试集,验证集的三个迭代器] 
B --> C[identity_block函数的编写]
C --> D[bottleneck_block函数的编写]
D --> F[根据resnet网络构建表来构建网络]
F --> G[模型训练与验证]
G --> H[模型保存]
H --> I(模型在测试集上测试)

# coding=utf-8
from keras.models import Model
from keras.layers import Input, Dense, Dropout, BatchNormalization, Conv2D, MaxPooling2D, AveragePooling2D, concatenate,     Activation, ZeroPadding2D
from keras.layers import add, Flatten
from keras.utils import plot_model
from keras.metrics import top_k_categorical_accuracy
from keras.preprocessing.image import ImageDataGenerator
from keras.models import load_model
import os

# Global Constants
NB_CLASS=20
IM_WIDTH=224
IM_HEIGHT=224
train_root=‘/home/faith/keras/dataset/traindata/‘
vaildation_root=‘/home/faith/keras/dataset/vaildationdata/‘
test_root=‘/home/faith/keras/dataset/testdata/‘
batch_size=32
EPOCH=60

# train data
train_datagen = ImageDataGenerator(
    width_shift_range=0.1,
    height_shift_range=0.1,
    shear_range=0.1,
    zoom_range=0.1,
    horizontal_flip=True,
    rescale=1./255
)
train_generator = train_datagen.flow_from_directory(
    train_root,
    target_size=(IM_WIDTH, IM_HEIGHT),
    batch_size=batch_size,
    shuffle=True
)

# vaild data
vaild_datagen = ImageDataGenerator(
    width_shift_range=0.1,
    height_shift_range=0.1,
    shear_range=0.1,
    zoom_range=0.1,
    horizontal_flip=True,
    rescale=1./255
)
vaild_generator = train_datagen.flow_from_directory(
    vaildation_root,
    target_size=(IM_WIDTH, IM_HEIGHT),
    batch_size=batch_size,
)

# test data
test_datagen = ImageDataGenerator(
    rescale=1./255
)
test_generator = train_datagen.flow_from_directory(
    test_root,
    target_size=(IM_WIDTH, IM_HEIGHT),
    batch_size=batch_size,
)

def Conv2d_BN(x, nb_filter, kernel_size, strides=(1, 1), padding=‘same‘, name=None):
    if name is not None:
        bn_name = name + ‘_bn‘
        conv_name = name + ‘_conv‘
    else:
        bn_name = None
        conv_name = None

    x = Conv2D(nb_filter, kernel_size, padding=padding, strides=strides, activation=‘relu‘, name=conv_name)(x)
    x = BatchNormalization(axis=3, name=bn_name)(x)
    return x


def identity_Block(inpt, nb_filter, kernel_size, strides=(1, 1), with_conv_shortcut=False):
    x = Conv2d_BN(inpt, nb_filter=nb_filter, kernel_size=kernel_size, strides=strides, padding=‘same‘)
    x = Conv2d_BN(x, nb_filter=nb_filter, kernel_size=kernel_size, padding=‘same‘)
    if with_conv_shortcut:
        shortcut = Conv2d_BN(inpt, nb_filter=nb_filter, strides=strides, kernel_size=kernel_size)
        x = add([x, shortcut])
        return x
    else:
        x = add([x, inpt])
        return x

def bottleneck_Block(inpt,nb_filters,strides=(1,1),with_conv_shortcut=False):
    k1,k2,k3=nb_filters
    x = Conv2d_BN(inpt, nb_filter=k1, kernel_size=1, strides=strides, padding=‘same‘)
    x = Conv2d_BN(x, nb_filter=k2, kernel_size=3, padding=‘same‘)
    x = Conv2d_BN(x, nb_filter=k3, kernel_size=1, padding=‘same‘)
    if with_conv_shortcut:
        shortcut = Conv2d_BN(inpt, nb_filter=k3, strides=strides, kernel_size=1)
        x = add([x, shortcut])
        return x
    else:
        x = add([x, inpt])
        return x

def resnet_34(width,height,channel,classes):
    inpt = Input(shape=(width, height, channel))
    x = ZeroPadding2D((3, 3))(inpt)

    #conv1
    x = Conv2d_BN(x, nb_filter=64, kernel_size=(7, 7), strides=(2, 2), padding=‘valid‘)
    x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding=‘same‘)(x)

    #conv2_x
    x = identity_Block(x, nb_filter=64, kernel_size=(3, 3))
    x = identity_Block(x, nb_filter=64, kernel_size=(3, 3))
    x = identity_Block(x, nb_filter=64, kernel_size=(3, 3))

    #conv3_x
    x = identity_Block(x, nb_filter=128, kernel_size=(3, 3), strides=(2, 2), with_conv_shortcut=True)
    x = identity_Block(x, nb_filter=128, kernel_size=(3, 3))
    x = identity_Block(x, nb_filter=128, kernel_size=(3, 3))
    x = identity_Block(x, nb_filter=128, kernel_size=(3, 3))

    #conv4_x
    x = identity_Block(x, nb_filter=256, kernel_size=(3, 3), strides=(2, 2), with_conv_shortcut=True)
    x = identity_Block(x, nb_filter=256, kernel_size=(3, 3))
    x = identity_Block(x, nb_filter=256, kernel_size=(3, 3))
    x = identity_Block(x, nb_filter=256, kernel_size=(3, 3))
    x = identity_Block(x, nb_filter=256, kernel_size=(3, 3))
    x = identity_Block(x, nb_filter=256, kernel_size=(3, 3))

    #conv5_x
    x = identity_Block(x, nb_filter=512, kernel_size=(3, 3), strides=(2, 2), with_conv_shortcut=True)
    x = identity_Block(x, nb_filter=512, kernel_size=(3, 3))
    x = identity_Block(x, nb_filter=512, kernel_size=(3, 3))
    x = AveragePooling2D(pool_size=(7, 7))(x)
    x = Flatten()(x)
    x = Dense(classes, activation=‘softmax‘)(x)

    model = Model(inputs=inpt, outputs=x)
    return model

def resnet_50(width,height,channel,classes):
    inpt = Input(shape=(width, height, channel))
    x = ZeroPadding2D((3, 3))(inpt)
    x = Conv2d_BN(x, nb_filter=64, kernel_size=(7, 7), strides=(2, 2), padding=‘valid‘)
    x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding=‘same‘)(x)

    #conv2_x
    x = bottleneck_Block(x, nb_filters=[64,64,256],strides=(1,1),with_conv_shortcut=True)
    x = bottleneck_Block(x, nb_filters=[64,64,256])
    x = bottleneck_Block(x, nb_filters=[64,64,256])

    #conv3_x
    x = bottleneck_Block(x, nb_filters=[128, 128, 512],strides=(2,2),with_conv_shortcut=True)
    x = bottleneck_Block(x, nb_filters=[128, 128, 512])
    x = bottleneck_Block(x, nb_filters=[128, 128, 512])
    x = bottleneck_Block(x, nb_filters=[128, 128, 512])

    #conv4_x
    x = bottleneck_Block(x, nb_filters=[256, 256, 1024],strides=(2,2),with_conv_shortcut=True)
    x = bottleneck_Block(x, nb_filters=[256, 256, 1024])
    x = bottleneck_Block(x, nb_filters=[256, 256, 1024])
    x = bottleneck_Block(x, nb_filters=[256, 256, 1024])
    x = bottleneck_Block(x, nb_filters=[256, 256, 1024])
    x = bottleneck_Block(x, nb_filters=[256, 256, 1024])

    #conv5_x
    x = bottleneck_Block(x, nb_filters=[512, 512, 2048], strides=(2, 2), with_conv_shortcut=True)
    x = bottleneck_Block(x, nb_filters=[512, 512, 2048])
    x = bottleneck_Block(x, nb_filters=[512, 512, 2048])

    x = AveragePooling2D(pool_size=(7, 7))(x)
    x = Flatten()(x)
    x = Dense(classes, activation=‘softmax‘)(x)

    model = Model(inputs=inpt, outputs=x)
    return model

def acc_top2(y_true, y_pred):
    return top_k_categorical_accuracy(y_true, y_pred, k=2)


def check_print():
    # Create a Keras Model
    model = resnet_50(IM_WIDTH,IM_HEIGHT,3,NB_CLASS)
    model.summary()
    # Save a PNG of the Model Build
    plot_model(model, to_file=‘resnet.png‘)
    model.compile(optimizer=‘adam‘, loss=‘categorical_crossentropy‘, metrics=[‘acc‘,top_k_categorical_accuracy])
    print ‘Model Compiled‘
    return model


if __name__ == ‘__main__‘:
    if os.path.exists(‘resnet_50.h5‘):
        model=load_model(‘resnet_50.h5‘)
    else:
        model=check_print()

    model.fit_generator(train_generator,validation_data=vaild_generator,epochs=EPOCH,steps_per_epoch=train_generator.n/batch_size
                        ,validation_steps=vaild_generator.n/batch_size)
    model.save(‘resnet_50.h5‘)
    loss,acc,top_acc=model.evaluate_generator(test_generator, steps=test_generator.n / batch_size)
    print ‘Test result:loss:%f,acc:%f,top_acc:%f‘ % (loss, acc, top_acc)

实验结果

实验结果分析

我们可以发现模型最后在测试集上的效果与训练集上的效果有一定程度上的差距，模型出现了一点过拟合。为了防止过拟合，而且为了加速收敛，本文在每一层之间都是用了 BatchNormalization 层。由于本文只训练了 60 个 epoch，每个 epoch 差不多迭代 500 次，由于训练的次数太少，故效果并未具体显现。

本博客相关引用

以下是本博客的引用，再次本人对每个引用的作者表示感谢。读者如果对 Resnet 这个网络仍然存在一些疑虑，或者想要有更深的理解，可以参考以下的引用。

引用博客 1

引用博客 2

引用文献 1:Deep Residual Learning for Image Recognition

引用文献 2:Residual Networks are Exponential Ensembles of Relatively Shallow Networks