stylegan2_mmcv

configs/_base_/datasets/unconditional_imgs_flip_256x256.py

+dataset_type = 'UnconditionalImageDataset'
+
+train_pipeline = [
+    dict(type='LoadImageFromFile', key='real_img', io_backend='disk'),
+    dict(type='Resize', keys=['real_img'], scale=(256, 256)),
+    dict(type='Flip', keys=['real_img'], direction='horizontal'),
+    dict(
+        type='Normalize',
+        keys=['real_img'],
+        mean=[127.5] * 3,
+        std=[127.5] * 3,
+        to_rgb=False),
+    dict(type='ImageToTensor', keys=['real_img']),
+    dict(type='Collect', keys=['real_img'], meta_keys=['real_img_path'])
+]
+
+# `samples_per_gpu` and `imgs_root` need to be set.
+data = dict(
+    samples_per_gpu=None,
+    workers_per_gpu=4,
+    train=dict(type=dataset_type, imgs_root=None, pipeline=train_pipeline))

configs/_base_/datasets/unconditional_imgs_flip_512x512.py

+dataset_type = 'UnconditionalImageDataset'
+
+train_pipeline = [
+    dict(type='LoadImageFromFile', key='real_img', io_backend='disk'),
+    dict(type='Resize', keys=['real_img'], scale=(512, 512)),
+    dict(type='Flip', keys=['real_img'], direction='horizontal'),
+    dict(
+        type='Normalize',
+        keys=['real_img'],
+        mean=[127.5] * 3,
+        std=[127.5] * 3,
+        to_rgb=False),
+    dict(type='ImageToTensor', keys=['real_img']),
+    dict(type='Collect', keys=['real_img'], meta_keys=['real_img_path'])
+]
+
+# `samples_per_gpu` and `imgs_root` need to be set.
+data = dict(
+    samples_per_gpu=None,
+    workers_per_gpu=4,
+    train=dict(type=dataset_type, imgs_root=None, pipeline=train_pipeline))

configs/_base_/datasets/unconditional_imgs_flip_lanczos_resize_256x256.py

+dataset_type = 'UnconditionalImageDataset'
+
+train_pipeline = [
+    dict(type='LoadImageFromFile', key='real_img'),
+    dict(
+        type='Resize',
+        keys=['real_img'],
+        scale=(256, 256),
+        interpolation='lanczos',
+        backend='pillow'),
+    dict(type='Flip', keys=['real_img'], direction='horizontal'),
+    dict(
+        type='Normalize',
+        keys=['real_img'],
+        mean=[127.5] * 3,
+        std=[127.5] * 3,
+        to_rgb=False),
+    dict(type='ImageToTensor', keys=['real_img']),
+    dict(type='Collect', keys=['real_img'], meta_keys=['real_img_path'])
+]
+
+# `samples_per_gpu` and `imgs_root` need to be set.
+data = dict(
+    samples_per_gpu=None,
+    workers_per_gpu=4,
+    train=dict(
+        type='RepeatDataset',
+        times=100,
+        dataset=dict(
+            type=dataset_type, imgs_root=None, pipeline=train_pipeline)),
+    val=dict(type=dataset_type, imgs_root=None, pipeline=train_pipeline))

configs/_base_/datasets/unpaired_imgs_256x256.py

