srcnn fsrcnn espcn rdn超分网络的结构

1.Srcnn

Code：

数据集制作方法：以x2为例
训练数据：一张原始图作为高分辨率图像（h, w），先下采样到（h/2, w/2）,然后再cubic上采样到（h, w）得到低分辨率图像， 该网络只处理Y通道图像， 训练的时候patch_size 默认设为33。
事实上两者的分辨率是一样的，也就是网络的输入和输出尺寸是相同的，但是清晰度不同

评估和预测的时候网络输入是 整幅图像

网络模型：
参考论文和srcnn网络结构可视化

2.FSrcnn

相关code1

相关code2

1）.是对srcnn的加速

主要看下图即可：
1）去掉bicubic interpolation，直接进入特征提取层，但是在网络最后加入反卷积层
2）特征映射层（mapping layer）替换为shrinking-mapping-expanding，达到加速目的
3）Fsrcnn更深的网络，更低的计算量
4）Fsrcnn除了反卷积层，其他层对于2x,3x,4x的训练参数是可以共享的，因此可以加速训练和测试

2）.Srcnn和fsrcnn的一些对比

首先速度

其次结果

3）.关于反卷积层

最后一层是反卷积层，进行图像尺寸的放大，因此前面层的训练参数可以共享，不同的分辨率放大倍数，只需要对 反卷积层微调即可，不同放大倍数反卷积层的stride有差异。

3）.Espcn：Real-Time Single Image and Video Super-Resolution Using an Efficient

Sub-Pixel Convolutional Neural Network
1.Sub-pixel convolution layer
子像素卷积层 作为 扩大 图像尺寸的层， fsrcnn是用的反卷积层 扩大图像尺寸

就是 以放大二倍来说，倒数第二层 会有 4个通道， 然后4个通道重新排布扩大为4个像素。也就将倒数第二层的 size扩大了2倍

2.网络架构
三个conv2d + 一个pixel shuffle

RDN：Residual Dense Network for Image Super-Resolution
1.网络架构
EDSR 利用了residual block
SRDenseNet 利用了 dense skip block
RDN将两者结合在一起，进一步提升特征提取和融合的能力，主要结构如下：

其中 residual dense block结构如下

RDN model

import argparse

import torch
from torch import nn


class DenseLayer(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(DenseLayer, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=3 // 2)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        return torch.cat([x, self.relu(self.conv(x))], 1)


class RDB(nn.Module):
    def __init__(self, in_channels, growth_rate, num_layers):
        super(RDB, self).__init__()
        self.layers = nn.Sequential(*[DenseLayer(in_channels + growth_rate * i, growth_rate) for i in range(num_layers)])

        # local feature fusion
        self.lff = nn.Conv2d(in_channels + growth_rate * num_layers, growth_rate, kernel_size=1)

    def forward(self, x):
        return x + self.lff(self.layers(x))  # local residual learning


class RDN(nn.Module):
    def __init__(self, scale_factor, num_channels, num_features, growth_rate, num_blocks, num_layers):
        super(RDN, self).__init__()
        self.G0 = num_features
        self.G = growth_rate
        self.D = num_blocks
        self.C = num_layers

        # shallow feature extraction
        self.sfe1 = nn.Conv2d(num_channels, num_features, kernel_size=3, padding=3 // 2)
        self.sfe2 = nn.Conv2d(num_features, num_features, kernel_size=3, padding=3 // 2)

        # residual dense blocks
        self.rdbs = nn.ModuleList([RDB(self.G0, self.G, self.C)])
        for _ in range(self.D - 1):
            self.rdbs.append(RDB(self.G, self.G, self.C))

        # global feature fusion
        self.gff = nn.Sequential(
            nn.Conv2d(self.G * self.D, self.G0, kernel_size=1),
            nn.Conv2d(self.G0, self.G0, kernel_size=3, padding=3 // 2)
        )

        # up-sampling
        assert 2 <= scale_factor <= 4
        if scale_factor == 2 or scale_factor == 4:
            self.upscale = []
            for _ in range(scale_factor // 2):
                self.upscale.extend([nn.Conv2d(self.G0, self.G0 * (2 ** 2), kernel_size=3, padding=3 // 2),
                                     nn.PixelShuffle(2)])
            self.upscale = nn.Sequential(*self.upscale)
        else:
            self.upscale = nn.Sequential(
                nn.Conv2d(self.G0, self.G0 * (scale_factor ** 2), kernel_size=3, padding=3 // 2),
                nn.PixelShuffle(scale_factor)
            )

        self.output = nn.Conv2d(self.G0, num_channels, kernel_size=3, padding=3 // 2)

    def forward(self, x):
        sfe1 = self.sfe1(x)
        sfe2 = self.sfe2(sfe1)

        x = sfe2
        local_features = []
        for i in range(self.D):
            x = self.rdbs[i](x)
            local_features.append(x)

        x = self.gff(torch.cat(local_features, 1)) + sfe1  # global residual learning
        x = self.upscale(x)
        x = self.output(x)
        return x

from torchviz import make_dot
import tensorwatch as tw
from torchinfo import summary
import netron
if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument('--num-features', type=int, default=64)
    parser.add_argument('--growth-rate', type=int, default=64)
    parser.add_argument('--num-blocks', type=int, default=16)
    parser.add_argument('--num-layers', type=int, default=8)
    parser.add_argument('--scale', type=int, default=4)
    parser.add_argument('--patch-size', type=int, default=32)
    parser.add_argument('--lr', type=float, default=1e-4)
    parser.add_argument('--batch-size', type=int, default=16)
    parser.add_argument('--num-epochs', type=int, default=800)
    parser.add_argument('--num-workers', type=int, default=8)
    parser.add_argument('--seed', type=int, default=123)
    args = parser.parse_args()

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    # device = 'cpu'
    modelviz = RDN(scale_factor=args.scale,
                num_channels=3,
                num_features=args.num_features,
                growth_rate=args.growth_rate,
                num_blocks=args.num_blocks,
                num_layers=args.num_layers).to(device)
    # 打印模型结构
    h, w, c = 20, 20, 3
    print(modelviz)
    summary(modelviz, input_size=(8, c, h, w), col_names=["kernel_size", "output_size", "num_params", "mult_adds"])
    for p in modelviz.parameters():
        if p.requires_grad:
            print(p.shape)
    # 创建输入, 看看输出结果

    input = torch.rand(8, c, h, w).to(device)
    out = modelviz(input)
    print(out.shape)
    # 1. 使用 torchviz 可视化
    g = make_dot(out)
    g.view()  # 直接在当前路径下保存 pdf 并打开
    # g.render(filename='netStructure/myNetModel', view=False, format='pdf')  # 保存 pdf 到指定路径不打开


    # 2. 保存成pt文件后进行可视化
    torch.save(modelviz, "modelviz.pt")
    modelData = 'modelviz.pt'
    netron.start(modelData)

    # 3. 使用tensorwatch可视化
    print(tw.model_stats(modelviz, (8, c, h, w)))
    # tw.draw_model(modelviz, input)```




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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139