update mobilenet_block

paddleslim/nas/search_space/mobilenet_block.py

@@ -38,6 +38,7 @@ class MobileNetV2BlockSpace(SearchSpaceBase):
         super(MobileNetV2BlockSpace, self).__init__(input_size, output_size,
                                                     block_num, block_mask)
 
+        if self.block_mask == None:
             # use input_size and output_size to compute self.downsample_num
             self.downsample_num = compute_downsample_num(self.input_size, self.output_size)
         if self.block_num != None:
@@ -111,12 +112,23 @@ class MobileNetV2BlockSpace(SearchSpaceBase):
                     self.bottleneck_params_list.append(self.mutiply[tokens[j * 4], self.filter_num[tokens[j * 4 + 1]],
                                self.repeat[tokens[j * 4 + 2]], 1, self.k_size[tokens[j * 4 + 3]])
 
-        def net_arch(input, return_mid_layer=False):
+        def net_arch(input, return_mid_layer=False, return_block=[]):
+            assert isinstance(return_block, list), 'return_block must be a list.'
             # all padding is 'SAME' in the conv2d, can compute the actual padding automatic. 
             # bottleneck sequences
             in_c = int(32 * self.scale)
+            mid_layer = dict()
+            layer_count = 0
+            depthwise_conv = None
+
             for i, layer_setting in enumerate(self.bottleneck_params_list):
                 t, c, n, s, k = layer_setting
+
+                if s == 2:
+                    layer_count += 1
+                if (layer_count - 1) in return_block:
+                    mid_layer[layer_count] = depthwise_conv
+
                 input, depthwise_conv = self._invresi_blocks(
                     input=input,
                     in_c=in_c,
@@ -129,7 +141,7 @@ class MobileNetV2BlockSpace(SearchSpaceBase):
                 in_c = int(c * self.scale)
 
             if return_mid_layer:
-                return input, depthwise_conv
+                return input, mid_layer
             else:
                 return input,
 
@@ -309,12 +321,19 @@ class MobileNetV1BlockSpace(SearchSpaceBase):
                     self.bottleneck_params_list.append(self.filter_num[tokens[j * 3], self.filter_num[tokens[j * 3 + 1]],
                                1, self.k_size[tokens[j * 3 + 2]])
 
-        def net_arch(input, return_mid_layer=False):
 
+        def net_arch(input, return_mid_layer=False, return_block=[]):
+            assert isinstance(return_block, list), 'return_block must be a list.'
+            mid_layer = dict()
+            layer_count = 0
             
-        def net_arch(input):
             for i, layer_setting in enumerate(self.bottleneck_params_list):
                 filter_num1, filter_num2, stride, kernel_size = layer_setting
+                if stride == 2:
+                    layer_count += 1
+                if (layer_count - 1) in return_block:
+                    mid_layer[layer_count] = input
+
                 input = self._depthwise_separable(
                     input=input,
                     num_filters1=filter_num1,
@@ -324,6 +343,9 @@ class MobileNetV1BlockSpace(SearchSpaceBase):
                     scale=self.scale,
                     kernel_size=kernel_size,
                     name='mobilenetv1_{}'.format(str(i + 1)))
+            if return_mid_layer:
+                return input, mid_layer
+            else:
                 return input
 
         return net_arch

paddleslim/nas/search_space/search_space_base.py

@@ -31,8 +31,8 @@ class SearchSpaceBase(object):
                 "If block_mask is NOT None, we will use block_mask as major configs!"
             )
             self.block_num = None
-        if self.block_mask == None and self.block_num == None:
-            print("block_mask and block num can NOT be None at the same time!")
+        if self.block_mask == None and (self.block_num == None or self.input_size == None or self.output_size == None):
+            print("block_mask and (block num or input_size or output_size) can NOT be None at the same time!")
 
     def init_tokens(self):
         """Get init tokens in search space.