Myosotis-Researches 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

myosotis_researches/CcGAN/models_256/ResNet_embed.py

@@ -0,0 +1,188 @@
+'''
+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 = 256
+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 256
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            nn.MaxPool2d(2,2), #h=h/2 128
+            # 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 64
+            nn.MaxPool2d(2,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_256/ResNet_regre_eval.py

@@ -0,0 +1,178 @@
+'''
+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

@@ -0,0 +1,8 @@
+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

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