def __init__(self, args, conv=common.default_conv):
super(RCAN, self).__init__()
self.args = args
self.n_resgroups = args.n_resgroups
n_resblocks = args.n_resblocks
n_feats = args.n_feats
kernel_size = 3
reduction = args.reduction
scale = args.scale[0]
act = nn.ReLU(True)
# RGB mean for DIV2K
self.sub_mean = common.MeanShift(args.rgb_range)
# define head module
modules_head = [conv(args.n_colors, n_feats, kernel_size)]
# define body module
for group_id in range(self.n_resgroups):
setattr(self, 'body_group{}'.format(str(group_id)), ResidualGroup(conv, n_feats, kernel_size, reduction, act=act, res_scale=args.res_scale, n_resblocks=n_resblocks))
self.body_tail = 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)]
self.add_mean = common.MeanShift(args.rgb_range, sign=1)
self.head = nn.Sequential(*modules_head)
self.tail = nn.Sequential(*modules_tail)
def __init__(self, args, conv=common.default_conv):
super(EDSR, self).__init__()
n_resblock = args['n_resblocks']
n_feats = args['n_feats']
kernel_size = 3
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
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_resblock)
]
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.add_mean = common.MeanShift(args['rgb_range'], rgb_mean, rgb_std, 1)
self.head = nn.Sequential(*m_head)
self.body = nn.Sequential(*m_body)
self.tail = nn.Sequential(*m_tail)
def __init__(self, args, conv=common.default_conv):
super(FERM, self).__init__()
in_channel = 3
out_channel = 3
n_feats = 64
act = nn.ReLU(True)
n_resblocks = 20
n_resgroups = 10
bn = False
# RGB mean for DIV2K
self.sub_mean = common.MeanShift(1)
self.add_mean = common.MeanShift(1, sign=1)
head = [conv(in_channel, n_feats)]
body = [
RG(conv, n_feats, bn=bn, act=act, n_resblocks=n_resblocks) \
for _ in range(n_resgroups)]
body.append(conv(n_feats, n_feats))
tail = [conv(n_feats, n_feats), conv(n_feats, out_channel)]
self.head = nn.Sequential(*head)
self.body = nn.Sequential(*body)
self.tail = nn.Sequential(*tail)
def __init__(self, args, conv=common.default_conv):
super(EDSR, self).__init__()
self.args = args
n_resblocks = args.n_resblocks
n_feats = args.n_feats
kernel_size = 3
scale = args.scale[0]
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
self.block_num = [
int(n_resblocks / 3),
int(2 * n_resblocks / 3) - int(n_resblocks / 3),
n_resblocks - int(2 * n_resblocks / 3)
]
m_body1 = [
common.ResBlock(conv,
n_feats,
kernel_size,
act=act,
res_scale=args.res_scale)
for _ in range(self.block_num[0])
]
m_body2 = [
common.ResBlock(conv,
n_feats,
kernel_size,
act=act,
res_scale=args.res_scale)
for _ in range(self.block_num[1])
]
m_body3 = [
common.ResBlock(conv,
n_feats,
kernel_size,
act=act,
res_scale=args.res_scale)
for _ in range(self.block_num[2])
]
m_body3.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.body1 = nn.Sequential(*m_body1)
self.body2 = nn.Sequential(*m_body2)
self.body3 = nn.Sequential(*m_body3)
self.tail = nn.Sequential(*m_tail)
def __init__(self, args, conv=common.default_conv):
super(RCAN, self).__init__()
n_resgroups = args['n_resgroups']
n_resblocks = args['n_resblocks']
n_feats = args['n_feats']
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)]
#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)
]
#define tail module
modules_tail = [
common.Upsampler(conv, scale, n_feats, act=False),
conv(n_feats, args['n_colors'], kernel_size)
]
self.add_mean = common.MeanShift(args['rgb_range'], rgb_mean, rgb_std, 1)
self.head = nn.Sequential(*modules_head)
self.body = nn.Sequential(*modules_body)
self.tail = nn.Sequential(*modules_tail)
def __init__(self, args, conv=common.default_conv):
super(SAN, self).__init__()
n_resgroups = args.n_resgroups
n_resblocks = args.n_resblocks
n_feats = args.n_feats
kernel_size = 3
reduction = args.reduction
scale = args.scale[0]
act = nn.ReLU(inplace=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)
# self.soca= SOCA(n_feats, reduction=reduction)
# define head module
modules_head = [conv(args.n_colors, n_feats, kernel_size)]
# define body module
## share-source skip connection
##
self.gamma = nn.Parameter(torch.zeros(1))
# self.gamma = 0.2
self.n_resgroups = n_resgroups
self.RG = nn.ModuleList([LSRAG(conv, n_feats, kernel_size, reduction, \
act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) for _ in range(n_resgroups)])
self.conv_last = conv(n_feats, n_feats, kernel_size)
# 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)
]
self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1)
self.non_local = Nonlocal_CA(in_feat=n_feats,
inter_feat=n_feats // 4,
reduction=8,
sub_sample=False,
bn_layer=False)
self.head = nn.Sequential(*modules_head)
# self.body = nn.Sequential(*modules_body)
self.tail = nn.Sequential(*modules_tail)
if n_resgroups == 20:
self.pos = [6, 13]
elif n_resgroups == 6:
self.pos = [1, 3]
def __init__(self, args, conv=common.default_conv):
conv = common.default_conv
conv_1x1 = common.conv_1x1_9_layer
super(RCAN, self).__init__()
self.args = args
n_resgroups = args.n_resgroups
n_resblocks = args.n_resblocks
n_feats = args.n_feats
kernel_size = 3
reduction = args.reduction
scale = args.scale
if args.act_ver == 1:
act = nn.ReLU(True)
elif args.act_ver == 2:
act = nn.LeakyReLU(negative_slope=0.01, inplace=True)
elif args.act_ver == 3:
act = nn.PReLU()
# 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, args.rgb_mean,
args.rgb_std)
# define head module
modules_head = [conv(args.n_colors, n_feats, kernel_size)]
# define body module
# 3x3 conv, secure receptive field modules (original)
modules_body = [
ResidualGroup(
conv, n_feats, kernel_size, reduction, act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) \
for _ in range(3)]
# 1x1 conv, secure depth modules
modules_body += [
ResidualGroup_1x1(
conv_1x1, n_feats, kernel_size, reduction, act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) \
for _ in range(3, n_resgroups)]
modules_body.append(conv_1x1(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)
]
self.add_mean = common.MeanShift(args.rgb_range, args.rgb_mean,
args.rgb_std, 1)
self.head = nn.Sequential(*modules_head)
self.body = nn.Sequential(*modules_body)
self.tail = nn.Sequential(*modules_tail)
def __init__(self, args, conv=common.default_conv):
conv = common.default_conv
conv1x1 = common.conv_1x1_9_layer
super(EDSR, self).__init__()
self.args = args
n_resblocks = args.n_resblocks
n_feats = args.n_feats
kernel_size = 3
scale = args.scale
act = nn.ReLU(True)
# url_name = 'r{}f{}x{}'.format(n_resblocks, n_feats, scale)
# if url_name in url:
# self.url = url[url_name]
# else:
# self.url = None
self.sub_mean = common.MeanShift(args.rgb_range, args.rgb_mean,
args.rgb_std)
self.add_mean = common.MeanShift(args.rgb_range, args.rgb_mean,
args.rgb_std, 1)
# define head module
m_head = [conv(args.n_colors, n_feats, kernel_size)]
# define body module
# 3x3 conv, secure receptive field modules (original)
m_body = [
common.ResBlock(conv,
n_feats,
kernel_size,
act=act,
res_scale=args.res_scale) for _ in range(60)
]
# 1x1 conv, secure depth modules
m_body += [
common.ResBlock(conv1x1,
n_feats,
kernel_size,
act=act,
res_scale=args.res_scale)
for _ in range(60, n_resblocks)
]
m_body.append(conv1x1(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)
def __init__(self, args, in_nc, out_nc, nf, nb, gc=32): # nb:23
super(RRDBNet, self).__init__()
RRDB_block_f = functools.partial(RRDB, nf=nf, gc=gc)
self.args = args
self.ref_model = args.RRDB_ref
self.sub_mean = common.MeanShift(args.rgb_range, args.rgb_mean, args.rgb_std)
self.conv_first = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True)
self.RRDB_trunk = make_layer(RRDB_block_f, nb)
self.trunk_conv = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
#### upsampling
self.upconv1 = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.upconv2 = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.HRconv = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.conv_last = nn.Conv2d(nf, out_nc, 3, 1, 1, bias=True)
self.add_mean = common.MeanShift(args.rgb_range, args.rgb_mean, args.rgb_std, 1)
self.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=True)
def __init__(self, n_feats, rgb_range):
super(RIDNET, self).__init__()
kernel_size = 3
rgb_mean = (0.4488, 0.4371, 0.4040)
rgb_std = (1.0, 1.0, 1.0)
self.sub_mean = common.MeanShift(rgb_range, rgb_mean, rgb_std)
self.add_mean = common.MeanShift(rgb_range, rgb_mean, rgb_std, 1)
self.head = ops.BasicBlock(3, n_feats, kernel_size, 1, 1)
self.conv = nn.Conv2d((3 + n_feats), n_feats, kernel_size, 1, 1)
self.b1 = Block(n_feats, n_feats)
self.b2 = Block(n_feats, n_feats)
self.b3 = Block(n_feats, n_feats)
self.b4 = Block(n_feats, n_feats)
self.tail = nn.Conv2d(n_feats, 3, kernel_size, 1, 1, 1)
def __init__(self, args, conv=common.default_conv):
super(RCAN, self).__init__()
##added
# self.down4x = nn.Upsample(scale_factor=4, mode='bilinear')
###
n_resgroups = args.n_resgroups
n_resblocks = args.n_resblocks
n_feats = args.n_feats
kernel_size = 3
reduction = args.reduction
scale = args.scale[0]
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)]
# 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)
]
self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1)
self.head = nn.Sequential(*modules_head)
self.body = nn.Sequential(*modules_body)
self.tail = nn.Sequential(*modules_tail)
def __init__(self, conv_index, rgb_range=1):
super(VGG, self).__init__()
vgg_features = models.vgg19(pretrained=True).features
modules = [m for m in vgg_features]
if conv_index == '22':
self.vgg = nn.Sequential(*modules[:8])
elif conv_index == '54':
self.vgg = nn.Sequential(*modules[:35])
vgg_mean = (0.485, 0.456, 0.406)
vgg_std = (0.229 * rgb_range, 0.224 * rgb_range, 0.225 * rgb_range)
self.sub_mean = common.MeanShift(rgb_range, vgg_mean, vgg_std)
self.vgg.requires_grad = False
def __init__(self, args, conv=common.default_conv):
super(SWLA, self).__init__()
self.args = args
self.scale = args.scale
self.lr_p_size = args.patch_size // self.scale
self.device = torch.device('cpu' if args.cpu else 'cuda')
n_resgroups = args.n_resgroups
n_resblocks = args.n_resblocks
n_feats = args.n_feats
kernel_size = 3
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, args.rgb_mean, args.rgb_std)
# define head module
modules_head = [conv(args.n_colors, n_feats, kernel_size)]
# define body module
modules_body = [
ResidualGroup(
conv, n_feats, kernel_size, 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, self.args.scale, n_feats, act=False),
conv(n_feats, args.n_colors, kernel_size)]
self.add_mean = common.MeanShift(args.rgb_range, args.rgb_mean, args.rgb_std, 1)
self.head = nn.Sequential(*modules_head)
self.body = nn.Sequential(*modules_body)
self.tail = nn.Sequential(*modules_tail)
def __init__(self, args, conv=common.default_conv):
super(SAN, self).__init__()
self.args = args
conv = common.default_conv
conv1x1 = common.conv_1x1_9_layer
n_resgroups = args.n_resgroups
n_resblocks = args.n_resblocks
n_feats = args.n_feats
kernel_size = 3
reduction = args.reduction
scale = args.scale
act = nn.ReLU(inplace=True) # change it to leaky relu???!#!#!#!#
if args.act_ver == 1:
act = nn.ReLU(True)
elif args.act_ver == 2:
act = nn.LeakyReLU(negative_slope=0.2, inplace=True)
elif args.act_ver == 3:
act = nn.PReLU()
# 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, args.rgb_mean,
args.rgb_std)
# self.soca= SOCA(n_feats, reduction=reduction)
# define head module
modules_head = [conv(args.n_colors, n_feats, kernel_size)]
# define body module
## share-source skip connection
##
self.gamma = nn.Parameter(torch.zeros(1))
# self.gamma = 0.2
self.n_resgroups = n_resgroups
# 3x3 conv, secure proper receptive field area
RG = [LSRAG(conv, n_feats, kernel_size, reduction, \
act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) for _ in
range(3)]
# 1x1 conv, secure depth area
RG += [LSRAG(conv1x1, n_feats, kernel_size, reduction, \
act=act, res_scale=args.res_scale, n_resblocks=n_resblocks) for _ in
range(3, n_resgroups)]
self.RG = nn.ModuleList(RG)
self.conv_last = conv1x1(n_feats, n_feats, kernel_size)
# 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)
]
self.add_mean = common.MeanShift(args.rgb_range, args.rgb_mean,
args.rgb_std, 1)
self.non_local = Nonlocal_CA(in_feat=n_feats,
inter_feat=n_feats // 8,
reduction=8,
sub_sample=False,
bn_layer=False)
self.head = nn.Sequential(*modules_head)
# self.body = nn.Sequential(*modules_body)
self.tail = nn.Sequential(*modules_tail)
