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

myosotis_researches/CcGAN/models_256/cGAN_SAGAN.py

@@ -0,0 +1,280 @@
+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 ConditionalBatchNorm2d(nn.Module):
+    # https://github.com/pytorch/pytorch/issues/8985#issuecomment-405080775
+    def __init__(self, num_features, num_classes):
+        super().__init__()
+        self.num_features = num_features
+        self.bn = nn.BatchNorm2d(num_features, momentum=0.001, affine=False)
+        self.embed = nn.Embedding(num_classes, num_features * 2)
+        # self.embed.weight.data[:, :num_features].normal_(1, 0.02)  # Initialise scale at N(1, 0.02)
+        self.embed.weight.data[:, :num_features].fill_(1.)  # Initialize scale to 1
+        self.embed.weight.data[:, num_features:].zero_()  # Initialize bias at 0
+
+    def forward(self, x, y):
+        out = self.bn(x)
+        gamma, beta = self.embed(y).chunk(2, 1)
+        out = gamma.view(-1, self.num_features, 1, 1) * out + beta.view(-1, self.num_features, 1, 1)
+        return out
+
+
+class GenBlock(nn.Module):
+    def __init__(self, in_channels, out_channels, num_classes):
+        super(GenBlock, self).__init__()
+        self.cond_bn1 = ConditionalBatchNorm2d(in_channels, num_classes)
+        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 = ConditionalBatchNorm2d(out_channels, num_classes)
+        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, labels):
+        x0 = x
+
+        x = self.cond_bn1(x, labels)
+        x = self.relu(x)
+        x = F.interpolate(x, scale_factor=2, mode='nearest') # upsample
+        x = self.snconv2d1(x)
+        x = self.cond_bn2(x, labels)
+        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_SAGAN_Generator(nn.Module):
+    """Generator."""
+
+    def __init__(self, z_dim, num_classes, g_conv_dim=64):
+        super(cGAN_SAGAN_Generator, self).__init__()
+
+        self.z_dim = z_dim
+        self.g_conv_dim = g_conv_dim
+        self.snlinear0 = snlinear(in_features=z_dim, out_features=g_conv_dim*16*4*4)
+        self.block1 = GenBlock(g_conv_dim*16, g_conv_dim*16, num_classes)
+        self.block2 = GenBlock(g_conv_dim*16, g_conv_dim*8, num_classes)
+        self.block3 = GenBlock(g_conv_dim*8, g_conv_dim*4, num_classes)
+        self.block4 = GenBlock(g_conv_dim*4, g_conv_dim*2, num_classes)
+        self.self_attn = Self_Attn(g_conv_dim*2)
+        self.block5 = GenBlock(g_conv_dim*2, g_conv_dim*2, num_classes)
+        self.block6 = GenBlock(g_conv_dim*2, g_conv_dim, num_classes)
+        self.bn = nn.BatchNorm2d(g_conv_dim, eps=1e-5, momentum=0.0001, affine=True)
+        self.relu = nn.ReLU(inplace=True)
+        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(z)            # 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, labels)    # n x g_conv_dim*16 x 8 x 8
+        act2 = self.block2(act1, labels)    # n x g_conv_dim*8 x 16 x 16
+        act3 = self.block3(act2, labels)    # n x g_conv_dim*4 x 32 x 32
+        act4 = self.block4(act3, labels)    # 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, labels)    # n x g_conv_dim  x 128 x 128
+        act6 = self.block6(act5, labels)    # 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_SAGAN_Discriminator(nn.Module):
+    """Discriminator."""
+
+    def __init__(self, num_classes, d_conv_dim=64):
+        super(cGAN_SAGAN_Discriminator, self).__init__()
+        self.d_conv_dim = d_conv_dim
+        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(inplace=True)
+        self.snlinear1 = snlinear(in_features=d_conv_dim*16, out_features=1)
+        self.sn_embedding1 = sn_embedding(num_classes, d_conv_dim*16)
+
+        # Weight init
+        self.apply(init_weights)
+        xavier_uniform_(self.sn_embedding1.weight)
+
+    def forward(self, x, labels):
+        # 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
+        h6 = self.relu(h6)              # n x d_conv_dim*16 x 4 x 4
+        h6 = torch.sum(h6, dim=[2,3])   # n x d_conv_dim*16
+        output1 = torch.squeeze(self.snlinear1(h6)) # n
+        # Projection
+        h_labels = self.sn_embedding1(labels)   # n x d_conv_dim*16
+        proj = torch.mul(h6, h_labels)          # n x d_conv_dim*16
+        output2 = torch.sum(proj, dim=[1])      # n
+        # Out
+        output = output1 + output2              # n
+        return output
+
+
+
+if __name__ == "__main__":
+    
+    num_classes = 10
+
+    netG = cGAN_SAGAN_Generator(z_dim=128, num_classes=num_classes, g_conv_dim=128).cuda()
+    netD = cGAN_SAGAN_Discriminator(num_classes=num_classes, d_conv_dim=128).cuda()
+
+    n = 4
+    # target = torch.randint(high=num_classes, size=(1,n)) # set size (2,10) for MHE
+    # y = torch.zeros(n, num_classes)
+    # y[range(y.shape[0]), target]=1
+    # y = y.type(torch.long).cuda()
+    y = torch.randint(high=num_classes, size=(n,)).type(torch.long).cuda()
+    z = torch.randn(n, 128).cuda()
+    x = netG(z,y)
+    o = netD(x,y)
+    print(x.size())
+    print(o.size())