+train_dataset_type = 'UnpairedImageDataset'
+val_dataset_type = 'UnpairedImageDataset'
+img_norm_cfg = dict(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+domain_a = None  # set by user
+domain_b = None  # set by user
+train_pipeline = [
+    dict(
+        type='LoadImageFromFile',
+        io_backend='disk',
+        key=f'img_{domain_a}',
+        flag='color'),
+    dict(
+        type='LoadImageFromFile',
+        io_backend='disk',
+        key=f'img_{domain_b}',
+        flag='color'),
+    dict(
+        type='Resize',
+        keys=[f'img_{domain_a}', f'img_{domain_b}'],
+        scale=(286, 286),
+        interpolation='bicubic'),
+    dict(
+        type='Crop',
+        keys=[f'img_{domain_a}', f'img_{domain_b}'],
+        crop_size=(256, 256),
+        random_crop=True),
+    dict(type='Flip', keys=[f'img_{domain_a}'], direction='horizontal'),
+    dict(type='Flip', keys=[f'img_{domain_b}'], direction='horizontal'),
+    dict(type='RescaleToZeroOne', keys=[f'img_{domain_a}', f'img_{domain_b}']),
+    dict(
+        type='Normalize',
+        keys=[f'img_{domain_a}', f'img_{domain_b}'],
+        to_rgb=False,
+        mean=[0.5, 0.5, 0.5],
+        std=[0.5, 0.5, 0.5]),
+    dict(type='ImageToTensor', keys=[f'img_{domain_a}', f'img_{domain_b}']),
+    dict(
+        type='Collect',
+        keys=[f'img_{domain_a}', f'img_{domain_b}'],
+        meta_keys=[f'img_{domain_a}_path', f'img_{domain_b}_path'])
+]
+test_pipeline = [
+    dict(
+        type='LoadImageFromFile', io_backend='disk', key='image',
+        flag='color'),
+    dict(
+        type='Resize',
+        keys=['image'],
+        scale=(256, 256),
+        interpolation='bicubic'),
+    dict(type='RescaleToZeroOne', keys=['image']),
+    dict(
+        type='Normalize',
+        keys=['image'],
+        to_rgb=False,
+        mean=[0.5, 0.5, 0.5],
+        std=[0.5, 0.5, 0.5]),
+    dict(type='ImageToTensor', keys=['image']),
+    dict(type='Collect', keys=['image'], meta_keys=['image_path'])
+]
+data_root = None
+data = dict(
+    samples_per_gpu=1,
+    workers_per_gpu=4,
+    drop_last=True,
+    train=dict(
+        type=train_dataset_type,
+        dataroot=data_root,
+        pipeline=train_pipeline,
+        test_mode=False,
+        domain_a=domain_a,
+        domain_b=domain_b),
+    val=dict(
+        type=val_dataset_type,
+        dataroot=data_root,
+        pipeline=test_pipeline,
+        test_mode=True,
+        domain_a=domain_a,
+        domain_b=domain_b),
+    test=dict(
+        type=val_dataset_type,
+        dataroot=data_root,
+        pipeline=test_pipeline,
+        test_mode=True,
+        domain_a=domain_a,
+        domain_b=domain_b))

configs/_base_/default_metrics.py

+metrics = dict(
+    fid50k=dict(type='FID', num_images=50000),
+    pr50k3=dict(type='PR', num_images=50000, k=3),
+    is50k=dict(type='IS', num_images=50000),
+    ppl_zfull=dict(type='PPL', space='Z', sampling='full', num_images=50000),
+    ppl_wfull=dict(type='PPL', space='W', sampling='full', num_images=50000),
+    ppl_zend=dict(type='PPL', space='Z', sampling='end', num_images=50000),
+    ppl_wend=dict(type='PPL', space='W', sampling='end', num_images=50000),
+    ms_ssim10k=dict(type='MS_SSIM', num_images=10000),
+    swd16k=dict(type='SWD', num_images=16384))

configs/_base_/default_runtime.py

+checkpoint_config = dict(interval=10000, by_epoch=False)
+# yapf:disable
+log_config = dict(
+    interval=100,
+    hooks=[
+        dict(type='TextLoggerHook'),
+        # dict(type='TensorboardLoggerHook'),
+    ])
+# yapf:enable
+
+custom_hooks = [
+    dict(
+        type='VisualizeUnconditionalSamples',
+        output_dir='training_samples',
+        interval=1000)
+]
+
+# use dynamic runner
+runner = dict(
+    type='DynamicIterBasedRunner',
+    is_dynamic_ddp=True,
+    pass_training_status=True)
+
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 2)] # 设置epoch
+find_unused_parameters = True
+cudnn_benchmark = True
+
+# disable opencv multithreading to avoid system being overloaded
+opencv_num_threads = 0
+# set multi-process start method as `fork` to speed up the training
+mp_start_method = 'fork'

configs/_base_/models/biggan/biggan_128x128.py

+model = dict(
+    type='BasiccGAN',
+    generator=dict(
+        type='BigGANGenerator',
+        output_scale=128,
+        noise_size=120,
+        num_classes=1000,
+        base_channels=96,
+        shared_dim=128,
+        with_shared_embedding=True,
+        sn_eps=1e-6,
+        init_type='ortho',
+        act_cfg=dict(type='ReLU', inplace=True),
+        split_noise=True,
+        auto_sync_bn=False),
+    discriminator=dict(
+        type='BigGANDiscriminator',
+        input_scale=128,
+        num_classes=1000,
+        base_channels=96,
+        sn_eps=1e-6,
+        init_type='ortho',
+        act_cfg=dict(type='ReLU', inplace=True),
+        with_spectral_norm=True),
+    gan_loss=dict(type='GANLoss', gan_type='hinge'))
+
+train_cfg = dict(
+    disc_steps=8, gen_steps=1, batch_accumulation_steps=8, use_ema=True)
+test_cfg = None
+optimizer = dict(
+    generator=dict(type='Adam', lr=0.0001, betas=(0.0, 0.999), eps=1e-6),
+    discriminator=dict(type='Adam', lr=0.0004, betas=(0.0, 0.999), eps=1e-6))

