Myosotis-Researches 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

myosotis_researches/CcGAN/models_256/cGAN_concat_SAGAN.py

@@ -1,249 +0,0 @@
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from torch.nn.utils import spectral_norm
-from torch.nn.init import xavier_uniform_
-
-
-def init_weights(m):
-    if type(m) == nn.Linear or type(m) == nn.Conv2d:
-        xavier_uniform_(m.weight)
-        m.bias.data.fill_(0.)
-
-
-def snconv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True):
-    return spectral_norm(nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size,
-                                   stride=stride, padding=padding, dilation=dilation, groups=groups, bias=bias))
-
-
-def snlinear(in_features, out_features):
-    return spectral_norm(nn.Linear(in_features=in_features, out_features=out_features))
-
-
-def sn_embedding(num_embeddings, embedding_dim):
-    return spectral_norm(nn.Embedding(num_embeddings=num_embeddings, embedding_dim=embedding_dim))
-
-
-class Self_Attn(nn.Module):
-    """ Self attention Layer"""
-
-    def __init__(self, in_channels):
-        super(Self_Attn, self).__init__()
-        self.in_channels = in_channels
-        self.snconv1x1_theta = snconv2d(in_channels=in_channels, out_channels=in_channels//8, kernel_size=1, stride=1, padding=0)
-        self.snconv1x1_phi = snconv2d(in_channels=in_channels, out_channels=in_channels//8, kernel_size=1, stride=1, padding=0)
-        self.snconv1x1_g = snconv2d(in_channels=in_channels, out_channels=in_channels//2, kernel_size=1, stride=1, padding=0)
-        self.snconv1x1_attn = snconv2d(in_channels=in_channels//2, out_channels=in_channels, kernel_size=1, stride=1, padding=0)
-        self.maxpool = nn.MaxPool2d(2, stride=2, padding=0)
-        self.softmax  = nn.Softmax(dim=-1)
-        self.sigma = nn.Parameter(torch.zeros(1))
-
-    def forward(self, x):
-        """
-            inputs :
-                x : input feature maps(B X C X W X H)
-            returns :
-                out : self attention value + input feature 
-                attention: B X N X N (N is Width*Height)
-        """
-        _, ch, h, w = x.size()
-        # Theta path
-        theta = self.snconv1x1_theta(x)
-        theta = theta.view(-1, ch//8, h*w)
-        # Phi path
-        phi = self.snconv1x1_phi(x)
-        phi = self.maxpool(phi)
-        phi = phi.view(-1, ch//8, h*w//4)
-        # Attn map
-        attn = torch.bmm(theta.permute(0, 2, 1), phi)
-        attn = self.softmax(attn)
-        # g path
-        g = self.snconv1x1_g(x)
-        g = self.maxpool(g)
-        g = g.view(-1, ch//2, h*w//4)
-        # Attn_g
-        attn_g = torch.bmm(g, attn.permute(0, 2, 1))
-        attn_g = attn_g.view(-1, ch//2, h, w)
-        attn_g = self.snconv1x1_attn(attn_g)
-        # Out
-        out = x + self.sigma*attn_g
-        return out
-
-
-class GenBlock(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        super(GenBlock, self).__init__()
-        self.cond_bn1 = nn.BatchNorm2d(in_channels)
-        self.relu = nn.ReLU(inplace=True)
-        self.snconv2d1 = snconv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, stride=1, padding=1)
-        self.cond_bn2 = nn.BatchNorm2d(out_channels)
-        self.snconv2d2 = snconv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=3, stride=1, padding=1)
-        self.snconv2d0 = snconv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0)
-
-    def forward(self, x):
-        x0 = x
-
-        x = self.cond_bn1(x)
-        x = self.relu(x)
-        x = F.interpolate(x, scale_factor=2, mode='nearest') # upsample
-        x = self.snconv2d1(x)
-        x = self.cond_bn2(x)
-        x = self.relu(x)
-        x = self.snconv2d2(x)
-
-        x0 = F.interpolate(x0, scale_factor=2, mode='nearest') # upsample
-        x0 = self.snconv2d0(x0)
-
-        out = x + x0
-        return out
-
-
-class cGAN_concat_SAGAN_Generator(nn.Module):
-    """Generator."""
-
-    def __init__(self, z_dim, dim_c=1, g_conv_dim=64):
-        super(cGAN_concat_SAGAN_Generator, self).__init__()
-
-        self.z_dim = z_dim
-        self.dim_c = dim_c
-        self.g_conv_dim = g_conv_dim
-        self.snlinear0 = snlinear(in_features=z_dim+dim_c, out_features=g_conv_dim*16*4*4)
-        self.block1 = GenBlock(g_conv_dim*16, g_conv_dim*16)
-        self.block2 = GenBlock(g_conv_dim*16, g_conv_dim*8)
-        self.block3 = GenBlock(g_conv_dim*8, g_conv_dim*4)
-        self.block4 = GenBlock(g_conv_dim*4, g_conv_dim*2)
-        self.self_attn = Self_Attn(g_conv_dim*2)
-        self.block5 = GenBlock(g_conv_dim*2, g_conv_dim*2)
-        self.block6 = GenBlock(g_conv_dim*2, g_conv_dim)
-        self.bn = nn.BatchNorm2d(g_conv_dim, eps=1e-5, momentum=0.0001, affine=True)
-        self.relu = nn.ReLU()
-        self.snconv2d1 = snconv2d(in_channels=g_conv_dim, out_channels=3, kernel_size=3, stride=1, padding=1)
-        self.tanh = nn.Tanh()
-
-        # Weight init
-        self.apply(init_weights)
-
-    def forward(self, z, labels):
-        # n x z_dim
-        act0 = self.snlinear0(torch.cat((z, labels.view(-1,1)),dim=1))            # n x g_conv_dim*16*4*4
-        act0 = act0.view(-1, self.g_conv_dim*16, 4, 4) # n x g_conv_dim*16 x 4 x 4
-        act1 = self.block1(act0)    # n x g_conv_dim*16 x 8 x 8
-        act2 = self.block2(act1)    # n x g_conv_dim*8 x 16 x 16
-        act3 = self.block3(act2)    # n x g_conv_dim*4 x 32 x 32
-        act4 = self.block4(act3)    # n x g_conv_dim*2 x 64 x 64
-        act4 = self.self_attn(act4)         # n x g_conv_dim*2 x 64 x 64
-        act5 = self.block5(act4)    # n x g_conv_dim  x 128 x 128
-        act6 = self.block6(act5)    # n x g_conv_dim  x 256 x 256
-        act6 = self.bn(act6)                # n x g_conv_dim  x 256 x 256
-        act6 = self.relu(act6)              # n x g_conv_dim  x 256 x 256
-        act7 = self.snconv2d1(act6)         # n x 3 x 256 x 256
-        act7 = self.tanh(act7)              # n x 3 x 256 x 256
-        return act7
-
-
-class DiscOptBlock(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        super(DiscOptBlock, self).__init__()
-        self.snconv2d1 = snconv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, stride=1, padding=1)
-        self.relu = nn.ReLU(inplace=True)
-        self.snconv2d2 = snconv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=3, stride=1, padding=1)
-        self.downsample = nn.AvgPool2d(2)
-        self.snconv2d0 = snconv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0)
-
-    def forward(self, x):
-        x0 = x
-
-        x = self.snconv2d1(x)
-        x = self.relu(x)
-        x = self.snconv2d2(x)
-        x = self.downsample(x)
-
-        x0 = self.downsample(x0)
-        x0 = self.snconv2d0(x0)
-
-        out = x + x0
-        return out
-
-
-class DiscBlock(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        super(DiscBlock, self).__init__()
-        self.relu = nn.ReLU(inplace=True)
-        self.snconv2d1 = snconv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, stride=1, padding=1)
-        self.snconv2d2 = snconv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=3, stride=1, padding=1)
-        self.downsample = nn.AvgPool2d(2)
-        self.ch_mismatch = False
-        if in_channels != out_channels:
-            self.ch_mismatch = True
-        self.snconv2d0 = snconv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0)
-
-    def forward(self, x, downsample=True):
-        x0 = x
-
-        x = self.relu(x)
-        x = self.snconv2d1(x)
-        x = self.relu(x)
-        x = self.snconv2d2(x)
-        if downsample:
-            x = self.downsample(x)
-
-        if downsample or self.ch_mismatch:
-            x0 = self.snconv2d0(x0)
-            if downsample:
-                x0 = self.downsample(x0)
-
-        out = x + x0
-        return out
-
-
-class cGAN_concat_SAGAN_Discriminator(nn.Module):
-    """Discriminator."""
-
-    def __init__(self, dim_c=1, d_conv_dim=64):
-        super(cGAN_concat_SAGAN_Discriminator, self).__init__()
-        self.d_conv_dim = d_conv_dim
-        self.dim_c = dim_c
-        self.opt_block1 = DiscOptBlock(3, d_conv_dim)
-        self.block1 = DiscBlock(d_conv_dim, d_conv_dim*2)
-        self.self_attn = Self_Attn(d_conv_dim*2)
-        self.block2 = DiscBlock(d_conv_dim*2, d_conv_dim*4)
-        self.block3 = DiscBlock(d_conv_dim*4, d_conv_dim*6)
-        self.block4 = DiscBlock(d_conv_dim*6, d_conv_dim*12)
-        self.block5 = DiscBlock(d_conv_dim*12, d_conv_dim*12)
-        self.block6 = DiscBlock(d_conv_dim*12, d_conv_dim*16)
-        self.relu = nn.ReLU()
-        self.snlinear1 = snlinear(in_features=d_conv_dim*16*4*4+dim_c, out_features=1)
-
-    def forward(self, x, labels):
-        labels = labels.view(-1,1)
-        # n x 3 x 256 x 256
-        h0 = self.opt_block1(x) # n x d_conv_dim   x 128 x 128
-        h1 = self.block1(h0)    # n x d_conv_dim*2 x 64 x 64
-        h1 = self.self_attn(h1) # n x d_conv_dim*2 x 64 x 64
-        h2 = self.block2(h1)    # n x d_conv_dim*4 x 32 x 32
-        h3 = self.block3(h2)    # n x d_conv_dim*8 x 16 x 16
-        h4 = self.block4(h3)    # n x d_conv_dim*16 x 8 x  8
-        h5 = self.block5(h4)    # n x d_conv_dim*16 x 4 x 4
-        h6 = self.block6(h5, downsample=False)  # n x d_conv_dim*16 x 4 x 4
-        out = self.relu(h6)              # n x d_conv_dim*16 x 4 x 4
-        out = out.view(-1,self.d_conv_dim*16*4*4)
-        out = torch.cat((out, labels),dim=1)
-        out = self.snlinear1(out)
-        return out
-
-
-
-if __name__ == "__main__":
-    
-    netG = cGAN_concat_SAGAN_Generator(z_dim=128).cuda()
-    netD = cGAN_concat_SAGAN_Discriminator().cuda()
-
-    n = 4
-    y = torch.randn(n, 1).cuda()
-    z = torch.randn(n, 128).cuda()
-    x = netG(z,y)
-    print(x.size())
-    o = netD(x,y)
-    print(o.size())

myosotis_researches/CcGAN/train_128/DiffAugment_pytorch.py

@@ -1,76 +0,0 @@
-# Differentiable Augmentation for Data-Efficient GAN Training
-# Shengyu Zhao, Zhijian Liu, Ji Lin, Jun-Yan Zhu, and Song Han
-# https://arxiv.org/pdf/2006.10738
-
-import torch
-import torch.nn.functional as F
-
-
-def DiffAugment(x, policy='', channels_first=True):
-    if policy:
-        if not channels_first:
-            x = x.permute(0, 3, 1, 2)
-        for p in policy.split(','):
-            for f in AUGMENT_FNS[p]:
-                x = f(x)
-        if not channels_first:
-            x = x.permute(0, 2, 3, 1)
-        x = x.contiguous()
-    return x
-
-
-def rand_brightness(x):
-    x = x + (torch.rand(x.size(0), 1, 1, 1, dtype=x.dtype, device=x.device) - 0.5)
-    return x
-
-
-def rand_saturation(x):
-    x_mean = x.mean(dim=1, keepdim=True)
-    x = (x - x_mean) * (torch.rand(x.size(0), 1, 1, 1, dtype=x.dtype, device=x.device) * 2) + x_mean
-    return x
-
-
-def rand_contrast(x):
-    x_mean = x.mean(dim=[1, 2, 3], keepdim=True)
-    x = (x - x_mean) * (torch.rand(x.size(0), 1, 1, 1, dtype=x.dtype, device=x.device) + 0.5) + x_mean
-    return x
-
-
-def rand_translation(x, ratio=0.125):
-    shift_x, shift_y = int(x.size(2) * ratio + 0.5), int(x.size(3) * ratio + 0.5)
-    translation_x = torch.randint(-shift_x, shift_x + 1, size=[x.size(0), 1, 1], device=x.device)
-    translation_y = torch.randint(-shift_y, shift_y + 1, size=[x.size(0), 1, 1], device=x.device)
-    grid_batch, grid_x, grid_y = torch.meshgrid(
-        torch.arange(x.size(0), dtype=torch.long, device=x.device),
-        torch.arange(x.size(2), dtype=torch.long, device=x.device),
-        torch.arange(x.size(3), dtype=torch.long, device=x.device),
-    )
-    grid_x = torch.clamp(grid_x + translation_x + 1, 0, x.size(2) + 1)
-    grid_y = torch.clamp(grid_y + translation_y + 1, 0, x.size(3) + 1)
-    x_pad = F.pad(x, [1, 1, 1, 1, 0, 0, 0, 0])
-    x = x_pad.permute(0, 2, 3, 1).contiguous()[grid_batch, grid_x, grid_y].permute(0, 3, 1, 2)
-    return x
-
-
-def rand_cutout(x, ratio=0.5):
-    cutout_size = int(x.size(2) * ratio + 0.5), int(x.size(3) * ratio + 0.5)
-    offset_x = torch.randint(0, x.size(2) + (1 - cutout_size[0] % 2), size=[x.size(0), 1, 1], device=x.device)
-    offset_y = torch.randint(0, x.size(3) + (1 - cutout_size[1] % 2), size=[x.size(0), 1, 1], device=x.device)
-    grid_batch, grid_x, grid_y = torch.meshgrid(
-        torch.arange(x.size(0), dtype=torch.long, device=x.device),
-        torch.arange(cutout_size[0], dtype=torch.long, device=x.device),
-        torch.arange(cutout_size[1], dtype=torch.long, device=x.device),
-    )
-    grid_x = torch.clamp(grid_x + offset_x - cutout_size[0] // 2, min=0, max=x.size(2) - 1)
-    grid_y = torch.clamp(grid_y + offset_y - cutout_size[1] // 2, min=0, max=x.size(3) - 1)
-    mask = torch.ones(x.size(0), x.size(2), x.size(3), dtype=x.dtype, device=x.device)
-    mask[grid_batch, grid_x, grid_y] = 0
-    x = x * mask.unsqueeze(1)
-    return x
-
-
-AUGMENT_FNS = {
-    'color': [rand_brightness, rand_saturation, rand_contrast],
-    'translation': [rand_translation],
-    'cutout': [rand_cutout],
-}

myosotis_researches/CcGAN/train_128/eval_metrics.py

@@ -1,205 +0,0 @@
-"""
-Compute
-Inception Score (IS),
-Frechet Inception Discrepency (FID), ref "https://github.com/mseitzer/pytorch-fid/blob/master/fid_score.py"
-Maximum Mean Discrepancy (MMD)
-for a set of fake images
-
-use numpy array
-Xr: high-level features for real images; nr by d array
-Yr: labels for real images
-Xg: high-level features for fake images; ng by d array
-Yg: labels for fake images
-IMGSr: real images
-IMGSg: fake images
-
-"""
-
-import os
-import gc
-import numpy as np
-# from numpy import linalg as LA
-from scipy import linalg
-import torch
-import torch.nn as nn
-from scipy.stats import entropy
-from torch.nn import functional as F
-from torchvision.utils import save_image
-
-from .utils import SimpleProgressBar, IMGs_dataset
-
-
-def normalize_images(batch_images):
-    batch_images = batch_images/255.0
-    batch_images = (batch_images - 0.5)/0.5
-    return batch_images
-
-##############################################################################
-# FID scores
-##############################################################################
-# compute FID based on extracted features
-def FID(Xr, Xg, eps=1e-10):
-    '''
-    The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1)
-    and X_2 ~ N(mu_2, C_2) is
-            d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)).
-    '''
-    #sample mean
-    MUr = np.mean(Xr, axis = 0)
-    MUg = np.mean(Xg, axis = 0)
-    mean_diff = MUr - MUg
-    #sample covariance
-    SIGMAr = np.cov(Xr.transpose())
-    SIGMAg = np.cov(Xg.transpose())
-
-    # Product might be almost singular
-    covmean, _ = linalg.sqrtm(SIGMAr.dot(SIGMAg), disp=False)#square root of a matrix
-    covmean = covmean.real
-    if not np.isfinite(covmean).all():
-        msg = ('fid calculation produces singular product; '
-               'adding %s to diagonal of cov estimates') % eps
-        print(msg)
-        offset = np.eye(SIGMAr.shape[0]) * eps
-        covmean = linalg.sqrtm((SIGMAr + offset).dot(SIGMAg + offset))
-
-    #fid score
-    fid_score = mean_diff.dot(mean_diff) + np.trace(SIGMAr + SIGMAg - 2*covmean)
-
-    return fid_score
-
-##test
-#Xr = np.random.rand(10000,1000)
-#Xg = np.random.rand(10000,1000)
-#print(FID(Xr, Xg))
-
-# compute FID from raw images
-def cal_FID(PreNetFID, IMGSr, IMGSg, batch_size = 500, resize = None, norm_img = False):
-    #resize: if None, do not resize; if resize = (H,W), resize images to 3 x H x W
-    
-    PreNetFID.eval()
-
-    nr = IMGSr.shape[0]
-    ng = IMGSg.shape[0]
-
-    nc = IMGSr.shape[1] #IMGSr is nrxNCxIMG_SIExIMG_SIZE
-    img_size = IMGSr.shape[2]
-
-    if batch_size > min(nr, ng):
-        batch_size = min(nr, ng)
-        # print("FID: recude batch size to {}".format(batch_size))
-
-    #compute the length of extracted features
-    with torch.no_grad():
-        test_img = torch.from_numpy(IMGSr[0].reshape((1,nc,img_size,img_size))).type(torch.float).cuda()
-        if resize is not None:
-            test_img = nn.functional.interpolate(test_img, size = resize, scale_factor=None, mode='bilinear', align_corners=False)
-        if norm_img:
-            test_img = normalize_images(test_img)
-        # _, test_features = PreNetFID(test_img)
-        test_features = PreNetFID(test_img)
-        d = test_features.shape[1] #length of extracted features
-
-    Xr = np.zeros((nr, d))
-    Xg = np.zeros((ng, d))
-
-    #batch_size = 500
-    with torch.no_grad():
-        tmp = 0
-        pb1 = SimpleProgressBar()
-        for i in range(nr//batch_size):
-            imgr_tensor = torch.from_numpy(IMGSr[tmp:(tmp+batch_size)]).type(torch.float).cuda()
-            if resize is not None:
-                imgr_tensor = nn.functional.interpolate(imgr_tensor, size = resize, scale_factor=None, mode='bilinear', align_corners=False)
-            if norm_img:
-                imgr_tensor = normalize_images(imgr_tensor)
-            # _, Xr_tmp = PreNetFID(imgr_tensor)
-            Xr_tmp = PreNetFID(imgr_tensor)
-            Xr[tmp:(tmp+batch_size)] = Xr_tmp.detach().cpu().numpy()
-            tmp+=batch_size
-            # pb1.update(min(float(i)*100/(nr//batch_size), 100))
-            pb1.update(min(max(tmp/nr*100,100), 100))
-        del Xr_tmp,imgr_tensor; gc.collect()
-        torch.cuda.empty_cache()
-
-        tmp = 0
-        pb2 = SimpleProgressBar()
-        for j in range(ng//batch_size):
-            imgg_tensor = torch.from_numpy(IMGSg[tmp:(tmp+batch_size)]).type(torch.float).cuda()
-            if resize is not None:
-                imgg_tensor = nn.functional.interpolate(imgg_tensor, size = resize, scale_factor=None, mode='bilinear', align_corners=False)
-            if norm_img:
-                imgg_tensor = normalize_images(imgg_tensor)
-            # _, Xg_tmp = PreNetFID(imgg_tensor)
-            Xg_tmp = PreNetFID(imgg_tensor)
-            Xg[tmp:(tmp+batch_size)] = Xg_tmp.detach().cpu().numpy()
-            tmp+=batch_size
-            # pb2.update(min(float(j)*100/(ng//batch_size), 100))
-            pb2.update(min(max(tmp/ng*100, 100), 100))
-        del Xg_tmp,imgg_tensor; gc.collect()
-        torch.cuda.empty_cache()
-
-
-    fid_score = FID(Xr, Xg, eps=1e-6)
-
-    return fid_score
-
-
-
-
-
-
-##############################################################################
-# label_score
-# difference between assigned label and predicted label
-##############################################################################
-def cal_labelscore(PreNet, images, labels_assi, min_label_before_shift, max_label_after_shift, batch_size = 500, resize = None, norm_img = False, num_workers=0):
-    '''
-    PreNet: pre-trained CNN
-    images: fake images
-    labels_assi: assigned labels
-    resize: if None, do not resize; if resize = (H,W), resize images to 3 x H x W
-    '''
-
-    PreNet.eval()
-
-    # assume images are nxncximg_sizeximg_size
-    n = images.shape[0]
-    nc = images.shape[1] #number of channels
-    img_size = images.shape[2]
-    labels_assi = labels_assi.reshape(-1)
-
-    eval_trainset = IMGs_dataset(images, labels_assi, normalize=False)
-    eval_dataloader = torch.utils.data.DataLoader(eval_trainset, batch_size=batch_size, shuffle=False, num_workers=num_workers)
-
-    labels_pred = np.zeros(n+batch_size)
-
-    nimgs_got = 0
-    pb = SimpleProgressBar()
-    for batch_idx, (batch_images, batch_labels) in enumerate(eval_dataloader):
-        batch_images = batch_images.type(torch.float).cuda()
-        batch_labels = batch_labels.type(torch.float).cuda()
-        batch_size_curr = len(batch_labels)
-
-        if norm_img:
-            batch_images = normalize_images(batch_images)
-
-        batch_labels_pred, _ = PreNet(batch_images)
-        labels_pred[nimgs_got:(nimgs_got+batch_size_curr)] = batch_labels_pred.detach().cpu().numpy().reshape(-1)
-
-        nimgs_got += batch_size_curr
-        pb.update((float(nimgs_got)/n)*100)
-
-        del batch_images; gc.collect()
-        torch.cuda.empty_cache()
-    #end for batch_idx
-
-    labels_pred = labels_pred[0:n]
-
-
-    labels_pred = (labels_pred*max_label_after_shift)-np.abs(min_label_before_shift)
-    labels_assi = (labels_assi*max_label_after_shift)-np.abs(min_label_before_shift)
-
-    ls_mean = np.mean(np.abs(labels_pred-labels_assi))
-    ls_std = np.std(np.abs(labels_pred-labels_assi))
-
-    return ls_mean, ls_std

myosotis_researches/CcGAN/train_128/opts.py

@@ -1,87 +0,0 @@
-import argparse
-
-def parse_opts():
-    parser = argparse.ArgumentParser()
-
-    ''' Overall Settings '''
-    parser.add_argument('--root_path', type=str, default='')
-    parser.add_argument('--data_path', type=str, default='')
-    parser.add_argument('--eval_ckpt_path', type=str, default='')
-    parser.add_argument('--seed', type=int, default=2021, metavar='S', help='random seed (default: 2020)')
-    parser.add_argument('--num_workers', type=int, default=0)
-
-
-    ''' Dataset '''
-    ## Data split: RC-49 is split into a train set (the last decimal of the degree is odd) and a test set (the last decimal of the degree is even); the unique labels in two sets do not overlap.
-    parser.add_argument('--data_split', type=str, default='train',
-                        choices=['all', 'train'])
-    parser.add_argument('--min_label', type=float, default=0.0)
-    parser.add_argument('--max_label', type=float, default=90.0)
-    parser.add_argument('--num_channels', type=int, default=3, metavar='N')
-    parser.add_argument('--img_size', type=int, default=128, metavar='N')
-    parser.add_argument('--max_num_img_per_label', type=int, default=50, metavar='N')
-    parser.add_argument('--max_num_img_per_label_after_replica', type=int, default=0, metavar='N')
-    parser.add_argument('--show_real_imgs', action='store_true', default=False)
-    parser.add_argument('--visualize_fake_images', action='store_true', default=False)
-
-
-    ''' GAN settings '''
-    parser.add_argument('--GAN', type=str, default='CcGAN', choices=['cGAN', 'cGAN-concat', 'CcGAN'])
-    parser.add_argument('--GAN_arch', type=str, default='SAGAN', choices=['SAGAN'])
-
-    # label embedding setting
-    parser.add_argument('--net_embed', type=str, default='ResNet34_embed') #ResNetXX_emebed
-    parser.add_argument('--epoch_cnn_embed', type=int, default=200) #epoch of cnn training for label embedding
-    parser.add_argument('--resumeepoch_cnn_embed', type=int, default=0) #epoch of cnn training for label embedding
-    parser.add_argument('--epoch_net_y2h', type=int, default=500)
-    parser.add_argument('--dim_embed', type=int, default=128) #dimension of the embedding space
-    parser.add_argument('--batch_size_embed', type=int, default=256, metavar='N')
-
-    parser.add_argument('--loss_type_gan', type=str, default='hinge')
-    parser.add_argument('--niters_gan', type=int, default=10000, help='number of iterations')
-    parser.add_argument('--resume_niters_gan', type=int, default=0)
-    parser.add_argument('--save_niters_freq', type=int, default=2000, help='frequency of saving checkpoints')
-    parser.add_argument('--lr_g_gan', type=float, default=1e-4, help='learning rate for generator')
-    parser.add_argument('--lr_d_gan', type=float, default=1e-4, help='learning rate for discriminator')
-    parser.add_argument('--dim_gan', type=int, default=128, help='Latent dimension of GAN')
-    parser.add_argument('--batch_size_disc', type=int, default=64)
-    parser.add_argument('--batch_size_gene', type=int, default=64)
-    parser.add_argument('--num_D_steps', type=int, default=4, help='number of Ds updates in one iteration')
-    parser.add_argument('--cGAN_num_classes', type=int, default=20, metavar='N') #bin label into cGAN_num_classes
-    parser.add_argument('--visualize_freq', type=int, default=2000, help='frequency of visualization')
-
-    parser.add_argument('--kernel_sigma', type=float, default=-1.0,
-                        help='If kernel_sigma<0, then use rule-of-thumb formula to compute the sigma.')
-    parser.add_argument('--threshold_type', type=str, default='hard', choices=['soft', 'hard'])
-    parser.add_argument('--kappa', type=float, default=-1)
-    parser.add_argument('--nonzero_soft_weight_threshold', type=float, default=1e-3,
-                        help='threshold for determining nonzero weights for SVDL; we neglect images with too small weights')
-
-    # DiffAugment setting
-    parser.add_argument('--gan_DiffAugment', action='store_true', default=False)
-    parser.add_argument('--gan_DiffAugment_policy', type=str, default='color,translation,cutout')
-
-
-    # evaluation setting
-    '''
-    Four evaluation modes:
-    Mode 1: eval on unique labels used for GAN training;
-    Mode 2. eval on all unique labels in the dataset and when computing FID use all real images in the dataset;
-    Mode 3. eval on all unique labels in the dataset and when computing FID only use real images for GAN training in the dataset (to test SFID's effectiveness on unseen labels);
-    Mode 4. eval on a interval [min_label, max_label] with num_eval_labels labels.
-    '''
-    parser.add_argument('--eval_mode', type=int, default=2)
-    parser.add_argument('--num_eval_labels', type=int, default=-1)
-    parser.add_argument('--samp_batch_size', type=int, default=200)
-    parser.add_argument('--nfake_per_label', type=int, default=200)
-    parser.add_argument('--nreal_per_label', type=int, default=-1)
-    parser.add_argument('--comp_FID', action='store_true', default=False)
-    parser.add_argument('--epoch_FID_CNN', type=int, default=200)
-    parser.add_argument('--FID_radius', type=float, default=0)
-    parser.add_argument('--FID_num_centers', type=int, default=-1)
-    parser.add_argument('--dump_fake_for_NIQE', action='store_true', default=False,
-                        help='Dump fake images for computing NIQE')
-
-    args = parser.parse_args()
-
-    return args