def _conv_norm(self, input, ch_out, filter_size, stride, padding, act='mish', name=None): conv = fluid.layers.conv2d(input=input, num_filters=ch_out, filter_size=filter_size, stride=stride, padding=padding, act=None, param_attr=ParamAttr(name=name + ".conv.weights"), bias_attr=False) bn_name = name + ".bn" bn_param_attr = ParamAttr(regularizer=L2Decay(float(self.norm_decay)), name=bn_name + '.scale') bn_bias_attr = ParamAttr(regularizer=L2Decay(float(self.norm_decay)), name=bn_name + '.offset') out = fluid.layers.batch_norm(input=conv, act=None, param_attr=bn_param_attr, bias_attr=bn_bias_attr, moving_mean_name=bn_name + '.mean', moving_variance_name=bn_name + '.var') if act == 'mish': out = self._mish(out) return out
def __init__(self, name_scope, cfg, mode='train'): super(suffixnet, self).__init__() self.cfg = cfg self.mode = mode self.mask_out = fluid.dygraph.Conv2DTranspose( num_channels=2048, num_filters=self.cfg.dim_reduced, filter_size=2, stride=2, act='relu', param_attr=ParamAttr(name='conv5_mask_w', initializer=MSRA(uniform=False)), bias_attr=ParamAttr(name='conv5_mask_b', learning_rate=2., regularizer=L2Decay(0.))) self.mask_fcn_logits = fluid.dygraph.Conv2D( num_channels=self.cfg.dim_reduced, num_filters=self.cfg.class_num, filter_size=1, act='sigmoid' if self.mode != 'train' else None, param_attr=ParamAttr(name='mask_fcn_logits_w', initializer=MSRA(uniform=False)), bias_attr=ParamAttr(name='mask_fcn_logits_b', learning_rate=2., regularizer=L2Decay(0.0)))
def __call__(self, inputs, name=''): x = fluid.layers.swish(inputs) # depthwise x = fluid.layers.conv2d(x, self.num_chan, filter_size=3, padding='SAME', groups=self.num_chan, param_attr=ParamAttr(initializer=Xavier(), name=name + '_dw_w'), bias_attr=False) # pointwise x = fluid.layers.conv2d(x, self.num_chan, filter_size=1, param_attr=ParamAttr(initializer=Xavier(), name=name + '_pw_w'), bias_attr=ParamAttr(regularizer=L2Decay(0.), name=name + '_pw_b')) # bn + act x = fluid.layers.batch_norm( x, momentum=0.997, epsilon=1e-04, param_attr=ParamAttr(initializer=Constant(1.0), regularizer=L2Decay(0.), name=name + '_bn_w'), bias_attr=ParamAttr(regularizer=L2Decay(0.), name=name + '_bn_b')) return x
def conv_bn(self, input, # 输入 num_filters, # 卷积核数量 filter_size, # 卷积核大小 stride, # 步幅 padding, # 填充 use_cudnn=True): # 2d卷积操作 conv = fluid.layers.conv2d(input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, act=None, use_cudnn=use_cudnn, # 是否使用cudnn param_attr=ParamAttr(initializer=fluid.initializer.Normal(0., 0.02)), bias_attr=False) # batch_norm中的参数不需要参与正则化 # 正则化的目的,是为了防止过拟合,较小的L2值能防止过拟合 param_attr = ParamAttr(initializer=fluid.initializer.Normal(0., 0.02), regularizer=L2Decay(0.)) bias_attr = ParamAttr(initializer=fluid.initializer.Constant(0.0), regularizer=L2Decay(0.)) out = fluid.layers.batch_norm(input=conv, act=None, param_attr=param_attr, bias_attr=bias_attr) # leaky_relu: Leaky ReLU是给所有负值赋予一个非零斜率 out = fluid.layers.leaky_relu(out, 0.1) return out
def conv_bn_layer(input, ch_out, filter_size, stride, padding, act='leaky', is_test=True, name=None): conv1 = fluid.layers.conv2d( input=input, num_filters=ch_out, filter_size=filter_size, stride=stride, padding=padding, act=None, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0., 0.02), name=name + ".conv.weights"), bias_attr=False) bn_name = name + ".bn" out = fluid.layers.batch_norm( input=conv1, act=None, is_test=is_test, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0., 0.02), regularizer=L2Decay(0.), name=bn_name + '.scale'), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), regularizer=L2Decay(0.), name=bn_name + '.offset'), moving_mean_name=bn_name + '.mean', moving_variance_name=bn_name + '.var') if act == 'leaky': out = fluid.layers.leaky_relu(x=out, alpha=0.1) return out
def conv_bn(self, input, num_filters, filter_size, stride, padding, use_cudnn=True): ''' DarkNet53里基本卷积块:Conv + BN + LeakyReLU ''' conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, act=None, use_cudnn=use_cudnn, param_attr=ParamAttr( initializer=fluid.initializer.Normal(0., 0.02)), bias_attr=False) # batch_norm中的参数不需要参与正则化,所以主动使用正则系数为0的正则项屏蔽掉 out = fluid.layers.batch_norm( input=conv, act=None, param_attr=ParamAttr(initializer=fluid.initializer.Normal( 0., 0.02), regularizer=L2Decay(0.)), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), regularizer=L2Decay(0.))) # 在batch_norm中使用 leaky 的话,只能使用默认的 alpha=0.02;如果需要设值,必须提出去单独来 out = fluid.layers.leaky_relu(out, 0.1) return out
def _conv_bn(self, input, ch_out, filter_size, stride, padding, act='leaky', is_test=True, name=None): conv = fluid.layers.conv2d(input=input, num_filters=ch_out, filter_size=filter_size, stride=stride, padding=padding, act=None, param_attr=ParamAttr(name=name + ".conv.weights"), bias_attr=False) bn_name = name + ".bn" bn_param_attr = ParamAttr(regularizer=L2Decay(self.norm_decay), name=bn_name + '.scale') bn_bias_attr = ParamAttr(regularizer=L2Decay(self.norm_decay), name=bn_name + '.offset') out = fluid.layers.batch_norm(input=conv, act=None, is_test=is_test, param_attr=bn_param_attr, bias_attr=bn_bias_attr, moving_mean_name=bn_name + '.mean', moving_variance_name=bn_name + '.var') if act == 'leaky': out = fluid.layers.leaky_relu(x=out, alpha=0.1) return out
def box_subnet(self, subnet_input, num_conv=4, name=None): subnet_blob = subnet_input for i in range(num_conv): subnet_blob_in = subnet_blob subnet_blob = fluid.layers.conv2d( input=subnet_blob_in, num_filters=256, filter_size=3, stride=1, padding=1, act='relu', name=name + "_sub{}_reg".format(i), param_attr=ParamAttr(name="sub{}_reg_w".format(i), initializer=Normal(loc=0., scale=0.01)), bias_attr=ParamAttr(name="sub{}_reg_b".format(i), learning_rate=2., regularizer=L2Decay(0.))) num_anchors = cfg.scales_per_octave * len(cfg.aspect_ratio) out_channel = 4 * num_anchors out = fluid.layers.conv2d(input=subnet_blob, num_filters=out_channel, filter_size=3, stride=1, padding=1, act=None, name=name + '_bbox_pred', param_attr=ParamAttr( name='bbox_pred_w', initializer=Normal(loc=0., scale=0.01)), bias_attr=ParamAttr(name='bbox_pred_b', learning_rate=2., regularizer=L2Decay(0.))) return out
def _mask_conv_head(self, roi_feat, num_convs): for i in range(num_convs): layer_name = "mask_inter_feat_" + str(i + 1) fan = self.num_chan_reduced * 3 * 3 roi_feat = fluid.layers.conv2d( input=roi_feat, num_filters=self.num_chan_reduced, filter_size=3, padding=1 * self.dilation, act='relu', stride=1, dilation=self.dilation, name=layer_name, param_attr=ParamAttr(name=layer_name + '_w', initializer=MSRA(uniform=False, fan_in=fan)), bias_attr=ParamAttr(name=layer_name + '_b', learning_rate=2., regularizer=L2Decay(0.))) fan = roi_feat.shape[1] * 2 * 2 feat = fluid.layers.conv2d_transpose( input=roi_feat, num_filters=self.num_chan_reduced, filter_size=2, stride=2, act='relu', param_attr=ParamAttr(name='conv5_mask_w', initializer=MSRA(uniform=False, fan_in=fan)), bias_attr=ParamAttr(name='conv5_mask_b', learning_rate=2., regularizer=L2Decay(0.))) return feat
def _se_block(self, input, num_out_filter, ratio=4, name=None): lr_idx = self.curr_stage // 3 lr_idx = min(lr_idx, len(self.lr_mult_list) - 1) lr_mult = self.lr_mult_list[lr_idx] num_mid_filter = int(num_out_filter // ratio) pool = fluid.layers.pool2d(input=input, pool_type='avg', global_pooling=True, use_cudnn=False) conv1 = fluid.layers.conv2d( input=pool, filter_size=1, num_filters=num_mid_filter, act='relu', param_attr=ParamAttr(name=name + '_1_weights', learning_rate=lr_mult, regularizer=L2Decay(self.conv_decay)), bias_attr=ParamAttr(name=name + '_1_offset', learning_rate=lr_mult, regularizer=L2Decay(self.conv_decay))) conv2 = fluid.layers.conv2d( input=conv1, filter_size=1, num_filters=num_out_filter, act='hard_sigmoid', param_attr=ParamAttr(name=name + '_2_weights', learning_rate=lr_mult, regularizer=L2Decay(self.conv_decay)), bias_attr=ParamAttr(name=name + '_2_offset', learning_rate=lr_mult, regularizer=L2Decay(self.conv_decay))) scale = fluid.layers.elementwise_mul(x=input, y=conv2, axis=0) return scale
def fpn(up_from, up_to): ch = up_to.shape[1] b_attr = ParamAttr(learning_rate=2., regularizer=L2Decay(0.)) conv1 = fluid.layers.conv2d( up_from, ch, 1, act='relu', bias_attr=b_attr) if self.use_transposed_conv2d: w_attr = ParamAttr( learning_rate=0., regularizer=L2Decay(0.), initializer=Bilinear()) upsampling = fluid.layers.conv2d_transpose( conv1, ch, output_size=None, filter_size=4, padding=1, stride=2, groups=ch, param_attr=w_attr, bias_attr=False, use_cudnn=True) else: upsampling = fluid.layers.resize_bilinear( conv1, out_shape=up_to.shape[2:]) conv2 = fluid.layers.conv2d( up_to, ch, 1, act='relu', bias_attr=b_attr) if self.is_infer: upsampling = fluid.layers.crop(upsampling, shape=conv2) # eltwise mul conv_fuse = upsampling * conv2 return conv_fuse
def __call__(self, roi_feat): fan = roi_feat.shape[1] * roi_feat.shape[2] * roi_feat.shape[3] fc6 = fluid.layers.fc(input=roi_feat, size=self.mlp_dim, act='relu', name='fc6', param_attr=ParamAttr( name='fc6_w', initializer=Xavier(fan_out=fan)), bias_attr=ParamAttr(name='fc6_b', learning_rate=2., regularizer=L2Decay(0.))) head_feat = fluid.layers.fc(input=fc6, size=self.mlp_dim, act='relu', name='fc7', param_attr=ParamAttr(name='fc7_w', initializer=Xavier()), bias_attr=ParamAttr( name='fc7_b', learning_rate=2., regularizer=L2Decay(0.))) return head_feat
def _bbox_subnet(self, body_feats, spatial_scale): """ Get bounding box predictions of all level FPN level. Args: fpn_dict(dict): A dictionary represents the output of FPN with their name. spatial_scale(list): A list of multiplicative spatial scale factor. Returns: bbox_pred_input(list): Bounding box prediction of all input fpn levels. """ assert len(body_feats) == self.max_level - self.min_level + 1 fpn_name_list = list(body_feats.keys()) bbox_pred_list = [] for lvl in range(self.min_level, self.max_level + 1): fpn_name = fpn_name_list[self.max_level - lvl] subnet_blob = body_feats[fpn_name] for i in range(self.num_convs_per_octave): conv_name = 'retnet_bbox_conv_n{}_fpn{}'.format(i, lvl) conv_share_name = 'retnet_bbox_conv_n{}_fpn{}'.format( i, self.min_level) subnet_blob_in = subnet_blob subnet_blob = fluid.layers.conv2d( input=subnet_blob_in, num_filters=self.num_chan, filter_size=3, stride=1, 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.))) # bbox prediction bbox_name = 'retnet_bbox_pred_fpn{}'.format(lvl) bbox_share_name = 'retnet_bbox_pred_fpn{}'.format(self.min_level) num_anchors = self.num_scales_per_octave * len( self.anchor_generator.aspect_ratios) bbox_dim = num_anchors * 4 out_bbox = fluid.layers.conv2d( input=subnet_blob, num_filters=bbox_dim, filter_size=3, stride=1, padding=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.))) bbox_pred_list.append(out_bbox) return bbox_pred_list
def _conv_norm(self, input, filter_size, num_filters, stride, padding, num_groups=1, act='relu', use_cudnn=True, name=None): parameter_attr = ParamAttr( learning_rate=self.conv_learning_rate, initializer=fluid.initializer.MSRA(), name=name + "_weights") conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, groups=num_groups, act=None, use_cudnn=use_cudnn, param_attr=parameter_attr, bias_attr=False) bn_name = name + "_bn" norm_decay = self.norm_decay bn_param_attr = ParamAttr(regularizer=L2Decay(norm_decay), name=bn_name + '_scale') bn_bias_attr = ParamAttr(regularizer=L2Decay(norm_decay), name=bn_name + '_offset') return fluid.layers.batch_norm( input=conv, act=act, param_attr=bn_param_attr, bias_attr=bn_bias_attr, moving_mean_name=bn_name + '_mean', moving_variance_name=bn_name + '_variance')
def _bn(self, input, act=None, bn_name=None): 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)) global_stats = True if self.freeze_norm else False out = fluid.layers.batch_norm( input=input, 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) if self.freeze_norm: scale.stop_gradient = True bias.stop_gradient = True return out
def __init__(self, ch_in, ch_out, filter_size=3, stride=1, groups=1, padding=0, act="leaky", is_test=True): super(ConvBNLayer, self).__init__() self.conv = Conv2D(num_channels=ch_in, num_filters=ch_out, filter_size=filter_size, stride=stride, padding=padding, groups=groups, param_attr=ParamAttr( initializer=fluid.initializer.Normal(0., 0.02)), bias_attr=False, act=None) self.batch_norm = BatchNorm( num_channels=ch_out, is_test=is_test, param_attr=ParamAttr(initializer=fluid.initializer.Normal( 0., 0.02), regularizer=L2Decay(0.)), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), regularizer=L2Decay(0.))) self.act = act
def fast_rcnn_heads( self, roi_input): # 这里的roi_input就是body_conv: [-1, 1024, 84, 84] if self.mode == 'train': pool_rois = self.rois else: pool_rois = self.rpn_rois self.res5_2_sum = self.add_roi_box_head_func(roi_input, pool_rois) rcnn_out = fluid.layers.pool2d(self.res5_2_sum, pool_type='avg', pool_size=7, name="res5_pool") self.cls_score = fluid.layers.fc( input=rcnn_out, size=cfg.class_num, act=None, name='cls_score', param_attr=ParamAttr(name='cls_score_w', initializer=Normal(loc=0.0, scale=0.001)), bias_attr=ParamAttr(name='cls_score_b', learning_rate=2., regularizer=L2Decay(0.))) self.bbox_pred = fluid.layers.fc( input=rcnn_out, size=4 * cfg.class_num, act=None, name='bbox_pred', param_attr=ParamAttr(name='bbox_pred_w', initializer=Normal(loc=0.0, scale=0.01)), bias_attr=ParamAttr(name='bbox_pred_b', learning_rate=2., regularizer=L2Decay(0.)))
def __call__(self, roi_feat): fan = roi_feat.shape[1] * roi_feat.shape[2] * roi_feat.shape[3] mixed_precision_enabled = mixed_precision_global_state() is not None if mixed_precision_enabled: roi_feat = fluid.layers.cast(roi_feat, 'float16') fc6 = fluid.layers.fc(input=roi_feat, size=self.mlp_dim, act='relu', name='fc6', param_attr=ParamAttr( name='fc6_w', initializer=Xavier(fan_out=fan)), bias_attr=ParamAttr(name='fc6_b', learning_rate=2., regularizer=L2Decay(0.))) head_feat = fluid.layers.fc(input=fc6, size=self.mlp_dim, act='relu', name='fc7', param_attr=ParamAttr(name='fc7_w', initializer=Xavier()), bias_attr=ParamAttr( name='fc7_b', learning_rate=2., regularizer=L2Decay(0.))) if mixed_precision_enabled: head_feat = fluid.layers.cast(head_feat, 'float32') return head_feat
def conv2d_unit(x, filters, kernels, stride, padding, name, is_test, trainable): x = fluid.layers.conv2d( input=x, num_filters=filters, filter_size=kernels, stride=stride, padding=padding, act=None, param_attr=ParamAttr(initializer=fluid.initializer.Normal(0.0, 0.01), name=name + ".conv.weights", trainable=trainable), bias_attr=False) bn_name = name + ".bn" if not trainable: # 冻结层时(即trainable=False),bn的均值、标准差也还是会变化,只有设置is_test=True才保证不变 is_test = True x = fluid.layers.batch_norm( input=x, act=None, is_test=is_test, param_attr=ParamAttr(initializer=fluid.initializer.Constant(1.0), regularizer=L2Decay(0.), trainable=trainable, name=bn_name + '.scale'), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), regularizer=L2Decay(0.), trainable=trainable, name=bn_name + '.offset'), moving_mean_name=bn_name + '.mean', moving_variance_name=bn_name + '.var') x = fluid.layers.leaky_relu(x, alpha=0.1) return x
def fast_rcnn_heads(self, roi_input): if self.mode == 'train': pool_rois = self.rois else: pool_rois = self.rpn_rois pool = rotated_roi_align(input=roi_input, rois=pool_rois, pooled_height=cfg.roi_resolution, pooled_width=cfg.roi_resolution, spatial_scale=cfg.spatial_scale) self.res5_2_sum = self.add_roi_box_head_func(pool) rcnn_out = fluid.layers.pool2d(self.res5_2_sum, pool_type='avg', pool_size=7, name='res5_pool') self.cls_score = fluid.layers.fc( input=rcnn_out, size=cfg.class_num, act=None, name='cls_score', param_attr=ParamAttr(name='cls_score_w', initializer=Normal(loc=0.0, scale=0.001)), bias_attr=ParamAttr(name='cls_score_b', learning_rate=2., regularizer=L2Decay(0.))) self.bbox_pred = fluid.layers.fc( input=rcnn_out, size=5 * cfg.class_num, act=None, name='bbox_pred', param_attr=ParamAttr(name='bbox_pred_w', initializer=Normal(loc=0.0, scale=0.01)), bias_attr=ParamAttr(name='bbox_pred_b', learning_rate=2., regularizer=L2Decay(0.)))
def fast_rcnn_heads(self, roi_input): if self.is_train: pool_rois = self.rois else: pool_rois = self.rpn_rois self.res5_2_sum = self.add_roi_box_head_func(roi_input, pool_rois) rcnn_out = fluid.layers.pool2d( self.res5_2_sum, pool_type='avg', pool_size=7, name='res5_pool') self.cls_score = fluid.layers.fc(input=rcnn_out, size=cfg.class_num, act=None, name='cls_score', param_attr=ParamAttr( name='cls_score_w', initializer=Normal( loc=0.0, scale=0.001)), bias_attr=ParamAttr( name='cls_score_b', learning_rate=2., regularizer=L2Decay(0.))) self.bbox_pred = fluid.layers.fc(input=rcnn_out, size=4 * cfg.class_num, act=None, name='bbox_pred', param_attr=ParamAttr( name='bbox_pred_w', initializer=Normal( loc=0.0, scale=0.01)), bias_attr=ParamAttr( name='bbox_pred_b', learning_rate=2., regularizer=L2Decay(0.))) if not self.is_train: self.eval_bbox()
def __call__(self, roi_feat, wb_scalar=1.0, name=''): fan = roi_feat.shape[1] * roi_feat.shape[2] * roi_feat.shape[3] fc6 = fluid.layers.fc(input=roi_feat, size=self.mlp_dim, act='relu', name='fc6' + name, param_attr=ParamAttr( name='fc6%s_w' % name, initializer=Xavier(fan_out=fan), learning_rate=wb_scalar), bias_attr=ParamAttr(name='fc6%s_b' % name, learning_rate=wb_scalar * 2, regularizer=L2Decay(0.))) head_feat = fluid.layers.fc( input=fc6, size=self.mlp_dim, act='relu', name='fc7' + name, param_attr=ParamAttr(name='fc7%s_w' % name, initializer=Xavier(), learning_rate=wb_scalar), bias_attr=ParamAttr(name='fc7%s_b' % name, learning_rate=wb_scalar * 2, regularizer=L2Decay(0.))) return head_feat
def SuffixNet(self, conv5): mask_out = fluid.layers.conv2d_transpose( input=conv5, num_filters=cfg.dim_reduced, filter_size=2, stride=2, act='relu', param_attr=ParamAttr(name='conv5_mask_w', initializer=MSRA(uniform=False)), bias_attr=ParamAttr(name='conv5_mask_b', learning_rate=2., regularizer=L2Decay(0.))) act_func = None if self.mode != 'train': act_func = 'sigmoid' mask_fcn_logits = fluid.layers.conv2d( input=mask_out, num_filters=cfg.class_num, filter_size=1, act=act_func, param_attr=ParamAttr(name='mask_fcn_logits_w', initializer=MSRA(uniform=False)), bias_attr=ParamAttr(name="mask_fcn_logits_b", learning_rate=2., regularizer=L2Decay(0.))) if self.mode != 'train': mask_fcn_logits = fluid.layers.lod_reset(mask_fcn_logits, self.pred_result) return mask_fcn_logits
def _get_output(self, roi_feat): """ Get bbox head output. Args: roi_feat (Variable): RoI feature from RoIExtractor. Returns: cls_score(Variable): Output of rpn head with shape of [N, num_anchors, H, W]. bbox_pred(Variable): Output of rpn head with shape of [N, num_anchors * 4, H, W]. """ head_feat = self.get_head_feat(roi_feat) # when ResNetC5 output a single feature map if not isinstance(self.head, TwoFCHead): head_feat = fluid.layers.pool2d(head_feat, pool_type='avg', global_pooling=True) cls_score = fluid.layers.fc( input=head_feat, size=self.num_classes, act=None, name='cls_score', param_attr=ParamAttr(name='cls_score_w', initializer=Normal(loc=0.0, scale=0.01)), bias_attr=ParamAttr(name='cls_score_b', learning_rate=2., regularizer=L2Decay(0.))) bbox_pred = fluid.layers.fc( input=head_feat, size=4 * self.num_classes, act=None, name='bbox_pred', param_attr=ParamAttr(name='bbox_pred_w', initializer=Normal(loc=0.0, scale=0.001)), bias_attr=ParamAttr(name='bbox_pred_b', learning_rate=2., regularizer=L2Decay(0.))) return cls_score, bbox_pred
def conv_bn(self, input, num_filters, filter_size, stride, padding, num_groups=1, use_cudnn=True): conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, act=None, groups=num_groups, use_cudnn=use_cudnn, param_attr=ParamAttr( initializer=fluid.initializer.Normal(0., 0.02)), bias_attr=False) # batch_norm中的参数不需要参与正则化,所以主动使用正则系数为0的正则项屏蔽掉 out = fluid.layers.batch_norm( input=conv, act='relu', param_attr=ParamAttr(initializer=fluid.initializer.Normal( 0., 0.02), regularizer=L2Decay(0.)), bias_attr=ParamAttr(initializer=fluid.initializer.Constant(0.0), regularizer=L2Decay(0.))) return out
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, self.anchor_var = self.anchor_generator(input=rpn_conv) 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 batch_norm(inputs, momentum, eps, name=None): param_attr = fluid.ParamAttr(name=name + '_scale', regularizer=L2Decay(0.)) bias_attr = fluid.ParamAttr(name=name + '_offset', regularizer=L2Decay(0.)) return fluid.layers.batch_norm(input=inputs, momentum=momentum, epsilon=eps, name=name, moving_mean_name=name + '_mean', moving_variance_name=name + '_variance', param_attr=param_attr, bias_attr=bias_attr)
def _head(self, x, out_c, conv_num=1, head_out_c=None, name=None, is_test=False): head_out_c = self.head_conv if not head_out_c else head_out_c conv_w_std = 0.01 if '.hm' in name else 0.001 conv_w_init = Normal(0, conv_w_std) for i in range(conv_num): conv_name = '{}.{}.conv'.format(name, i) if self.dcn_head: x = DeformConv( x, head_out_c, 3, initializer=conv_w_init, name=conv_name + '.dcn') x = fluid.layers.relu(x) else: x = fluid.layers.conv2d( x, head_out_c, 3, padding=1, param_attr=ParamAttr( initializer=conv_w_init, name=conv_name + '.weight'), bias_attr=ParamAttr( learning_rate=2., regularizer=L2Decay(0.), name=conv_name + '.bias'), act='relu') if self.drop_block and '.hm' in name: x = DropBlock( x, block_size=self.block_size, keep_prob=self.keep_prob, is_test=is_test) bias_init = float(-np.log((1 - 0.01) / 0.01)) if '.hm' in name else 0. conv_b_init = Constant(bias_init) x = fluid.layers.conv2d( x, out_c, 1, param_attr=ParamAttr( initializer=conv_w_init, name='{}.{}.weight'.format(name, conv_num)), bias_attr=ParamAttr( learning_rate=2., regularizer=L2Decay(0.), name='{}.{}.bias'.format(name, conv_num), initializer=conv_b_init)) return x
def _conv_bn_layer(self, input, filter_size, num_filters, stride, padding, num_groups=1, if_act=True, act=None, name=None, use_cudnn=True): lr_idx = self.curr_stage // self.lr_interval lr_idx = min(lr_idx, len(self.lr_mult_list) - 1) lr_mult = self.lr_mult_list[lr_idx] if self.num_classes: regularizer = None else: regularizer = L2Decay(self.conv_decay) conv_param_attr = ParamAttr( name=name + '_weights', learning_rate=lr_mult, regularizer=regularizer) conv = fluid.layers.conv2d( input=input, num_filters=num_filters, filter_size=filter_size, stride=stride, padding=padding, groups=num_groups, act=None, use_cudnn=use_cudnn, param_attr=conv_param_attr, bias_attr=False) bn_name = name + '_bn' bn_param_attr = ParamAttr( name=bn_name + "_scale", regularizer=L2Decay(self.norm_decay)) bn_bias_attr = ParamAttr( name=bn_name + "_offset", regularizer=L2Decay(self.norm_decay)) bn = fluid.layers.batch_norm( input=conv, param_attr=bn_param_attr, bias_attr=bn_bias_attr, moving_mean_name=bn_name + '_mean', moving_variance_name=bn_name + '_variance') if if_act: if act == 'relu': bn = fluid.layers.relu(bn) elif act == 'hard_swish': bn = self._hard_swish(bn) elif act == 'relu6': bn = fluid.layers.relu6(bn) return bn
def get_output(self, roi_feat, res_feat=None, return_logits=True, return_feat=False, wb_scalar=1.0, name=''): class_num = self.num_classes if res_feat is not None: res_feat = fluid.layers.conv2d(res_feat, roi_feat.shape[1], 1, name='res_net' + name) roi_feat = fluid.layers.sum([roi_feat, res_feat]) # configure the conv number for FPN if necessary head_feat = self._mask_conv_head(roi_feat, self.num_convs, self.norm_type, wb_scalar, name) if return_logits: fan0 = roi_feat.shape[1] * 2 * 2 up_head_feat = fluid.layers.conv2d_transpose( input=head_feat, num_filters=self.conv_dim, filter_size=2, stride=2, act='relu', param_attr=ParamAttr(name='conv5_mask_w' + name, initializer=MSRA(uniform=False, fan_in=fan0)), bias_attr=ParamAttr(name='conv5_mask_b' + name, learning_rate=wb_scalar * self.lr_ratio, regularizer=L2Decay(0.))) fan = class_num mask_logits = fluid.layers.conv2d( input=up_head_feat, num_filters=class_num, filter_size=1, act=None, param_attr=ParamAttr(name='mask_fcn_logits_w' + name, initializer=MSRA(uniform=False, fan_in=fan)), bias_attr=ParamAttr(name="mask_fcn_logits_b" + name, learning_rate=wb_scalar * self.lr_ratio, regularizer=L2Decay(0.))) if return_feat: return mask_logits, head_feat else: return mask_logits if return_feat: return head_feat