configs/_base_/models/biggan/biggan_32x32.py

+model = dict(
+    type='BasiccGAN',
+    num_classes=10,
+    generator=dict(
+        type='BigGANGenerator',
+        output_scale=32,
+        noise_size=128,
+        num_classes=10,
+        base_channels=64,
+        with_shared_embedding=False,
+        sn_eps=1e-8,
+        sn_style='torch',
+        init_type='N02',
+        split_noise=False,
+        auto_sync_bn=False),
+    discriminator=dict(
+        type='BigGANDiscriminator',
+        input_scale=32,
+        num_classes=10,
+        base_channels=64,
+        sn_eps=1e-8,
+        sn_style='torch',
+        init_type='N02',
+        with_spectral_norm=True),
+    gan_loss=dict(type='GANLoss', gan_type='hinge'))
+
+train_cfg = dict(
+    disc_steps=4, gen_steps=1, batch_accumulation_steps=1, use_ema=True)
+test_cfg = None
+optimizer = dict(
+    generator=dict(type='Adam', lr=0.0002, betas=(0.0, 0.999)),
+    discriminator=dict(type='Adam', lr=0.0002, betas=(0.0, 0.999)))

configs/_base_/models/cyclegan/cyclegan_lsgan_resnet.py

+_domain_a = None  # set by user
+_domain_b = None  # set by user
+model = dict(
+    type='CycleGAN',
+    generator=dict(
+        type='ResnetGenerator',
+        in_channels=3,
+        out_channels=3,
+        base_channels=64,
+        norm_cfg=dict(type='IN'),
+        use_dropout=False,
+        num_blocks=9,
+        padding_mode='reflect',
+        init_cfg=dict(type='normal', gain=0.02)),
+    discriminator=dict(
+        type='PatchDiscriminator',
+        in_channels=3,
+        base_channels=64,
+        num_conv=3,
+        norm_cfg=dict(type='IN'),
+        init_cfg=dict(type='normal', gain=0.02)),
+    gan_loss=dict(
+        type='GANLoss',
+        gan_type='lsgan',
+        real_label_val=1.0,
+        fake_label_val=0.0,
+        loss_weight=1.0),
+    default_domain=None,  # set by user
+    reachable_domains=None,  # set by user
+    related_domains=None,  # set by user
+    gen_auxiliary_loss=[
+        dict(
+            type='L1Loss',
+            loss_weight=10.0,
+            loss_name='cycle_loss',
+            data_info=dict(
+                pred=f'cycle_{_domain_a}', target=f'real_{_domain_a}'),
+            reduction='mean'),
+        dict(
+            type='L1Loss',
+            loss_weight=10.0,
+            loss_name='cycle_loss',
+            data_info=dict(
+                pred=f'cycle_{_domain_b}',
+                target=f'real_{_domain_b}',
+            ),
+            reduction='mean'),
+        dict(
+            type='L1Loss',
+            loss_weight=0.5,
+            loss_name='id_loss',
+            data_info=dict(
+                pred=f'identity_{_domain_a}', target=f'real_{_domain_a}'),
+            reduction='mean'),
+        dict(
+            type='L1Loss',
+            loss_weight=0.5,
+            loss_name='id_loss',
+            data_info=dict(
+                pred=f'identity_{_domain_b}', target=f'real_{_domain_b}'),
+            reduction='mean')
+    ])
+train_cfg = dict(buffer_size=50)
+test_cfg = None

configs/_base_/models/dcgan/dcgan_128x128.py

+# define GAN model
+model = dict(
+    type='StaticUnconditionalGAN',
+    generator=dict(
+        type='DCGANGenerator', output_scale=128, base_channels=1024),
+    discriminator=dict(
+        type='DCGANDiscriminator',
+        input_scale=128,
+        output_scale=4,
+        out_channels=100),
+    gan_loss=dict(type='GANLoss', gan_type='vanilla'))
+
+train_cfg = dict(disc_steps=1)
+test_cfg = None
+
+# define optimizer
+optimizer = dict(
+    generator=dict(type='Adam', lr=0.0002, betas=(0.5, 0.999)),
+    discriminator=dict(type='Adam', lr=0.0002, betas=(0.5, 0.999)))

