def __init__(self, in_nc=3, out_nc=3, nc=64, nb=8, upscale=4, act_mode='L', upsample_mode='pixelshuffle', negative_slope=0.05): """ in_nc: channel number of input out_nc: channel number of output nc: channel number nb: number of residual blocks upscale: up-scale factor act_mode: activation function upsample_mode: 'upconv' | 'pixelshuffle' | 'convtranspose' """ super(IMDN, self).__init__() assert 'R' in act_mode or 'L' in act_mode, 'Examples of activation function: R, L, BR, BL, IR, IL' m_head = B.conv(in_nc, nc, mode='C') m_body = [B.IMDBlock(nc, nc, mode='C'+act_mode, negative_slope=negative_slope) for _ in range(nb)] m_body.append(B.conv(nc, nc, mode='C')) if upsample_mode == 'upconv': upsample_block = B.upsample_upconv elif upsample_mode == 'pixelshuffle': upsample_block = B.upsample_pixelshuffle elif upsample_mode == 'convtranspose': upsample_block = B.upsample_convtranspose else: raise NotImplementedError('upsample mode [{:s}] is not found'.format(upsample_mode)) m_uper = upsample_block(nc, out_nc, mode=str(upscale)) self.model = B.sequential(m_head, B.ShortcutBlock(B.sequential(*m_body)), *m_uper)
def __init__(self, in_nc=3, out_nc=3, nc=64, nb=16, upscale=4, act_mode='R', upsample_mode='upconv'): """ in_nc: channel number of input out_nc: channel number of output nc: channel number nb: number of residual blocks upscale: up-scale factor act_mode: activation function upsample_mode: 'upconv' | 'pixelshuffle' | 'convtranspose' """ super(MSRResNet0, self).__init__() assert 'R' in act_mode or 'L' in act_mode, 'Examples of activation function: R, L, BR, BL, IR, IL' n_upscale = int(math.log(upscale, 2)) if upscale == 3: n_upscale = 1 m_head = B.conv(in_nc, nc, mode='C') m_body = [ B.ResBlock(nc, nc, mode='C' + act_mode + 'C') for _ in range(nb) ] m_body.append(B.conv(nc, nc, mode='C')) if upsample_mode == 'upconv': upsample_block = B.upsample_upconv elif upsample_mode == 'pixelshuffle': upsample_block = B.upsample_pixelshuffle elif upsample_mode == 'convtranspose': upsample_block = B.upsample_convtranspose else: raise NotImplementedError( 'upsample mode [{:s}] is not found'.format(upsample_mode)) if upscale == 3: m_uper = upsample_block(nc, nc, mode='3' + act_mode) else: m_uper = [ upsample_block(nc, nc, mode='2' + act_mode) for _ in range(n_upscale) ] H_conv0 = B.conv(nc, nc, mode='C' + act_mode) H_conv1 = B.conv(nc, out_nc, bias=False, mode='C') m_tail = B.sequential(H_conv0, H_conv1) self.model = B.sequential(m_head, B.ShortcutBlock(B.sequential(*m_body)), *m_uper, m_tail)
def __init__(self, in_nc=1, out_nc=1, nc=64, nb=15, act_mode='R'): """ # ------------------------------------ in_nc: channel number of input out_nc: channel number of output nc: channel number nb: total number of conv layers act_mode: batch norm + activation function; 'BR' means BN+ReLU. # ------------------------------------ # ------------------------------------ """ super(FFDNet, self).__init__() assert 'R' in act_mode or 'L' in act_mode, 'Examples of activation function: R, L, BR, BL, IR, IL' bias = True sf = 2 self.m_down = B.PixelUnShuffle(upscale_factor=sf) m_head = B.conv(in_nc * sf * sf + 1, nc, mode='C' + act_mode[-1], bias=bias) m_body = [ B.conv(nc, nc, mode='C' + act_mode, bias=bias) for _ in range(nb - 2) ] m_tail = B.conv(nc, out_nc * sf * sf, mode='C', bias=bias) self.model = B.sequential(m_head, *m_body, m_tail) self.m_up = nn.PixelShuffle(upscale_factor=sf)
def __init__(self, in_nc=1, out_nc=1, nc=64, nb=17, act_mode='BR'): """ # ------------------------------------ in_nc: channel number of input out_nc: channel number of output nc: channel number nb: total number of conv layers act_mode: batch norm + activation function; 'BR' means BN+ReLU. # ------------------------------------ Batch normalization and residual learning are beneficial to Gaussian denoising (especially for a single noise level). The residual of a noisy image corrupted by additive white Gaussian noise (AWGN) follows a constant Gaussian distribution which stablizes batch normalization during training. # ------------------------------------ """ super(DnCNN, self).__init__() assert 'R' in act_mode or 'L' in act_mode, 'Examples of activation function: R, L, BR, BL, IR, IL' bias = True m_head = B.conv(in_nc, nc, mode='C' + act_mode[-1], bias=bias) m_body = [ B.conv(nc, nc, mode='C' + act_mode, bias=bias) for _ in range(nb - 2) ] m_tail = B.conv(nc, out_nc, mode='C', bias=bias) self.model = B.sequential(m_head, *m_body, m_tail)
def __init__(self, in_nc=3, base_nc=64, ac_type='BL'): super(Discriminator_VGG_192, self).__init__() # features # hxw, c # 192, 64 conv0 = B.conv(in_nc, base_nc, kernel_size=3, mode='C') conv1 = B.conv(base_nc, base_nc, kernel_size=4, stride=2, mode='C'+ac_type) # 96, 64 conv2 = B.conv(base_nc, base_nc*2, kernel_size=3, stride=1, mode='C'+ac_type) conv3 = B.conv(base_nc*2, base_nc*2, kernel_size=4, stride=2, mode='C'+ac_type) # 48, 128 conv4 = B.conv(base_nc*2, base_nc*4, kernel_size=3, stride=1, mode='C'+ac_type) conv5 = B.conv(base_nc*4, base_nc*4, kernel_size=4, stride=2, mode='C'+ac_type) # 24, 256 conv6 = B.conv(base_nc*4, base_nc*8, kernel_size=3, stride=1, mode='C'+ac_type) conv7 = B.conv(base_nc*8, base_nc*8, kernel_size=4, stride=2, mode='C'+ac_type) # 12, 512 conv8 = B.conv(base_nc*8, base_nc*8, kernel_size=3, stride=1, mode='C'+ac_type) conv9 = B.conv(base_nc*8, base_nc*8, kernel_size=4, stride=2, mode='C'+ac_type) # 6, 512 conv10 = B.conv(base_nc*8, base_nc*8, kernel_size=3, stride=1, mode='C'+ac_type) conv11 = B.conv(base_nc*8, base_nc*8, kernel_size=4, stride=2, mode='C'+ac_type) # 3, 512 self.features = B.sequential(conv0, conv1, conv2, conv3, conv4, conv5, conv6, conv7, conv8, conv9, conv10, conv11) # classifier self.classifier = nn.Sequential(nn.Linear(512 * 3 * 3, 100), nn.LeakyReLU(0.2, True), nn.Linear(100, 1))
def __init__(self, in_nc=3, out_nc=3, nc=64, nb=23, gc=32, upscale=4, act_mode='L', upsample_mode='upconv'): super(RRDB, self).__init__() assert 'R' in act_mode or 'L' in act_mode, 'Examples of activation function: R, L, BR, BL, IR, IL' n_upscale = int(math.log(upscale, 2)) if upscale == 3: n_upscale = 1 m_head = B.conv(in_nc, nc, mode='C') m_body = [B.RRDB(nc, gc=32, mode='C' + act_mode) for _ in range(nb)] m_body.append(B.conv(nc, nc, mode='C')) if upsample_mode == 'upconv': upsample_block = B.upsample_upconv elif upsample_mode == 'pixelshuffle': upsample_block = B.upsample_pixelshuffle elif upsample_mode == 'convtranspose': upsample_block = B.upsample_convtranspose else: raise NotImplementedError( 'upsample mode [{:s}] is not found'.format(upsample_mode)) if upscale == 3: m_uper = upsample_block(nc, nc, mode='3' + act_mode) else: m_uper = [ upsample_block(nc, nc, mode='2' + act_mode) for _ in range(n_upscale) ] H_conv0 = B.conv(nc, nc, mode='C' + act_mode) H_conv1 = B.conv(nc, out_nc, mode='C') m_tail = B.sequential(H_conv0, H_conv1) self.model = B.sequential(m_head, B.ShortcutBlock(B.sequential(*m_body)), *m_uper, m_tail)
def __init__(self, in_nc=1, out_nc=1, nc=[64, 128, 256, 512], nb=2, act_mode='R', downsample_mode='strideconv', upsample_mode='convtranspose'): super(UNet, self).__init__() self.m_head = B.conv(in_nc, nc[0], mode='C' + act_mode[-1]) # downsample if downsample_mode == 'avgpool': downsample_block = B.downsample_avgpool elif downsample_mode == 'maxpool': downsample_block = B.downsample_maxpool elif downsample_mode == 'strideconv': downsample_block = B.downsample_strideconv else: raise NotImplementedError( 'downsample mode [{:s}] is not found'.format(downsample_mode)) self.m_down1 = B.sequential( *[B.conv(nc[0], nc[0], mode='C' + act_mode) for _ in range(nb)], downsample_block(nc[0], nc[1], mode='2' + act_mode)) self.m_down2 = B.sequential( *[B.conv(nc[1], nc[1], mode='C' + act_mode) for _ in range(nb)], downsample_block(nc[1], nc[2], mode='2' + act_mode)) self.m_down3 = B.sequential( *[B.conv(nc[2], nc[2], mode='C' + act_mode) for _ in range(nb)], downsample_block(nc[2], nc[3], mode='2' + act_mode)) self.m_body = B.sequential( * [B.conv(nc[3], nc[3], mode='C' + act_mode) for _ in range(nb + 1)]) # upsample if upsample_mode == 'upconv': upsample_block = B.upsample_upconv elif upsample_mode == 'pixelshuffle': upsample_block = B.upsample_pixelshuffle elif upsample_mode == 'convtranspose': upsample_block = B.upsample_convtranspose else: raise NotImplementedError( 'upsample mode [{:s}] is not found'.format(upsample_mode)) self.m_up3 = B.sequential( upsample_block(nc[3], nc[2], mode='2' + act_mode), *[B.conv(nc[2], nc[2], mode='C' + act_mode) for _ in range(nb)]) self.m_up2 = B.sequential( upsample_block(nc[2], nc[1], mode='2' + act_mode), *[B.conv(nc[1], nc[1], mode='C' + act_mode) for _ in range(nb)]) self.m_up1 = B.sequential( upsample_block(nc[1], nc[0], mode='2' + act_mode), *[B.conv(nc[0], nc[0], mode='C' + act_mode) for _ in range(nb)]) self.m_tail = B.conv(nc[0], out_nc, bias=True, mode='C')
def __init__(self, in_nc=3, out_nc=3, nc=64, nb=16, upscale=4, act_mode='R', upsample_mode='upconv'): super(SRResNet, self).__init__() n_upscale = int(math.log(upscale, 2)) if upscale == 3: n_upscale = 1 m_head = B.conv(in_nc, nc, mode='C') m_body = [ B.ResBlock(nc, nc, mode='C' + act_mode + 'C') for _ in range(nb) ] m_body.append(B.conv(nc, nc, mode='C')) if upsample_mode == 'upconv': upsample_block = B.upsample_upconv elif upsample_mode == 'pixelshuffle': upsample_block = B.upsample_pixelshuffle elif upsample_mode == 'convtranspose': upsample_block = B.upsample_convtranspose else: raise NotImplementedError( 'upsample mode [{:s}] is not found'.format(upsample_mode)) if upscale == 3: m_uper = upsample_block(nc, nc, mode='3' + act_mode) else: m_uper = [ upsample_block(nc, nc, mode='2' + act_mode) for _ in range(n_upscale) ] H_conv0 = B.conv(nc, nc, mode='C' + act_mode) H_conv1 = B.conv(nc, out_nc, bias=False, mode='C') m_tail = B.sequential(H_conv0, H_conv1) self.model = B.sequential(m_head, B.ShortcutBlock(B.sequential(*m_body)), *m_uper, m_tail)
def __init__(self, in_nc: int = 65, nc_x: List[int] = [64, 128, 256, 512], nb: int = 4): super(NetX, self).__init__() self.m_down1 = B.sequential( *[ B.ResBlock(in_nc, in_nc, bias=False, mode='CRC') for _ in range(nb) ], B.downsample_strideconv(in_nc, nc_x[1], bias=False, mode='2')) self.m_down2 = B.sequential( *[ B.ResBlock(nc_x[1], nc_x[1], bias=False, mode='CRC') for _ in range(nb) ], B.downsample_strideconv(nc_x[1], nc_x[2], bias=False, mode='2')) self.m_down3 = B.sequential( *[ B.ResBlock(nc_x[2], nc_x[2], bias=False, mode='CRC') for _ in range(nb) ], B.downsample_strideconv(nc_x[2], nc_x[3], bias=False, mode='2')) self.m_body = B.sequential(*[ B.ResBlock(nc_x[-1], nc_x[-1], bias=False, mode='CRC') for _ in range(nb) ]) self.m_up3 = B.sequential( B.upsample_convtranspose(nc_x[3], nc_x[2], bias=False, mode='2'), *[ B.ResBlock(nc_x[2], nc_x[2], bias=False, mode='CRC') for _ in range(nb) ]) self.m_up2 = B.sequential( B.upsample_convtranspose(nc_x[2], nc_x[1], bias=False, mode='2'), *[ B.ResBlock(nc_x[1], nc_x[1], bias=False, mode='CRC') for _ in range(nb) ]) self.m_up1 = B.sequential( B.upsample_convtranspose(nc_x[1], nc_x[0], bias=False, mode='2'), *[ B.ResBlock(nc_x[0], nc_x[0], bias=False, mode='CRC') for _ in range(nb) ]) self.m_tail = B.conv(nc_x[0], nc_x[0], bias=False, mode='C')
def __init__(self, in_nc=2, out_nc=1, nc=64, nb=20, act_mode='R'): """ in_nc: channel number of input out_nc: channel number of output nc: channel number nb: total number of conv layers act_mode: batch norm + activation function; 'BR' means BN+ReLU. """ super(FDnCNN, self).__init__() assert 'R' in act_mode or 'L' in act_mode, 'Examples of activation function: R, L, BR, BL, IR, IL' bias = True m_head = B.conv(in_nc, nc, mode='C' + act_mode[-1], bias=bias) m_body = [ B.conv(nc, nc, mode='C' + act_mode, bias=bias) for _ in range(nb - 2) ] m_tail = B.conv(nc, out_nc, mode='C', bias=bias) self.model = B.sequential(m_head, *m_body, m_tail)
def __init__(self, in_nc=19, out_nc=3, nc=128, nb=12, upscale=4, act_mode='R', upsample_mode='pixelshuffle'): """ # ------------------------------------ in_nc: channel number of input, default: 3+15 out_nc: channel number of output nc: channel number nb: total number of conv layers upscale: scale factor act_mode: batch norm + activation function; 'BR' means BN+ReLU upsample_mode: default 'pixelshuffle' = conv + pixelshuffle # ------------------------------------ """ super(SRMD, self).__init__() assert 'R' in act_mode or 'L' in act_mode, 'Examples of activation function: R, L, BR, BL, IR, IL' bias = True if upsample_mode == 'upconv': upsample_block = B.upsample_upconv elif upsample_mode == 'pixelshuffle': upsample_block = B.upsample_pixelshuffle elif upsample_mode == 'convtranspose': upsample_block = B.upsample_convtranspose else: raise NotImplementedError( 'upsample mode [{:s}] is not found'.format(upsample_mode)) m_head = B.conv(in_nc, nc, mode='C' + act_mode[-1], bias=bias) m_body = [ B.conv(nc, nc, mode='C' + act_mode, bias=bias) for _ in range(nb - 2) ] m_tail = upsample_block(nc, out_nc, mode=str(upscale), bias=bias) self.model = B.sequential(m_head, *m_body, m_tail)
def __init__(self, in_nc=1, out_nc=1, nc=64): """ # ------------------------------------ denoiser of IRCNN in_nc: channel number of input out_nc: channel number of output nc: channel number nb: total number of conv layers act_mode: batch norm + activation function; 'BR' means BN+ReLU. # ------------------------------------ Batch normalization and residual learning are beneficial to Gaussian denoising (especially for a single noise level). The residual of a noisy image corrupted by additive white Gaussian noise (AWGN) follows a constant Gaussian distribution which stablizes batch normalization during training. # ------------------------------------ """ super(IRCNN, self).__init__() L = [] L.append( nn.Conv2d(in_channels=in_nc, out_channels=nc, kernel_size=3, stride=1, padding=1, dilation=1, bias=True)) L.append(nn.ReLU(inplace=True)) L.append( nn.Conv2d(in_channels=nc, out_channels=nc, kernel_size=3, stride=1, padding=2, dilation=2, bias=True)) L.append(nn.ReLU(inplace=True)) L.append( nn.Conv2d(in_channels=nc, out_channels=nc, kernel_size=3, stride=1, padding=3, dilation=3, bias=True)) L.append(nn.ReLU(inplace=True)) L.append( nn.Conv2d(in_channels=nc, out_channels=nc, kernel_size=3, stride=1, padding=4, dilation=4, bias=True)) L.append(nn.ReLU(inplace=True)) L.append( nn.Conv2d(in_channels=nc, out_channels=nc, kernel_size=3, stride=1, padding=3, dilation=3, bias=True)) L.append(nn.ReLU(inplace=True)) L.append( nn.Conv2d(in_channels=nc, out_channels=nc, kernel_size=3, stride=1, padding=2, dilation=2, bias=True)) L.append(nn.ReLU(inplace=True)) L.append( nn.Conv2d(in_channels=nc, out_channels=out_nc, kernel_size=3, stride=1, padding=1, dilation=1, bias=True)) self.model = B.sequential(*L)