From 51c23929d8398b32ffba8fed4510c2446e0bacba Mon Sep 17 00:00:00 2001 From: ceci3 <592712189@qq.com> Date: Thu, 5 Dec 2019 07:39:59 +0000 Subject: [PATCH] fix --- paddleslim/nas/search_space/__init__.py | 4 + .../nas/search_space/combine_search_space.py | 39 ++-- .../nas/search_space/inception_block.py | 186 +++++++++++------- .../nas/search_space/mobilenet_block.py | 7 +- paddleslim/nas/search_space/resnet_block.py | 38 ++-- 5 files changed, 166 insertions(+), 108 deletions(-) diff --git a/paddleslim/nas/search_space/__init__.py b/paddleslim/nas/search_space/__init__.py index b415930b..807f02d3 100644 --- a/paddleslim/nas/search_space/__init__.py +++ b/paddleslim/nas/search_space/__init__.py @@ -20,6 +20,10 @@ import mobilenetv1 from .mobilenetv1 import * import resnet from .resnet import * +import resnet_block +from .resnet_block import * +import inception_block +from .inception_block import * import search_space_registry from search_space_registry import * import search_space_factory diff --git a/paddleslim/nas/search_space/combine_search_space.py b/paddleslim/nas/search_space/combine_search_space.py index 2f862955..8e18060b 100644 --- a/paddleslim/nas/search_space/combine_search_space.py +++ b/paddleslim/nas/search_space/combine_search_space.py @@ -29,6 +29,7 @@ __all__ = ["CombineSearchSpace"] _logger = get_logger(__name__, level=logging.INFO) + class CombineSearchSpace(object): """ Combine Search Space. @@ -42,11 +43,13 @@ class CombineSearchSpace(object): for config_list in config_lists: if isinstance(config_list, tuple): key, config = config_list - if isinstance(config_list, str): + elif isinstance(config_list, str): key = config_list config = None else: - raise NotImplementedError('the type of config is Error!!! Please check the config information. Receive the type of config is {}'.format(type(config_list))) + raise NotImplementedError( + 'the type of config is Error!!! Please check the config information. Receive the type of config is {}'. + format(type(config_list))) self.spaces.append(self._get_single_search_space(key, config)) self.init_tokens() @@ -61,6 +64,8 @@ class CombineSearchSpace(object): model space(class) """ cls = SEARCHSPACE.get(key) + assert cls != None, '{} is NOT a correct space, the space we support is {}'.format( + key, SEARCHSPACE) if config is None: block_mask = None @@ -69,21 +74,27 @@ class CombineSearchSpace(object): block_num = None else: if 'Block' not in cls.__name__: - _logger.warn('if space is not a Block space, config is useless, current space is {}'.format(cls.__name__)) - - block_mask = config['block_mask'] if 'block_mask' in config else None - input_size = config['input_size'] if 'input_size' in config else None - output_size = config['output_size'] if 'output_size' in config else None + _logger.warn( + 'if space is not a Block space, config is useless, current space is {}'. + format(cls.__name__)) + + block_mask = config[ + 'block_mask'] if 'block_mask' in config else None + input_size = config[ + 'input_size'] if 'input_size' in config else None + output_size = config[ + 'output_size'] if 'output_size' in config else None block_num = config['block_num'] if 'block_num' in config else None if 'Block' in cls.__name__: - if block_mask == None and (self.block_num == None or self.input_size == None or self.output_size == None): - raise NotImplementedError("block_mask or (block num and input_size and output_size) can NOT be None at the same time in Block SPACE!") - - space = cls(input_size, - output_size, - block_num, - block_mask=block_mask) + if block_mask == None and (self.block_num == None or + self.input_size == None or + self.output_size == None): + raise NotImplementedError( + "block_mask or (block num and input_size and output_size) can NOT be None at the same time in Block SPACE!" + ) + + space = cls(input_size, output_size, block_num, block_mask=block_mask) return space def init_tokens(self): diff --git a/paddleslim/nas/search_space/inception_block.py b/paddleslim/nas/search_space/inception_block.py index 34778f1b..4a3bfcfa 100644 --- a/paddleslim/nas/search_space/inception_block.py +++ b/paddleslim/nas/search_space/inception_block.py @@ -81,7 +81,7 @@ class InceptionABlockSpace(SearchSpaceBase): range_table_base.append(len(self.filter_num)) range_table_base.append(len(self.filter_num)) range_table_base.append(len(self.k_size)) - range_table_base.append(len(self.pooltype)) + range_table_base.append(len(self.pool_type)) return range_table_base @@ -97,51 +97,69 @@ class InceptionABlockSpace(SearchSpaceBase): if self.block_mask != None: for i in range(len(self.block_mask)): self.bottleneck_params_list.append( - (self.filter_num[i * 9], self.filter_num[i * 9 + 1], - self.filter_num[i * 9 + 2], self.filter_num[i * 9 + 3], - self.filter_num[i * 9 + 4], self.filter_num[i * 9 + 5], - self.filter_num[i * 9 + 6], self.k_size[i * 9 + 7], 2 if - self.block_mask == 1 else 1, self.pool_type[i * 9 + 8])) + (self.filter_num[tokens[i * 9]], + self.filter_num[tokens[i * 9 + 1]], + self.filter_num[tokens[i * 9 + 2]], + self.filter_num[tokens[i * 9 + 3]], + self.filter_num[tokens[i * 9 + 4]], + self.filter_num[tokens[i * 9 + 5]], + self.filter_num[tokens[i * 9 + 6]], + self.k_size[tokens[i * 9 + 7]], 2 if self.block_mask == 1 + else 1, self.pool_type[tokens[i * 9 + 8]])) else: repeat_num = self.block_num / self.downsample_num num_minus = self.block_num % self.downsample_num ### if block_num > downsample_num, add stride=1 block at last (block_num-downsample_num) layers for i in range(self.downsample_num): self.bottleneck_params_list.append( - (self.filter_num[i * 9], self.filter_num[i * 9 + 1], - self.filter_num[i * 9 + 2], self.filter_num[i * 9 + 3], - self.filter_num[i * 9 + 4], self.filter_num[i * 9 + 5], - self.filter_num[i * 9 + 6], self.k_size[i * 9 + 7], 2, - self.pool_type[i * 9 + 8])) + (self.filter_num[tokens[i * 9]], + self.filter_num[tokens[i * 9 + 1]], + self.filter_num[tokens[i * 9 + 2]], + self.filter_num[tokens[i * 9 + 3]], + self.filter_num[tokens[i * 9 + 4]], + self.filter_num[tokens[i * 9 + 5]], + self.filter_num[tokens[i * 9 + 6]], + self.k_size[tokens[i * 9 + 7]], 2, + self.pool_type[tokens[i * 9 + 8]])) ### if block_num / downsample_num > 1, add (block_num / downsample_num) times stride=1 block for k in range(repeat_num - 1): kk = k * self.downsample_num + i self.bottleneck_params_list.append( - (self.filter_num[kk * 9], self.filter_num[kk * 9 + 1], - self.filter_num[kk * 9 + 2], - self.filter_num[kk * 9 + 3], - self.filter_num[kk * 9 + 4], - self.filter_num[kk * 9 + 5], - self.filter_num[kk * 9 + 6], self.k_size[kk * 9 + 7], - 1, self.pool_type[kk * 9 + 8])) + (self.filter_num[tokens[kk * 9]], + self.filter_num[tokens[kk * 9 + 1]], + self.filter_num[tokens[kk * 9 + 2]], + self.filter_num[tokens[kk * 9 + 3]], + self.filter_num[tokens[kk * 9 + 4]], + self.filter_num[tokens[kk * 9 + 5]], + self.filter_num[tokens[kk * 9 + 6]], + self.k_size[tokens[kk * 9 + 7]], 1, + self.pool_type[tokens[kk * 9 + 8]])) if self.downsample_num - i <= num_minus: j = self.downsample_num * repeat_num + i - self.bottleneck_params_list.append(( - self.filter_num[j * 9], self.filter_num[j * 9 + 1], - self.filter_num[j * 9 + 2], self.filter_num[j * 9 + 3], - self.filter_num[j * 9 + 4], self.filter_num[j * 9 + 5], - self.filter_num[j * 9 + 6], self.k_size[j * 9 + 7], 1, - self.pool_type[j * 9 + 8])) + self.bottleneck_params_list.append( + (self.filter_num[tokens[j * 9]], + self.filter_num[tokens[j * 9 + 1]], + self.filter_num[tokens[j * 9 + 2]], + self.filter_num[tokens[j * 9 + 3]], + self.filter_num[tokens[j * 9 + 4]], + self.filter_num[tokens[j * 9 + 5]], + self.filter_num[tokens[j * 9 + 6]], + self.k_size[tokens[j * 9 + 7]], 1, + self.pool_type[tokens[j * 9 + 8]])) if self.downsample_num == 0 and self.block_num != 0: for i in range(len(self.block_num)): - self.bottleneck_params_list.append(( - self.filter_num[i * 9], self.filter_num[i * 9 + 1], - self.filter_num[i * 9 + 2], self.filter_num[i * 9 + 3], - self.filter_num[i * 9 + 4], self.filter_num[i * 9 + 5], - self.filter_num[i * 9 + 6], self.k_size[i * 9 + 7], 1, - self.pool_type[i * 9 + 8])) + self.bottleneck_params_list.append( + (self.filter_num[tokens[i * 9]], + self.filter_num[tokens[i * 9 + 1]], + self.filter_num[tokens[i * 9 + 2]], + self.filter_num[tokens[i * 9 + 3]], + self.filter_num[tokens[i * 9 + 4]], + self.filter_num[tokens[i * 9 + 5]], + self.filter_num[tokens[i * 9 + 6]], + self.k_size[tokens[i * 9 + 7]], 1, + self.pool_type[tokens[i * 9 + 8]])) def net_arch(input, return_mid_layer=False, return_block=[]): assert isinstance(return_block, @@ -169,7 +187,7 @@ class InceptionABlockSpace(SearchSpaceBase): if return_mid_layer: return input, mid_layer else: - return input + return input, return net_arch @@ -247,7 +265,7 @@ class InceptionABlockSpace(SearchSpaceBase): @SEARCHSPACE.register class InceptionCBlockSpace(SearchSpaceBase): def __init__(self, input_size, output_size, block_num, block_mask): - super(InceptionABlockSpace, self).__init__(input_size, output_size, + super(InceptionCBlockSpace, 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 @@ -274,9 +292,9 @@ class InceptionCBlockSpace(SearchSpaceBase): The initial token. """ if self.block_mask != None: - return [0] * (len(self.block_mask) * 9) + return [0] * (len(self.block_mask) * 11) else: - return [0] * (self.block_num * 9) + return [0] * (self.block_num * 11) def range_table(self): """ @@ -297,7 +315,7 @@ class InceptionCBlockSpace(SearchSpaceBase): range_table_base.append(len(self.filter_num)) range_table_base.append(len(self.filter_num)) range_table_base.append(len(self.k_size)) - range_table_base.append(len(self.pooltype)) + range_table_base.append(len(self.pool_type)) return range_table_base @@ -313,63 +331,79 @@ class InceptionCBlockSpace(SearchSpaceBase): if self.block_mask != None: for i in range(len(self.block_mask)): self.bottleneck_params_list.append( - (self.filter_num[i * 11], self.filter_num[i * 11 + 1], - self.filter_num[i * 11 + 2], self.filter_num[i * 11 + 3], - self.filter_num[i * 11 + 4], self.filter_num[i * 11 + 5], - self.filter_num[i * 11 + 6], self.filter_num[i * 11 + 7], - self.filter_num[i * 11 + 8], self.k_size[i * 11 + 9], 2 if - self.block_mask == 1 else 1, self.pool_type[i * 11 + 10])) + (self.filter_num[tokens[i * 11]], + self.filter_num[tokens[i * 11 + 1]], + self.filter_num[tokens[i * 11 + 2]], + self.filter_num[tokens[i * 11 + 3]], + self.filter_num[tokens[i * 11 + 4]], + self.filter_num[tokens[i * 11 + 5]], + self.filter_num[tokens[i * 11 + 6]], + self.filter_num[tokens[i * 11 + 7]], + self.filter_num[tokens[i * 11 + 8]], + self.k_size[tokens[i * 11 + 9]], 2 if self.block_mask == 1 + else 1, self.pool_type[tokens[i * 11 + 10]])) else: repeat_num = self.block_num / self.downsample_num num_minus = self.block_num % self.downsample_num ### if block_num > downsample_num, add stride=1 block at last (block_num-downsample_num) layers for i in range(self.downsample_num): self.bottleneck_params_list.append( - (self.filter_num[i * 11], self.filter_num[i * 11 + 1], - self.filter_num[i * 11 + 2], self.filter_num[i * 11 + 3], - self.filter_num[i * 11 + 4], self.filter_num[i * 11 + 5], - self.filter_num[i * 11 + 6], self.filter_num[i * 11 + 7], - self.filter_num[i * 11 + 8], self.k_size[i * 11 + 9], 2, - self.pool_type[i * 11 + 10])) + (self.filter_num[tokens[i * 11]], + self.filter_num[tokens[i * 11 + 1]], + self.filter_num[tokens[i * 11 + 2]], + self.filter_num[tokens[i * 11 + 3]], + self.filter_num[tokens[i * 11 + 4]], + self.filter_num[tokens[i * 11 + 5]], + self.filter_num[tokens[i * 11 + 6]], + self.filter_num[tokens[i * 11 + 7]], + self.filter_num[tokens[i * 11 + 8]], + self.k_size[tokens[i * 11 + 9]], 2, + self.pool_type[tokens[i * 11 + 10]])) ### if block_num / downsample_num > 1, add (block_num / downsample_num) times stride=1 block for k in range(repeat_num - 1): kk = k * self.downsample_num + i - self.bottleneck_params_list.append(( - self.filter_num[kk * 11], self.filter_num[kk * 11 + 1], - self.filter_num[kk * 11 + 2], - self.filter_num[kk * 11 + 3], - self.filter_num[kk * 11 + 4], - self.filter_num[kk * 11 + 5], - self.filter_num[kk * 11 + 6], - self.filter_num[kk * 11 + 7], - self.filter_num[kk * 11 + 8], self.k_size[kk * 11 + 9], - 1, self.pool_type[kk * 11 + 10])) + self.bottleneck_params_list.append( + (self.filter_num[tokens[kk * 11]], + self.filter_num[tokens[kk * 11 + 1]], + self.filter_num[tokens[kk * 11 + 2]], + self.filter_num[tokens[kk * 11 + 3]], + self.filter_num[tokens[kk * 11 + 4]], + self.filter_num[tokens[kk * 11 + 5]], + self.filter_num[tokens[kk * 11 + 6]], + self.filter_num[tokens[kk * 11 + 7]], + self.filter_num[tokens[kk * 11 + 8]], + self.k_size[tokens[kk * 11 + 9]], 1, + self.pool_type[tokens[kk * 11 + 10]])) if self.downsample_num - i <= num_minus: j = self.downsample_num * repeat_num + i self.bottleneck_params_list.append( - (self.filter_num[j * 11], self.filter_num[j * 11 + 1], - self.filter_num[j * 11 + 2], - self.filter_num[j * 11 + 3], - self.filter_num[j * 11 + 4], - self.filter_num[j * 11 + 5], - self.filter_num[j * 11 + 6], - self.filter_num[j * 11 + 7], - self.filter_num[j * 11 + 8], self.k_size[j * 11 + 9], - 1, self.pool_type[j * 11 + 10])) + (self.filter_num[tokens[j * 11]], + self.filter_num[tokens[j * 11 + 1]], + self.filter_num[tokens[j * 11 + 2]], + self.filter_num[tokens[j * 11 + 3]], + self.filter_num[tokens[j * 11 + 4]], + self.filter_num[tokens[j * 11 + 5]], + self.filter_num[tokens[j * 11 + 6]], + self.filter_num[tokens[j * 11 + 7]], + self.filter_num[tokens[j * 11 + 8]], + self.k_size[tokens[j * 11 + 9]], 1, + self.pool_type[tokens[j * 11 + 10]])) if self.downsample_num == 0 and self.block_num != 0: for i in range(len(self.block_num)): self.bottleneck_params_list.append( - (self.filter_num[i * 11], self.filter_num[i * 11 + 1], - self.filter_num[i * 11 + 2], - self.filter_num[i * 11 + 3], - self.filter_num[i * 11 + 4], - self.filter_num[i * 11 + 5], - self.filter_num[i * 11 + 6], - self.filter_num[i * 11 + 7], - self.filter_num[i * 11 + 8], self.k_size[i * 11 + 9], - 1, self.pool_type[i * 11 + 10])) + (self.filter_num[tokens[i * 11]], + self.filter_num[tokens[i * 11 + 1]], + self.filter_num[tokens[i * 11 + 2]], + self.filter_num[tokens[i * 11 + 3]], + self.filter_num[tokens[i * 11 + 4]], + self.filter_num[tokens[i * 11 + 5]], + self.filter_num[tokens[i * 11 + 6]], + self.filter_num[tokens[i * 11 + 7]], + self.filter_num[tokens[i * 11 + 8]], + self.k_size[tokens[i * 11 + 9]], 1, + self.pool_type[tokens[i * 11 + 10]])) def net_arch(input, return_mid_layer=False, return_block=[]): assert isinstance(return_block, @@ -397,7 +431,7 @@ class InceptionCBlockSpace(SearchSpaceBase): if return_mid_layer: return input, mid_layer else: - return input + return input, return net_arch diff --git a/paddleslim/nas/search_space/mobilenet_block.py b/paddleslim/nas/search_space/mobilenet_block.py index 78751844..39438cd1 100644 --- a/paddleslim/nas/search_space/mobilenet_block.py +++ b/paddleslim/nas/search_space/mobilenet_block.py @@ -334,7 +334,7 @@ class MobileNetV1BlockSpace(SearchSpaceBase): if tokens == None: tokens = self.init_tokens() - self.bottleneck_param_list = [] + self.bottleneck_params_list = [] if self.block_mask != None: for i in range(len(self.block_mask)): self.bottleneck_params_list.append( @@ -391,7 +391,6 @@ class MobileNetV1BlockSpace(SearchSpaceBase): input=input, num_filters1=filter_num1, num_filters2=filter_num2, - num_groups=filter_num1, stride=stride, scale=self.scale, kernel_size=kernel_size, @@ -408,17 +407,17 @@ class MobileNetV1BlockSpace(SearchSpaceBase): input, num_filters1, num_filters2, - num_groups, stride, scale, kernel_size, name=None): + num_groups = input.shape[1] depthwise_conv = conv_bn_layer( input=input, filter_size=kernel_size, num_filters=int(num_filters1 * scale), stride=stride, - num_groups=int(num_groups * scale), + num_groups=num_groups, use_cudnn=False, name=name + '_dw') pointwise_conv = conv_bn_layer( diff --git a/paddleslim/nas/search_space/resnet_block.py b/paddleslim/nas/search_space/resnet_block.py index 25599796..c9f215d3 100644 --- a/paddleslim/nas/search_space/resnet_block.py +++ b/paddleslim/nas/search_space/resnet_block.py @@ -29,9 +29,9 @@ __all__ = ["ResNetBlockSpace"] @SEARCHSPACE.register class ResNetBlockSpace(SearchSpaceBase): - def __init__(input_size, output_size, block_num, block_mask): - super(ResNetSpace, self).__init__(input_size, output_size, block_num, - block_mask) + def __init__(self, input_size, output_size, block_num, block_mask=None): + super(ResNetBlockSpace, self).__init__(input_size, output_size, + block_num, block_mask) # use input_size and output_size to compute self.downsample_num self.downsample_num = compute_downsample_num(self.input_size, self.output_size) @@ -52,6 +52,14 @@ class ResNetBlockSpace(SearchSpaceBase): def range_table(self): range_table_base = [] + if self.block_mask != None: + range_table_length = len(self.block_mask) + else: + range_table_length = self.block_mum + + for i in range(range_table_length): + range_table_base.append(len(self.filter_num)) + range_table_base.append(len(self.k_size)) return range_table_base @@ -63,39 +71,39 @@ class ResNetBlockSpace(SearchSpaceBase): if self.block_mask != None: for i in range(len(self.block_mask)): self.bottleneck_params_list.append( - (self.num_filters[tokens[i * 2]], - self.kernel_size[tokens[i * 2 + 1]], 2 + (self.filter_num[tokens[i * 2]], + self.k_size[tokens[i * 2 + 1]], 2 if self.block_mask[i] == 1 else 1)) else: repeat_num = self.block_num / self.downsample_num num_minus = self.block_num % self.downsample_num for i in range(self.downsample_num): self.bottleneck_params_list.append( - self.num_filters[tokens[i * 2]], - self.kernel_size[tokens[i * 2 + 1]], 2) + self.filter_num[tokens[i * 2]], + self.k_size[tokens[i * 2 + 1]], 2) for k in range(repeat_num - 1): kk = k * self.downsample_num + i self.bottleneck_params_list.append( - self.num_filters[tokens[kk * 2]], - self.kernel_size[tokens[kk * 2 + 1]], 1) + self.filter_num[tokens[kk * 2]], + self.k_size[tokens[kk * 2 + 1]], 1) if self.downsample_num - i <= num_minus: j = self.downsample_num * repeat_num + i self.bottleneck_params_list.append( - self.num_filters[tokens[j * 2]], - self.kernel_size[tokens[j * 2 + 1]], 1) + self.filter_num[tokens[j * 2]], + self.k_size[tokens[j * 2 + 1]], 1) if self.downsample_num == 0 and self.block_num != 0: for i in range(len(self.block_num)): self.bottleneck_params_list.append( - self.num_filters[tokens[i * 2]], - self.kernel_size[tokens[i * 2 + 1]], 1) + self.filter_num[tokens[i * 2]], + self.k_size[tokens[i * 2 + 1]], 1) def net_arch(input, return_mid_layer=False, return_block=[]): assert isinstance(return_block, list), 'return_block must be a list.' layer_count = 0 mid_layer = dict() - for layer_setting in self.bottleneck_params_list: + for i, layer_setting in enumerate(self.bottleneck_params_list): filter_num, k_size, stride = layer_setting if stride == 2: layer_count += 1 @@ -138,6 +146,7 @@ class ResNetBlockSpace(SearchSpaceBase): input=input, num_filters=num_filters, filter_size=1, + stride=1, act='relu', name=name + '_bottleneck_conv0') conv1 = conv_bn_layer( @@ -151,6 +160,7 @@ class ResNetBlockSpace(SearchSpaceBase): input=conv1, num_filters=num_filters * 4, filter_size=1, + stride=1, act=None, name=name + '_bottleneck_conv2') -- GitLab