Dilation for Fully Convolutional Networks

efficientnet_pytorch/model.py

@@ -47,9 +47,12 @@ def __init__(self, block_args, global_params):
         # Depthwise convolution phase
         k = self._block_args.kernel_size
         s = self._block_args.stride
+        d = self._block_args.dilation
+        if d is None:
+            d = 1
         self._depthwise_conv = Conv2d(
             in_channels=oup, out_channels=oup, groups=oup,  # groups makes it depthwise
-            kernel_size=k, stride=s, bias=False)
+            kernel_size=k, stride=s, bias=False, dilation=d)
         self._bn1 = nn.BatchNorm2d(num_features=oup, momentum=self._bn_mom, eps=self._bn_eps)
 
         # Squeeze and Excitation layer, if desired
@@ -131,21 +134,35 @@ def __init__(self, blocks_args=None, global_params=None):
         self._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False)
         self._bn0 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps)
 
+        dilate_count = 0
+        dilations = []
+        # determine blocks to dilate from last to first
+        for block_args in reversed(self._blocks_args):
+            if (block_args.stride == [2] or block_args.stride == [2, 2]) and dilate_count < self._global_params.num_dilation:
+                dilations += [True]
+                dilate_count += 1
+            else:
+                dilations += [False]
+        # Organize from first to last
+        dilations.reverse()
+
         # Build blocks
         self._blocks = nn.ModuleList([])
-        for block_args in self._blocks_args:
-
+        for block_args, dilate in zip(self._blocks_args, dilations):
+            
             # Update block input and output filters based on depth multiplier.
             block_args = block_args._replace(
                 input_filters=round_filters(block_args.input_filters, self._global_params),
                 output_filters=round_filters(block_args.output_filters, self._global_params),
-                num_repeat=round_repeats(block_args.num_repeat, self._global_params)
+                num_repeat=round_repeats(block_args.num_repeat, self._global_params),
+                stride=[1, 1] if dilate else block_args.stride,
+                dilation=[2, 2] if dilate else block_args.dilation
             )
 
             # The first block needs to take care of stride and filter size increase.
             self._blocks.append(MBConvBlock(block_args, self._global_params))
             if block_args.num_repeat > 1:
-                block_args = block_args._replace(input_filters=block_args.output_filters, stride=1)
+                block_args = block_args._replace(input_filters=block_args.output_filters, stride=1, dilation=1)
             for _ in range(block_args.num_repeat - 1):
                 self._blocks.append(MBConvBlock(block_args, self._global_params))
 
@@ -206,8 +223,8 @@ def from_name(cls, model_name, override_params=None):
         return cls(blocks_args, global_params)
 
     @classmethod
-    def from_pretrained(cls, model_name, num_classes=1000, in_channels = 3):
-        model = cls.from_name(model_name, override_params={'num_classes': num_classes})
+    def from_pretrained(cls, model_name, num_classes=1000, in_channels=3, num_dilation=0):
+        model = cls.from_name(model_name, override_params={'num_classes': num_classes, 'num_dilation': num_dilation})
         load_pretrained_weights(model, model_name, load_fc=(num_classes == 1000))
         if in_channels != 3:
             Conv2d = get_same_padding_conv2d(image_size = model._global_params.image_size)
@@ -216,8 +233,8 @@ def from_pretrained(cls, model_name, num_classes=1000, in_channels = 3):
         return model
 
     @classmethod
-    def from_pretrained(cls, model_name, num_classes=1000):
-        model = cls.from_name(model_name, override_params={'num_classes': num_classes})
+    def from_pretrained(cls, model_name, num_classes=1000, num_dilation=0):
+        model = cls.from_name(model_name, override_params={'num_classes': num_classes, 'num_dilation': num_dilation})
         load_pretrained_weights(model, model_name, load_fc=(num_classes == 1000))
 
         return model

efficientnet_pytorch/utils.py