configs/_base_/models/dcgan/dcgan_64x64.py

+# define GAN model
+model = dict(
+    type='StaticUnconditionalGAN',
+    generator=dict(type='DCGANGenerator', output_scale=64, base_channels=1024),
+    discriminator=dict(
+        type='DCGANDiscriminator',
+        input_scale=64,
+        output_scale=4,
+        out_channels=1),
+    gan_loss=dict(type='GANLoss', gan_type='vanilla'))
+
+train_cfg = dict(disc_steps=1)
+test_cfg = None
+
+# define optimizer
+optimizer = dict(
+    generator=dict(type='Adam', lr=0.0002, betas=(0.5, 0.999)),
+    discriminator=dict(type='Adam', lr=0.0002, betas=(0.5, 0.999)))

configs/_base_/models/improved_ddpm/ddpm_32x32.py

+model = dict(
+    type='BasicGaussianDiffusion',
+    num_timesteps=4000,
+    betas_cfg=dict(type='cosine'),
+    denoising=dict(
+        type='DenoisingUnet',
+        image_size=32,
+        in_channels=3,
+        base_channels=128,
+        resblocks_per_downsample=3,
+        attention_res=[16, 8],
+        use_scale_shift_norm=True,
+        dropout=0.3,
+        num_heads=4,
+        use_rescale_timesteps=True,
+        output_cfg=dict(mean='eps', var='learned_range')),
+    timestep_sampler=dict(type='UniformTimeStepSampler'),
+    ddpm_loss=[
+        dict(
+            type='DDPMVLBLoss',
+            rescale_mode='constant',
+            rescale_cfg=dict(scale=4000 / 1000),
+            data_info=dict(
+                mean_pred='mean_pred',
+                mean_target='mean_posterior',
+                logvar_pred='logvar_pred',
+                logvar_target='logvar_posterior'),
+            log_cfgs=[
+                dict(
+                    type='quartile',
+                    prefix_name='loss_vlb',
+                    total_timesteps=4000),
+                dict(type='name')
+            ]),
+        dict(
+            type='DDPMMSELoss',
+            log_cfgs=dict(
+                type='quartile', prefix_name='loss_mse', total_timesteps=4000),
+        )
+    ],
+)
+
+train_cfg = dict(use_ema=True, real_img_key='img')
+test_cfg = None
+optimizer = dict(denoising=dict(type='AdamW', lr=1e-4, weight_decay=0))

configs/_base_/models/improved_ddpm/ddpm_64x64.py

+model = dict(
+    type='BasicGaussianDiffusion',
+    num_timesteps=4000,
+    betas_cfg=dict(type='cosine'),
+    denoising=dict(
+        type='DenoisingUnet',
+        image_size=64,
+        in_channels=3,
+        base_channels=128,
+        resblocks_per_downsample=3,
+        attention_res=[16, 8],
+        use_scale_shift_norm=True,
+        dropout=0,
+        num_heads=4,
+        use_rescale_timesteps=True,
+        output_cfg=dict(mean='eps', var='learned_range')),
+    timestep_sampler=dict(type='UniformTimeStepSampler'),
+    ddpm_loss=[
+        dict(
+            type='DDPMVLBLoss',
+            rescale_mode='constant',
+            rescale_cfg=dict(scale=4000 / 1000),
+            data_info=dict(
+                mean_pred='mean_pred',
+                mean_target='mean_posterior',
+                logvar_pred='logvar_pred',
+                logvar_target='logvar_posterior'),
+            log_cfgs=[
+                dict(
+                    type='quartile',
+                    prefix_name='loss_vlb',
+                    total_timesteps=4000),
+                dict(type='name')
+            ]),
+        dict(
+            type='DDPMMSELoss',
+            log_cfgs=dict(
+                type='quartile', prefix_name='loss_mse', total_timesteps=4000),
+        )
+    ],
+)
+
+train_cfg = dict(use_ema=True, real_img_key='img')
+test_cfg = None
+optimizer = dict(denoising=dict(type='AdamW', lr=1e-4, weight_decay=0))

configs/_base_/models/lsgan/lsgan_128x128.py

