def __init__(self,
in_channels,
out_channels,
num_features,
upscale_factor,
res_scale=1,
conv=blocks.default_conv):
super(GraphNet, self).__init__()
rgb_mean = (0.4488, 0.4371, 0.4040)
rgb_std = (1.0, 1.0, 1.0)
##define network head
net_head = [conv(in_channels, num_features, 3)]
##define network body
net_body = nn.ModuleList()
for i in range(20):
net_body.append(Block(conv, num_features, num_features))
##deine network tail
net_tail = [
conv(num_features, num_features, 3),
blocks.Upsampler(conv, upscale_factor, num_features),
conv(num_features, out_channels=3, kernel_size=3)
]
self.sub_mean = blocks.MeanShift(rgb_mean, rgb_std, sign=-1)
self.head = nn.Sequential(*net_head)
self.body = nn.Sequential(*net_body)
self.concat = conv(num_features * 21, num_features, 1)
self.tail = nn.Sequential(*net_tail)
self.add_mean = blocks.MeanShift(rgb_mean, rgb_std, 1)
def __init__(self,
in_channels,
out_channels,
num_features,
upscale_factor,
conv=blocks.default_conv):
super(GCNSR, self).__init__()
rgb_mean = (0.4488, 0.4371, 0.4040)
rgb_std = (1.0, 1.0, 1.0)
## define network head
self.head = conv(in_channels, num_features, 3)
## define network body
net_body = nn.ModuleList()
for _ in range(20):
net_body.append(Backbone(conv, num_features))
self.body = nn.Sequential(*net_body)
## define network tail
net_tail = [
conv(num_features, num_features, 3),
blocks.Upsampler(conv, upscale_factor, num_features),
conv(num_features, out_channels=3, kernel_size=3)
]
self.tail = nn.Sequential(*net_tail)
self.sub_mean = blocks.MeanShift(rgb_mean, rgb_std, sign=-1)
self.fusion = conv(num_features * 21, num_features, 1)
self.add_mean = blocks.MeanShift(rgb_mean, rgb_std, 1)
self.adj = Cal_adj_matrix()
def __init__(self,
in_channels,
out_channels,
num_features,
upscale_factor,
conv=blocks.default_conv):
super(GroupNet, self).__init__()
rgb_mean = (0.4488, 0.4371, 0.4040)
rgb_std = (1.0, 1.0, 1.0)
n_resblocks = 8
self.sub_mean = blocks.MeanShift(rgb_mean, rgb_std, sign=-1)
self.add_mean = blocks.MeanShift(rgb_mean, rgb_std, sign=1)
#define network head
self.head = conv(in_channels, num_features, 3)
#define network body
self.block1 = ResBlock(conv, num_features, num_features)
self.block2 = ResBlock(conv, num_features, num_features)
self.node1 = conv(num_features * 2, num_features, 1)
self.block3 = ResBlock(conv, num_features, num_features)
self.block4 = ResBlock(conv, num_features, num_features)
self.node2 = conv(num_features * 2, num_features, 1)
self.block5 = ResBlock(conv, num_features, num_features)
self.block6 = ResBlock(conv, num_features, num_features)
self.node3 = conv(num_features * 4, num_features * 2, 1)
self.block7 = ResBlock(conv, num_features * 2, num_features * 2)
self.block8 = ResBlock(conv, num_features * 2, num_features * 2)
self.node4 = conv(num_features * 4, num_features * 2, 1)
self.block9 = ResBlock(conv, num_features * 2, num_features * 2)
self.block10 = ResBlock(conv, num_features * 2, num_features * 2)
self.node5 = conv(num_features * 2 * 3, num_features * 3, 1)
self.block11 = ResBlock(conv, num_features * 3, num_features * 3)
self.block12 = ResBlock(conv, num_features * 3, num_features * 3)
self.node6 = conv(num_features * 2 * 3, num_features * 3, 1)
self.block13 = ResBlock(conv, num_features * 3, num_features * 3)
self.block14 = ResBlock(conv, num_features * 3, num_features * 3)
self.node7 = conv(num_features * 15, 480, 1)
#define network tail
network_tail_1 = [
conv(480, num_features, 3),
blocks.Upsampler(conv, upscale_factor, num_features),
conv(num_features, out_channels, 3)
]
network_tail_2 = [
blocks.Upsampler(conv, upscale_factor, num_features),
conv(num_features, out_channels, 3)
]
self.tail_1 = nn.Sequential(*network_tail_1)
self.tail_2 = nn.Sequential(*network_tail_2)
def __init__(
self, in_channels, out_channels, n_feats, upscale_factor, conv=blocks.default_conv):
super(GroupNet, self).__init__()
# RGB mean for DIV2K
rgb_mean = (0.4488, 0.4371, 0.4040)
rgb_std = (1.0, 1.0, 1.0)
self.sub_mean = blocks.MeanShift(rgb_mean, rgb_std, sign=-1)
self.add_mean = blocks.MeanShift(rgb_mean, rgb_std, sign=1)
# define head module
self.head = conv(in_channels, n_feats, kernel_size=3)
# define body module
self.unit1 = BasicUnit(conv,n_feats)
self.unit2 = BasicUnit(conv,n_feats)
self.node1 = conv(n_feats*2,n_feats,1)
self.unit3 = BasicUnit(conv,n_feats)
self.unit4 = BasicUnit(conv,n_feats)
self.node2 = conv(n_feats*2,n_feats, 1)
self.unit5 = BasicUnit(conv,n_feats)
self.unit6 = BasicUnit(conv,n_feats)
self.node3 = conv(n_feats*4,n_feats*2, 1)
self.unit7 = BasicUnit(conv,n_feats*2)
self.unit8 = BasicUnit(conv,n_feats*2)
self.node4 = conv(n_feats*4,n_feats*2, 1)
self.unit9 = BasicUnit(conv,n_feats*2)
self.unit10 = BasicUnit(conv,n_feats*2)
self.node5 = conv(n_feats*2*3,n_feats*3,1)
self.unit11 = BasicUnit(conv,n_feats*3)
self.unit12 = BasicUnit(conv,n_feats*3)
self.node6 = conv(n_feats*6,n_feats*3,1)
self.unit13 = BasicUnit(conv,n_feats*3)
self.unit14 = BasicUnit(conv,n_feats*3)
self.node7 = conv(n_feats*15,480, 1)
# define tail module
modules_tail_1 = [
conv(480, n_feats, kernel_size=3),
common.Upsampler(conv, upscale_factor, n_feats, act=False),
conv(n_feats, out_channels, kernel_size=3)]
modules_tail_2 = [
common.Upsampler(conv, upscale_factor, n_feats, act=False),
conv(n_feats, out_channels, kernel_size=3)]
self.tail_1 =nn.Sequential(*modules_tail_1)
self.tail_2 =nn.Sequential(*modules_tail_2)
def __init__(self,
num_features,
n_resgroups,
n_resblocks,
kernel_size,
reduction,
upscale_factor,
norm_type=False,
act_type='relu',
conv=blocks.default_conv):
super(RCAN, self).__init__()
rgb_mean = (0.4488, 0.4371, 0.4040)
rgb_std = (1.0, 1.0, 1.0)
self.sub_mean = blocks.MeanShift(rgb_mean, rgb_std)
modules_head = [
conv(in_channels=3,
out_channels=num_features,
kernel_size=kernel_size)
]
modules_body = [
ResidualGroup(conv,
num_features,
kernel_size,
reduction,
res_scale=1,
n_resblocks=20,
act_type='relu') for i in range(n_resgroups)
]
modules_body.append(conv(num_features, num_features, kernel_size))
modules_tail = [
blocks.Upsampler(conv,
upscale_factor,
num_features,
act_type=False),
conv(num_features, out_channels=3, kernel_size=kernel_size)
]
self.head = nn.Sequential(*modules_head)
self.body = nn.Sequential(*modules_body)
self.tail = nn.Sequential(*modules_tail)
self.add_mean = blocks.MeanShift(rgb_mean, rgb_std, sign=1)