【文章阅读】【超解像】--Residual Dense Network for Image Super-Resolution

【文章阅读】【超解像】–Residual Dense Network for Image Super-Resolution

论文链接：https://arxiv.org/pdf/1802.08797.pdf

code：https://github.com/yulunzhang/RDN

1.主要贡献

​ 本文作者结合Residual Black和Dense Black提出了RDN(Residual Dense Network)网络结构,网络主要由RDB(Residual Dense block)网络组成,网络的结构图如下:

2.论文分析

如上图,网络主要由四部分构成:

(1) SFFNet(shallow feature extraction net)

​ 上图中的前两个卷基层组成了SFFNet,上图中的$F_0=H_{SFE2}\left(F_{-1}\right)$,$F_{-1}=H_{SFE1}\left(I_{LR}\right)$ $F_0$为SFFNet输出.

(2) RDBs(redidual dense blocks)

​ 上图中$F_1,Fd$表示该模块的中间模块输出,根据之前的输入获得:
$$\begin{array}{rl}{F}_d& =H_{RDB,d}\left(F_{d-1}\right)\\ & =H_{RDB,d}\left(H_{RDB,d-1}\left(\cdots \left(H_{RDB,1}\left(F_0\right)\right)\cdots \right)\right)\end{array}$$
​ 该模块的结构图为:

​ 该模块将残差模块Residual block和dense block模块进行了整合,三个模块的区别如下:

​ RDB模块的输入是$F_{d-1}$,输出$F_d$, $G_0$表示$F_{d-1}$和$F_d$的特征向量数,RDB中间某层输出为:
$$F_{d,c}=\sigma \left(W_{d,c}\left[F_{d-1},F_{d,1},\cdots ,F_{d,c-1}\right]\right)$$
假设$F_{d,c}$包含$G$个特征图($G$也被称为增长率);

RDB模块中主要包含3个部分内容:

• Contiguous memory

  该模块将$F_{d-1},F_{d,1},F_{d,c},F_{dC}$的特征都结合起来;

• Local feature fusion

  该模块是concat之后的$1\ast 1$卷积操作,该操作的作用是CM后非常多的feature map不易于模型训练,利用该模块对输出的维度进行了压缩.

• Local residual learning

  该模块表示将$F_{d-1}$和$F_{d,LF}$的特征进行融合,该操作有助于提升模型的表达能力;
  $$F_d=F_{d-1}+F_{d,LF}$$

(3) DFF(Dense feature fusion)

​ 该模块主要包含两个模块,Global feature fusion和Global Residual learning,其中Global feature fusion模块的作用是将$F_1,F_2,......FD$联合起来$F_{GF}=H_{GFF}\left(\left[F_1,\cdots ,F_D\right]\right)$,Global Residual learning表示将$F_{-1}$和$F_{GF}$相加得到$F_{DF}$输出,$F_{DF}=F_{-1}+F_{GF}$.该操作和RDB操作一样.

(4) UPNet(Up-sampleing net)

​ 该模块在网络的最后利用上采样和卷积实现图像的放大.

RDN与DenseNet区别:

• RDN中去掉了DenseNet中的BN和pooling模块;
• DenseNet中只有每一个dense block的输出是concat起来的,而RDB中的利用局部特征融合将RDB中的各层信息都进行了融合;
• RDN利用全局特征融合将各个RDB模块中的信息都concat起来,并利用了最开始的特征;

RDN与SRDenseNet的区别:

• RDN加入了contiguous memory,使得先前的RDB模块和当前的模块信息直接融合,利用LFF,RDB模块可以利用更大的增长率;RDB中的LRF的应用增加了信息和梯度的流动;
• RDB内部没有密集连接.
• RDB使用了L1 loss,而SRDenseNet使用了L2 loss;

RDN与MemNet区别:

• MemNet需要对原图使用Bicubic插值方式对低分辨率图像进行上采样,RDN直接使用低分辨率图像进行处理,减少了计算量和提高效率;
• Memnet中包含逆向和门限单元模块,不接受先前模块的输入,而RDB的各个模块之间是有信息交流的;
• MemNet没有全部利用中间的特征信息,而RDN利用GRL将所有的信息都利用起来;