+# define GAN model
+model = dict(
+    type='StaticUnconditionalGAN',
+    generator=dict(
+        type='LSGANGenerator',
+        output_scale=128,
+        base_channels=256,
+        noise_size=1024),
+    discriminator=dict(
+        type='LSGANDiscriminator', input_scale=128, base_channels=64),
+    gan_loss=dict(type='GANLoss', gan_type='lsgan'))
+
+train_cfg = dict(disc_steps=1)
+test_cfg = None
+
+# define optimizer
+optimizer = dict(
+    generator=dict(type='Adam', lr=0.0002, betas=(0.5, 0.999)),
+    discriminator=dict(type='Adam', lr=0.0002, betas=(0.5, 0.999)))

configs/_base_/models/pggan/pggan_1024.py

+# define GAN model
+model = dict(
+    type='ProgressiveGrowingGAN',
+    generator=dict(type='PGGANGenerator', out_scale=1024, noise_size=512),
+    discriminator=dict(type='PGGANDiscriminator', in_scale=1024),
+    gan_loss=dict(type='GANLoss', gan_type='wgan'),
+    disc_auxiliary_loss=[
+        dict(
+            type='DiscShiftLoss',
+            loss_weight=0.001 * 0.5,
+            data_info=dict(pred='disc_pred_fake')),
+        dict(
+            type='DiscShiftLoss',
+            loss_weight=0.001 * 0.5,
+            data_info=dict(pred='disc_pred_real')),
+        dict(
+            type='GradientPenaltyLoss',
+            loss_weight=10,
+            norm_mode='HWC',
+            data_info=dict(
+                discriminator='disc_partial',
+                real_data='real_imgs',
+                fake_data='fake_imgs'))
+    ])
+
+train_cfg = dict(
+    use_ema=True,
+    nkimgs_per_scale={
+        '4': 600,
+        '8': 1200,
+        '16': 1200,
+        '32': 1200,
+        '64': 1200,
+        '128': 1200,
+        '256': 1200,
+        '512': 1200,
+        '1024': 12000,
+    },
+    transition_kimgs=600,
+    optimizer_cfg=dict(
+        generator=dict(type='Adam', lr=0.001, betas=(0., 0.99)),
+        discriminator=dict(type='Adam', lr=0.001, betas=(0., 0.99))),
+    g_lr_base=0.001,
+    d_lr_base=0.001,
+    g_lr_schedule={
+        '128': 0.0015,
+        '256': 0.002,
+        '512': 0.003,
+        '1024': 0.003
+    },
+    d_lr_schedule={
+        '128': 0.0015,
+        '256': 0.002,
+        '512': 0.003,
+        '1024': 0.003
+    })
+
+test_cfg = None

configs/_base_/models/pggan/pggan_128x128.py

+# define GAN model
+model = dict(
+    type='ProgressiveGrowingGAN',
+    generator=dict(type='PGGANGenerator', out_scale=128, noise_size=512),
+    discriminator=dict(type='PGGANDiscriminator', in_scale=128),
+    gan_loss=dict(type='GANLoss', gan_type='wgan'),
+    disc_auxiliary_loss=[
+        dict(
+            type='DiscShiftLoss',
+            loss_weight=0.001 * 0.5,
+            data_info=dict(pred='disc_pred_fake')),
+        dict(
+            type='DiscShiftLoss',
+            loss_weight=0.001 * 0.5,
+            data_info=dict(pred='disc_pred_real')),
+        dict(
+            type='GradientPenaltyLoss',
+            loss_weight=10,
+            norm_mode='HWC',
+            data_info=dict(
+                discriminator='disc_partial',
+                real_data='real_imgs',
+                fake_data='fake_imgs'))
+    ])
+
+train_cfg = dict(
+    use_ema=True,
+    nkimgs_per_scale={
+        '4': 600,
+        '8': 1200,
+        '16': 1200,
+        '32': 1200,
+        '64': 1200,
+        '128': 12000
+    },
+    transition_kimgs=600,
+    optimizer_cfg=dict(
+        generator=dict(type='Adam', lr=0.001, betas=(0., 0.99)),
+        discriminator=dict(type='Adam', lr=0.001, betas=(0., 0.99))),
+    g_lr_base=0.001,
+    d_lr_base=0.001,
+    g_lr_schedule={'128': 0.0015},
+    d_lr_schedule={'128': 0.0015})
+
+test_cfg = None

configs/_base_/models/pix2pix/pix2pix_vanilla_unet_bn.py

