def __init__(self): super(EDSR, self).__init__() conv = common.default_conv n_resblocks = 16 n_feats = 64 kernel_size = 3 scale = 2 n_colors = 3 res_scale = 0.1 act = nn.ReLU(True) self.sub_mean = common.MeanShift(255) self.add_mean = common.MeanShift(255, sign=1) # define head module m_head = [conv(n_colors, n_feats, kernel_size)] # define body module m_body = [ common.ResBlock(conv, n_feats, kernel_size, act=act, res_scale=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, 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, conv=common.default_conv): super(SFNet, self).__init__() n_resblocks = args.n_resblocks n_feats = args.n_feats kernel_size = 3 scale = args.scale act = nn.LeakyReLU(0.2, inplace=True) # act = nn.ReLU(True) # 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.o_colors, kernel_size) ] self.head = nn.Sequential(*m_head) self.body = nn.Sequential(*m_body) self.downscaled = nn.Aver(3, stride=2) self.tail = nn.Sequential(*m_tail)
def __init__(self, conv=common.default_conv): super(EDSR, self).__init__() # n_resblock = args.n_resblocks n_resblock = 8 # n_feats = args.n_feats n_feats = 64 kernel_size = 3 # scale = args.scale[0] scale = 2 act = nn.ReLU(True) # n_colors = args.n_colors n_colors = 1 n_view = 9 # args.rgb_range rgb_range = 255 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) # define head module m_head = [conv(n_view, n_feats, kernel_size)] central_head = [conv(n_colors, n_feats, kernel_size)] # define body module # res_scale = args.res_scale m_body = [ common.ResBlock(conv, n_feats, kernel_size, act=act, res_scale=1) 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), nn.Conv2d(n_feats, n_colors, kernel_size, padding=(kernel_size // 2)) ] self.add_mean = common.MeanShift(rgb_range, rgb_mean, rgb_std, 1) self.head = nn.Sequential(*m_head) self.central_head = nn.Sequential(*central_head) self.body = nn.Sequential(*m_body) self.tail = nn.Sequential(*m_tail)
def __init__(self, conv=common.default_conv, n_view=9, scale=2): super(resLF, self).__init__() # 4 resblock in each image stack n_resblock = 4 # 4 resblock in the global part n_mid_resblock = 4 n_feats = 32 kernel_size = 3 act = nn.ReLU(True) n_colors = 1 self.n_view = n_view # define head module m_head = [conv(n_view, n_feats, kernel_size)] central_head = [conv(n_colors, n_feats, kernel_size)] # define body module m_mid_body = [ common.ResBlock(conv, n_feats, kernel_size, act=act, res_scale=1) for _ in range(n_mid_resblock) ] m_body = [ common.ResBlock(conv, n_feats * 4, kernel_size, act=act, res_scale=1) for _ in range(n_resblock) ] m_body.append(conv(n_feats * 4, n_feats, kernel_size)) # define tail module m_tail = [ common.Upsampler(conv, scale, n_feats, act=False), nn.Conv2d(n_feats, n_colors, kernel_size, padding=(kernel_size // 2)) ] self.head = nn.Sequential(*m_head) self.central_head = nn.Sequential(*central_head) self.midbody = nn.Sequential(*m_mid_body) self.body = nn.Sequential(*m_body) self.tail = nn.Sequential(*m_tail)
def __init__(self, args, conv=common.default_conv): super(ERCAN, 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 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, sign=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(EDSR, self).__init__() n_resblocks = args.n_resblocks n_feats = args.n_feats kernel_size = 3 scale = args.scale[0] 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) 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)
def __init__(self, args, conv3D=common.default_conv3D): super(DCRSR, self).__init__() n_dresblocks = args.n_dresblocks n_feats = args.n_feats kernel_size = 3 res_scale = args.res_scale n_resblocks = args.n_resblocks act = nn.ReLU(True) branched = args.branched branches = args.branches self.scale = args.scale[0] self.head = conv3D(1, n_feats, kernel_size) con_feats = n_feats self.dresmodules = nn.ModuleList() for i in range(n_dresblocks): self.dresmodules.append( common.DResBlock(conv3D, con_feats, n_feats, kernel_size, n_resblocks, act=act, res_scale=res_scale, branched=branched, branches=branches)) con_feats = n_feats * 2 self.body = nn.Sequential( conv3D(con_feats, n_feats, 1), act # conv3D(n_feats,n_feats,kernel_size) ) self.tail = nn.Sequential( common.Upsampler(conv3D, self.scale, n_feats), #nn.Upsample(scale_factor=scale), conv3D(n_feats, 1, kernel_size)) self.res_scale = res_scale
def __init__(self, args, conv=common.default_conv): super(RDN, self).__init__() 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) kernel_size = 3 self.is_sub_mean = args.is_sub_mean self.conv1 = conv(args.n_channel_in, args.n_feats, kernel_size, bias=True) self.conv2 = conv(args.n_feats, args.n_feats, kernel_size, bias=True) self.RDBs = [] for i in xrange(args.n_denseblocks): RDB = common.RDB(args.n_feats, args.n_layers, args.growth_rate, conv, kernel_size, True) self.add_module('RDB{}'.format(i + 1), RDB) self.RDBs.append(RDB) self.gff_1 = nn.Conv2d(args.n_feats * args.n_denseblocks, args.n_feats, kernel_size=1, padding=0, bias=True) self.gff_3 = conv(args.n_feats, args.n_feats, kernel_size, bias=True) m_tail = [ common.Upsampler(conv, args.scale[0], args.n_feats, act=False), conv(args.n_feats, args.n_channel_out, kernel_size) ] self.tail = nn.Sequential(*m_tail) self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1)
def __init__(self, args, conv=common.default_conv): super(SRResNet, self).__init__() kernel_size = 3 scale = args.scale[0] act = nn.LeakyReLU(negative_slope=0.2) self.is_sub_mean = args.is_sub_mean 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) head = [ conv(args.n_channel_in, args.n_feats, kernel_size), nn.LeakyReLU(negative_slope=0.2) ] body = [common.ResBlock(conv,args.n_feats,kernel_size,bn=True,act=act) \ for _ in xrange(args.n_resblocks)] body.extend([ conv(args.n_feats, args.n_feats, kernel_size), nn.BatchNorm2d(args.n_feats) ]) tail = [ common.Upsampler(conv, scale, args.n_feats, act=nn.LeakyReLU, act_kwargs={'negative_slope': .2}), conv(args.n_feats, args.n_channel_out, kernel_size) ] self.head = nn.Sequential(*head) self.body = nn.Sequential(*body) self.tail = nn.Sequential(*tail) self.add_mean = common.MeanShift(args.rgb_range, rgb_mean, rgb_std, 1)