@@ -21,12 +21,12 @@
 GlobalParams = collections.namedtuple('GlobalParams', [
     'batch_norm_momentum', 'batch_norm_epsilon', 'dropout_rate',
     'num_classes', 'width_coefficient', 'depth_coefficient',
-    'depth_divisor', 'min_depth', 'drop_connect_rate', 'image_size'])
+    'depth_divisor', 'min_depth', 'drop_connect_rate', 'image_size', 'num_dilation'])
 
 # Parameters for an individual model block
 BlockArgs = collections.namedtuple('BlockArgs', [
     'kernel_size', 'num_repeat', 'input_filters', 'output_filters',
-    'expand_ratio', 'id_skip', 'stride', 'se_ratio'])
+    'expand_ratio', 'id_skip', 'stride', 'se_ratio', 'dilation'])
 
 # Change namedtuple defaults
 GlobalParams.__new__.__defaults__ = (None,) * len(GlobalParams._fields)
@@ -202,7 +202,8 @@ def _decode_block_string(block_string):
             expand_ratio=int(options['e']),
             id_skip=('noskip' not in block_string),
             se_ratio=float(options['se']) if 'se' in options else None,
-            stride=[int(options['s'][0])])
+            stride=[int(options['s'][0])],
+            dilation=[int(options['d'][0]), int(options['d'][1])] if 'd' in options else [1, 1])
 
     @staticmethod
     def _encode_block_string(block):
@@ -213,7 +214,8 @@ def _encode_block_string(block):
             's%d%d' % (block.strides[0], block.strides[1]),
             'e%s' % block.expand_ratio,
             'i%d' % block.input_filters,
-            'o%d' % block.output_filters
+            'o%d' % block.output_filters,
+            'd%d%d' % (block.dilation[0], block.dilation[1]),
         ]
         if 0 < block.se_ratio <= 1:
             args.append('se%s' % block.se_ratio)
@@ -250,7 +252,7 @@ def encode(blocks_args):
 
 
 def efficientnet(width_coefficient=None, depth_coefficient=None, dropout_rate=0.2,
-                 drop_connect_rate=0.2, image_size=None, num_classes=1000):
+                 drop_connect_rate=0.2, image_size=None, num_classes=1000, num_dilation=0):
     """ Creates a efficientnet model. """
 
     blocks_args = [
@@ -273,6 +275,7 @@ def efficientnet(width_coefficient=None, depth_coefficient=None, dropout_rate=0.
         depth_divisor=8,
         min_depth=None,
         image_size=image_size,
+        num_dilation=num_dilation
     )
 
     return blocks_args, global_params

tf_to_pytorch/convert_tf_to_pt/original_tf/efficientnet_builder.py

@@ -66,7 +66,8 @@ def _decode_block_string(self, block_string):
         expand_ratio=int(options['e']),
         id_skip=('noskip' not in block_string),
         se_ratio=float(options['se']) if 'se' in options else None,
-        strides=[int(options['s'][0]), int(options['s'][1])])
+        strides=[int(options['s'][0]), int(options['s'][1])],
+        dilation=[int(options['d'][0]), int(options['d'][1])] if 'd' in options else [1, 1])
 
   def _encode_block_string(self, block):
     """Encodes a block to a string."""
@@ -76,7 +77,8 @@ def _encode_block_string(self, block):
         's%d%d' % (block.strides[0], block.strides[1]),
         'e%s' % block.expand_ratio,
         'i%d' % block.input_filters,
-        'o%d' % block.output_filters
+        'o%d' % block.output_filters,
+        'd%d%d' % (block.dilation[0], block.dilation[1]),
     ]
     if block.se_ratio > 0 and block.se_ratio <= 1:
       args.append('se%s' % block.se_ratio)
@@ -134,7 +136,8 @@ def efficientnet(width_coefficient=None,
       width_coefficient=width_coefficient,
       depth_coefficient=depth_coefficient,
       depth_divisor=8,
-      min_depth=None)
+      min_depth=None,
+      num_dilation=0)
   decoder = BlockDecoder()
   return decoder.decode(blocks_args), global_params
 

tf_to_pytorch/convert_tf_to_pt/original_tf/efficientnet_model.py

@@ -36,7 +36,7 @@
 GlobalParams = collections.namedtuple('GlobalParams', [
     'batch_norm_momentum', 'batch_norm_epsilon', 'dropout_rate', 'data_format',
     'num_classes', 'width_coefficient', 'depth_coefficient',
-    'depth_divisor', 'min_depth', 'drop_connect_rate',
+    'depth_divisor', 'min_depth', 'drop_connect_rate', 'num_dilation'
 ])
 GlobalParams.__new__.__defaults__ = (None,) * len(GlobalParams._fields)