图像超分辨之RCAN:Image Super-Resolution Using Very Deep Residual Channel Attention Networks

ECCV2018
论文：http://arxiv.org/pdf/1807.02758.pdf

1.摘要

SR任务应该尽可能多的恢复一些高频信息（图像的高频信息就是灰度变化快的地方，比如边缘、角点等）。由于LR图像主要都是低频信息，最好将其直接输给最终的HR，没有必要浪费计算量。然而现有的EDSR等网络直接从LR中提取特征并对每个通道都做一样的处理，把计算量浪费在了低频信息上，阻碍了网络的性能提升。

有两个创新点：
1.Residual in residual结构，可以构造更深的的网络结构。因为我暂时不想在上采样的时候设计过深的网络，所以浅浅介绍。具有长跳跃连接的残差组构成的residual in residual（RIR）结构来构建深度网络。每个残差组中包含一些具有短跳跃连接的残差块。整个RIR结构通过运用多个跳跃连接，让低频信息绕过网络，使主干网络只学习到高频信息。之前好像看过一篇论文叫ResNet In ResNet，也是重构残差模块来构造更深层网络。

2.Channel Attention
提出了一个信道注意机制来自适应调整信道特征通过考虑信道间的相互依赖性
最后作者把Residual in residual和Channel Attention 结合到一起组成了RCAB模块作为RCAN的基础模块。

本文就是通过注意力和残差块来构造更深的网络，然后又有长短两种连接

2.Residual in residual

从上面的结构图中可以看出，residual in residual（RIR）结构的最外层由G个残差组以及一个长跳跃连接构成，从而形成了一个粗粒度的残差学习。在每一个残差组的内部，则是由B个残差通道注意力块（RCAB）以及一个小的跳跃连接构成。简单来说，这个residual in residual就是大残差内部再套小残差。
在srresnet中也有这种大残差套小残差的结构

def forward(self, x):
        x = self.sub_mean(x)
        x = self.head(x)

        res = self.body(x)#内部有short connect
        res += x#long connect

        x = self.tail(res)
        x = self.add_mean(x)

        return x 

3.Channel Attention

先将输入进行 conv—relu—conv，然后将得到的特征map经过CALayer
CALayer是先进行均值池化，在通过1*1conv（降通道）—relu-1*1conv（升通道）。内部就是short connect短连接
RCAB代码：

class RCAB(nn.Module):#2Residual+2CALayer=4
    def __init__(
        self, conv, n_feat, kernel_size, reduction,
        bias=True, bn=False, act=nn.ReLU(True), res_scale=1):

        super(RCAB, self).__init__()
        modules_body = []
        for i in range(2):
            modules_body.append(conv(n_feat, n_feat, kernel_size, bias=bias))
            if bn: modules_body.append(nn.BatchNorm2d(n_feat))#也是默认不使用bn层
            if i == 0: modules_body.append(act)
        modules_body.append(CALayer(n_feat, reduction))
        self.body = nn.Sequential(*modules_body)
        self.res_scale = res_scale

    def forward(self, x):
        res = self.body(x)
        res += x#在注意力中加残差
        return res

CALayer代码：

class CALayer(nn.Module):

    def __init__(self, channel, reduction=16):     

        super(CALayer, self).__init__()
        # global average pooling: feature --> point
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        # feature channel downscale and upscale --> channel weight
        self.conv_du = nn.Sequential(
                nn.Conv2d(channel, channel // reduction, 1, padding=0, bias=True),
                nn.ReLU(inplace=True),
                nn.Conv2d(channel // reduction, channel, 1, padding=0, bias=True),
                nn.Sigmoid()
        )

    def forward(self, x):
        y = self.avg_pool(x)
        y = self.conv_du(y)
        return x * y
 # y权重通过上面方式求出，然后在和x求乘积

4.网络结构

先通过一个3*3卷积把通道由3升到64，然后再走ResidualGroup模块
RIR结构设置10个Residual Group (RG)，每个RG中RCAB20个，一个RCAB有4个卷积，10个RG之后再经过一个3*3的卷积。最后也是使用PixelShuffle做上采样，再通过一层3*3卷积降通道到3。

整个模型代码：

# define head module
        modules_head = [conv(args.n_colors, n_feats, kernel_size)]

        # define body module
        modules_body = [
            ResidualGroup(
                conv, n_feats, kernel_size, reduction, act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) \
            for _ in range(n_resgroups)]

        modules_body.append(conv(n_feats, n_feats, kernel_size))

        # define tail module
        modules_tail = [
            common.Upsampler(conv, scale, n_feats, act=False),
            conv(n_feats, args.n_colors, kernel_size)]

Residual Group代码：

modules_body = [
            RCAB(
                conv, n_feat, kernel_size, reduction, bias=True, bn=False, act=nn.ReLU(True), res_scale=1) \
            for _ in range(n_resblocks)]#20个
        modules_body.append(conv(n_feat, n_feat, kernel_size))
        self.body = nn.Sequential(*modules_body)

    def forward(self, x):
        res = self.body(x)
        res += x
        return res