3.结果分析

训练数据集:利用DIV2K进行训练,进行如下3种处理:

(1) BI方式:通过Bicubic对图像进行下采样,缩小比例为x2,x3,x4;

(2)BD方式:先对原图进行($7\ast 7$卷积,方差为1.6)的高斯滤波,再对滤波后的图像进行下采样;

(3)DN方法:先做Bicubic下采样,再加上30%的高斯噪声;

4.参考

1.https://blog.csdn.net/qq_14845119/article/details/81459859

5.附录

RDB的Pytorch代码实现如下:

class RDB_Conv(nn.Module):
    def __init__(self, inChannels, growRate, kSize=3):
        super(RDB_Conv, self).__init__()
        Cin = inChannels
        G  = growRate
        self.conv = nn.Sequential(*[
            nn.Conv2d(Cin, G, kSize, padding=(kSize-1)//2, stride=1),
            nn.ReLU()
        ])

    def forward(self, x):
        out = self.conv(x)
        return torch.cat((x, out), 1) 

class RDB(nn.Module):
    def __init__(self, growRate0, growRate, nConvLayers, kSize=3):
        super(RDB, self).__init__()
        G0 = growRate0
        G  = growRate
        C  = nConvLayers
        
        convs = []
        for c in range(C):
            convs.append(RDB_Conv(G0 + c*G, G))
        self.convs = nn.Sequential(*convs)
        
        # Local Feature Fusion
        self.LFF = nn.Conv2d(G0 + C*G, G0, 1, padding=0, stride=1)

    def forward(self, x):
        return self.LFF(self.convs(x)) + x

RDN的Pytorch代码如下:

class RDN(nn.Module):
    def __init__(self, args):
        super(RDN, self).__init__()
        r = args.scale[0]
        G0 = args.G0
        kSize = args.RDNkSize

        # number of RDB blocks, conv layers, out channels
        self.D, C, G = {
            'A': (20, 6, 32),
            'B': (16, 8, 64),
        }[args.RDNconfig]

        # Shallow feature extraction net
        self.SFENet1 = nn.Conv2d(args.n_colors, G0, kSize, padding=(kSize-1)//2, stride=1)
        self.SFENet2 = nn.Conv2d(G0, G0, kSize, padding=(kSize-1)//2, stride=1)

        # Redidual dense blocks and dense feature fusion
        self.RDBs = nn.ModuleList()
        for i in range(self.D):
            self.RDBs.append(
                RDB(growRate0 = G0, growRate = G, nConvLayers = C)
            )

        # Global Feature Fusion
        self.GFF = nn.Sequential(*[
            nn.Conv2d(self.D * G0, G0, 1, padding=0, stride=1),
            nn.Conv2d(G0, G0, kSize, padding=(kSize-1)//2, stride=1)
        ])

        # Up-sampling net
        if r == 2 or r == 3:
            self.UPNet = nn.Sequential(*[
                nn.Conv2d(G0, G * r * r, kSize, padding=(kSize-1)//2, stride=1),
                nn.PixelShuffle(r),
                nn.Conv2d(G, args.n_colors, kSize, padding=(kSize-1)//2, stride=1)
            ])
        elif r == 4:
            self.UPNet = nn.Sequential(*[
                nn.Conv2d(G0, G * 4, kSize, padding=(kSize-1)//2, stride=1),
                nn.PixelShuffle(2),
                nn.Conv2d(G, G * 4, kSize, padding=(kSize-1)//2, stride=1),
                nn.PixelShuffle(2),
                nn.Conv2d(G, args.n_colors, kSize, padding=(kSize-1)//2, stride=1)
            ])
        else:
            raise ValueError("scale must be 2 or 3 or 4.")

    def forward(self, x):
        f__1 = self.SFENet1(x)
        x  = self.SFENet2(f__1)

        RDBs_out = []
        for i in range(self.D):
            x = self.RDBs[i](x)
            RDBs_out.append(x)

        x = self.GFF(torch.cat(RDBs_out,1))
        x += f__1

        return self.UPNet(x)

论文个人理解，如有问题，烦请指正，谢谢！