Myosotis-Researches 0.1.6__tar.gz → 0.1.8__tar.gz

{myosotis_researches-0.1.6 → myosotis_researches-0.1.8/Myosotis_Researches.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Myosotis-Researches
-Version: 0.1.6
+Version: 0.1.8
 Summary: A repository for storing my progress of researches.
 Home-page: https://github.com/Zeyu-Xie/Myosotis-Researches
 Author: Zeyu Xie

{myosotis_researches-0.1.6 → myosotis_researches-0.1.8}/Myosotis_Researches.egg-info/SOURCES.txt

@@ -57,5 +57,6 @@ myosotis_researches/CcGAN/utils/SimpleProgressBar.py
 myosotis_researches/CcGAN/utils/__init__.py
 myosotis_researches/CcGAN/utils/concat_image.py
 myosotis_researches/CcGAN/utils/make_h5.py
+myosotis_researches/CcGAN/utils/opts.py
 myosotis_researches/CcGAN/utils/print_hdf5.py
 myosotis_researches/CcGAN/utils/train.py

{myosotis_researches-0.1.6/Myosotis_Researches.egg-info → myosotis_researches-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Myosotis-Researches
-Version: 0.1.6
+Version: 0.1.8
 Summary: A repository for storing my progress of researches.
 Home-page: https://github.com/Zeyu-Xie/Myosotis-Researches
 Author: Zeyu Xie

{myosotis_researches-0.1.6 → myosotis_researches-0.1.8}/myosotis_researches/CcGAN/utils/__init__.py

@@ -3,7 +3,8 @@ from .concat_image import concat_image
 from .make_h5 import make_h5
 from .SimpleProgressBar import SimpleProgressBar
 from .IMGs_dataset import IMGs_dataset
-from .train import PlotLoss, compute_entropy, predict_class_labels
+from .train import PlotLoss, compute_entropy, predict_class_labels, DiffAugment
+from .opts import parse_opts
 
 __all__ = [
     "print_hdf5",
@@ -14,4 +15,6 @@ __all__ = [
     "PlotLoss",
     "compute_entropy",
     "predict_class_labels",
+    "DiffAugment",
+    "parse_opts"
 ]

myosotis_researches-0.1.8/myosotis_researches/CcGAN/utils/opts.py

@@ -0,0 +1,89 @@
+import argparse
+
+def parse_opts():
+    parser = argparse.ArgumentParser()
+
+    ''' Overall Settings '''
+    parser.add_argument('--data_path', type=str, default='')
+    parser.add_argument('--output_dir', 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: Ra 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
+
+__all__ = ["parse_opts"]

myosotis_researches-0.1.8/myosotis_researches/CcGAN/utils/train.py

@@ -0,0 +1,156 @@
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+def PlotLoss(loss, filename):
+    x_axis = np.arange(start=1, stop=len(loss) + 1)
+    plt.switch_backend("agg")
+    mpl.style.use("seaborn")
+    fig = plt.figure()
+    ax = plt.subplot(111)
+    ax.plot(x_axis, np.array(loss))
+    plt.xlabel("epoch")
+    plt.ylabel("training loss")
+    plt.legend()
+    # ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.15),  shadow=True, ncol=3)
+    # plt.title('Training Loss')
+    plt.savefig(filename)
+
+
+# compute entropy of class labels; labels is a numpy array
+def compute_entropy(labels, base=None):
+    value, counts = np.unique(labels, return_counts=True)
+    norm_counts = counts / counts.sum()
+    base = np.e if base is None else base
+    return -(norm_counts * np.log(norm_counts) / np.log(base)).sum()
+
+
+def predict_class_labels(net, images, batch_size=500, verbose=False, num_workers=0):
+    net = net.cuda()
+    net.eval()
+
+    n = len(images)
+    if batch_size > n:
+        batch_size = n
+    dataset_pred = IMGs_dataset(images, normalize=False)
+    dataloader_pred = torch.utils.data.DataLoader(
+        dataset_pred, batch_size=batch_size, shuffle=False, num_workers=num_workers
+    )
+
+    class_labels_pred = np.zeros(n + batch_size)
+    with torch.no_grad():
+        nimgs_got = 0
+        if verbose:
+            pb = SimpleProgressBar()
+        for batch_idx, batch_images in enumerate(dataloader_pred):
+            batch_images = batch_images.type(torch.float).cuda()
+            batch_size_curr = len(batch_images)
+
+            outputs, _ = net(batch_images)
+            _, batch_class_labels_pred = torch.max(outputs.data, 1)
+            class_labels_pred[nimgs_got : (nimgs_got + batch_size_curr)] = (
+                batch_class_labels_pred.detach().cpu().numpy().reshape(-1)
+            )
+
+            nimgs_got += batch_size_curr
+            if verbose:
+                pb.update((float(nimgs_got) / n) * 100)
+        # end for batch_idx
+    class_labels_pred = class_labels_pred[0:n]
+    return class_labels_pred
+
+
+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],
+}
+
+
+__all__ = ["PlotLoss", "compute_entropy", "predict_class_labels", "DiffAugment"]

{myosotis_researches-0.1.6 → myosotis_researches-0.1.8}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="Myosotis-Researches",
-    version="0.1.6",
+    version="0.1.8",
     description="A repository for storing my progress of researches.",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",

myosotis_researches-0.1.6/myosotis_researches/CcGAN/utils/train.py

@@ -1,65 +0,0 @@
-import numpy as np
-import torch
-import matplotlib.pyplot as plt
-import matplotlib as mpl
-
-
-def PlotLoss(loss, filename):
-    x_axis = np.arange(start=1, stop=len(loss) + 1)
-    plt.switch_backend("agg")
-    mpl.style.use("seaborn")
-    fig = plt.figure()
-    ax = plt.subplot(111)
-    ax.plot(x_axis, np.array(loss))
-    plt.xlabel("epoch")
-    plt.ylabel("training loss")
-    plt.legend()
-    # ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.15),  shadow=True, ncol=3)
-    # plt.title('Training Loss')
-    plt.savefig(filename)
-
-
-# compute entropy of class labels; labels is a numpy array
-def compute_entropy(labels, base=None):
-    value, counts = np.unique(labels, return_counts=True)
-    norm_counts = counts / counts.sum()
-    base = np.e if base is None else base
-    return -(norm_counts * np.log(norm_counts) / np.log(base)).sum()
-
-
-def predict_class_labels(net, images, batch_size=500, verbose=False, num_workers=0):
-    net = net.cuda()
-    net.eval()
-
-    n = len(images)
-    if batch_size > n:
-        batch_size = n
-    dataset_pred = IMGs_dataset(images, normalize=False)
-    dataloader_pred = torch.utils.data.DataLoader(
-        dataset_pred, batch_size=batch_size, shuffle=False, num_workers=num_workers
-    )
-
-    class_labels_pred = np.zeros(n + batch_size)
-    with torch.no_grad():
-        nimgs_got = 0
-        if verbose:
-            pb = SimpleProgressBar()
-        for batch_idx, batch_images in enumerate(dataloader_pred):
-            batch_images = batch_images.type(torch.float).cuda()
-            batch_size_curr = len(batch_images)
-
-            outputs, _ = net(batch_images)
-            _, batch_class_labels_pred = torch.max(outputs.data, 1)
-            class_labels_pred[nimgs_got : (nimgs_got + batch_size_curr)] = (
-                batch_class_labels_pred.detach().cpu().numpy().reshape(-1)
-            )
-
-            nimgs_got += batch_size_curr
-            if verbose:
-                pb.update((float(nimgs_got) / n) * 100)
-        # end for batch_idx
-    class_labels_pred = class_labels_pred[0:n]
-    return class_labels_pred
-
-
-__all__ = ["PlotLoss", "compute_entropy", "predict_class_labels"]