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

myosotis_researches/CcGAN/models_128/ResNet_embed.py

@@ -1,188 +0,0 @@
-'''
-ResNet-based model to map an image from pixel space to a features space.
-Need to be pretrained on the dataset.
-
-if isometric_map = True, there is an extra step (elf.classifier_1 = nn.Linear(512, 32*32*3)) to increase the dimension of the feature map from 512 to 32*32*3. This selection is for desity-ratio estimation in feature space.
-
-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 = 128
-DIM_EMBED = 128
-
-
-#------------------------------------------------------------------------------
-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_embed(nn.Module):
-    def __init__(self, block, num_blocks, nc=NC, dim_embed=DIM_EMBED):
-        super(ResNet_embed, self).__init__()
-        self.in_planes = 64
-
-        self.main = nn.Sequential(
-            nn.Conv2d(nc, 64, kernel_size=3, stride=1, padding=1, bias=False),  # h=h
-            # nn.Conv2d(nc, 64, kernel_size=4, stride=2, padding=1, bias=False),  # h=h/2
-            nn.BatchNorm2d(64),
-            nn.ReLU(),
-            nn.MaxPool2d(2,2), #h=h/2 64
-            # self._make_layer(block, 64, num_blocks[0], stride=1),  # h=h
-            self._make_layer(block, 64, num_blocks[0], stride=2),  # h=h/2 32
-            self._make_layer(block, 128, num_blocks[1], stride=2), # h=h/2 16
-            self._make_layer(block, 256, num_blocks[2], stride=2), # h=h/2 8
-            self._make_layer(block, 512, num_blocks[3], stride=2), # h=h/2 4
-            # nn.AvgPool2d(kernel_size=4)
-            nn.AdaptiveAvgPool2d((1, 1))
-        )
-
-        self.x2h_res = nn.Sequential(
-            nn.Linear(512, 512),
-            nn.BatchNorm1d(512),
-            nn.ReLU(),
-
-            nn.Linear(512, dim_embed),
-            nn.BatchNorm1d(dim_embed),
-            nn.ReLU(),
-        )
-
-        self.h2y = nn.Sequential(
-            nn.Linear(dim_embed, 1),
-            nn.ReLU()
-        )
-
-    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):
-
-        features = self.main(x)
-        features = features.view(features.size(0), -1)
-        features = self.x2h_res(features)
-        out = self.h2y(features)
-
-        return out, features
-
-
-def ResNet18_embed(dim_embed=DIM_EMBED):
-    return ResNet_embed(BasicBlock, [2,2,2,2], dim_embed=dim_embed)
-
-def ResNet34_embed(dim_embed=DIM_EMBED):
-    return ResNet_embed(BasicBlock, [3,4,6,3], dim_embed=dim_embed)
-
-def ResNet50_embed(dim_embed=DIM_EMBED):
-    return ResNet_embed(Bottleneck, [3,4,6,3], dim_embed=dim_embed)
-
-#------------------------------------------------------------------------------
-# map labels to the embedding space
-class model_y2h(nn.Module):
-    def __init__(self, dim_embed=DIM_EMBED):
-        super(model_y2h, self).__init__()
-        self.main = nn.Sequential(
-            nn.Linear(1, dim_embed),
-            # nn.BatchNorm1d(dim_embed),
-            nn.GroupNorm(8, dim_embed),
-            nn.ReLU(),
-
-            nn.Linear(dim_embed, dim_embed),
-            # nn.BatchNorm1d(dim_embed),
-            nn.GroupNorm(8, dim_embed),
-            nn.ReLU(),
-
-            nn.Linear(dim_embed, dim_embed),
-            # nn.BatchNorm1d(dim_embed),
-            nn.GroupNorm(8, dim_embed),
-            nn.ReLU(),
-
-            nn.Linear(dim_embed, dim_embed),
-            # nn.BatchNorm1d(dim_embed),
-            nn.GroupNorm(8, dim_embed),
-            nn.ReLU(),
-
-            nn.Linear(dim_embed, dim_embed),
-            nn.ReLU()
-        )
-
-    def forward(self, y):
-        y = y.view(-1, 1) +1e-8
-        # y = torch.exp(y.view(-1, 1))
-        return self.main(y)
-
-
-
-if __name__ == "__main__":
-    net = ResNet34_embed(dim_embed=128).cuda()
-    x = torch.randn(16,NC,IMG_SIZE,IMG_SIZE).cuda()
-    out, features = net(x)
-    print(out.size())
-    print(features.size())
-
-    net_y2h = model_y2h()

myosotis_researches/CcGAN/models_128/ResNet_regre_eval.py

@@ -1,175 +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 = 128
-
-
-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 64
-            self._make_layer(block, 64, num_blocks[0], stride=2),  # h=h/2 32
-        )
-        self.block2 = 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_128/__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_128/autoencoder.py

@@ -1,119 +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; 64
-            nn.BatchNorm2d(ch),
-            nn.ReLU(),
-            nn.MaxPool2d(2,2), #h=h/2; 32
-            nn.Conv2d(ch, ch, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch),
-            nn.ReLU(),
-
-            nn.Conv2d(ch, ch*2, kernel_size=4, stride=2, padding=1), #h=h/2; 16
-            nn.BatchNorm2d(ch*2),
-            nn.ReLU(),
-            nn.Conv2d(ch*2, ch*2, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*2),
-            nn.ReLU(),
-
-            nn.Conv2d(ch*2, ch*4, kernel_size=4, stride=2, padding=1), #h=h/2; 8
-            nn.BatchNorm2d(ch*4),
-            nn.ReLU(),
-            nn.Conv2d(ch*4, ch*4, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*4),
-            nn.ReLU(),
-
-            nn.Conv2d(ch*4, ch*8, kernel_size=4, stride=2, padding=1), #h=h/2; 4
-            nn.BatchNorm2d(ch*8),
-            nn.ReLU(),
-            nn.Conv2d(ch*8, ch*8, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*8),
-            nn.ReLU(),
-        )
-
-        self.linear = nn.Sequential(
-            nn.Linear(ch*8*4*4, dim_bottleneck),
-            # nn.ReLU()
-        )
-
-    def forward(self, x):
-        feature = self.conv(x)
-        feature = feature.view(-1, self.ch*8*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*8, kernel_size=4, stride=2, padding=1), #h=2h; 8
-            nn.BatchNorm2d(ch*8),
-            nn.ReLU(True),
-            nn.Conv2d(ch*8, ch*8, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*8),
-            nn.ReLU(),
-
-            nn.ConvTranspose2d(ch*8, ch*4, kernel_size=4, stride=2, padding=1), #h=2h; 16
-            nn.BatchNorm2d(ch*4),
-            nn.ReLU(True),
-            nn.Conv2d(ch*4, ch*4, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*4),
-            nn.ReLU(),
-
-            nn.ConvTranspose2d(ch*4, ch*2, kernel_size=4, stride=2, padding=1), #h=2h; 32
-            nn.BatchNorm2d(ch*2),
-            nn.ReLU(True),
-            nn.Conv2d(ch*2, ch*2, kernel_size=3, stride=1, padding=1), #h=h
-            nn.BatchNorm2d(ch*2),
-            nn.ReLU(),
-
-            nn.ConvTranspose2d(ch*2, ch, kernel_size=4, stride=2, padding=1), #h=2h; 64
-            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; 128
-            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, 128, 128).cuda()
-    f = net_encoder(x)
-    xh = net_decoder(f)
-    print(f.size())
-    print(xh.size())