+source_domain = None  # set by user
+target_domain = None  # set by user
+# model settings
+model = dict(
+    type='Pix2Pix',
+    generator=dict(
+        type='UnetGenerator',
+        in_channels=3,
+        out_channels=3,
+        num_down=8,
+        base_channels=64,
+        norm_cfg=dict(type='BN'),
+        use_dropout=True,
+        init_cfg=dict(type='normal', gain=0.02)),
+    discriminator=dict(
+        type='PatchDiscriminator',
+        in_channels=6,
+        base_channels=64,
+        num_conv=3,
+        norm_cfg=dict(type='BN'),
+        init_cfg=dict(type='normal', gain=0.02)),
+    gan_loss=dict(
+        type='GANLoss',
+        gan_type='vanilla',
+        real_label_val=1.0,
+        fake_label_val=0.0,
+        loss_weight=1.0),
+    default_domain=target_domain,
+    reachable_domains=[target_domain],
+    related_domains=[target_domain, source_domain],
+    gen_auxiliary_loss=dict(
+        type='L1Loss',
+        loss_weight=100.0,
+        loss_name='pixel_loss',
+        data_info=dict(
+            pred=f'fake_{target_domain}', target=f'real_{target_domain}'),
+        reduction='mean'))
+# model training and testing settings
+train_cfg = None
+test_cfg = None

configs/_base_/models/sagan/sagan_128x128.py

+# define GAN model
+model = dict(
+    type='BasiccGAN',
+    generator=dict(
+        type='SAGANGenerator',
+        output_scale=128,
+        base_channels=64,
+        attention_cfg=dict(type='SelfAttentionBlock'),
+        attention_after_nth_block=4,
+        with_spectral_norm=True),
+    discriminator=dict(
+        type='ProjDiscriminator',
+        input_scale=128,
+        base_channels=64,
+        attention_cfg=dict(type='SelfAttentionBlock'),
+        attention_after_nth_block=1,
+        with_spectral_norm=True),
+    gan_loss=dict(type='GANLoss', gan_type='hinge'))
+
+train_cfg = dict(disc_steps=1)
+test_cfg = None
+
+# define optimizer
+optimizer = dict(
+    generator=dict(type='Adam', lr=0.0001, betas=(0.0, 0.999)),
+    discriminator=dict(type='Adam', lr=0.0004, betas=(0.0, 0.999)))

configs/_base_/models/sagan/sagan_32x32.py

+# define GAN model
+model = dict(
+    type='BasiccGAN',
+    generator=dict(
+        type='SAGANGenerator',
+        output_scale=32,
+        base_channels=256,
+        attention_cfg=dict(type='SelfAttentionBlock'),
+        attention_after_nth_block=2,
+        with_spectral_norm=True),
+    discriminator=dict(
+        type='ProjDiscriminator',
+        input_scale=32,
+        base_channels=128,
+        attention_cfg=dict(type='SelfAttentionBlock'),
+        attention_after_nth_block=1,
+        with_spectral_norm=True),
+    gan_loss=dict(type='GANLoss', gan_type='hinge'))
+
+train_cfg = dict(disc_steps=5)
+test_cfg = None
+
+# define optimizer
+optimizer = dict(
+    generator=dict(type='Adam', lr=0.0002, betas=(0.5, 0.999)),
+    discriminator=dict(type='Adam', lr=0.0002, betas=(0.5, 0.999)))

configs/_base_/models/singan/singan.py

+model = dict(
+    type='SinGAN',
+    generator=dict(
+        type='SinGANMultiScaleGenerator',
+        in_channels=3,
+        out_channels=3,
+        num_scales=None,  # need to be specified
+    ),
+    discriminator=dict(
+        type='SinGANMultiScaleDiscriminator',
+        in_channels=3,
+        num_scales=None,  # need to be specified
+    ),
+    gan_loss=dict(type='GANLoss', gan_type='wgan', loss_weight=1),
+    disc_auxiliary_loss=[
+        dict(
+            type='GradientPenaltyLoss',
+            loss_weight=0.1,
+            norm_mode='pixel',
+            data_info=dict(
+                discriminator='disc_partial',
+                real_data='real_imgs',
+                fake_data='fake_imgs'))
+    ],
+    gen_auxiliary_loss=dict(
+        type='MSELoss',
+        loss_weight=10,
+        data_info=dict(pred='recon_imgs', target='real_imgs'),
+    ))
+
+train_cfg = dict(
+    noise_weight_init=0.1,
+    iters_per_scale=2000,
+    curr_scale=-1,
+    disc_steps=3,
+    generator_steps=3,
+    lr_d=0.0005,
+    lr_g=0.0005,
+    lr_scheduler_args=dict(milestones=[1600], gamma=0.1))
+
+test_cfg = None