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

myosotis_researches/CcGAN/models_256/ResNet_regre_eval.py

@@ -1,178 +0,0 @@
-'''
-codes are based on
-@article{
-zhang2018mixup,
-title={mixup: Beyond Empirical Risk Minimization},
-author={Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, David Lopez-Paz},
-journal={International Conference on Learning Representations},
-year={2018},
-url={https://openreview.net/forum?id=r1Ddp1-Rb},
-}
-'''
-
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-NC = 3
-IMG_SIZE = 256
-
-
-class BasicBlock(nn.Module):
-    expansion = 1
-
-    def __init__(self, in_planes, planes, stride=1):
-        super(BasicBlock, self).__init__()
-        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
-        self.bn1 = nn.BatchNorm2d(planes)
-        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
-        self.bn2 = nn.BatchNorm2d(planes)
-
-        self.shortcut = nn.Sequential()
-        if stride != 1 or in_planes != self.expansion*planes:
-            self.shortcut = nn.Sequential(
-                nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False),
-                nn.BatchNorm2d(self.expansion*planes)
-            )
-
-    def forward(self, x):
-        out = F.relu(self.bn1(self.conv1(x)))
-        out = self.bn2(self.conv2(out))
-        out += self.shortcut(x)
-        out = F.relu(out)
-        return out
-
-
-class Bottleneck(nn.Module):
-    expansion = 4
-
-    def __init__(self, in_planes, planes, stride=1):
-        super(Bottleneck, self).__init__()
-        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
-        self.bn1 = nn.BatchNorm2d(planes)
-        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
-        self.bn2 = nn.BatchNorm2d(planes)
-        self.conv3 = nn.Conv2d(planes, self.expansion*planes, kernel_size=1, bias=False)
-        self.bn3 = nn.BatchNorm2d(self.expansion*planes)
-
-        self.shortcut = nn.Sequential()
-        if stride != 1 or in_planes != self.expansion*planes:
-            self.shortcut = nn.Sequential(
-                nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False),
-                nn.BatchNorm2d(self.expansion*planes)
-            )
-
-    def forward(self, x):
-        out = F.relu(self.bn1(self.conv1(x)))
-        out = F.relu(self.bn2(self.conv2(out)))
-        out = self.bn3(self.conv3(out))
-        out += self.shortcut(x)
-        out = F.relu(out)
-        return out
-
-
-class ResNet_regre_eval(nn.Module):
-    def __init__(self, block, num_blocks, nc=NC, ngpu = 1, feature_layer='f3'):
-        super(ResNet_regre_eval, self).__init__()
-        self.in_planes = 64
-        self.ngpu = ngpu
-        self.feature_layer=feature_layer
-
-        self.block1 = nn.Sequential(
-            nn.Conv2d(nc, 64, kernel_size=3, stride=1, padding=1, bias=False),  # h=h
-            nn.BatchNorm2d(64),
-            nn.ReLU(),
-            nn.MaxPool2d(2,2), #h=h/2 128
-            self._make_layer(block, 64, num_blocks[0], stride=2),  # h=h/2 64
-        )
-        self.block2 = nn.Sequential(
-            nn.MaxPool2d(2,2), #h=h/2 32
-            self._make_layer(block, 128, num_blocks[1], stride=2) # h=h/2 16
-        )
-        self.block3 = self._make_layer(block, 256, num_blocks[2], stride=2) # h=h/2 8
-        self.block4 = self._make_layer(block, 512, num_blocks[3], stride=2) # h=h/2 4
-
-        self.pool1 = nn.AvgPool2d(kernel_size=4)
-        if self.feature_layer == 'f2':
-            self.pool2 = nn.AdaptiveAvgPool2d((2,2))
-        elif self.feature_layer == 'f3':
-            self.pool2 = nn.AdaptiveAvgPool2d((2,2))
-        else:
-            self.pool2 = nn.AdaptiveAvgPool2d((1,1))
-
-        linear_layers = [
-                nn.Linear(512*block.expansion, 128),
-                nn.BatchNorm1d(128),
-                nn.ReLU(),
-                nn.Linear(128, 128),
-                nn.BatchNorm1d(128),
-                nn.ReLU(),
-                nn.Linear(128, 1),
-                # nn.Sigmoid()
-                nn.ReLU(),
-            ]
-        self.linear = nn.Sequential(*linear_layers)
-
-
-    def _make_layer(self, block, planes, num_blocks, stride):
-        strides = [stride] + [1]*(num_blocks-1)
-        layers = []
-        for stride in strides:
-            layers.append(block(self.in_planes, planes, stride))
-            self.in_planes = planes * block.expansion
-        return nn.Sequential(*layers)
-
-    def forward(self, x):
-
-        if x.is_cuda and self.ngpu > 1:
-            ft1 = nn.parallel.data_parallel(self.block1, x, range(self.ngpu))
-            ft2 = nn.parallel.data_parallel(self.block2, ft1, range(self.ngpu))
-            ft3 = nn.parallel.data_parallel(self.block3, ft2, range(self.ngpu))
-            ft4 = nn.parallel.data_parallel(self.block4, ft3, range(self.ngpu))
-            out = nn.parallel.data_parallel(self.pool1, ft4, range(self.ngpu))
-            out = out.view(out.size(0), -1)
-            out = nn.parallel.data_parallel(self.linear, out, range(self.ngpu))
-        else:
-            ft1 = self.block1(x)
-            ft2 = self.block2(ft1)
-            ft3 = self.block3(ft2)
-            ft4 = self.block4(ft3)
-            out = self.pool1(ft4)
-            out = out.view(out.size(0), -1)
-            out = self.linear(out)
-
-        if self.feature_layer == 'f2':
-            ext_features = self.pool2(ft2)
-        elif self.feature_layer == 'f3':
-            ext_features = self.pool2(ft3)
-        else:
-            ext_features = self.pool2(ft4)
-
-        ext_features = ext_features.view(ext_features.size(0), -1)
-
-        return out, ext_features
-
-
-def ResNet18_regre_eval(ngpu = 1):
-    return ResNet_regre_eval(BasicBlock, [2,2,2,2], ngpu = ngpu)
-
-def ResNet34_regre_eval(ngpu = 1):
-    return ResNet_regre_eval(BasicBlock, [3,4,6,3], ngpu = ngpu)
-
-def ResNet50_regre_eval(ngpu = 1):
-    return ResNet_regre_eval(Bottleneck, [3,4,6,3], ngpu = ngpu)
-
-def ResNet101_regre_eval(ngpu = 1):
-    return ResNet_regre_eval(Bottleneck, [3,4,23,3], ngpu = ngpu)
-
-def ResNet152_regre_eval(ngpu = 1):
-    return ResNet_regre_eval(Bottleneck, [3,8,36,3], ngpu = ngpu)
-
-
-if __name__ == "__main__":
-    net = ResNet34_regre_eval(ngpu = 1).cuda()
-    x = torch.randn(4,NC,IMG_SIZE,IMG_SIZE).cuda()
-    out, features = net(x)
-    print(out.size())
-    print(features.size())