myosotis_researches/CcGAN/models_256/cGAN_concat_SAGAN.py

@@ -0,0 +1,249 @@
+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/visualize/__init__.py

@@ -0,0 +1,3 @@
+from .visualize_datasets import visualize_datasets
+
+__all__ = ["visualize_datasets"]

myosotis_researches/CcGAN/visualize/visualize_datasets.py

@@ -0,0 +1,98 @@
+import base64
+from flask import Flask, send_file
+import h5py
+from importlib import resources
+from io import BytesIO
+from jinja2 import Template
+from myosotis_researches.CcGAN.internal import *
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+
+def Image_to_Base64(image: Image):
+    buffered = BytesIO()
+    image.save(buffered, format="PNG")
+    img_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    return f"data:image/png;base64,{img_base64}"
+
+
+def datasets_to_html(indexes, datasets_path, list_path, template_path):
+
+    N = len(indexes)
+
+    # Get template
+    with open(template_path, "r") as f:
+        template = Template(f.read())
+
+    # Get data
+    with h5py.File(datasets_path, "r") as f:
+        images = f["images"][indexes]
+        index_train = f["index_train"][:]
+        index_valid = f["index_valid"][:]
+        labels = f["labels"][indexes]
+        types = f["types"][indexes]
+
+    # Get list
+    df = pd.read_csv(list_path)
+    tool_wears = df.loc[indexes, "tool_wear"]
+    surfaces = df.loc[indexes, "surface"]
+    image_names = df.loc[indexes, "image_name"]
+
+    # Transform data to base64
+    images = np.transpose(images, (0, 2, 3, 1))
+    images = [Image.fromarray(image) for image in images]
+    images_base64 = [Image_to_Base64(image) for image in images]
+
+    # Render template
+    items = []
+    for i in range(N):
+        items.append(
+            {
+                "image": images_base64[i],
+                "image_name": image_names[i],
+                "label": labels[i],
+                "type": types[i],
+                "index": indexes[i],
+            }
+        )
+
+    return template.render(
+        indexes=indexes,
+        datasets_path=datasets_path,
+        list_path=list_path,
+        template_path=template_path,
+        items=items,
+    )
+
+
+def visualize_datasets(
+    indexes,
+    datasets_path,
+    list_path,
+    template_path=resources.files("myosotis_researches").joinpath(
+        "CcGAN", "visualize", "src", "template.html"
+    ),
+    host="127.0.0.1",
+    port=8000,
+    debug=True,
+):
+    # Local server
+    app = Flask(__name__)
+
+    @app.route("/")
+    def index():
+        return datasets_to_html(indexes, datasets_path, list_path, template_path)
+
+    @app.route("/style.css")
+    def style():
+        return send_file(
+            resources.files("myosotis_researches").joinpath(
+                "CcGAN", "visualize", "src", "style.css"
+            )
+        )
+
+    app.run(host=host, port=port, debug=debug)
+
+
+__all__ = ["visualize_datasets"]

