def __init__(self, arg):
super(PAN_Blanced_attention, self).__init__()
# SCPA
self.scale = arg.scale
in_nc = arg.in_nc_pan
out_nc = arg.out_nc_pan
nf = arg.nf_pan
unf = arg.unf_pan
nb = arg.nb_pan
SCPA_block_f = functools.partial(SCPA, nf=nf, reduction=2)
### first convolution
self.conv_first = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True)
### main blocks
self.SCPA_trunk = arch_util.make_layer(SCPA_block_f, nb)
self.trunk_conv = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
#### upsampling
self.upconv1 = nn.Conv2d(nf, unf, 3, 1, 1, bias=True)
self.att1 = BlancedAttention(unf, reduction=8)
self.HRconv1 = nn.Conv2d(unf, unf, 3, 1, 1, bias=True)
if self.scale == 4:
self.upconv2 = nn.Conv2d(unf, unf, 3, 1, 1, bias=True)
self.att2 = BlancedAttention(unf, reduction=8)
self.HRconv2 = nn.Conv2d(unf, unf, 3, 1, 1, bias=True)
self.conv_last = nn.Conv2d(unf, out_nc, 3, 1, 1, bias=True)
self.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=True)
def __init__(self, upscale=4):
super(CARN_blanced_attention, self).__init__()
# scale = kwargs.get("scale")
# multi_scale = kwargs.get("multi_scale")
# group = kwargs.get("group", 1)
self.scale = upscale
multi_scale = True
group = 1
self.sub_mean = ops.MeanShift((0.4488, 0.4371, 0.4040), sub=True)
self.add_mean = ops.MeanShift((0.4488, 0.4371, 0.4040), sub=False)
self.entry = nn.Conv2d(3, 64, 3, 1, 1)
self.b1 = Block(64, 64)
self.b2 = Block(64, 64)
self.b3 = Block(64, 64)
self.c1 = nn.Sequential(ops.BasicBlock(64 * 2, 64, 1, 1, 0),BlancedAttention(64))
self.c2 = nn.Sequential(ops.BasicBlock(64 * 3, 64, 1, 1, 0),BlancedAttention(64))
self.c3 = nn.Sequential(ops.BasicBlock(64 * 4, 64, 1, 1, 0),BlancedAttention(64))
self.upsample = ops.UpsampleBlock(64, scale=upscale,
multi_scale=multi_scale,
group=group)
self.exit = nn.Conv2d(64, 3, 3, 1, 1)
def __init__(self, in_channels, out_channels, group=1):
super(Block_BlancedAttention, self).__init__()
self.r1 = ops.ResidualBlock(in_channels, out_channels)
self.r2 = ops.ResidualBlock(in_channels * 2, out_channels * 2)
self.r3 = ops.ResidualBlock(in_channels * 4, out_channels * 4)
self.g = ops.BasicBlock(in_channels * 8, out_channels, 1, 1, 0)
self.ca = BlancedAttention(in_channels)
def __init__(self, in_channels, distillation_rate=0.25):
super(IMDModule_blancedattention, self).__init__()
self.distilled_channels = int(in_channels * distillation_rate)
self.remaining_channels = int(in_channels - self.distilled_channels)
self.c1 = conv_layer(in_channels, in_channels, 3)
self.c2 = conv_layer(self.remaining_channels, in_channels, 3)
self.c3 = conv_layer(self.remaining_channels, in_channels, 3)
self.c4 = conv_layer(self.remaining_channels, self.distilled_channels,
3)
self.act = activation('lrelu', neg_slope=0.05)
self.c5 = conv_layer(in_channels, in_channels, 1)
self.attention = BlancedAttention(self.distilled_channels * 4,
reduction=16)
def __init__(self, conv=common.default_conv, n_feats=64):
super(MSRB_blanced_attention, self).__init__()
kernel_size_1 = 3
kernel_size_2 = 5
self.conv_3_1 = conv(n_feats, n_feats, kernel_size_1)
self.conv_3_2 = conv(n_feats * 2, n_feats * 2, kernel_size_1)
self.conv_5_1 = conv(n_feats, n_feats, kernel_size_2)
self.conv_5_2 = conv(n_feats * 2, n_feats * 2, kernel_size_2)
self.confusion = nn.Conv2d(n_feats * 4,
n_feats,
1,
padding=0,
stride=1)
self.relu = nn.ReLU(inplace=True)
self.attention = BlancedAttention(n_feats)
def __init__(self,
inp,
kernel_size=3,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1):
super(ResBlock_blanced_attention, self).__init__()
modules = []
for i in range(2):
modules.append(conv(inp, inp, kernel_size, bias=bias))
if bn: modules.append(nn.BatchNorm2d(inp))
if i == 0: modules.append(act)
self.body = nn.Sequential(*modules)
self.res_scale = res_scale
self.attention = BlancedAttention(inp)
def __init__(self, args):
super(AWSRN_blanced_attention, self).__init__()
# hyper-params
self.args = args
scale = args.scale
n_resblocks = args.n_resblocks_awsrn
n_feats = args.n_feats_awsrn
kernel_size = 3
res_scale = args.res_scale_awsrn
n_awru = args.n_awru_awsrn
act = nn.ReLU(True)
# wn = lambda x: x
wn = lambda x: torch.nn.utils.weight_norm(x)
self.rgb_mean = torch.autograd.Variable(torch.FloatTensor([0.4488, 0.4371, 0.4040])).view([1, 3, 1, 1])
# define head module
# head = HEAD(args, n_feats, kernel_size, wn)
head = []
head.append(
wn(nn.Conv2d(3, n_feats, 3, padding=3 // 2)))
# define body module
body = []
for i in range(n_resblocks):
body.append(
LFB(n_feats, kernel_size, args.block_feats_awsrn, n_awru, wn=wn, res_scale=res_scale, act=act))
# define tail module
out_feats = scale * scale * 3
tail = AWMS(args, scale, n_feats, kernel_size, wn)
skip = []
skip.append(
wn(nn.Conv2d(3, out_feats, 3, padding=3 // 2))
)
skip.append(nn.PixelShuffle(scale))
# make object members
self.head = nn.Sequential(*head)
self.body = nn.Sequential(*body)
self.tail = tail
self.skip = nn.Sequential(*skip)
self.attention=BlancedAttention(args.block_feats_awsrn//4,reduction=8)
def __init__(self,
conv,
n_feat,
kernel_size,
reduction,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1):
super(RCAB_ori_blanced_attention, 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))
if i == 0: modules_body.append(act)
modules_body.append(BlancedAttention(n_feat, reduction))
self.body = nn.Sequential(*modules_body)
self.res_scale = res_scale
def __init__(self, args, conv=default_conv):
super(EDSR_blanced_attention, self).__init__()
n_resblocks = args.n_resblocks_edsr # 16
n_feats = args.n_feats_edsr # 64
kernel_size = 3
scale = args.scale # 4
act = nn.ReLU(True)
self.url = url['r{}f{}x{}'.format(n_resblocks, n_feats, scale)]
self.sub_mean = common.MeanShift(args.rgb_range) # 标准化输入
self.add_mean = common.MeanShift(args.rgb_range, sign=1) # 还原输出
# define head module
m_head = [conv(args.n_colors, n_feats, kernel_size)] # channels：3->64
# define body module
m_body = [ # 16个resblock
common.ResBlock( # ## 参数：64, 3, relu, 1
conv,
n_feats,
kernel_size,
act=act,
res_scale=args.res_scale) for _ in range(n_resblocks)
]
m_body.append(conv(n_feats, n_feats, kernel_size)) # channels：64->64
# define tail module
m_tail = [
common.Upsampler(conv, scale, n_feats, act=False), # 上采样集中在这里
conv(n_feats, args.n_colors, kernel_size)
]
self.head = nn.Sequential(*m_head)
self.body = nn.Sequential(*m_body)
self.tail = nn.Sequential(*m_tail)
self.attention = BlancedAttention(n_feats)
def __init__(self, args, conv=common.default_conv):
super(oisr_LF_s_blanced_attention, self).__init__()
n_resblocks = args.n_resblocks_oisr_LF_s
n_feats = args.n_feats_oisr_LF_s
kernel_size = 3
scale = args.scale
act = nn.ReLU(True)
self.sub_mean = common.MeanShift(args.rgb_range)
self.add_mean = common.MeanShift(args.rgb_range, sign=1)
# define head module
m_head = [conv(args.n_colors, n_feats, kernel_size)]
# define body module
m_body = [
common.ResBlock(conv,
n_feats,
kernel_size,
act=act,
res_scale=args.res_scale)
for _ in range(n_resblocks)
]
m_body.append(conv(n_feats, n_feats, kernel_size))
# define tail module
m_tail = [
common.Upsampler(conv, scale, n_feats, act=False),
conv(n_feats, args.n_colors, kernel_size)
]
self.head = nn.Sequential(*m_head)
self.body = nn.Sequential(*m_body)
self.tail = nn.Sequential(*m_tail)
self.attention = BlancedAttention(n_feats)
def __init__(self, args, conv=common.default_conv):
super(LWSR_blanced_attention, self).__init__()
# n_resgroups = args.n_resgroups
# n_resblocks = args.n_resblocks
n_feats = args.n_feats_s_LWSR
kernel_size = 3
reduction = args.reduction
scale = args.scale
act = nn.ReLU(True)
# RGB mean for DIV2K
rgb_mean = (0.4488, 0.4371, 0.4040)
rgb_std = (1.0, 1.0, 1.0)
self.sub_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std)
# define head module
modules_head = [conv(args.n_colors, n_feats, kernel_size)]
self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1)
self.head = nn.Sequential(*modules_head)
# define body module
# def __init__(
# self, conv, n_feat, kernel_size,
# bias=True, bn=False, act=nn.ReLU(True), res_scale=1):
self.feat2_1 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
self.feat2_2 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
self.feat2_3 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1)
self.feat3_1 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
self.feat3_2 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
self.feat3_3 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1)
self.feat4_1 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1)
self.feat4_2 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
self.feat4_3 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1)
self.feat5_1 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1)
self.feat5_2 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
self.feat5_3 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1)
self.feat6_1 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1)
self.feat6_2 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1)
self.conv1 = conv(6 * n_feats, n_feats, 1, bias=False)
self.feat7_1 = ResBlock2(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1)
self.feat7_2 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
self.conv7 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
# self.conv7 = ConvBlock(base_filter2, base_filter, 1, 1, 0, activation='prelu', norm=None)
self.feat8_1 = ResBlock2(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1)
self.feat8_2 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
self.conv8 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
# self.conv8 = ConvBlock(base_filter2, base_filter, 1, 1, 0, activation='prelu', norm=None)
self.feat9_1 = ResBlock2(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1)
self.feat9_2 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
# self.conv9 = nn.conv2d(base_filter2, base_filter, kernel_size = 1, stride = 1, padding = 0)
self.conv9 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
self.feat10_1 = ResBlock2(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(True),
res_scale=1)
self.feat10_2 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
# self.conv10 = nn.conv2d(base_filter2, base_filter, kernel_size = 1, stride = 1, padding = 0)
self.conv10 = ResBlock(conv,
n_feats,
kernel_size,
bias=True,
bn=False,
act=nn.ReLU(False),
res_scale=1)
self.attention = BlancedAttention(n_feats)
# self.conv11 = torch.nn.Conv2d(base_filter*2, base_filter, 1, 1, 0)
# define tail module
modules_tail = [
common.Upsampler(conv, scale, n_feats, act=False),
conv(n_feats, args.n_colors, kernel_size)
]
self.tail = nn.Sequential(*modules_tail)