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
