startup_prog = fluid.Program() train_prog = fluid.Program() with fluid.program_guard(train_prog, startup_prog): with fluid.unique_name.guard(): inputs = P.data(name='input_1', shape=[-1, 3, 32, 32], append_batch_size=False, dtype='float32') conv01_out_tensor = fluid.layers.conv2d( input=inputs, num_filters=8, filter_size=1, stride=1, padding=0, param_attr=ParamAttr(name="conv01_weights"), bias_attr=ParamAttr( name="conv01_bias", initializer=fluid.initializer.NormalInitializer(loc=0.0, scale=1.0, seed=0))) act01_out_tensor = fluid.layers.leaky_relu(conv01_out_tensor, alpha=0.1) filter_size = 3 filters = 512 stride = 2 padding = 1 conv_name = 'dcnv2' offset_mask = fluid.layers.conv2d( input=act01_out_tensor,
def net(self, img): # darknet-tiny stages = [16, 32, 64, 128, 256, 512] assert len(self.anchor_mask) <= len( stages), "anchor masks can't bigger than downsample times" # 256x256 tmp = img blocks = [] for i, stage_count in enumerate(stages): if i == len(stages) - 1: block = self.conv_bn(tmp, stage_count, filter_size=3, stride=1, padding=1) blocks.append(block) block = self.depthwise_conv_bn(blocks[-1]) block = self.depthwise_conv_bn(blocks[-1]) block = self.conv_bn(blocks[-1], stage_count * 2, filter_size=1, stride=1, padding=0) blocks.append(block) else: tmp = self.basicblock(tmp, stage_count) blocks.append(tmp) blocks = [blocks[-1], blocks[3]] # yolo detector for i, block in enumerate(blocks): # yolo 中跨视域链接 if i > 0: block = fluid.layers.concat(input=[route, block], axis=1) if i < 1: route, tip = self.yolo_detection_block(block, num_filters=256 // (2**i)) else: tip = self.conv_bn(block, num_filters=256, filter_size=3, stride=1, padding=1) block_out = fluid.layers.conv2d( input=tip, num_filters=len(self.anchor_mask[i]) * (self.class_num + 5), # 5 elements represent x|y|h|w|score filter_size=1, stride=1, padding=0, act=None, param_attr=ParamAttr( initializer=fluid.initializer.Normal(0., 0.02)), bias_attr=ParamAttr( initializer=fluid.initializer.Constant(0.0), regularizer=L2Decay(0.))) self.outputs.append(block_out) # 为了跨视域链接,差值方式提升特征图尺寸 if i < len(blocks) - 1: route = self.conv_bn(route, 128 // (2**i), filter_size=1, stride=1, padding=0) route = self.upsample(route) return self.outputs
def net(self, input, class_dim=1000, data_format="NCHW"): layers = self.layers supported_layers = [18, 34, 50, 101, 152] assert layers in supported_layers, \ "supported layers are {} but input layer is {}".format(supported_layers, layers) if layers == 18: depth = [2, 2, 2, 2] elif layers == 34 or layers == 50: depth = [3, 4, 6, 3] elif layers == 101: depth = [3, 4, 23, 3] elif layers == 152: depth = [3, 8, 36, 3] num_filters = [64, 128, 256, 512] conv = self.conv_bn_layer(input=input, num_filters=64, filter_size=7, stride=2, act='relu', name="conv1", data_format=data_format) conv = fluid.layers.pool2d(input=conv, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max', data_format=data_format) if layers >= 50: for block in range(len(depth)): for i in range(depth[block]): if layers in [101, 152] and block == 2: if i == 0: conv_name = "res" + str(block + 2) + "a" else: conv_name = "res" + str(block + 2) + "b" + str(i) else: conv_name = "res" + str(block + 2) + chr(97 + i) conv = self.bottleneck_block( input=conv, num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, name=conv_name, data_format=data_format) else: for block in range(len(depth)): for i in range(depth[block]): conv_name = "res" + str(block + 2) + chr(97 + i) conv = self.basic_block( input=conv, num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, is_first=block == i == 0, name=conv_name, data_format=data_format) pool = fluid.layers.pool2d(input=conv, pool_type='avg', global_pooling=True, data_format=data_format) stdv = 1.0 / math.sqrt(pool.shape[1] * 1.0) out = fluid.layers.fc(input=pool, size=class_dim, param_attr=fluid.param_attr.ParamAttr( name="fc_0.w_0", initializer=fluid.initializer.Uniform( -stdv, stdv)), bias_attr=ParamAttr(name="fc_0.b_0")) return out
def _get_outputs(self, input, is_train=True): """ Get YOLOv3 head output Args: input (list): List of Variables, output of backbone stages is_train (bool): whether in train or test mode Returns: outputs (list): Variables of each output layer """ outputs = [] # get last out_layer_num blocks in reverse order out_layer_num = len(self.anchor_masks) blocks = input[-1:-out_layer_num - 1:-1] route = None for i, block in enumerate(blocks): if i > 0: # perform concat in first 2 detection_block block = fluid.layers.concat(input=[route, block], axis=1) route, tip = self._detection_block( block, channel=512 // (2**i), is_test=(not is_train), name=self.prefix_name + "yolo_block.{}".format(i)) # out channel number = mask_num * (5 + class_num) if self.iou_aware: num_filters = len(self.anchor_masks[i]) * (self.num_classes + 6) else: num_filters = len(self.anchor_masks[i]) * (self.num_classes + 5) with fluid.name_scope('yolo_output'): block_out = fluid.layers.conv2d( input=tip, num_filters=num_filters, filter_size=1, stride=1, padding=0, act=None, param_attr=ParamAttr( name=self.prefix_name + "yolo_output.{}.conv.weights".format(i)), bias_attr=ParamAttr( regularizer=L2Decay(0.), name=self.prefix_name + "yolo_output.{}.conv.bias".format(i))) outputs.append(block_out) if i < len(blocks) - 1: # do not perform upsample in the last detection_block route = self._conv_bn( input=route, ch_out=256 // (2**i), filter_size=1, stride=1, padding=0, is_test=(not is_train), name=self.prefix_name + "yolo_transition.{}".format(i)) # upsample route = self._upsample(route) return outputs
def net(self, input, class_dim=1000): # get network args args = self.get_net_args(self.layers) bws = args['bw'] inc_sec = args['inc_sec'] rs = args['r'] k_r = args['k_r'] k_sec = args['k_sec'] G = args['G'] init_num_filter = args['init_num_filter'] init_filter_size = args['init_filter_size'] init_padding = args['init_padding'] ## define Dual Path Network # conv1 conv1_x_1 = fluid.layers.conv2d( input=input, num_filters=init_num_filter, filter_size=init_filter_size, stride=2, padding=init_padding, groups=1, act=None, bias_attr=False, name="conv1", param_attr=ParamAttr(name="conv1_weights"), ) conv1_x_1 = fluid.layers.batch_norm( input=conv1_x_1, act='relu', is_test=False, name="conv1_bn", param_attr=ParamAttr(name='conv1_bn_scale'), bias_attr=ParamAttr('conv1_bn_offset'), moving_mean_name='conv1_bn_mean', moving_variance_name='conv1_bn_variance', ) convX_x_x = fluid.layers.pool2d(input=conv1_x_1, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max', name="pool1") #conv2 - conv5 match_list, num = [], 0 for gc in range(4): bw = bws[gc] inc = inc_sec[gc] R = (k_r * bw) // rs[gc] if gc == 0: _type1 = 'proj' _type2 = 'normal' match = 1 else: _type1 = 'down' _type2 = 'normal' match = match + k_sec[gc - 1] match_list.append(match) convX_x_x = self.dual_path_factory(convX_x_x, R, R, bw, inc, G, _type1, name="dpn" + str(match)) for i_ly in range(2, k_sec[gc] + 1): num += 1 if num in match_list: num += 1 convX_x_x = self.dual_path_factory(convX_x_x, R, R, bw, inc, G, _type2, name="dpn" + str(num)) conv5_x_x = fluid.layers.concat(convX_x_x, axis=1) conv5_x_x = fluid.layers.batch_norm( input=conv5_x_x, act='relu', is_test=False, name="final_concat_bn", param_attr=ParamAttr(name='final_concat_bn_scale'), bias_attr=ParamAttr('final_concat_bn_offset'), moving_mean_name='final_concat_bn_mean', moving_variance_name='final_concat_bn_variance', ) pool5 = fluid.layers.pool2d( input=conv5_x_x, pool_size=7, pool_stride=1, pool_padding=0, global_pooling=True, pool_type='avg', ) stdv = 0.01 fc6 = fluid.layers.fc(input=pool5, size=class_dim, param_attr=ParamAttr( initializer=fluid.initializer.Uniform( -stdv, stdv), name='fc_weights'), bias_attr=ParamAttr(name='fc_offset')) return fc6
def net(self, input, class_dim=1000, data_format="NCHW"): layers = self.layers supported_layers = [50, 101] assert layers in supported_layers, \ "supported layers are {} but input layer is {}".format( supported_layers, layers) if layers == 50: depth = [3, 3, 5, 2] elif layers == 101: depth = [3, 3, 22, 2] num_filters = [64, 128, 256, 512] conv = self.conv_bn_layer(input=input, num_filters=64, filter_size=7, stride=2, act=self.act, name="conv1", data_format=data_format) conv = fluid.layers.pool2d(input=conv, pool_size=2, pool_stride=2, pool_padding=0, pool_type='max', data_format=data_format) for block in range(len(depth)): conv_name = "res" + str(block + 2) + chr(97) if block != 0: conv = self.conv_bn_layer(input=conv, num_filters=num_filters[block], filter_size=3, stride=2, act=self.act, name=conv_name + "_downsample", data_format=data_format) # split left = conv right = conv if block == 0: ch = num_filters[block] else: ch = num_filters[block] * 2 right = self.conv_bn_layer(input=right, num_filters=ch, filter_size=1, act=self.act, name=conv_name + "_right_first_route", data_format=data_format) for i in range(depth[block]): conv_name = "res" + str(block + 2) + chr(97 + i) right = self.bottleneck_block(input=right, num_filters=num_filters[block], stride=1, name=conv_name, data_format=data_format) # route left = self.conv_bn_layer(input=left, num_filters=num_filters[block] * 2, filter_size=1, act=self.act, name=conv_name + "_left_route", data_format=data_format) right = self.conv_bn_layer(input=right, num_filters=num_filters[block] * 2, filter_size=1, act=self.act, name=conv_name + "_right_route", data_format=data_format) conv = fluid.layers.concat([left, right], axis=1) conv = self.conv_bn_layer(input=conv, num_filters=num_filters[block] * 2, filter_size=1, stride=1, act=self.act, name=conv_name + "_merged_transition", data_format=data_format) pool = fluid.layers.pool2d(input=conv, pool_type='avg', global_pooling=True, data_format=data_format) stdv = 1.0 / math.sqrt(pool.shape[1] * 1.0) out = fluid.layers.fc(input=pool, size=class_dim, param_attr=fluid.param_attr.ParamAttr( name="fc_0.w_0", initializer=fluid.initializer.Uniform( -stdv, stdv)), bias_attr=ParamAttr(name="fc_0.b_0")) return out
def get_output(self, body_dict): """ Add FPN onto backbone. Args: body_dict(OrderedDict): Dictionary of variables and each element is the output of backbone. Return: fpn_dict(OrderedDict): A dictionary represents the output of FPN with their name. spatial_scale(list): A list of multiplicative spatial scale factor. """ spatial_scale = copy.deepcopy(self.spatial_scale) body_name_list = list(body_dict.keys())[::-1] num_backbone_stages = len(body_name_list) self.fpn_inner_output = [[] for _ in range(num_backbone_stages)] fpn_inner_name = 'fpn_inner_' + body_name_list[0] body_input = body_dict[body_name_list[0]] fan = body_input.shape[1] if self.norm_type: initializer = Xavier(fan_out=fan) self.fpn_inner_output[0] = ConvNorm(body_input, self.num_chan, 1, initializer=initializer, norm_type=self.norm_type, freeze_norm=self.freeze_norm, name=fpn_inner_name, norm_name=fpn_inner_name) else: self.fpn_inner_output[0] = fluid.layers.conv2d( body_input, self.num_chan, 1, param_attr=ParamAttr(name=fpn_inner_name + "_w", initializer=Xavier(fan_out=fan)), bias_attr=ParamAttr(name=fpn_inner_name + "_b", learning_rate=2., regularizer=L2Decay(0.)), name=fpn_inner_name) for i in range(1, num_backbone_stages): body_name = body_name_list[i] body_input = body_dict[body_name] top_output = self.fpn_inner_output[i - 1] fpn_inner_single = self._add_topdown_lateral( body_name, body_input, top_output) self.fpn_inner_output[i] = fpn_inner_single fpn_dict = {} fpn_name_list = [] # print(body_name_list) for i in range(num_backbone_stages): fpn_name = 'fpn_' + body_name_list[i] fan = self.fpn_inner_output[i].shape[1] * 3 * 3 if self.norm_type: initializer = Xavier(fan_out=fan) fpn_output = ConvNorm(self.fpn_inner_output[i], self.num_chan, 3, initializer=initializer, norm_type=self.norm_type, freeze_norm=self.freeze_norm, name=fpn_name, norm_name=fpn_name) else: fpn_output = fluid.layers.conv2d( self.fpn_inner_output[i], self.num_chan, filter_size=3, padding=1, act='relu', param_attr=ParamAttr(name=fpn_name + "_w", initializer=Xavier(fan_out=fan)), bias_attr=ParamAttr(name=fpn_name + "_b", learning_rate=2., regularizer=L2Decay(0.)), name=fpn_name) fpn_dict[fpn_name] = fpn_output fpn_name_list.append(fpn_name) if not self.has_extra_convs and self.max_level - self.min_level == len( spatial_scale): body_top_name = fpn_name_list[0] body_top_extension = fluid.layers.pool2d(fpn_dict[body_top_name], 1, 'max', pool_stride=2, name=body_top_name + '_subsampled_2x') fpn_dict[body_top_name + '_subsampled_2x'] = body_top_extension fpn_name_list.insert(0, body_top_name + '_subsampled_2x') spatial_scale.insert(0, spatial_scale[0] * 0.5) # Coarser FPN levels introduced for RetinaNet print(fpn_name_list) highest_backbone_level = self.min_level + len(spatial_scale) - 1 if self.has_extra_convs and self.max_level > highest_backbone_level: # fpn_blob = body_dict[body_name_list[0]] fpn_blob = fpn_dict[fpn_name_list[0]] for i in range(highest_backbone_level + 1, self.max_level + 1): fpn_blob_in = fpn_blob fpn_name = 'fpn_' + str(i) # if i > highest_backbone_level + 1: # fpn_blob_in = fluid.layers.relu(fpn_blob) fan = fpn_blob_in.shape[1] * 3 * 3 fpn_blob = fluid.layers.conv2d( input=fpn_blob_in, num_filters=self.num_chan, filter_size=3, stride=2, padding=1, param_attr=ParamAttr(name=fpn_name + "_w", initializer=Xavier(fan_out=fan)), bias_attr=ParamAttr(name=fpn_name + "_b", learning_rate=2., regularizer=L2Decay(0.)), name=fpn_name) fpn_dict[fpn_name] = fpn_blob fpn_name_list.insert(0, fpn_name) spatial_scale.insert(0, spatial_scale[0] * 0.5) res_dict = OrderedDict([(k, fpn_dict[k]) for k in fpn_name_list]) return res_dict, spatial_scale
def net(self, input, class_dim=1000): layers = self.layers supported_layers = [50, 101, 152] assert layers in supported_layers, \ "supported layers are {} but input layer is {}".format(supported_layers, layers) if layers == 50: cardinality = 32 reduction_ratio = 16 depth = [3, 4, 6, 3] num_filters = [128, 256, 512, 1024] conv = self.conv_bn_layer( input=input, num_filters=64, filter_size=7, stride=2, act='relu', name='conv1', ) conv = fluid.layers.pool2d(input=conv, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max', use_cudnn=False) elif layers == 101: cardinality = 32 reduction_ratio = 16 depth = [3, 4, 23, 3] num_filters = [128, 256, 512, 1024] conv = self.conv_bn_layer( input=input, num_filters=64, filter_size=7, stride=2, act='relu', name="conv1", ) conv = fluid.layers.pool2d(input=conv, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max', use_cudnn=False) elif layers == 152: cardinality = 64 reduction_ratio = 16 depth = [3, 8, 36, 3] num_filters = [128, 256, 512, 1024] conv = self.conv_bn_layer(input=input, num_filters=64, filter_size=3, stride=2, act='relu', name='conv1') conv = self.conv_bn_layer(input=conv, num_filters=64, filter_size=3, stride=1, act='relu', name='conv2') conv = self.conv_bn_layer(input=conv, num_filters=128, filter_size=3, stride=1, act='relu', name='conv3') conv = fluid.layers.pool2d(input=conv, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max', use_cudnn=False) n = 1 if layers == 50 or layers == 101 else 3 for block in range(len(depth)): n += 1 for i in range(depth[block]): conv = self.bottleneck_block( input=conv, num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, cardinality=cardinality, reduction_ratio=reduction_ratio, name=str(n) + '_' + str(i + 1)) pool = fluid.layers.pool2d(input=conv, pool_type='avg', global_pooling=True, use_cudnn=False) drop = fluid.layers.dropout(x=pool, dropout_prob=0.5) stdv = 1.0 / math.sqrt(drop.shape[1] * 1.0) out = fluid.layers.fc(input=drop, size=class_dim, param_attr=ParamAttr( initializer=fluid.initializer.Uniform( -stdv, stdv), name='fc6_weights'), bias_attr=ParamAttr(name='fc6_offset')) return out
def _fcos_head(self, features, fpn_stride, fpn_scale, is_training=False): """ Args: features (Variables): feature map from FPN fpn_stride (int): the stride of current feature map is_training (bool): whether is train or test mode """ subnet_blob_cls = features subnet_blob_reg = features in_channles = features.shape[1] if self.use_dcn_in_tower: conv_norm = DeformConvNorm else: conv_norm = ConvNorm for lvl in range(0, self.num_convs): conv_cls_name = 'fcos_head_cls_tower_conv_{}'.format(lvl) subnet_blob_cls = conv_norm(input=subnet_blob_cls, num_filters=in_channles, filter_size=3, stride=1, norm_type=self.norm_type, act='relu', initializer=Normal(loc=0., scale=0.01), bias_attr=True, norm_name=conv_cls_name + "_norm", name=conv_cls_name) conv_reg_name = 'fcos_head_reg_tower_conv_{}'.format(lvl) subnet_blob_reg = conv_norm(input=subnet_blob_reg, num_filters=in_channles, filter_size=3, stride=1, norm_type=self.norm_type, act='relu', initializer=Normal(loc=0., scale=0.01), bias_attr=True, norm_name=conv_reg_name + "_norm", name=conv_reg_name) conv_cls_name = "fcos_head_cls" bias_init_value = -math.log((1 - self.prior_prob) / self.prior_prob) cls_logits = fluid.layers.conv2d( input=subnet_blob_cls, num_filters=self.num_classes, filter_size=3, stride=1, padding=1, param_attr=ParamAttr(name=conv_cls_name + "_weights", initializer=Normal(loc=0., scale=0.01)), bias_attr=ParamAttr(name=conv_cls_name + "_bias", initializer=Constant(value=bias_init_value)), name=conv_cls_name) conv_reg_name = "fcos_head_reg" bbox_reg = fluid.layers.conv2d( input=subnet_blob_reg, num_filters=4, filter_size=3, stride=1, padding=1, param_attr=ParamAttr(name=conv_reg_name + "_weights", initializer=Normal(loc=0., scale=0.01)), bias_attr=ParamAttr(name=conv_reg_name + "_bias", initializer=Constant(value=0)), name=conv_reg_name) bbox_reg = bbox_reg * fpn_scale if self.norm_reg_targets: bbox_reg = fluid.layers.relu(bbox_reg) if not is_training: bbox_reg = bbox_reg * fpn_stride else: bbox_reg = fluid.layers.exp(bbox_reg) conv_centerness_name = "fcos_head_centerness" if self.centerness_on_reg: subnet_blob_ctn = subnet_blob_reg else: subnet_blob_ctn = subnet_blob_cls centerness = fluid.layers.conv2d( input=subnet_blob_ctn, num_filters=1, filter_size=3, stride=1, padding=1, param_attr=ParamAttr(name=conv_centerness_name + "_weights", initializer=Normal(loc=0., scale=0.01)), bias_attr=ParamAttr(name=conv_centerness_name + "_bias", initializer=Constant(value=0)), name=conv_centerness_name) return cls_logits, bbox_reg, centerness
def build_model(is_training): input_text = fluid.layers.data(name="text", shape=[-1, max_len, 1], dtype="int64") input_text_len = fluid.layers.data(name="text_len", shape=[-1], dtype="int32") if is_training: input_label = fluid.layers.data(name="label", shape=[-1, 1], dtype="int64") input_text_emb = fluid.layers.embedding( input=input_text, size=[vocab_size, embedding_dims], param_attr=ParamAttr(name="shared_emb")) input_text_emb = fluid.layers.transpose(input_text_emb, perm=[0, 2, 1]) input_text_emb = fluid.layers.reshape( input_text_emb, shape=[-1, embedding_dims, max_len, 1]) input_text_conv = fluid.layers.conv2d(input=input_text_emb, num_filters=filters, filter_size=(kernel_size, 1), stride=(conv_stride, 1)) input_text_conv = fluid.layers.relu(input_text_conv) input_text_conv = fluid.layers.pool2d(input_text_conv, pool_size=(pool_size, 1), pool_stride=(pool_stride, 1)) input_text_conv = fluid.layers.squeeze(input_text_conv, axes=[3]) _, _, input_text_lstm = basic_lstm(input_text_conv, None, None, lstm_hidden_size, num_layers=1, sequence_length=input_text_len) input_text_lstm = fluid.layers.transpose(input_text_lstm, perm=[1, 0, 2]) input_text_lstm = fluid.layers.reshape(input_text_lstm, shape=[-1, lstm_hidden_size]) input_text_hidden = fluid.layers.fc(input_text_lstm, size=2, act="softmax") if is_training: loss = fluid.layers.cross_entropy(input_text_hidden, input_label) loss = fluid.layers.reduce_mean(loss) optimizer = fluid.optimizer.AdamOptimizer(learning_rate=0.01) optimizer.minimize(loss) return loss else: return input_text_hidden
def _conv_norm(self, input, num_filters, filter_size, stride=1, groups=1, act=None, name=None, dcn_v2=False): _name = self.prefix_name + name if self.prefix_name != '' else name if not dcn_v2: conv = fluid.layers.conv2d(input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=(filter_size - 1) // 2, groups=groups, act=None, param_attr=ParamAttr(name=_name + "_weights"), bias_attr=False, name=_name + '.conv2d.output.1') else: # select deformable conv" offset_mask = self._conv_offset(input=input, filter_size=filter_size, stride=stride, padding=(filter_size - 1) // 2, act=None, name=_name + "_conv_offset") offset_channel = filter_size**2 * 2 mask_channel = filter_size**2 offset, mask = fluid.layers.split( input=offset_mask, num_or_sections=[offset_channel, mask_channel], dim=1) mask = fluid.layers.sigmoid(mask) conv = fluid.layers.deformable_conv( input=input, offset=offset, mask=mask, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=(filter_size - 1) // 2, groups=groups, deformable_groups=1, im2col_step=1, param_attr=ParamAttr(name=_name + "_weights"), bias_attr=False, name=_name + ".conv2d.output.1") bn_name = "bn_" + name if name == "conv1" else "bn" + name[3:] bn_name = self.prefix_name + bn_name if self.prefix_name != '' else bn_name norm_lr = 0. if self.freeze_norm else 1. norm_decay = self.norm_decay pattr = ParamAttr(name=bn_name + '_scale', learning_rate=norm_lr, regularizer=L2Decay(norm_decay)) battr = ParamAttr(name=bn_name + '_offset', learning_rate=norm_lr, regularizer=L2Decay(norm_decay)) if self.norm_type in ['bn', 'sync_bn']: global_stats = True if self.freeze_norm else False out = fluid.layers.batch_norm(input=conv, act=act, name=bn_name + '.output.1', param_attr=pattr, bias_attr=battr, moving_mean_name=bn_name + '_mean', moving_variance_name=bn_name + '_variance', use_global_stats=global_stats) scale = fluid.framework._get_var(pattr.name) bias = fluid.framework._get_var(battr.name) elif self.norm_type == 'affine_channel': scale = fluid.layers.create_parameter( shape=[conv.shape[1]], dtype=conv.dtype, attr=pattr, default_initializer=fluid.initializer.Constant(1.)) bias = fluid.layers.create_parameter( shape=[conv.shape[1]], dtype=conv.dtype, attr=battr, default_initializer=fluid.initializer.Constant(0.)) out = fluid.layers.affine_channel(x=conv, scale=scale, bias=bias, act=act) if self.freeze_norm: scale.stop_gradient = True bias.stop_gradient = True return out
def net(self, input, class_dim=1000, include_top=True): is_3x3 = self.is_3x3 layers = self.layers supported_layers = [18, 34, 50, 101, 152, 200] assert layers in supported_layers, \ "supported layers are {} but input layer is {}".format(supported_layers, layers) if layers == 18: depth = [2, 2, 2, 2] elif layers == 34 or layers == 50: depth = [3, 4, 6, 3] elif layers == 101: depth = [3, 4, 23, 3] elif layers == 152: depth = [3, 8, 36, 3] elif layers == 200: depth = [3, 12, 48, 3] num_filters = [64, 128, 256, 512] if is_3x3 == False: conv = self.conv_bn_layer(input=input, num_filters=64, filter_size=7, stride=2, act='relu') else: conv = self.conv_bn_layer(input=input, num_filters=32, filter_size=3, stride=2, act='relu', name='conv1_1') conv = self.conv_bn_layer(input=conv, num_filters=32, filter_size=3, stride=1, act='relu', name='conv1_2') conv = self.conv_bn_layer(input=conv, num_filters=64, filter_size=3, stride=1, act='relu', name='conv1_3') conv = fluid.layers.pool2d(input=conv, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max') if layers >= 50: for block in range(len(depth)): self.curr_stage += 1 for i in range(depth[block]): if layers in [101, 152, 200] and block == 2: if i == 0: conv_name = "res" + str(block + 2) + "a" else: conv_name = "res" + str(block + 2) + "b" + str(i) else: conv_name = "res" + str(block + 2) + chr(97 + i) conv = self.bottleneck_block( input=conv, num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, if_first=block == i == 0, name=conv_name) else: for block in range(len(depth)): self.curr_stage += 1 for i in range(depth[block]): conv_name = "res" + str(block + 2) + chr(97 + i) conv = self.basic_block( input=conv, num_filters=num_filters[block], stride=2 if i == 0 and block != 0 else 1, if_first=block == i == 0, name=conv_name) pool = fluid.layers.pool2d(input=conv, pool_type='avg', global_pooling=True) stdv = 1.0 / math.sqrt(pool.shape[1] * 1.0) if include_top: out = fluid.layers.fc( input=pool, size=class_dim, param_attr=fluid.param_attr.ParamAttr( name="fc_0.w_0" + self.postfix_name, initializer=fluid.initializer.Uniform(-stdv, stdv)), bias_attr=ParamAttr(name="fc_0.b_0" + self.postfix_name)) else: out = pool return out
def search_mobilenetv2_block(config, args, image_size): image_shape = [3, image_size, image_size] if args.is_server: sa_nas = SANAS(config, server_addr=("", port), init_temperature=init_temperature, reduce_rate=reduce_rate, search_steps=args.search_steps, is_server=True) else: sa_nas = SANAS(config, server_addr=(server_address, port), init_temperature=init_temperature, reduce_rate=reduce_rate, search_steps=args.search_steps, is_server=False) for step in range(args.search_steps): archs = sa_nas.next_archs()[0] train_program = fluid.Program() test_program = fluid.Program() startup_program = fluid.Program() with fluid.program_guard(train_program, startup_program): train_loader, data, label = create_data_loader(image_shape) data = conv_bn_layer(input=data, num_filters=32, filter_size=3, stride=2, padding='SAME', act='relu6', name='mobilenetv2_conv1') data = archs(data)[0] data = conv_bn_layer(input=data, num_filters=1280, filter_size=1, stride=1, padding='SAME', act='relu6', name='mobilenetv2_last_conv') data = fluid.layers.pool2d(input=data, pool_size=7, pool_stride=1, pool_type='avg', global_pooling=True, name='mobilenetv2_last_pool') output = fluid.layers.fc( input=data, size=args.class_dim, param_attr=ParamAttr(name='mobilenetv2_fc_weights'), bias_attr=ParamAttr(name='mobilenetv2_fc_offset')) softmax_out = fluid.layers.softmax(input=output, use_cudnn=False) cost = fluid.layers.cross_entropy(input=softmax_out, label=label) avg_cost = fluid.layers.mean(cost) acc_top1 = fluid.layers.accuracy(input=softmax_out, label=label, k=1) acc_top5 = fluid.layers.accuracy(input=softmax_out, label=label, k=5) test_program = train_program.clone(for_test=True) optimizer = fluid.optimizer.Momentum( learning_rate=0.1, momentum=0.9, regularization=fluid.regularizer.L2Decay(1e-4)) optimizer.minimize(avg_cost) current_flops = flops(train_program) print('step: {}, current_flops: {}'.format(step, current_flops)) if current_flops > max_flops: continue place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace() exe = fluid.Executor(place) exe.run(startup_program) if args.data == 'cifar10': train_reader = paddle.batch(paddle.reader.shuffle( paddle.dataset.cifar.train10(cycle=False), buf_size=1024), batch_size=args.batch_size, drop_last=True) test_reader = paddle.batch( paddle.dataset.cifar.test10(cycle=False), batch_size=args.batch_size, drop_last=False) elif args.data == 'imagenet': train_reader = paddle.batch(imagenet_reader.train(), batch_size=args.batch_size, drop_last=True) test_reader = paddle.batch(imagenet_reader.val(), batch_size=args.batch_size, drop_last=False) test_loader, _, _ = create_data_loader(image_shape) train_loader.set_sample_list_generator( train_reader, places=fluid.cuda_places() if args.use_gpu else fluid.cpu_places()) test_loader.set_sample_list_generator(test_reader, places=place) build_strategy = fluid.BuildStrategy() train_compiled_program = fluid.CompiledProgram( train_program).with_data_parallel(loss_name=avg_cost.name, build_strategy=build_strategy) for epoch_id in range(retain_epoch): for batch_id, data in enumerate(train_loader()): fetches = [avg_cost.name] s_time = time.time() outs = exe.run(train_compiled_program, feed=data, fetch_list=fetches)[0] batch_time = time.time() - s_time if batch_id % 10 == 0: _logger.info( 'TRAIN: steps: {}, epoch: {}, batch: {}, cost: {}, batch_time: {}ms' .format(step, epoch_id, batch_id, outs[0], batch_time)) reward = [] for batch_id, data in enumerate(test_loader()): test_fetches = [avg_cost.name, acc_top1.name, acc_top5.name] batch_reward = exe.run(test_program, feed=data, fetch_list=test_fetches) reward_avg = np.mean(np.array(batch_reward), axis=1) reward.append(reward_avg) _logger.info( 'TEST: step: {}, batch: {}, avg_cost: {}, acc_top1: {}, acc_top5: {}' .format(step, batch_id, batch_reward[0], batch_reward[1], batch_reward[2])) finally_reward = np.mean(np.array(reward), axis=0) _logger.info( 'FINAL TEST: avg_cost: {}, acc_top1: {}, acc_top5: {}'.format( finally_reward[0], finally_reward[1], finally_reward[2])) sa_nas.reward(float(finally_reward[1]))
def _get_output(self, input): """ Get anchor and RPN head output. Args: input(Variable): feature map from backbone with shape of [N, C, H, W] Returns: rpn_cls_score(Variable): Output of rpn head with shape of [N, num_anchors, H, W]. rpn_bbox_pred(Variable): Output of rpn head with shape of [N, num_anchors * 4, H, W]. """ dim_out = input.shape[1] rpn_conv = fluid.layers.conv2d( input=input, num_filters=dim_out, filter_size=3, stride=1, padding=1, act='relu', name='conv_rpn', param_attr=ParamAttr(name="conv_rpn_w", initializer=Normal(loc=0., scale=0.01)), bias_attr=ParamAttr(name="conv_rpn_b", learning_rate=2., regularizer=L2Decay(0.))) # Generate anchors self.anchor_generator self.anchor, self.anchor_var = fluid.layers.anchor_generator( input=rpn_conv, anchor_sizes=self.anchor_generator.anchor_sizes, aspect_ratios=self.anchor_generator.aspect_ratios, variance=self.anchor_generator.variance, stride=self.anchor_generator.stride) num_anchor = self.anchor.shape[2] # Proposal classification scores self.rpn_cls_score = fluid.layers.conv2d( rpn_conv, num_filters=num_anchor * self.num_classes, filter_size=1, stride=1, padding=0, act=None, name='rpn_cls_score', param_attr=ParamAttr(name="rpn_cls_logits_w", initializer=Normal(loc=0., scale=0.01)), bias_attr=ParamAttr(name="rpn_cls_logits_b", learning_rate=2., regularizer=L2Decay(0.))) # Proposal bbox regression deltas self.rpn_bbox_pred = fluid.layers.conv2d( rpn_conv, num_filters=4 * num_anchor, filter_size=1, stride=1, padding=0, act=None, name='rpn_bbox_pred', param_attr=ParamAttr(name="rpn_bbox_pred_w", initializer=Normal(loc=0., scale=0.01)), bias_attr=ParamAttr(name="rpn_bbox_pred_b", learning_rate=2., regularizer=L2Decay(0.))) return self.rpn_cls_score, self.rpn_bbox_pred
def __call__(self, input): scale = self.scale inplanes = self.inplanes cfg = self.cfg blocks = [] #conv1 conv = self._conv_bn_layer( input, filter_size=3, num_filters=self.make_divisible(inplanes * scale), stride=2, padding=1, num_groups=1, if_act=True, act='hard_swish', name='conv1') i = 0 inplanes = self.make_divisible(inplanes * scale) for layer_cfg in cfg: self.block_stride *= layer_cfg[5] if layer_cfg[5] == 2: blocks.append(conv) conv = self._residual_unit( input=conv, num_in_filter=inplanes, num_mid_filter=self.make_divisible(scale * layer_cfg[1]), num_out_filter=self.make_divisible(scale * layer_cfg[2]), act=layer_cfg[4], stride=layer_cfg[5], filter_size=layer_cfg[0], use_se=layer_cfg[3], name='conv' + str(i + 2)) inplanes = self.make_divisible(scale * layer_cfg[2]) i += 1 self.curr_stage = i blocks.append(conv) if self.for_seg: conv = self._conv_bn_layer( input=conv, filter_size=1, num_filters=self.make_divisible(scale * self.cls_ch_squeeze), stride=1, padding=0, num_groups=1, if_act=True, act='hard_swish', name='conv_last') return conv, self.decode_point if self.num_classes: conv = self._conv_bn_layer( input=conv, filter_size=1, num_filters=int(scale * self.cls_ch_squeeze), stride=1, padding=0, num_groups=1, if_act=True, act='hard_swish', name='conv_last') conv = fluid.layers.pool2d( input=conv, pool_type='avg', global_pooling=True, use_cudnn=False) conv = fluid.layers.conv2d( input=conv, num_filters=self.cls_ch_expand, filter_size=1, stride=1, padding=0, act=None, param_attr=ParamAttr(name='last_1x1_conv_weights'), bias_attr=False) conv = self._hard_swish(conv) drop = fluid.layers.dropout(x=conv, dropout_prob=0.2) out = fluid.layers.fc(input=drop, size=self.num_classes, param_attr=ParamAttr(name='fc_weights'), bias_attr=ParamAttr(name='fc_offset')) return out if not self.with_extra_blocks: return blocks # extra block conv_extra = self._conv_bn_layer( conv, filter_size=1, num_filters=int(scale * cfg[-1][1]), stride=1, padding="SAME", num_groups=1, if_act=True, act='hard_swish', name='conv' + str(i + 2)) self.end_points.append(conv_extra) i += 1 for block_filter in self.extra_block_filters: conv_extra = self._extra_block_dw(conv_extra, block_filter[0], block_filter[1], 2, 'conv' + str(i + 2)) self.end_points.append(conv_extra) i += 1 return self.end_points
def __call__(self, x): conv_name = self.name if self.use_dcn: offset_mask = fluid.layers.conv2d( input=x, num_filters=self.filter_size * self.filter_size * 3, filter_size=self.filter_size, stride=self.stride, padding=self.padding, act=None, param_attr=ParamAttr(initializer=Constant(0.0), name=conv_name + "_conv_offset.w_0"), bias_attr=ParamAttr(initializer=Constant(0.0), name=conv_name + "_conv_offset.b_0"), name=conv_name + "_conv_offset") offset = offset_mask[:, :self.filter_size**2 * 2, :, :] mask = offset_mask[:, self.filter_size**2 * 2:, :, :] mask = fluid.layers.sigmoid(mask) x = fluid.layers.deformable_conv( input=x, offset=offset, mask=mask, num_filters=self.filters, filter_size=self.filter_size, stride=self.stride, padding=self.padding, groups=1, deformable_groups=1, im2col_step=1, param_attr=ParamAttr(name=conv_name + "_weights"), bias_attr=False, name=conv_name + ".conv2d.output.1") else: battr = None if self.bias_attr: battr = ParamAttr(name=conv_name + "_bias") x = fluid.layers.conv2d(input=x, num_filters=self.filters, filter_size=self.filter_size, stride=self.stride, padding=self.padding, act=None, param_attr=ParamAttr(name=conv_name + "_weights"), bias_attr=battr, name=conv_name + '.conv2d.output.1') if self.bn: if conv_name == "conv1": bn_name = "bn_" + conv_name else: bn_name = "bn" + conv_name[3:] norm_lr = 0. if self.freeze_norm else 1. # 归一化层学习率 norm_decay = self.norm_decay # 衰减 pattr = ParamAttr(name=bn_name + '_scale', learning_rate=norm_lr, regularizer=L2Decay(norm_decay)) # L2权重衰减正则化 battr = ParamAttr(name=bn_name + '_offset', learning_rate=norm_lr, regularizer=L2Decay(norm_decay)) # L2权重衰减正则化 global_stats = True if self.freeze_norm else False x = fluid.layers.batch_norm(input=x, name=bn_name + '.output.1', param_attr=pattr, bias_attr=battr, moving_mean_name=bn_name + '_mean', moving_variance_name=bn_name + '_variance', use_global_stats=global_stats) scale = fluid.framework._get_var(pattr.name) bias = fluid.framework._get_var(battr.name) if self.freeze_norm: scale.stop_gradient = True bias.stop_gradient = True if self.act == 'leaky': x = fluid.layers.leaky_relu(x, alpha=0.1) elif self.act == 'relu': x = fluid.layers.relu(x) return x
def __init__(self, backbone, output_stride=16, class_dim=1000, **kwargs): super(XceptionDeeplab, self).__init__() bottleneck_params = gen_bottleneck_params(backbone) self.backbone = backbone self._conv1 = ConvBNLayer(3, 32, 3, stride=2, padding=1, act="relu", name=self.backbone + "/entry_flow/conv1") self._conv2 = ConvBNLayer(32, 64, 3, stride=1, padding=1, act="relu", name=self.backbone + "/entry_flow/conv2") """ bottleneck_params = { "entry_flow": (3, [2, 2, 2], [128, 256, 728]), "middle_flow": (16, 1, 728), "exit_flow": (2, [2, 1], [[728, 1024, 1024], [1536, 1536, 2048]]) } if output_stride == 16: entry_block3_stride = 2 middle_block_dilation = 1 exit_block_dilations = (1, 2) elif output_stride == 8: entry_block3_stride = 1 middle_block_dilation = 2 exit_block_dilations = (2, 4) """ self.block_num = bottleneck_params["entry_flow"][0] self.strides = bottleneck_params["entry_flow"][1] self.chns = bottleneck_params["entry_flow"][2] self.strides = check_data(self.strides, self.block_num) self.chns = check_data(self.chns, self.block_num) self.entry_flow = [] self.middle_flow = [] self.stride = 2 self.output_stride = output_stride s = self.stride for i in range(self.block_num): stride = self.strides[i] if check_stride(s * self.strides[i], self.output_stride) else 1 xception_block = self.add_sublayer( self.backbone + "/entry_flow/block" + str(i + 1), Xception_Block( input_channels=64 if i == 0 else self.chns[i - 1], output_channels=self.chns[i], strides=[1, 1, self.stride], name=self.backbone + "/entry_flow/block" + str(i + 1))) self.entry_flow.append(xception_block) s = s * stride self.stride = s self.block_num = bottleneck_params["middle_flow"][0] self.strides = bottleneck_params["middle_flow"][1] self.chns = bottleneck_params["middle_flow"][2] self.strides = check_data(self.strides, self.block_num) self.chns = check_data(self.chns, self.block_num) s = self.stride for i in range(self.block_num): stride = self.strides[i] if check_stride(s * self.strides[i], self.output_stride) else 1 xception_block = self.add_sublayer( self.backbone + "/middle_flow/block" + str(i + 1), Xception_Block(input_channels=728, output_channels=728, strides=[1, 1, self.strides[i]], skip_conv=False, name=self.backbone + "/middle_flow/block" + str(i + 1))) self.middle_flow.append(xception_block) s = s * stride self.stride = s self.block_num = bottleneck_params["exit_flow"][0] self.strides = bottleneck_params["exit_flow"][1] self.chns = bottleneck_params["exit_flow"][2] self.strides = check_data(self.strides, self.block_num) self.chns = check_data(self.chns, self.block_num) s = self.stride stride = self.strides[0] if check_stride(s * self.strides[0], self.output_stride) else 1 self._exit_flow_1 = Xception_Block(728, self.chns[0], [1, 1, stride], name=self.backbone + "/exit_flow/block1") s = s * stride stride = self.strides[1] if check_stride(s * self.strides[1], self.output_stride) else 1 self._exit_flow_2 = Xception_Block( self.chns[0][-1], self.chns[1], [1, 1, stride], dilation=2, has_skip=False, activation_fn_in_separable_conv=True, name=self.backbone + "/exit_flow/block2") s = s * stride self.stride = s self._drop = Dropout(p=0.5) self._pool = Pool2D(pool_type="avg", global_pooling=True) self._fc = Linear(self.chns[1][-1], class_dim, param_attr=ParamAttr(name="fc_weights"), bias_attr=ParamAttr(name="fc_bias"))
def net(self, input): """ 构造模型 :param input: :return: """ blocks = [] scale = 1.0 class_num = 20 bottleneck_params_list = [ (1, 16, 1, 1), (6, 24, 2, 2), (6, 32, 3, 2), (6, 64, 4, 2), (6, 96, 3, 1), (6, 160, 3, 2), (6, 320, 1, 1), ] # MobileNet的第一个卷积层 input = self.conv_bn_layer( input, num_filters=int(32 * scale), filter_size=3, stride=2, padding=1, if_act=True, name='conv1_1') # bottleneck sequences # MobileNet 一共有7个bottleneck(即残差块) i = 1 in_c = int(32 * scale) for layer_setting in bottleneck_params_list: t, c, n, s = layer_setting i += 1 input = self.invresi_blocks( input=input, in_c=in_c, t=t, c=int(c * scale), n=n, s=s, name='conv' + str(i)) in_c = int(c * scale) blocks.append(input) #最后一个卷积层 input = self.conv_bn_layer( input=input, num_filters=int(1280 * scale) if scale > 1.0 else 1280, filter_size=1, stride=1, padding=0, if_act=True, name='conv9') #最后一个池化层 input = fluid.layers.pool2d( input=input, pool_size=7, pool_stride=1, pool_type='avg', global_pooling=True) #2种不同尺寸的特征 blocks = [blocks[-1], blocks[-3]] print('blocks[0]:',blocks[0].shape) print('blocks[1]:',blocks[1].shape) # yolo detector for i, block in enumerate(blocks): # yolo 中跨视域链接 if i > 0: print('route:',route.shape) print('block:',block.shape) block = fluid.layers.concat(input=[route, block], axis=1) # print(block.shape) route, tip = self.yolo_detection_block(block, num_filters=256 // (2 ** i), k=2,name='dect_'+str(i)) block_out = fluid.layers.conv2d( input=tip, num_filters=len(self.anchor_mask[i]) * (self.class_num + 5), # 5 elements represent x|y|h|w|score filter_size=1, stride=1, padding=0, act=None, name="block-out-" + str(i), param_attr=ParamAttr(initializer=fluid.initializer.Normal(0., 0.02)), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), regularizer=L2Decay(0.))) self.outputs.append(block_out) # 为了跨视域链接,差值方式提升特征图尺寸 if i < len(blocks) - 1: route = self.conv_bn_layer(route, 128 // (2 ** i), filter_size=1, stride=1, padding=0,name='route'+str(i)) route = self.upsample(route) return self.outputs
def _get_outputs(self, input, is_train=True): outputs = [] filter_list = [1, 3, 1, 3, 1] spp_stage = len(input) - self.spp_stage # get last out_layer_num blocks in reverse order out_layer_num = len(self.anchor_masks) blocks = input[-1:-out_layer_num - 1:-1] blocks[spp_stage] = self.spp_module( blocks[spp_stage], name=self.prefix_name + "spp_module") blocks = self.pan_module( blocks, filter_list=filter_list, name=self.prefix_name + 'pan_module') # reverse order back to input blocks = blocks[::-1] route = None for i, block in enumerate(blocks): if i > 0: # perform concat in first 2 detection_block route = self._conv_bn( route, ch_out=route.shape[1] * 2, filter_size=3, stride=2, padding=1, name=self.prefix_name + 'yolo_block.route.{}'.format(i)) block = fluid.layers.concat(input=[route, block], axis=1) ch_list = [block.shape[1] // 2 * k for k in [1, 2, 1, 2, 1]] block = self.stack_conv( block, ch_list=ch_list, filter_list=filter_list, name=self.prefix_name + 'yolo_block.stack_conv.{}'.format(i)) route = block block_out = self._conv_bn( block, ch_out=block.shape[1] * 2, filter_size=3, stride=1, padding=1, name=self.prefix_name + 'yolo_output.{}.conv.0'.format(i)) if self.iou_aware: num_filters = len(self.anchor_masks[i]) * (self.num_classes + 6) else: num_filters = len(self.anchor_masks[i]) * (self.num_classes + 5) block_out = fluid.layers.conv2d( input=block_out, num_filters=num_filters, filter_size=1, stride=1, padding=0, act=None, param_attr=ParamAttr(name=self.prefix_name + "yolo_output.{}.conv.1.weights".format(i)), bias_attr=ParamAttr( regularizer=L2Decay(0.), name=self.prefix_name + "yolo_output.{}.conv.1.bias".format(i))) outputs.append(block_out) return outputs
def net(self, input, class_dim=1000): scale = self.scale inplanes = self.inplanes cfg = self.cfg cls_ch_squeeze = self.cls_ch_squeeze cls_ch_expand = self.cls_ch_expand #conv1 conv = self.conv_bn_layer(input, filter_size=3, num_filters=self.make_divisible(inplanes * scale), stride=2, padding=1, num_groups=1, if_act=True, act='hard_swish', name='conv1') i = 0 inplanes = self.make_divisible(inplanes * scale) for layer_cfg in cfg: conv = self.residual_unit( input=conv, num_in_filter=inplanes, num_mid_filter=self.make_divisible(scale * layer_cfg[1]), num_out_filter=self.make_divisible(scale * layer_cfg[2]), act=layer_cfg[4], stride=layer_cfg[5], filter_size=layer_cfg[0], use_se=layer_cfg[3], name='conv' + str(i + 2)) inplanes = self.make_divisible(scale * layer_cfg[2]) i += 1 conv = self.conv_bn_layer(input=conv, filter_size=1, num_filters=self.make_divisible( scale * cls_ch_squeeze), stride=1, padding=0, num_groups=1, if_act=True, act='hard_swish', name='conv_last') conv = fluid.layers.pool2d(input=conv, pool_type='avg', global_pooling=True, use_cudnn=False) conv = fluid.layers.conv2d( input=conv, num_filters=cls_ch_expand, filter_size=1, stride=1, padding=0, act=None, param_attr=ParamAttr(name='last_1x1_conv_weights'), bias_attr=False) conv = fluid.layers.hard_swish(conv) drop = fluid.layers.dropout(x=conv, dropout_prob=0.2) out = fluid.layers.fc(input=drop, size=class_dim, param_attr=ParamAttr(name='fc_weights'), bias_attr=ParamAttr(name='fc_offset')) return out, drop
def _get_output(self, input, feat_lvl): """ Get anchor and FPN RPN head output at one level. Args: input(Variable): Body feature from backbone. feat_lvl(int): Indicate the level of rpn output corresponding to the level of feature map. Return: rpn_cls_score(Variable): Output of one level of fpn rpn head with shape of [N, num_anchors, H, W]. rpn_bbox_pred(Variable): Output of one level of fpn rpn head with shape of [N, num_anchors * 4, H, W]. """ slvl = str(feat_lvl) conv_name = 'conv_rpn_fpn' + slvl cls_name = 'rpn_cls_logits_fpn' + slvl bbox_name = 'rpn_bbox_pred_fpn' + slvl conv_share_name = 'conv_rpn_fpn' + str(self.min_level) cls_share_name = 'rpn_cls_logits_fpn' + str(self.min_level) bbox_share_name = 'rpn_bbox_pred_fpn' + str(self.min_level) num_anchors = len(self.anchor_generator.aspect_ratios) conv_rpn_fpn = fluid.layers.conv2d( input=input, num_filters=self.num_chan, filter_size=3, padding=1, act='relu', name=conv_name, param_attr=ParamAttr(name=conv_share_name + '_w', initializer=Normal(loc=0., scale=0.01)), bias_attr=ParamAttr(name=conv_share_name + '_b', learning_rate=2., regularizer=L2Decay(0.))) self.anchors, self.anchor_var = self.anchor_generator( input=conv_rpn_fpn, anchor_sizes=(self.anchor_start_size * 2.**(feat_lvl - self.min_level), ), stride=(2.**feat_lvl, 2.**feat_lvl)) cls_num_filters = num_anchors * self.num_classes self.rpn_cls_score = fluid.layers.conv2d( input=conv_rpn_fpn, num_filters=cls_num_filters, filter_size=1, act=None, name=cls_name, param_attr=ParamAttr(name=cls_share_name + '_w', initializer=Normal(loc=0., scale=0.01)), bias_attr=ParamAttr(name=cls_share_name + '_b', learning_rate=2., regularizer=L2Decay(0.))) self.rpn_bbox_pred = fluid.layers.conv2d( input=conv_rpn_fpn, num_filters=num_anchors * 4, filter_size=1, act=None, name=bbox_name, param_attr=ParamAttr(name=bbox_share_name + '_w', initializer=Normal(loc=0., scale=0.01)), bias_attr=ParamAttr(name=bbox_share_name + '_b', learning_rate=2., regularizer=L2Decay(0.))) return self.rpn_cls_score, self.rpn_bbox_pred
from layers.bn import BatchNorm from layers.loss import MSELoss from layers.activations import * if __name__ == '__main__': use_gpu = False lr = 0.001 startup_prog = fluid.Program() train_prog = fluid.Program() with fluid.program_guard(train_prog, startup_prog): with fluid.unique_name.guard(): inputs = P.data(name='input_1', shape=[-1, 3, 28, 28], append_batch_size=False, dtype='float32') conv01_out_tensor = fluid.layers.conv2d(input=inputs, num_filters=8, filter_size=1, stride=1, padding=0, param_attr=ParamAttr(name="conv01_weights"), bias_attr=ParamAttr(name="conv01_bias")) bn_name = "bn01" bn01_out_tensor = fluid.layers.batch_norm( input=conv01_out_tensor, is_test=False, param_attr=ParamAttr(initializer=fluid.initializer.Constant(1.0), name=bn_name + '_scale'), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), name=bn_name + '_offset'), moving_mean_name=bn_name + '_mean', moving_variance_name=bn_name + '_variance') act01_out_tensor = fluid.layers.leaky_relu(bn01_out_tensor, alpha=0.1) conv02_out_tensor = fluid.layers.conv2d(input=act01_out_tensor, num_filters=8, filter_size=3, stride=1, padding=1, param_attr=ParamAttr(name="conv02_weights"), bias_attr=ParamAttr(name="conv02_bias")) bn_name = "bn02"
def get_DQN_prediction(self, image, target=False): image = image / 255.0 variable_field = 'target' if target else 'policy' conv1 = fluid.layers.conv2d( input=image, num_filters=32, filter_size=5, stride=1, padding=2, act='relu', param_attr=ParamAttr(name='{}_conv1'.format(variable_field)), bias_attr=ParamAttr(name='{}_conv1_b'.format(variable_field))) max_pool1 = fluid.layers.pool2d(input=conv1, pool_size=2, pool_stride=2, pool_type='max') conv2 = fluid.layers.conv2d( input=max_pool1, num_filters=32, filter_size=5, stride=1, padding=2, act='relu', param_attr=ParamAttr(name='{}_conv2'.format(variable_field)), bias_attr=ParamAttr(name='{}_conv2_b'.format(variable_field))) max_pool2 = fluid.layers.pool2d(input=conv2, pool_size=2, pool_stride=2, pool_type='max') conv3 = fluid.layers.conv2d( input=max_pool2, num_filters=64, filter_size=4, stride=1, padding=1, act='relu', param_attr=ParamAttr(name='{}_conv3'.format(variable_field)), bias_attr=ParamAttr(name='{}_conv3_b'.format(variable_field))) max_pool3 = fluid.layers.pool2d(input=conv3, pool_size=2, pool_stride=2, pool_type='max') conv4 = fluid.layers.conv2d( input=max_pool3, num_filters=64, filter_size=3, stride=1, padding=1, act='relu', param_attr=ParamAttr(name='{}_conv4'.format(variable_field)), bias_attr=ParamAttr(name='{}_conv4_b'.format(variable_field))) flatten = fluid.layers.flatten(conv4, axis=1) value = fluid.layers.fc( input=flatten, size=1, param_attr=ParamAttr(name='{}_value_fc'.format(variable_field)), bias_attr=ParamAttr(name='{}_value_fc_b'.format(variable_field))) advantage = fluid.layers.fc( input=flatten, size=self.action_dim, param_attr=ParamAttr( name='{}_advantage_fc'.format(variable_field)), bias_attr=ParamAttr( name='{}_advantage_fc_b'.format(variable_field))) Q = advantage + ( value - fluid.layers.reduce_mean(advantage, dim=1, keep_dim=True)) return Q
def _multi_box_head(self, inputs, image, num_classes=2, use_density_prior_box=False): def permute_and_reshape(input, last_dim): trans = fluid.layers.transpose(input, perm=[0, 2, 3, 1]) compile_shape = [0, -1, last_dim] return fluid.layers.reshape(trans, shape=compile_shape) locs, confs = [], [] boxes, vars = [], [] lmk_locs = [] b_attr = ParamAttr(learning_rate=2., regularizer=L2Decay(0.)) for i, input in enumerate(inputs): min_size = self.min_sizes[i] if use_density_prior_box: densities = self.densities[i] box, var = fluid.layers.density_prior_box( input, image, densities=densities, fixed_sizes=min_size, fixed_ratios=[1.], clip=False, offset=0.5, steps=[self.steps[i]] * 2) else: box, var = fluid.layers.prior_box(input, image, min_sizes=min_size, max_sizes=None, steps=[self.steps[i]] * 2, aspect_ratios=[1.], clip=False, flip=False, offset=0.5) num_boxes = box.shape[2] box = fluid.layers.reshape(box, shape=[-1, 4]) var = fluid.layers.reshape(var, shape=[-1, 4]) num_loc_output = num_boxes * 4 num_conf_output = num_boxes * num_classes # get loc mbox_loc = fluid.layers.conv2d(input, num_loc_output, 3, 1, 1, bias_attr=b_attr) loc = permute_and_reshape(mbox_loc, 4) # get conf mbox_conf = fluid.layers.conv2d(input, num_conf_output, 3, 1, 1, bias_attr=b_attr) conf = permute_and_reshape(mbox_conf, num_classes) if self.with_lmk: # get landmark lmk_loc_output = num_boxes * 10 lmk_box_loc = fluid.layers.conv2d( input, lmk_loc_output, 3, 1, 1, param_attr=ParamAttr(name='lmk' + str(i) + '_weights'), bias_attr=False) lmk_loc = permute_and_reshape(lmk_box_loc, 10) lmk_locs.append(lmk_loc) locs.append(loc) confs.append(conf) boxes.append(box) vars.append(var) face_mbox_loc = fluid.layers.concat(locs, axis=1) face_mbox_conf = fluid.layers.concat(confs, axis=1) prior_boxes = fluid.layers.concat(boxes) box_vars = fluid.layers.concat(vars) if self.with_lmk: self.landmark = fluid.layers.concat(lmk_locs, axis=1) return face_mbox_loc, face_mbox_conf, prior_boxes, box_vars
def ConvNorm(input, num_filters, filter_size, stride=1, groups=1, norm_decay=0., norm_type='affine_channel', norm_groups=32, dilation=1, lr_scale=1, freeze_norm=False, act=None, norm_name=None, initializer=None, bias_attr=False, name=None): fan = num_filters if bias_attr: bias_para = ParamAttr( name=name + "_bias", initializer=fluid.initializer.Constant(value=0), learning_rate=lr_scale * 2) else: bias_para = False conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=((filter_size - 1) // 2) * dilation, dilation=dilation, groups=groups, act=None, param_attr=ParamAttr( name=name + "_weights", initializer=initializer, learning_rate=lr_scale), bias_attr=bias_para, name=name + '.conv2d.output.1') norm_lr = 0. if freeze_norm else 1. pattr = ParamAttr( name=norm_name + '_scale', learning_rate=norm_lr * lr_scale, regularizer=L2Decay(norm_decay)) battr = ParamAttr( name=norm_name + '_offset', learning_rate=norm_lr * lr_scale, regularizer=L2Decay(norm_decay)) if norm_type in ['bn', 'sync_bn']: global_stats = True if freeze_norm else False out = fluid.layers.batch_norm( input=conv, act=act, name=norm_name + '.output.1', param_attr=pattr, bias_attr=battr, moving_mean_name=norm_name + '_mean', moving_variance_name=norm_name + '_variance', use_global_stats=global_stats) scale = fluid.framework._get_var(pattr.name) bias = fluid.framework._get_var(battr.name) elif norm_type == 'gn': out = fluid.layers.group_norm( input=conv, act=act, name=norm_name + '.output.1', groups=norm_groups, param_attr=pattr, bias_attr=battr) scale = fluid.framework._get_var(pattr.name) bias = fluid.framework._get_var(battr.name) elif norm_type == 'affine_channel': scale = fluid.layers.create_parameter( shape=[conv.shape[1]], dtype=conv.dtype, attr=pattr, default_initializer=fluid.initializer.Constant(1.)) bias = fluid.layers.create_parameter( shape=[conv.shape[1]], dtype=conv.dtype, attr=battr, default_initializer=fluid.initializer.Constant(0.)) out = fluid.layers.affine_channel( x=conv, scale=scale, bias=bias, act=act) if freeze_norm: scale.stop_gradient = True bias.stop_gradient = True return out
def conv_bn_layer_ac(self, input, num_filters, filter_size, stride=1, groups=1, act=None, name=None): """ ACNet conv bn """ padding = (filter_size - 1) // 2 square_conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, groups=groups, act=act if self.deploy else None, param_attr=ParamAttr(name=name + "_acsquare_weights"), bias_attr=ParamAttr(name=name + "_acsquare_bias") if self.deploy else False, name=name + '.acsquare.conv2d.output.1') if self.deploy: return square_conv else: ver_conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=(filter_size, 1), stride=stride, padding=(padding, 0), groups=groups, act=None, param_attr=ParamAttr(name=name + "_acver_weights"), bias_attr=False, name=name + '.acver.conv2d.output.1') hor_conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=(1, filter_size), stride=stride, padding=(0, padding), groups=groups, act=None, param_attr=ParamAttr(name=name + "_achor_weights"), bias_attr=False, name=name + '.achor.conv2d.output.1') if name == "conv1": bn_name = "bn_" + name else: bn_name = "bn" + name[3:] square_bn = fluid.layers.batch_norm( input=square_conv, act=None, name=bn_name + '.acsquare.output.1', param_attr=ParamAttr(name=bn_name + '_acsquare_scale'), bias_attr=ParamAttr(bn_name + '_acsquare_offset'), moving_mean_name=bn_name + '_acsquare_mean', moving_variance_name=bn_name + '_acsquare_variance', ) ver_bn = fluid.layers.batch_norm( input=ver_conv, act=None, name=bn_name + '.acver.output.1', param_attr=ParamAttr(name=bn_name + '_acver_scale'), bias_attr=ParamAttr(bn_name + '_acver_offset'), moving_mean_name=bn_name + '_acver_mean', moving_variance_name=bn_name + '_acver_variance', ) hor_bn = fluid.layers.batch_norm( input=hor_conv, act=None, name=bn_name + '.achor.output.1', param_attr=ParamAttr(name=bn_name + '_achor_scale'), bias_attr=ParamAttr(bn_name + '_achor_offset'), moving_mean_name=bn_name + '_achor_mean', moving_variance_name=bn_name + '_achor_variance', ) return fluid.layers.elementwise_add(x=square_bn, y=ver_bn + hor_bn, act=act)
def net(self, input, class_dim=1000, end_points=None, decode_points=None): scale = self.scale change_depth = self.change_depth #if change_depth is True, the new depth is 1.4 times as deep as before. bottleneck_params_list = self.bottleneck_params_list decode_ends = dict() def check_points(count, points): if points is None: return False else: if isinstance(points, list): return (True if count in points else False) else: return (True if count == points else False) #conv1 input = self.conv_bn_layer(input, num_filters=int(32 * scale), filter_size=3, stride=2, padding=1, if_act=True, name='conv1_1') layer_count = 1 #print("node test:", layer_count, input.shape) if check_points(layer_count, decode_points): decode_ends[layer_count] = input if check_points(layer_count, end_points): return input, decode_ends # bottleneck sequences i = 1 in_c = int(32 * scale) for layer_setting in bottleneck_params_list: t, c, n, s = layer_setting i += 1 input, depthwise_output = self.invresi_blocks(input=input, in_c=in_c, t=t, c=int(c * scale), n=n, s=s, name='conv' + str(i)) in_c = int(c * scale) layer_count += n #print("node test:", layer_count, input.shape) if check_points(layer_count, decode_points): decode_ends[layer_count] = depthwise_output if check_points(layer_count, end_points): return input, decode_ends #last_conv input = self.conv_bn_layer( input=input, num_filters=int(1280 * scale) if scale > 1.0 else 1280, filter_size=1, stride=1, padding=0, if_act=True, name='conv9') input = fluid.layers.pool2d(input=input, pool_size=7, pool_stride=1, pool_type='avg', global_pooling=True) output = fluid.layers.fc(input=input, size=class_dim, param_attr=ParamAttr(name='fc10_weights'), bias_attr=ParamAttr(name='fc10_offset')) return output
def net(self, input, class_dim=1000, scale=1.0): # conv1: 112x112 input = self.conv_bn_layer(input, filter_size=3, channels=3, num_filters=int(32 * scale), stride=2, padding=1) # 56x56 input = self.depthwise_separable(input, num_filters1=32, num_filters2=64, num_groups=32, stride=1, scale=scale) input = self.depthwise_separable(input, num_filters1=64, num_filters2=128, num_groups=64, stride=2, scale=scale) # 28x28 input = self.depthwise_separable(input, num_filters1=128, num_filters2=128, num_groups=128, stride=1, scale=scale) input = self.depthwise_separable(input, num_filters1=128, num_filters2=256, num_groups=128, stride=2, scale=scale) # 14x14 input = self.depthwise_separable(input, num_filters1=256, num_filters2=256, num_groups=256, stride=1, scale=scale) input = self.depthwise_separable(input, num_filters1=256, num_filters2=512, num_groups=256, stride=2, scale=scale) # 14x14 for i in range(5): input = self.depthwise_separable(input, num_filters1=512, num_filters2=512, num_groups=512, stride=1, scale=scale) # 7x7 input = self.depthwise_separable(input, num_filters1=512, num_filters2=1024, num_groups=512, stride=2, scale=scale) input = self.depthwise_separable(input, num_filters1=1024, num_filters2=1024, num_groups=1024, stride=1, scale=scale) input = fluid.layers.pool2d(input=input, pool_size=0, pool_stride=1, pool_type='avg', global_pooling=True) output = fluid.layers.fc(input=input, size=class_dim, act='softmax', param_attr=ParamAttr(initializer=MSRA())) return output
def net(self, input, bn_size=4, dropout=0, class_dim=1000, lesion_map=None, CAM=False): layers = self.layers supported_layers = [121, 161, 169, 201, 264] assert layers in supported_layers, \ "supported layers are {} but input layer is {}".format(supported_layers, layers) densenet_spec = { 121: (64, 32, [6, 12, 24, 16]), 161: (96, 48, [6, 12, 36, 24]), 169: (64, 32, [6, 12, 32, 32]), 201: (64, 32, [6, 12, 48, 32]), 264: (64, 32, [6, 12, 64, 48]) } num_init_features, growth_rate, block_config = densenet_spec[layers] conv = fluid.layers.conv2d(input=input, num_filters=num_init_features, filter_size=7, stride=2, padding=3, act=None, param_attr=ParamAttr(name="conv1_weights"), bias_attr=False) conv = fluid.layers.batch_norm( input=conv, act='relu', param_attr=ParamAttr(name='conv1_bn_scale'), bias_attr=ParamAttr(name='conv1_bn_offset'), moving_mean_name='conv1_bn_mean', moving_variance_name='conv1_bn_variance') conv = fluid.layers.pool2d(input=conv, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max') num_features = num_init_features for i, num_layers in enumerate(block_config): conv = self.make_dense_block(conv, num_layers, bn_size, growth_rate, dropout, name='conv' + str(i + 2)) num_features = num_features + num_layers * growth_rate if i != len(block_config) - 1: conv = self.make_transition(conv, num_features // 2, name='conv' + str(i + 2) + '_blk') num_features = num_features // 2 # 16, 16, 1024 conv = fluid.layers.batch_norm( input=conv, act='relu', param_attr=ParamAttr(name='conv5_blk_bn_scale'), bias_attr=ParamAttr(name='conv5_blk_bn_offset'), moving_mean_name='conv5_blk_bn_mean', moving_variance_name='conv5_blk_bn_variance') ### Modified by [email protected] @ 2019-9-10 ### # x.shape = 16,16,1024 -concat-> 16,16,1025 -conv1x1-> 16,16,1024 if lesion_map is not None: if not isinstance(lesion_map, str): conv = fluid.layers.concat([conv, lesion_map], axis=1, name='lesion_concat') conv = fluid.layers.conv2d( conv, num_filters=1024, filter_size=1, stride=1, padding=0, groups=1, act=None, param_attr=ParamAttr(name="lesion_conv"), bias_attr=False) conv = fluid.layers.batch_norm( conv, act='relu', param_attr=ParamAttr(name='lesion_bn_scale'), bias_attr=ParamAttr(name='lesion_bn_offset'), moving_mean_name='lesion_bn_mean', moving_variance_name='lesion_bn_variance') if CAM: heatmaps = conv conv = fluid.layers.pool2d(input=conv, pool_type='avg', global_pooling=True) stdv = 1.0 / math.sqrt(conv.shape[1] * 1.0) out = fluid.layers.fc(input=conv, size=class_dim, param_attr=fluid.param_attr.ParamAttr( initializer=fluid.initializer.Uniform( -stdv, stdv), name="fc_weights"), bias_attr=ParamAttr(name='fc_offset')) if CAM: return (out, heatmaps) else: return out
def bottleneck(self, input, num_filters, stride, is_first, name, dcn_v2=False, gcb=False, gcb_name=None, sac=False, rfp=False, rfp_feat=None, eca_k_size=None): if self.variant == 'a': stride1, stride2 = stride, 1 else: stride1, stride2 = 1, stride # ResNeXt groups = getattr(self, 'groups', 1) group_width = getattr(self, 'group_width', -1) if groups == 1: expand = 4 elif (groups * group_width) == 256: expand = 1 else: # FIXME hard code for now, handles 32x4d, 64x4d and 32x8d num_filters = num_filters // 2 expand = 2 conv_name1, conv_name2, conv_name3, \ shortcut_name = self.na.fix_bottleneck_name(name) std_senet = getattr(self, 'std_senet', False) if std_senet: conv_def = [ [int(num_filters / 2), 1, stride1, 'relu', 1, conv_name1], [num_filters, 3, stride2, 'relu', groups, conv_name2], [num_filters * expand, 1, 1, None, 1, conv_name3] ] else: conv_def = [[num_filters, 1, stride1, 'relu', 1, conv_name1], [num_filters, 3, stride2, 'relu', groups, conv_name2], [num_filters * expand, 1, 1, None, 1, conv_name3]] residual = input for i, (c, k, s, act, g, _name) in enumerate(conv_def): residual = self._conv_norm( input=residual, num_filters=c, filter_size=k, stride=s, act=act, groups=g, name=_name, dcn_v2=(i == 1 and dcn_v2), with_sac=(i == 1 and sac)) short = self._shortcut( input, num_filters * expand, stride, is_first=is_first, name=shortcut_name) # Squeeze-and-Excitation if callable(getattr(self, '_squeeze_excitation', None)): residual = self._squeeze_excitation( input=residual, num_channels=num_filters, name='fc' + name) # efficient channel attention if eca_k_size: residual = eca_layer(residual, eca_k_size, name='eca_' + name) if gcb: residual = add_gc_block(residual, name=gcb_name, **self.gcb_params) if rfp and rfp_feat is not None: # add recursive connection out = short + residual # 1x1 conv rfp_feat = fluid.layers.conv2d( input=rfp_feat, num_filters=num_filters * expand, filter_size=1, stride=1, padding=0, param_attr=ParamAttr( initializer=Constant(0.0), name=name + "rfp.w"), bias_attr=ParamAttr( initializer=Constant(0.0), name=name + "rfp.b"), act=None, name=name + ".rfp.output") out = fluid.layers.elementwise_add( x=out, y=rfp_feat, act='relu', name=name + ".add.output.5") else: # normal bottleneck out = fluid.layers.elementwise_add( x=short, y=residual, act='relu', name=name + ".add.output.5") return out