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

{myosotis_researches-0.1.7 → 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.7
+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.7/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.7
+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.7 → myosotis_researches-0.1.8}/myosotis_researches/CcGAN/utils/__init__.py

@@ -3,7 +3,7 @@ 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__ = [
@@ -15,5 +15,6 @@ __all__ = [
     "PlotLoss",
     "compute_entropy",
     "predict_class_labels",
+    "DiffAugment",
     "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.7 → myosotis_researches-0.1.8}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="Myosotis-Researches",
-    version="0.1.7",
+    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.7/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"]