def define_pairD(opt):
gpu_ids = opt['gpu_ids']
opt_net = opt['network_D']
which_model = opt_net['which_model_pairD']
if which_model == 'discriminator_vgg_128':
netD = arch.Discriminator_VGG_128(in_nc=opt_net['in_nc'],
nf=opt_net['nf'])
elif which_model == 'dis_acd': # sft-gan, Auxiliary Classifier Discriminator
netD = sft_arch.ACD_VGG_BN_96()
elif which_model == 'discriminator_vgg_96':
netD = arch.Discriminator_VGG_96(in_nc=opt_net['in_nc'], base_nf=opt_net['nf'], \
norm_type=opt_net['norm_type'], mode=opt_net['mode'], act_type=opt_net['act_type'])
elif which_model == 'discriminator_vgg_192':
netD = arch.Discriminator_VGG_192(in_nc=opt_net['in_nc'], base_nf=opt_net['nf'], \
norm_type=opt_net['norm_type'], mode=opt_net['mode'], act_type=opt_net['act_type'])
elif which_model == 'discriminator_vgg_48':
netD = arch.Discriminator_VGG_48(in_nc=opt_net['in_nc'], base_nf=opt_net['nf'], \
norm_type=opt_net['norm_type'], mode=opt_net['mode'], act_type=opt_net['act_type'])
elif which_model == 'discriminator_vgg_128_SN':
netD = arch.Discriminator_VGG_128_SN()
elif which_model == 'discriminator_vgg_128':
netD = arch.Discriminator_VGG_128()
elif which_model == 'discriminator_patch':
netD = arch.NLayerDiscriminator(opt_net['in_nc'], opt_net['nf'],
opt_net['n_layers'])
else:
raise NotImplementedError(
'Discriminator model [{:s}] not recognized'.format(which_model))
init_weights(netD, init_type='kaiming', scale=1)
if gpu_ids:
netD = nn.DataParallel(netD)
return netD
def define_patchD(opt, netD="basic", n_layers_D=3):
"""Create a discriminator
Parameters:
input_nc (int) -- the number of channels in input images
ndf (int) -- the number of filters in the first conv layer
netD (str) -- the architecture's name: basic | n_layers | pixel
n_layers_D (int) -- the number of conv layers in the discriminator; effective when netD=='n_layers'
norm (str) -- the type of normalization layers used in the network.
init_type (str) -- the name of the initialization method.
init_gain (float) -- scaling factor for normal, xavier and orthogonal.
gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2
Returns a discriminator
Our current implementation provides three types of discriminators:
[basic]: 'PatchGAN' classifier described in the original pix2pix paper.
It can classify whether 70×70 overlapping patches are real or fake.
Such a patch-level discriminator architecture has fewer parameters
than a full-image discriminator and can work on arbitrarily-sized images
in a fully convolutional fashion.
[n_layers]: With this mode, you can specify the number of conv layers in the discriminator
with the parameter <n_layers_D> (default=3 as used in [basic] (PatchGAN).)
[pixel]: 1x1 PixelGAN discriminator can classify whether a pixel is real or not.
It encourages greater color diversity but has no effect on spatial statistics.
The discriminator has been initialized by <init_net>. It uses Leakly RELU for non-linearity.
"""
gpu_ids = opt['gpu_ids']
opt_net = opt['network_D']
net = None
norm_layer = get_norm_layer(norm_type=opt_net['norm_type'])
if netD == 'basic': # default PatchGAN classifier
net = arch.NLayerDiscriminator(input_nc=opt_net['in_nc'],
ndf=opt_net['nf'],
n_layers=3,
norm_layer=norm_layer)
elif netD == 'n_layers': # more options
net = arch.NLayerDiscriminator(input_nc=opt_net['in_nc'],
ndf=opt_net['nf'],
n_layers=n_layers_D,
norm_layer=norm_layer)
else:
raise NotImplementedError(
'Discriminator model name [%s] is not recognized' % netD)
init_weights(net, init_type='kaiming', scale=1)
if gpu_ids:
net = nn.DataParallel(net)
return net