myosotis_researches/CcGAN/models_256/__init__.py

@@ -1,7 +0,0 @@
-from .autoencoder import *
-from .cGAN_SAGAN import cGAN_SAGAN_Generator, cGAN_SAGAN_Discriminator
-from .cGAN_concat_SAGAN import cGAN_concat_SAGAN_Generator, cGAN_concat_SAGAN_Discriminator
-from .CcGAN_SAGAN import CcGAN_SAGAN_Generator, CcGAN_SAGAN_Discriminator
-from .ResNet_embed import ResNet18_embed, ResNet34_embed, ResNet50_embed, model_y2h
-from .ResNet_regre_eval import ResNet34_regre_eval
-from .ResNet_class_eval import ResNet34_class_eval

myosotis_researches/CcGAN/models_256/autoencoder.py

@@ -1,133 +0,0 @@
-import torch
-from torch import nn
-
-
-
-class encoder(nn.Module):
-    def __init__(self, dim_bottleneck=512, ch=64):
-        super(encoder, self).__init__()
-        self.ch = ch
-        self.dim_bottleneck = dim_bottleneck
-
-        self.conv = nn.Sequential(
-            nn.Conv2d(3, ch, kernel_size=4, stride=2, padding=1), #h=h/2; 128
-            nn.BatchNorm2d(ch),
-            nn.ReLU(),
-            nn.MaxPool2d(2,2), #h=h/2; 64
-            nn.Conv2d(ch, ch, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch),
-            nn.ReLU(),
-
-            nn.Conv2d(ch, ch, kernel_size=4, stride=2, padding=1), #h=h/2; 32
-            nn.BatchNorm2d(ch),
-            nn.ReLU(),
-            nn.Conv2d(ch, ch*2, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*2),
-            nn.ReLU(),
-
-            nn.Conv2d(ch*2, ch*2, kernel_size=4, stride=2, padding=1), #h=h/2; 16
-            nn.BatchNorm2d(ch*2),
-            nn.ReLU(),
-            nn.Conv2d(ch*2, ch*4, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*4),
-            nn.ReLU(),
-
-            nn.Conv2d(ch*4, ch*4, kernel_size=4, stride=2, padding=1), #h=h/2; 8
-            nn.BatchNorm2d(ch*4),
-            nn.ReLU(),
-            nn.Conv2d(ch*4, ch*8, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*8),
-            nn.ReLU(),
-
-            nn.Conv2d(ch*8, ch*8, kernel_size=4, stride=2, padding=1), #h=h/2; 4
-            nn.BatchNorm2d(ch*8),
-            nn.ReLU(),
-            nn.Conv2d(ch*8, ch*16, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*16),
-            nn.ReLU(),
-        )
-
-        self.linear = nn.Sequential(
-            nn.Linear(ch*16*4*4, dim_bottleneck),
-            # nn.ReLU()
-        )
-
-    def forward(self, x):
-        feature = self.conv(x)
-        feature = feature.view(-1, self.ch*16*4*4)
-        feature = self.linear(feature)
-        return feature
-
-
-
-class decoder(nn.Module):
-    def __init__(self, dim_bottleneck=512, ch=64):
-        super(decoder, self).__init__()
-        self.ch = ch
-        self.dim_bottleneck = dim_bottleneck
-
-        self.linear = nn.Sequential(
-            nn.Linear(dim_bottleneck, ch*16*4*4)
-        )
-
-        self.deconv = nn.Sequential(
-            nn.ConvTranspose2d(ch*16, ch*16, kernel_size=4, stride=2, padding=1), #h=2h; 8
-            nn.BatchNorm2d(ch*16),
-            nn.ReLU(True),
-            nn.Conv2d(ch*16, ch*8, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*8),
-            nn.ReLU(),
-
-            nn.ConvTranspose2d(ch*8, ch*8, kernel_size=4, stride=2, padding=1), #h=2h; 16
-            nn.BatchNorm2d(ch*8),
-            nn.ReLU(True),
-            nn.Conv2d(ch*8, ch*4, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*4),
-            nn.ReLU(),
-
-            nn.ConvTranspose2d(ch*4, ch*4, kernel_size=4, stride=2, padding=1), #h=2h; 32
-            nn.BatchNorm2d(ch*4),
-            nn.ReLU(True),
-            nn.Conv2d(ch*4, ch*2, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*2),
-            nn.ReLU(),
-
-            nn.ConvTranspose2d(ch*2, ch*2, kernel_size=4, stride=2, padding=1), #h=2h; 64
-            nn.BatchNorm2d(ch*2),
-            nn.ReLU(True),
-            nn.Conv2d(ch*2, ch, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch),
-            nn.ReLU(),
-
-            nn.ConvTranspose2d(ch, ch, kernel_size=4, stride=2, padding=1), #h=2h; 128
-            nn.BatchNorm2d(ch),
-            nn.ReLU(True),
-            nn.Conv2d(ch, ch, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch),
-            nn.ReLU(),
-
-            nn.ConvTranspose2d(ch, ch, kernel_size=4, stride=2, padding=1), #h=2h; 256
-            nn.BatchNorm2d(ch),
-            nn.ReLU(True),
-            nn.Conv2d(ch, 3, kernel_size=3, stride=1, padding=1), #h=h
-            nn.Tanh()
-        )
-
-    def forward(self, feature):
-        out = self.linear(feature)
-        out = out.view(-1, self.ch*16, 4, 4)
-        out = self.deconv(out)
-        return out
-
-
-if __name__=="__main__":
-    #test
-
-    net_encoder = encoder(dim_bottleneck=512, ch=64).cuda()
-    net_decoder = decoder(dim_bottleneck=512, ch=64).cuda()
-
-    x = torch.randn(10, 3, 256, 256).cuda()
-    f = net_encoder(x)
-    xh = net_decoder(f)
-    print(f.size())
-    print(xh.size())

myosotis_researches/CcGAN/models_256/cGAN_SAGAN.py

@@ -1,280 +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 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())