{myosotis_researches-0.1.9.dist-info → myosotis_researches-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Myosotis-Researches
-Version: 0.1.9
+Version: 0.1.11
 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.11.dist-info/RECORD

@@ -0,0 +1,42 @@
+myosotis_researches/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+myosotis_researches/CcGAN/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+myosotis_researches/CcGAN/internal/__init__.py,sha256=b-63yANNRQXgLF9k9yGdrm7mlULqGic1HTQTzg9wIME,209
+myosotis_researches/CcGAN/internal/install_datasets.py,sha256=jJwLOZrDnHMrJSUhXxSIFobdeWK5N6eitPmjeBW9FyA,1144
+myosotis_researches/CcGAN/internal/show_datasets.py,sha256=BWtQ6vdiEUOTrOs8aMBv6utuUN0IiaLKcK5iXq9y2qI,363
+myosotis_researches/CcGAN/internal/uninstall_datasets.py,sha256=7pxPZcSe9RHncF0I_4rf8ZdI7eQwv-sFVfxzSVZfYHQ,297
+myosotis_researches/CcGAN/models_128/CcGAN_SAGAN.py,sha256=uYDngtHoB7frPg2Vs7YCFXeUh7Y7MjaAXbRWHXO_xvw,10629
+myosotis_researches/CcGAN/models_128/ResNet_class_eval.py,sha256=wa5CPkYzrS0X6kZ6pGHM-GxcGNkSpBdTTqgy5dKVKkU,5131
+myosotis_researches/CcGAN/models_128/ResNet_embed.py,sha256=HKSY-5WWa9jGniOgRoR1WOTfWhR1Dcj6cq2sgznZEbE,6344
+myosotis_researches/CcGAN/models_128/ResNet_regre_eval.py,sha256=VJYJiiwrjf9DvfZrlwOMJJAPu3PlwgFgIddDaRlGsac,6190
+myosotis_researches/CcGAN/models_128/__init__.py,sha256=PJQP7ozE9vY23k01he5qvEuGndPZKqxiWWxvgbLDhqg,449
+myosotis_researches/CcGAN/models_128/autoencoder.py,sha256=ugOwBNoSNP4-WiATVkhC4-igRjj6yEY91qU0egpX744,3827
+myosotis_researches/CcGAN/models_128/cGAN_SAGAN.py,sha256=JDr0Ss5osf9m-u34bVN_PvMsvMXkmi2jwPOAnls6EOA,11240
+myosotis_researches/CcGAN/models_128/cGAN_concat_SAGAN.py,sha256=GHAmrNjORXKu-8UqAdP-A5WG-_3BdQUmWsrWD1NX5-w,9634
+myosotis_researches/CcGAN/models_256/CcGAN_SAGAN.py,sha256=ju1dBYhqxl722_eeUGc2mKwf1AV_qsv1PlBL3tyOu48,10861
+myosotis_researches/CcGAN/models_256/ResNet_class_eval.py,sha256=tS5YxIpiFS9tDCNe2IDv1hTZNn40_JBD_nn97MfQJNI,5178
+myosotis_researches/CcGAN/models_256/ResNet_embed.py,sha256=9OcMQ-8nuWEbEbWc9tGaWQtfV1hdnkl0PrTphoGX77c,6295
+myosotis_researches/CcGAN/models_256/ResNet_regre_eval.py,sha256=tHAbRNM9XodyfPsu00ac5KMjcgRH8qdx8AtCN9QGXKc,6269
+myosotis_researches/CcGAN/models_256/__init__.py,sha256=PJQP7ozE9vY23k01he5qvEuGndPZKqxiWWxvgbLDhqg,449
+myosotis_researches/CcGAN/models_256/autoencoder.py,sha256=Nv3eSWJVrWaOufoVGe04sZ_KiXFLtu3Y0asZcAdyyj0,4382
+myosotis_researches/CcGAN/models_256/cGAN_SAGAN.py,sha256=wTHVkUcAp07n3lgweKFo6cqd91E_rEqgJrBDbBe6qrg,11510
+myosotis_researches/CcGAN/models_256/cGAN_concat_SAGAN.py,sha256=ZmGEpprDDlFR3dG32LT3NH5yiA1WR8Hg26rcbz42aCQ,9807
+myosotis_researches/CcGAN/train/__init__.py,sha256=-55Ccov89II6Yuaiszi8ziw9EoVQr7OJR0bQfPAE_10,127
+myosotis_researches/CcGAN/train/train_ccgan.py,sha256=0Qxibgd2-WaYgbyYeeOyiMkdcwkd_M1m1gSqoHTjN0w,13268
+myosotis_researches/CcGAN/train/train_cgan.py,sha256=sxMzvlmdjmqufwJFxBwatcoJecYqn2Uidedu15CL9ws,9619
+myosotis_researches/CcGAN/train/train_cgan_concat.py,sha256=OrQbwdU_ujUeKFGixUUpnini6rURtbuHv9NDrP6g0X0,8861
+myosotis_researches/CcGAN/train/train_net_for_label_embed.py,sha256=4j6r4_o4rXgAN4MdUQL-TXqZJpbhH7d9gWQR8YzBlXw,6976
+myosotis_researches/CcGAN/utils/IMGs_dataset.py,sha256=i45PBNSCeAEB5uUG0SluYRTuHWZwH_5ldz2wm6afkYs,927
+myosotis_researches/CcGAN/utils/SimpleProgressBar.py,sha256=S4eD_m6ysHRMHAmRtkTXVRNfXTR8kuHv-d3lUN0BVn4,546
+myosotis_researches/CcGAN/utils/__init__.py,sha256=em3aB0C-V230NQtT64hyuHGo4CjV6p2DwIdtNM0dk4k,516
+myosotis_researches/CcGAN/utils/concat_image.py,sha256=BIGKz52Inn9S7M5fBFKye2V9bLJ0DqEQILoOVWAXUiE,2165
+myosotis_researches/CcGAN/utils/make_h5.py,sha256=VtFYjr_i-JktsEW_BvofpilcDmChRmyLykv0VvlMuY0,963
+myosotis_researches/CcGAN/utils/opts.py,sha256=pd7-wknNPBO5hWRpO3YAPmmAsPKgZUUpKc4gWMs6Wto,5397
+myosotis_researches/CcGAN/utils/print_hdf5.py,sha256=VvmNAWtMDmg6D9V6ZbSUXrQTKRh9WIJeC4BR_ORJkco,300
+myosotis_researches/CcGAN/utils/train.py,sha256=5ZXgkGesuInqUooJRpLej_KHqYQtlSDq90_5wig5elQ,5152
+myosotis_researches/CcGAN/visualize/__init__.py,sha256=RHfzFo7FgcJhZVQ9DkEIGELK-lQNC5X915kPH8XGSiM,85
+myosotis_researches/CcGAN/visualize/visualize_datasets.py,sha256=NcrszJon9mFtffMyIR8SJyxl-ZXWWEutFcViXzpn5e0,2533
+myosotis_researches-0.1.11.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+myosotis_researches-0.1.11.dist-info/METADATA,sha256=e7evcqF20wMz7S5Ls1oBSzK1uJ-FWAy47Auvix01MMc,2664
+myosotis_researches-0.1.11.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+myosotis_researches-0.1.11.dist-info/top_level.txt,sha256=zxAiMn5eyZNJM28MewTAkgi_RZJMbfWbzVR-KF0LdZE,20
+myosotis_researches-0.1.11.dist-info/RECORD,,