论文解读|【Densenet】密集连接的卷积网络（附Pytorch代码讲解）_密集型网络rdn pytorch

---

@[t oc]

1 简单介绍

论文题目：Densely Connected Convolutional Networks
发表机构：康奈尔大学，清华大学，Facebook AI
发表时间：2018年1月
论文代码：https://github.com/WangXiaoCao/attention-is-all-you-need-pytorch
pytorch代码：https://github.com/WangXiaoCao/attention-is-all-you-need-pytorch

1.1 背景介绍

1.卷积神经网络CNN在计算机视觉物体识别上优势显著，典型的模型有：LeNet5, VGG, Highway Network, Residual Network.

2.CNN越深则效果越好，但是，会面临梯度弥散的问题，经过层数越多，则前面的信息就会渐渐减弱和消散。

3.目前已有很多措施去解决以上困境：
（1）Highway Network,Residual Network通过前后两层的残差链接使信息尽量不丢失
（2）Stochastic depth通过随机drop掉Resnet的一些层来缩短模型
（3）FractalNets通过重复组合一些平行的层序列来保证深度的同时减轻这个问题。
但这些措施都有一个共性：都是在前一层和后一层中都建立一个短连接。比如，酱紫：

1.2 本文概要

1.2.1 模型结构预览

本文提出的densenet就更霸道了，为了确保网络中最大的信息流通，让每层都与改层之前的所有层都相连，即每层的输入，是前面所有层的输出的concat.(resnet用的是sum).整体结构是酱紫的：

1.2.2 优点

1.需要更少参数。

2.使得信息（前向计算时）或梯度（后向计算时）在整个网络中的保持地更好，可以训练更深的模型。

3.dense connection有正则化的效果，在较少训练集上减少过拟合。

1.2.3 实验结果

在4个benchmark datasets (CIFAR-10, CIFAR-100, SVHN, and
ImageNet)上测试。
大部分任务上都优于state of art.

2 模型结构

2.1 整体结构

1.输入：图片
2.经过feature block（图中的第一个convolution层，后面可以加一个pooling层,这里没有画出来）
3.经过第一个dense block， 该Block中有n个dense layer,灰色圆圈表示，每个dense layer都是dense connection,即每一层的输入都是前面所有层的输出的拼接
4.经过第一个transition block,由convolution和poolling组成
5.经过第二个dense block
6.经过第二个transition block
7.经过第三个dense block
8.经过classification block,由pooling,linear层组成，输出softmax的score
9.经过prediction层，softmax分类
10.输出：分类概率

作者在4个数据集上进行测试，CIFAR-10, CIFAR-100, SVHN上构建的是以上3个dense block + 2个transition block；在ImageNet上构建的是4个dense block + 3个transition block。两者在参数的设置上略有不同，下文将以ImageNet上构建的densenet为例进行讲解。

2.2 Feature Block

Feature Block是输入层与第一个Dense Block之间的那一部分，上面结构图中只画了一个卷积，在ImageNet数据集上构建的densenet中其实后面还跟了一个poolling层。计算过程如下：

输入：图片 （244 * 244 * 3）
1.卷积层convolution计算：in_channel=3, out_channel=64,kernel_size=7,stride=2,padding=3，输出（122 * 122 * 64）
2.batch normalization计算，输入与输出维度不变 （122 * 122 * 64）
3.激活函数relu计算，输入与输出维度不变 （122 * 122 * 64）
4.池化层poollig计算，kenel_size=3, stride=2,padding=1，输出（56 * 56 * 64）

    from torch.nn import Sequential, Conv2d, BatchNorm2d, ReLU, MaxPool2d
    
    class FeatureBlock(RichRepr, Sequential):
        def __init__(self, in_channels, out_channels):
            super(FeatureBlock, self).__init__()
    
            self.in_channels = in_channels
            self.out_channels = out_channels
    
            # add_module:在现有model中增添子module
            self.add_module('conv', Conv2d(in_channels, out_channels, kernel_size=7, stride=2, padding=3, bias=False)),
            self.add_module('norm', BatchNorm2d(out_channels)),
            self.add_module('relu', ReLU(inplace=True)),
            self.add_module('pool', MaxPool2d(kernel_size=3, stride=2, padding=1)),
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.3 Dense Block 和 Dense Layer

2.3.1 Dense Layer

一个Dense Block中是由L层dense laryer组成，layer之间是dense connectivity。从下面这个公式上来体会什么是dense connectivity，第l层的输出是：

H_l是该layer的计算函数，输入是x0到x_l-1的拼接，即模型的原始输出(x0)和前面每层的输出的拼接。这个拼接是channel维度上的拼接，即维度（56 * 56 * 64）的数据 和（56 * 56 * 32）的数据拼接成（56 * 56 * 96）的数据维度。

而ResNet就不同了,是直接将前一层的输出加在该层的输出之上：

Dense Layer中函数H(·)的计算过程如下（括号中的数据维度是以第一个dense block的第一个dense layer为例的，整个模型的k值是预先设定的，本模型为k=32）：

输入：Feature Block的输出（56 * 56 * 64）或者是上一层dense layer的输出
1.Batch Normalization， 输出（56 * 56 * 64）
2.ReLU ，输出（56 * 56 * 64）
3.Bottleneck，是可选的，为了减少 feature-maps的数量，过程如下3步
-1x1 Convolution, kernel_size=1, channel = 4k, 则输出为（56 * 56 * 128）
-Batch Normalization（56 * 56 * 128）
-ReLU（56 * 56 * 128）
4.Convolution, kernel_size=3, channel = k （56 * 56 * 32）
5.Dropout,可选的,用于防止过拟合（56 * 56 * 32）

from typing import Optional
from torch.nn import Sequential, BatchNorm2d, ReLU, Conv2d, Dropout2d
from .bottleneck import Bottleneck

class DenseLayer(RichRepr, Sequential):
    r"""
    Dense Layer as described in [DenseNet](https://arxiv.org/abs/1608.06993)
    and implemented in https://github.com/liuzhuang13/DenseNet

    Consists of:

    - Batch Normalization
    - ReLU
    - (Bottleneck)
    - 3x3 Convolution
    - (Dropout)
    """

    def __init__(self, in_channels: int, out_channels: int,
                 bottleneck_ratio: Optional[int] = None, dropout: float = 0.0):
        super(DenseLayer, self).__init__()

        self.in_channels = in_channels
        self.out_channels = out_channels

        self.add_module('norm', BatchNorm2d(num_features=in_channels))
        self.add_module('relu', ReLU(inplace=True))

        if bottleneck_ratio is not None:
            self.add_module('bottleneck', Bottleneck(in_channels, bottleneck_ratio * out_channels)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29