updtead to solution 2

Author: minerva-ml

README.md

@@ -25,6 +25,7 @@ In this open source solution you will find references to the [neptune.ml](https:
 | link to code | CV | LB |
 |:---:|:---:|:---:|
 |solution 1|0.541|0.573|
+|solution 2|0.661|0.679|
 
 ## Start experimenting with ready-to-use code
 You can jump start your participation in the competition by using our starter pack. Installation instruction below will guide you through the setup.

common_blocks/architectures/classification.py

@@ -0,0 +1,16 @@
+import torch.nn as nn
+from torchvision.models import resnet101
+
+
+class Resnet101(nn.Module):
+    def __init__(self, pretrained):
+        super().__init__()
+        self.model = resnet101(pretrained=pretrained)
+        for p in self.model.parameters():
+            p.requires_grad = False
+        self.model.fc = nn.Linear(in_features=self.model.fc.in_features, out_features=1)
+        self.model.avgpool = nn.AdaptiveAvgPool2d(1)
+
+    def forward(self, input):
+        x = self.model(input)
+        return x.squeeze()

common_blocks/architectures/encoders.py

@@ -1,3 +1,7 @@
+from copy import deepcopy
+
+import torch
+from torch.autograd import Variable
 from torch import nn
 import torchvision
 import pretrainedmodels
@@ -93,11 +97,12 @@ def __init__(self, encoder_depth, pretrained='imagenet', pool0=False):
             self.encoder = pretrainedmodels.__dict__['se_resnext101_32x4d'](num_classes=1000, pretrained=pretrained)
         else:
             raise NotImplementedError('only 50, 101 version of Resnet are implemented')
+
         if pool0:
             self.conv1 = nn.Sequential(self.encoder.layer0.conv1,
                                        self.encoder.layer0.bn1,
                                        self.encoder.layer0.relu1,
-                                       self.encoder.layer0.pool0)
+                                       self.encoder.layer0.pool)
         else:
             self.conv1 = nn.Sequential(self.encoder.layer0.conv1,
                                        self.encoder.layer0.bn1,
@@ -162,3 +167,14 @@ def forward(self, x):
         encoder5 = self.encoder5(transition3)
 
         return encoder2, encoder3, encoder4, encoder5
+
+
+def get_encoder_channel_nr(encoder):
+    encoder_clone = deepcopy(encoder)
+    x = Variable(torch.ones((1, 3, 256, 256)))
+    if torch.cuda.is_available():
+        encoder_clone = encoder_clone.cuda()
+        x = x.cuda()
+    encoder2, encoder3, encoder4, encoder5 = encoder_clone(x)
+    encoder_channel_nr = [encoder2.shape[1], encoder3.shape[1], encoder4.shape[1], encoder5.shape[1]]
+    return encoder_channel_nr

common_blocks/architectures/large_kernel_matters.py

@@ -2,7 +2,7 @@
 from torch.nn import functional as F
 
 from .base import GlobalConvolutionalNetwork, BoundaryRefinement, DeconvConv2dBnRelu
-from .encoders import ResNetEncoders
+from .encoders import get_encoder_channel_nr
 
 
 class LargeKernelMatters(nn.Module):
@@ -11,34 +11,29 @@ class LargeKernelMatters(nn.Module):
         https://arxiv.org/pdf/1703.02719.pdf
     """
 
-    def __init__(self, encoder_depth, num_classes, kernel_size=9, internal_channels=21, use_relu=False, pool0=False,
-                 pretrained=False, dropout_2d=0.0):
+    def __init__(self, encoder, num_classes, kernel_size=9, internal_channels=21, use_relu=False, pool0=False,
+                 dropout_2d=0.0):
         super().__init__()
 
         self.dropout_2d = dropout_2d
+        self.pool0 = pool0
 
-        self.encoders = ResNetEncoders(encoder_depth, pretrained=pretrained, pool0=pool0)
+        self.encoder = encoder
+        encoder_channel_nr = get_encoder_channel_nr(self.encoder)
 
-        if encoder_depth in [18, 34]:
-            bottom_channel_nr = 512
-        elif encoder_depth in [50, 101, 152]:
-            bottom_channel_nr = 2048
-        else:
-            raise NotImplementedError('only 18, 34, 50, 101, 152 version of Resnet are implemented')
-
-        self.gcn2 = GlobalConvolutionalNetwork(in_channels=bottom_channel_nr // 8,
+        self.gcn2 = GlobalConvolutionalNetwork(in_channels=encoder_channel_nr[0],
                                                out_channels=internal_channels,
                                                kernel_size=kernel_size,
                                                use_relu=use_relu)
-        self.gcn3 = GlobalConvolutionalNetwork(in_channels=bottom_channel_nr // 4,
+        self.gcn3 = GlobalConvolutionalNetwork(in_channels=encoder_channel_nr[1],
                                                out_channels=internal_channels,
                                                kernel_size=kernel_size,
                                                use_relu=use_relu)
-        self.gcn4 = GlobalConvolutionalNetwork(in_channels=bottom_channel_nr // 2,
+        self.gcn4 = GlobalConvolutionalNetwork(in_channels=encoder_channel_nr[2],
                                                out_channels=internal_channels,
                                                kernel_size=kernel_size,
                                                use_relu=use_relu)
-        self.gcn5 = GlobalConvolutionalNetwork(in_channels=bottom_channel_nr,
+        self.gcn5 = GlobalConvolutionalNetwork(in_channels=encoder_channel_nr[3],
                                                out_channels=internal_channels,
                                                kernel_size=kernel_size,
                                                use_relu=use_relu)
@@ -79,10 +74,18 @@ def __init__(self, encoder_depth, num_classes, kernel_size=9, internal_channels=
         self.deconv3 = DeconvConv2dBnRelu(in_channels=internal_channels, out_channels=internal_channels)
         self.deconv2 = DeconvConv2dBnRelu(in_channels=internal_channels, out_channels=internal_channels)
 
+        self.deconv1 = DeconvConv2dBnRelu(in_channels=internal_channels, out_channels=internal_channels)
+        self.dec_br0_1 = BoundaryRefinement(in_channels=internal_channels,
+                                            out_channels=internal_channels,
+                                            kernel_size=3)
+        self.dec_br0_2 = BoundaryRefinement(in_channels=internal_channels,
+                                            out_channels=internal_channels,
+                                            kernel_size=3)
+
         self.final = nn.Conv2d(internal_channels, num_classes, kernel_size=1, padding=0)
 
     def forward(self, x):
-        encoder2, encoder3, encoder4, encoder5 = self.encoders(x)
+        encoder2, encoder3, encoder4, encoder5 = self.encoder(x)
         encoder5 = F.dropout2d(encoder5, p=self.dropout_2d)
 
         gcn2 = self.enc_br2(self.gcn2(encoder2))
@@ -95,4 +98,7 @@ def forward(self, x):
         decoder3 = self.deconv3(self.dec_br3(decoder4 + gcn3))
         decoder2 = self.dec_br1(self.deconv2(self.dec_br2(decoder3 + gcn2)))
 
+        if self.pool0:
+            decoder2 = self.dec_br0_2(self.deconv1(self.dec_br0_1(decoder2)))
+
         return self.final(decoder2)

common_blocks/architectures/pspnet.py

@@ -3,7 +3,7 @@
 import torch
 
 from .base import Conv2dBnRelu
-from .encoders import ResNetEncoders
+from .encoders import get_encoder_channel_nr
 
 
 class PSPModule(nn.Module):
@@ -42,48 +42,43 @@ def forward(self, x):
 
 class PSPNet(nn.Module):
     def __init__(self,
-                 encoder_depth,
+                 encoder,
                  num_classes=2,
                  sizes=(1, 2, 3, 6),
-                 deep_features_size=1024,
                  dropout_2d=0.2,
-                 pretrained=False,
                  use_hypercolumn=False,
                  pool0=False):
         super().__init__()
         self.num_classes = num_classes
         self.dropout_2d = dropout_2d
         self.use_hypercolumn = use_hypercolumn
+        self.pool0 = pool0
 
-        self.encoders = ResNetEncoders(encoder_depth, pretrained=pretrained, pool0=pool0)
+        self.encoder = encoder
+        encoder_channel_nr = get_encoder_channel_nr(self.encoder)
+        bottom_channel_nr = encoder_channel_nr[3]
 
-        if encoder_depth in [18, 34]:
-            bottom_channel_nr = 512
-        elif encoder_depth in [50, 101, 152]:
-            bottom_channel_nr = 2048
-        else:
-            raise NotImplementedError('only 18, 34, 50, 101, 152 version of Resnet are implemented')
-
-        self.psp = PSPModule(bottom_channel_nr, deep_features_size, sizes)
+        self.psp = PSPModule(bottom_channel_nr, bottom_channel_nr, sizes)
 
-        self.up4 = PSPUpsample(deep_features_size, deep_features_size // 2)
-        self.up3 = PSPUpsample(deep_features_size // 2, deep_features_size // 4)
-        self.up2 = PSPUpsample(deep_features_size // 4, deep_features_size // 8)
-        self.up1 = PSPUpsample(deep_features_size // 8, deep_features_size // 16)
+        self.up4 = PSPUpsample(bottom_channel_nr, bottom_channel_nr // 2)
+        self.up3 = PSPUpsample(bottom_channel_nr // 2, bottom_channel_nr // 4)
+        self.up2 = PSPUpsample(bottom_channel_nr // 4, bottom_channel_nr // 8)
+        self.up1 = PSPUpsample(bottom_channel_nr // 8, bottom_channel_nr // 16)
 
         if self.use_hypercolumn:
-            self.final = nn.Sequential(Conv2dBnRelu(15 * bottom_channel_nr // 8, bottom_channel_nr // 8),
-                                       nn.Conv2d(bottom_channel_nr // 8, num_classes, kernel_size=1, padding=0))
+            self.up0 = PSPUpsample(15 * bottom_channel_nr // 16, 15 * bottom_channel_nr // 16)
+            self.final = nn.Sequential(Conv2dBnRelu(15 * bottom_channel_nr // 16, bottom_channel_nr // 16),
+                                       nn.Conv2d(bottom_channel_nr // 16, num_classes, kernel_size=1, padding=0))
         else:
-            self.final = nn.Sequential(Conv2dBnRelu(bottom_channel_nr // 8, bottom_channel_nr // 8),
-                                       nn.Conv2d(bottom_channel_nr // 8, num_classes, kernel_size=1, padding=0))
+            self.up0 = PSPUpsample(bottom_channel_nr // 16, bottom_channel_nr // 16)
+            self.final = nn.Sequential(Conv2dBnRelu(bottom_channel_nr // 16, bottom_channel_nr // 16),
+                                       nn.Conv2d(bottom_channel_nr // 16, num_classes, kernel_size=1, padding=0))
 
     def forward(self, x):
-        encoder2, encoder3, encoder4, encoder5 = self.encoders(x)
+        encoder2, encoder3, encoder4, encoder5 = self.encoder(x)
         encoder5 = F.dropout2d(encoder5, p=self.dropout_2d)
 
         psp = self.psp(encoder5)
-
         up4 = self.up4(psp)
         up3 = self.up3(up4)
         up2 = self.up2(up3)
@@ -96,5 +91,8 @@ def forward(self, x):
                                      ], 1)
             drop = F.dropout2d(hypercolumn, p=self.dropout_2d)
         else:
-            drop = F.dropout2d(up4, p=self.dropout_2d)
-        return self.final(drop)
+            drop = F.dropout2d(up1, p=self.dropout_2d)
+
+        if self.pool0:
+            drop = self.up0(drop)
+        return self.final(drop)