def __init__(self,
nf=64,
nframes=5,
groups=8,
front_RBs=5,
back_RBs=10,
center=None,
predeblur=False,
HR_in=False,
w_TSA=True):
super(EDVR, self).__init__()
self.nf = nf
self.center = nframes // 2 if center is None else center
self.is_predeblur = True if predeblur else False
self.HR_in = True if HR_in else False
self.w_TSA = w_TSA
ResidualBlock_noBN_f = functools.partial(arch_util.ResidualBlock_noBN,
nf=nf)
ResidualCABlock_noBN_f = functools.partial(arch_util.RCAB, n_feat=nf)
#### extract features (for each frame)
if self.is_predeblur:
self.pre_deblur = Predeblur_ResNet_Pyramid(nf=nf, HR_in=self.HR_in)
self.conv_1x1 = nn.Conv2d(nf, nf, 1, 1, bias=True)
else:
if self.HR_in:
self.conv_first_1 = nn.Conv2d(3, nf, 3, 1, 1, bias=True)
self.conv_first_2 = nn.Conv2d(nf, nf, 3, 2, 1, bias=True)
self.conv_first_3 = nn.Conv2d(nf, nf, 3, 2, 1, bias=True)
else:
self.conv_first = nn.Conv2d(3, nf, 3, 1, 1, bias=True)
self.feature_extraction = arch_util.make_layer(ResidualBlock_noBN_f,
front_RBs)
self.fea_L2_conv1 = nn.Conv2d(nf, nf, 3, 2, 1, bias=True)
self.fea_L2_conv2 = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.fea_L3_conv1 = nn.Conv2d(nf, nf, 3, 2, 1, bias=True)
self.fea_L3_conv2 = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.pcd_align = PCD_Align(nf=nf, groups=groups)
if self.w_TSA:
self.tsa_fusion = TSA_Fusion(nf=nf,
nframes=nframes,
center=self.center)
else:
self.tsa_fusion = nn.Conv2d(nframes * nf, nf, 1, 1, bias=True)
#### reconstruction
# self.recon_trunk = arch_util.make_layer(ResidualBlock_noBN_f, back_RBs)
self.recon_trunk = arch_util.make_layer(ResidualCABlock_noBN_f,
back_RBs)
#### upsampling
self.upconv1 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.upconv2 = nn.Conv2d(nf, 64 * 4, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(2)
self.HRconv = nn.Conv2d(64, 64, 3, 1, 1, bias=True)
self.conv_last = nn.Conv2d(64, 3, 3, 1, 1, bias=True)
#### activation function
self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
def __init__(self, in_nc=3, nf=64):
super(ResNet_alpha_beta_sconv, self).__init__()
self.conv_1 = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True) # 64f
basic_block_64 = functools.partial(mutil.ResidualBlock_noBN, nf=nf)
self.encoder1 = mutil.make_layer(basic_block_64, 2) # 64f
self.down_conv_1 = nn.Conv2d(nf, nf, 4, 2, 1, bias=False)
self.conv_2 = nn.Conv2d(nf, nf * 2, 3, 1, 1, bias=True) # 128f
basic_block_128 = functools.partial(mutil.ResidualBlock_noBN,
nf=nf * 2)
self.encoder2 = mutil.make_layer(basic_block_128, 2) # 128f
self.down_conv_2 = nn.Conv2d(nf * 2, nf * 2, 4, 2, 1, bias=False)
self.conv_3 = nn.Conv2d(nf * 2, nf * 4, 3, 1, 1, bias=True) # 256f
basic_block_256 = functools.partial(mutil.ResidualBlock_noBN,
nf=nf * 4)
self.encoder3 = mutil.make_layer(basic_block_256, 2) # 256f
self.down_conv_3 = nn.Conv2d(nf * 4, nf * 4, 4, 2, 1, bias=False)
self.conv_4 = nn.Conv2d(nf * 4, nf, 3, 1, 1, bias=True) # 64f
self.conv_5 = nn.Conv2d(nf, 6, 3, 1, 1, bias=True) # 6f
# pooling
#self.avg_pool = nn.AvgPool2d(2)
self.global_avg_pool = nn.AdaptiveAvgPool2d(1)
# activation function
self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
def __init__(self, in_nc=3, nf=64):
super(ResNet_alpha_beta_sconv_3d, self).__init__()
self.conv_1 = nn.Conv3d(in_channels=in_nc,
out_channels=nf,
kernel_size=(3, 3, 3),
stride=1,
padding=(0, 0, 0),
bias=True)
basic_block_64 = functools.partial(mutil.ResidualBlock_noBN_3D, nf=nf)
self.encoder1 = mutil.make_layer(basic_block_64, 2) # 64f
self.down_conv_1 = nn.Conv3d(nf,
nf, (1, 4, 4), (1, 2, 2), (0, 1, 1),
bias=False)
self.conv_2 = nn.Conv3d(nf,
nf * 2, (3, 3, 3),
stride=1,
padding=(0, 0, 0),
bias=True) # 128f
basic_block_128 = functools.partial(mutil.ResidualBlock_noBN_3D,
nf=nf * 2)
self.encoder2 = mutil.make_layer(basic_block_128, 2) # 128f
self.down_conv_2 = nn.Conv3d(nf * 2,
nf * 2, (1, 4, 4), (1, 2, 2), (0, 1, 1),
bias=False)
self.conv_3 = nn.Conv3d(nf * 2,
nf * 4, (3, 3, 3),
stride=1,
padding=(0, 0, 0),
bias=True) # 256f
basic_block_256 = functools.partial(mutil.ResidualBlock_noBN_3D,
nf=nf * 4)
self.encoder3 = mutil.make_layer(basic_block_256, 2) # 256f
self.down_conv_3 = nn.Conv3d(nf * 4,
nf * 4, (1, 4, 4), (1, 2, 2), (0, 1, 1),
bias=False)
self.conv_4 = nn.Conv3d(nf * 4,
nf, (3, 3, 3),
stride=1,
padding=(0, 1, 1),
bias=True) # 64f
self.conv_5 = nn.Conv3d(nf,
6, (3, 3, 3),
stride=1,
padding=(0, 1, 1),
bias=True) # 6f
# pooling
#self.avg_pool = nn.AvgPool2d(2)
self.global_avg_pool = nn.AdaptiveAvgPool2d(1)
# activation function
self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
# padding
self.pad_3d = nn.ReplicationPad3d(1)
def __init__(self, in_nc=3, out_nc=3, nf=64, nb=32, cond_dim=2):
super(CResMDNet, self).__init__()
# condition mapping
self.global_scale = nn.Linear(cond_dim, out_nc, bias=True)
self.conv_first = nn.Conv2d(in_nc, nf, 3, 2, 1, bias=True)
basic_block = functools.partial(ResidualBlock_CRes,
nf=nf,
cond_dim=cond_dim)
self.recon_trunk = arch_util.make_layer(basic_block, nb)
self.upconv = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(2)
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.act = nn.ReLU(inplace=True)
# initialization
arch_util.initialize_weights(
[self.conv_first, self.upconv, self.HRconv, self.conv_last], 0.1)
arch_util.initialize_weights([self.global_scale], 0.1)
def __init__(self, in_nc=3, out_nc=3, nf=64, nb=16, upscale=4):
super(SRResNet, self).__init__()
self.upscale = upscale
self.conv_first = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True)
basic_block = functools.partial(arch_util.ResidualBlock_noBN, nf=nf)
self.recon_trunk = arch_util.make_layer(basic_block, nb)
self.LRconv = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
# upsampling
if self.upscale == 2:
self.upconv1 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(2)
elif self.upscale == 3:
self.upconv1 = nn.Conv2d(nf, nf * 9, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(3)
elif self.upscale == 4:
self.upconv1 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.upconv2 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(2)
self.HRconv = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.conv_last = nn.Conv2d(nf, out_nc, 3, 1, 1, bias=True)
# activation function
self.relu = nn.ReLU(inplace=True)
# initialization
arch_util.initialize_weights([self.conv_first, self.upconv1, self.HRconv, self.conv_last],
0.1)
if self.upscale == 4:
arch_util.initialize_weights(self.upconv2, 0.1)
def __init__(self, in_nc, out_nc, nf, unf, nb, scale=4):
super(PAN, self).__init__()
# SCPA
SCPA_block_f = functools.partial(SCPA, nf=nf, reduction=2)
self.scale = scale
### 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 = PA(unf)
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 = PA(unf)
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, in_nc=3, out_nc=3, nf=64, nb=16, adafm_ksize=None):
super(AdaFMNet, self).__init__()
self.conv_first = nn.Conv2d(in_nc, nf, 3, 2, 1, bias=True)
if adafm_ksize is not None:
basic_block = functools.partial(ResidualBlock_adafm,
nf=nf,
adafm_ksize=adafm_ksize)
else:
basic_block = functools.partial(arch_util.ResidualBlock_noBN,
nf=nf)
self.recon_trunk = arch_util.make_layer(basic_block, nb)
self.LR_conv = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.adafm = nn.Conv2d(nf,
nf,
kernel_size=adafm_ksize,
padding=(adafm_ksize - 1) // 2,
groups=nf,
bias=True)
self.upconv = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(2)
self.HRconv = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.conv_last = nn.Conv2d(nf, out_nc, 3, 1, 1, bias=True)
arch_util.initialize_weights(
[self.conv_first, self.upconv, self.HRconv, self.conv_last], 0.1)
arch_util.initialize_weights([self.adafm], 0.)
self.relu = nn.ReLU(inplace=True)
def __init__(self, in_nc=3, out_nc=3, nf=64, nb=16, upscale=4, n_condition=32):
super(MSRResNet_withSFT, self).__init__()
self.upscale = upscale
self.conv_first = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True)
basic_block = functools.partial(arch_util.ResidualBlock_noBN, nf=nf)
self.recon_trunk = arch_util.make_layer(basic_block, nb)
# upsampling
if self.upscale == 2:
self.upconv1 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(2)
elif self.upscale == 3:
self.upconv1 = nn.Conv2d(nf, nf * 9, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(3)
elif self.upscale == 4:
self.upconv1 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.upconv2 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(2)
self.HRconv = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.conv_last = nn.Conv2d(nf, out_nc, 3, 1, 1, bias=True)
# activation function
self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
# initialization
arch_util.initialize_weights([self.conv_first, self.upconv1, self.HRconv, self.conv_last],
0.1)
if self.upscale == 4:
arch_util.initialize_weights(self.upconv2, 0.1)
self.fc1 = nn.Linear(n_condition, 400)
self.fc2 = nn.Linear(400, 400)
self.fc3 = nn.Linear(400, n_condition)
def __init__(self, in_nc=3, out_nc=3, nf=64, upscale=4):
super(Coarse_Fine_RCANNet, self).__init__()
self.upscale = upscale
self.conv_first = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True)
self.conv_second = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.conv_third = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
basic_block = functools.partial(network_block.ResidualBlock_noBN_CA,
nf=nf)
self.recon_trunk1 = arch_util.make_layer(basic_block, 5)
self.recon_trunk2 = arch_util.make_layer(basic_block, 5)
self.recon_trunk3 = arch_util.make_layer(basic_block, 6)
# upsampling
if self.upscale == 2:
self.upconv1 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(2)
elif self.upscale == 3:
self.upconv1 = nn.Conv2d(nf, nf * 9, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(3)
elif self.upscale == 4:
self.upconv1 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.upconv2 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(2)
elif self.upscale == 8:
self.upconv1 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.upconv2 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.upconv3 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(2)
self.HRconv = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.conv_last = nn.Conv2d(nf, out_nc, 3, 1, 1, bias=True)
# activation function
self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
# initialization
arch_util.initialize_weights([
self.conv_first, self.conv_second, self.conv_third, self.upconv1,
self.HRconv, self.conv_last
], 0.1)
if self.upscale == 4:
arch_util.initialize_weights(self.upconv2, 0.1)
if self.upscale == 8:
arch_util.initialize_weights(self.upconv3, 0.1)
def __init__(self, in_nc=3, nf=64):
super(ResNet_alpha_beta_decoder_3x3_IN_encoder_8HW, self).__init__()
# encoder
self.conv_1 = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True) # 64f
basic_block_64 = functools.partial(mutil.ResidualBlock_IN, nf=nf)
self.encoder1 = mutil.make_layer(basic_block_64, 2) # 64f
self.conv_2 = nn.Conv2d(nf, nf * 2, 3, 1, 1, bias=True) # 128f
basic_block_128 = functools.partial(mutil.ResidualBlock_IN, nf=nf * 2)
self.encoder2 = mutil.make_layer(basic_block_128, 2) # 128f
self.conv_3 = nn.Conv2d(nf * 2, nf * 4, 3, 1, 1, bias=True) # 256f
basic_block_256 = functools.partial(mutil.ResidualBlock_IN, nf=nf * 4)
self.encoder3 = mutil.make_layer(basic_block_256, 2) # 256f
self.conv_4 = nn.Conv2d(nf * 4, nf, 3, 1, 1, bias=True) # 64f
self.bn_4 = nn.InstanceNorm2d(nf, affine=True)
self.conv_5 = nn.Conv2d(nf, 64, 3, 1, 1, bias=True) # 64f
# pooling
self.avg_pool = nn.AvgPool2d(2)
# activation function
self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
# decoder
self.conv_6 = nn.Conv2d(64, 32, 3, 1, padding=1, bias=True)
self.conv_7 = nn.Conv2d(96, 32, 3, 1, padding=1, bias=True)
self.conv_8 = nn.Conv2d(32, 32, 3, 1, padding=1, bias=True)
self.conv_9 = nn.Conv2d(288, 32, 3, 1, padding=1, bias=True)
self.conv_10 = nn.Conv2d(32, 32, 3, 1, padding=1, bias=True)
self.conv_11 = nn.Conv2d(160, 32, 3, 1, padding=1, bias=True)
self.conv_12 = nn.Conv2d(32, 32, 3, 1, padding=1, bias=True)
self.conv_13 = nn.Conv2d(96, 32, 3, 1, padding=1, bias=True)
self.conv_14 = nn.Conv2d(32, 6, 3, 1, padding=1, bias=True)
def __init__(self, in_nc=1, out_nc=1, nf=32, nb=1, gc=32):
super(RRDBNet_lite, self).__init__()
RRDB_block_f = functools.partial(RRDB, nf=nf, gc=gc)
self.conv_first = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True)
self.RRDB_trunk = arch_util.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.conv_last = nn.Conv2d(nf, out_nc, 3, 1, 1, bias=True)
self.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=False)
def __init__(self, in_nc, out_nc, nf, nb, gc=32):
super(RRDBNetTRConv_16x, self).__init__()
RRDB_block_f = functools.partial(RRDB, nf=nf, gc=gc)
self.conv_first = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True)
self.RRDB_trunk = arch_util.make_layer(RRDB_block_f, nb)
self.trunk_conv = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
#### upsampling
self.tr_conv = nn.ConvTranspose2d(nf, nf, 2, 2, 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.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=True)
def __init__(self, in_nc, out_nc, nf, nb):
super(FastNet, self).__init__()
BasicBlock_block_f = functools.partial(RRDB, nf=nf)
self.conv_first = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True)
self.RRDB_trunk = arch_util.make_layer(BasicBlock_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.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=True)
def __init__(self, nf=64, N_RBs=15, in_dim=3, depthwise_separable=False):
super(Conv_ResBlocks, self).__init__()
if depthwise_separable:
ResidualBlock_noBN_f = functools.partial(
mutil.ResidualBlock_noBN_depthwise_separable, nf=nf)
else:
ResidualBlock_noBN_f = functools.partial(mutil.ResidualBlock_noBN,
nf=nf)
#### extract features
self.conv_first = nn.Conv2d(in_dim, nf, 3, 1, 1, bias=True)
self.res_blocks = mutil.make_layer(ResidualBlock_noBN_f, N_RBs)
#### activation function
self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
def __init__(self, in_nc, out_nc, nf, nb, gc=32, upscale=2):
super(RRDBNet, self).__init__()
self.upscale = upscale
assert (upscale == 2 or upscale == 4)
RRDB_block_f = functools.partial(RRDB, nf=nf, gc=gc)
self.conv_first = nn.Conv2d(in_nc, nf, 3, 1, 1, bias=True)
self.RRDB_trunk = arch_util.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)
if self.upscale == 4:
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.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=True)
def __init__(self, in_nc=3, out_nc=3, nf=64, nb=32):
super(BaseNet, self).__init__()
self.conv_first = nn.Conv2d(in_nc, nf, 3, 2, 1, bias=True)
basic_block = functools.partial(arch_util.ResidualBlock_noBN, nf=nf)
self.recon_trunk = arch_util.make_layer(basic_block, nb)
self.upconv = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(2)
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.act = nn.ReLU(inplace=True)
# initialization
arch_util.initialize_weights(
[self.conv_first, self.upconv, self.HRconv, self.conv_last], 0.1)
def __init__(self,
nf=64,
nframes=5,
groups=8,
front_RBs=5,
back_RBs=10,
center=None,
predeblur=False,
HR_in=False,
w_TSA=True,
deconv=True):
super(MYEDVR_RES, self).__init__()
self.nf = nf
self.center = nframes // 2 if center is None else center
self.is_predeblur = True if predeblur else False
self.HR_in = True if HR_in else False
self.w_TSA = w_TSA
self.deconv = deconv
ResidualBlock_noBN_f = functools.partial(arch_util.ResidualBlock_noBN,
nf=nf)
#### extract features (for each frame)
if self.is_predeblur:
self.pre_deblur = Predeblur_ResNet_Pyramid(nf=nf, HR_in=self.HR_in)
self.conv_1x1 = nn.Conv2d(nf, nf, 1, 1, bias=True)
else:
if self.HR_in:
self.conv_first_1 = nn.Conv2d(3, nf, 3, 1, 1, bias=True)
self.conv_first_2 = nn.Conv2d(nf, nf, 3, 2, 1, bias=True)
self.conv_first_3 = nn.Conv2d(nf, nf, 3, 2, 1, bias=True)
else:
self.conv_first = nn.Conv2d(3, nf, 3, 1, 1, bias=True)
self.feature_extraction = arch_util.make_layer(ResidualBlock_noBN_f,
front_RBs)
self.fea_L2_conv1 = nn.Conv2d(nf, nf, 3, 2, 1, bias=True)
self.fea_L2_conv2 = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.fea_L3_conv1 = nn.Conv2d(nf, nf, 3, 2, 1, bias=True)
self.fea_L3_conv2 = nn.Conv2d(nf, nf, 3, 1, 1, bias=True)
self.pcd_align = PCD_Align(nf=nf, groups=groups)
if self.w_TSA:
self.tsa_fusion = TSA_Fusion(nf=nf,
nframes=nframes,
center=self.center)
else:
self.tsa_fusion = nn.Conv2d(nframes * nf, nf, 1, 1, bias=True)
#### reconstruction
self.recon_trunk = arch_util.make_layer(ResidualBlock_noBN_f, back_RBs)
#### upsampling
self.upconv1 = nn.Conv2d(nf, nf * 4, 3, 1, 1, bias=True)
self.upconv2 = nn.Conv2d(nf, 64 * 4, 3, 1, 1, bias=True)
self.pixel_shuffle = nn.PixelShuffle(2)
self.HRconv = nn.Conv2d(64, 64, 3, 1, 1, bias=True)
self.conv_last = nn.Conv2d(64, 3, 3, 1, 1, bias=True)
#### activation function
self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
### denoise block
self.denoise_block = FusionDenoise()
self.denoise_extract_fea = nn.Sequential(
nn.ReplicationPad3d(1),
nn.Conv3d(nf,
nf,
kernel_size=(3, 3, 3),
stride=1,
padding=(0, 0, 0),
bias=True))
### deconv upsampling
self.deconv_up = nn.ConvTranspose2d(3,
64,
kernel_size=4,
stride=4,
padding=0,
output_padding=0,
groups=1,
bias=True,
dilation=1,
padding_mode='zeros')
self.content_out = nn.Conv2d(64, 3, 3, 1, 1, bias=True)
### HF enhancer
self.HF_enhancer = nn.Sequential(
nn.Conv2d(3, nf, 3, 1, 1, bias=True),
arch_util.make_layer(ResidualBlock_noBN_f, 3),
nn.Conv2d(64, 3, 3, 1, 1, bias=True))
