def get_output(self, conv_fpn_feat):
if self.cls_logit_dict is not None and self.bbox_delta_dict is not None:
return self.cls_logit_dict, self.bbox_delta_dict
p = self.p
num_base_anchor = len(p.anchor_generate.ratio) * len(p.anchor_generate.scale)
conv_channel = p.head.conv_channel
# FPN RPN share weight
rpn_conv_weight = X.var('rpn_conv_weight', init=X.gauss(0.01))
rpn_conv_bias = X.var('rpn_conv_bias', init=X.zero_init())
rpn_conv_cls_weight = X.var('rpn_conv_cls_weight', init=X.gauss(0.01))
rpn_conv_cls_bias = X.var('rpn_conv_cls_bias', init=X.zero_init())
rpn_conv_bbox_weight = X.var('rpn_conv_bbox_weight', init=X.gauss(0.01))
rpn_conv_bbox_bias = X.var('rpn_conv_bbox_bias', init=X.zero_init())
cls_logit_dict = {}
bbox_delta_dict = {}
for stride in p.anchor_generate.stride:
rpn_conv = X.conv(
conv_fpn_feat['stride%s' % stride],
kernel=3,
filter=conv_channel,
name="rpn_conv_3x3_%s" % stride,
no_bias=False,
weight=rpn_conv_weight,
bias=rpn_conv_bias
)
rpn_relu = X.relu(rpn_conv, name='rpn_relu_%s' % stride)
if p.fp16:
rpn_relu = X.to_fp32(rpn_relu, name="rpn_relu_%s_fp32" % stride)
cls_logit = X.conv(
rpn_relu,
filter=2 * num_base_anchor,
name="rpn_cls_score_stride%s" % stride,
no_bias=False,
weight=rpn_conv_cls_weight,
bias=rpn_conv_cls_bias
)
bbox_delta = X.conv(
rpn_relu,
filter=4 * num_base_anchor,
name="rpn_bbox_pred_stride%s" % stride,
no_bias=False,
weight=rpn_conv_bbox_weight,
bias=rpn_conv_bbox_bias
)
cls_logit_dict[stride] = cls_logit
bbox_delta_dict[stride] = bbox_delta
self.cls_logit_dict = cls_logit_dict
self.bbox_delta_dict = bbox_delta_dict
return self.cls_logit_dict, self.bbox_delta_dict
def __init__(self, pRpn):
super().__init__(pRpn)
# init bias for cls
prior_prob = 0.01
pi = -math.log((1-prior_prob) / prior_prob)
# shared classification weight and bias
self.cls_conv1_weight = X.var("cls_conv1_weight", init=X.gauss(std=0.01))
self.cls_conv1_bias = X.var("cls_conv1_bias", init=X.zero_init())
self.cls_conv2_weight = X.var("cls_conv2_weight", init=X.gauss(std=0.01))
self.cls_conv2_bias = X.var("cls_conv2_bias", init=X.zero_init())
self.cls_conv3_weight = X.var("cls_conv3_weight", init=X.gauss(std=0.01))
self.cls_conv3_bias = X.var("cls_conv3_bias", init=X.zero_init())
self.cls_conv4_weight = X.var("cls_conv4_weight", init=X.gauss(std=0.01))
self.cls_conv4_bias = X.var("cls_conv4_bias", init=X.zero_init())
self.cls_pred_weight = X.var("cls_pred_weight", init=X.gauss(std=0.01))
self.cls_pred_bias = X.var("cls_pred_bias", init=X.constant(pi))
# shared regression weight and bias
self.bbox_conv1_weight = X.var("bbox_conv1_weight", init=X.gauss(std=0.01))
self.bbox_conv1_bias = X.var("bbox_conv1_bias", init=X.zero_init())
self.bbox_conv2_weight = X.var("bbox_conv2_weight", init=X.gauss(std=0.01))
self.bbox_conv2_bias = X.var("bbox_conv2_bias", init=X.zero_init())
self.bbox_conv3_weight = X.var("bbox_conv3_weight", init=X.gauss(std=0.01))
self.bbox_conv3_bias = X.var("bbox_conv3_bias", init=X.zero_init())
self.bbox_conv4_weight = X.var("bbox_conv4_weight", init=X.gauss(std=0.01))
self.bbox_conv4_bias = X.var("bbox_conv4_bias", init=X.zero_init())
self.bbox_pred_weight = X.var("bbox_pred_weight", init=X.gauss(std=0.01))
self.bbox_pred_bias = X.var("bbox_pred_bias", init=X.zero_init())
self._cls_logit_dict = None
self._bbox_delta_dict = None
def get_P0_features(c_features, p_names, dim_reduced, init, norm):
p_features = {}
for c_feature, p_name in zip(c_features, p_names):
p = X.conv(data=c_feature,
filter=dim_reduced,
no_bias=False,
weight=X.var(name=p_name + "_weight", init=init),
bias=X.var(name=p_name + "_bias", init=X.zero_init()),
name=p_name)
p = norm(p, name=p_name + '_bn')
p_features[p_name] = p
return p_features
def get_P0_features(c_features,
p_names,
dim_reduced,
init,
norm,
kernel=1):
p_features = []
for c_feature, p_name in zip(c_features, p_names):
p = X.conv(data=c_feature,
filter=dim_reduced,
kernel=kernel,
no_bias=False,
weight=X.var(name=p_name + "_weight", init=init),
bias=X.var(name=p_name + "_bias", init=X.zero_init()),
name=p_name)
p_features.append(p)
return p_features
def reluconvbn(data, num_filter, init, norm, name, prefix):
"""
:param data: data
:param num_filter: number of convolution filter
:param init: init method of conv weight
:param norm: normalizer
:param name: name
:return: relu-3x3conv-bn
"""
data = mx.sym.Activation(data, name=name + '_relu', act_type='relu')
weight = mx.sym.var(name=prefix + name + "_weight", init=init)
bias = mx.sym.var(name=prefix + name + "_bias", init=X.zero_init())
data = mx.sym.Convolution(data,
name=prefix + name,
weight=weight,
bias=bias,
num_filter=num_filter,
kernel=(3, 3),
pad=(1, 1),
stride=(1, 1))
data = norm(data, name=name + '_bn')
return data
def get_output(self, conv_fpn_feat):
if self.cls_logit_dict is not None and self.bbox_delta_dict is not None:
return self.cls_logit_dict, self.bbox_delta_dict
p = self.p
num_base_anchor = len(p.anchor_generate.ratio) * len(p.anchor_generate.scale)
conv_channel = p.head.conv_channel
# FPN RPN share weight
rpn_conv_weight = X.var('rpn_conv_weight', init=X.gauss(0.01))
rpn_conv_bias = X.var('rpn_conv_bias', init=X.zero_init())
rpn_conv_gamma = X.var('rpn_conv_gamma')
rpn_conv_beta = X.var('rpn_conv_beta')
rpn_conv_mmean = X.var('rpn_conv_moving_mean')
rpn_conv_mvar = X.var('rpn_conv_moving_var')
rpn_conv_cls_weight = X.var('rpn_conv_cls_weight', init=X.gauss(0.01))
rpn_conv_cls_bias = X.var('rpn_conv_cls_bias', init=X.zero_init())
rpn_conv_bbox_weight = X.var('rpn_conv_bbox_weight', init=X.gauss(0.01))
rpn_conv_bbox_bias = X.var('rpn_conv_bbox_bias', init=X.zero_init())
cls_logit_dict = {}
bbox_delta_dict = {}
for stride in p.anchor_generate.stride:
rpn_conv = X.conv(
conv_fpn_feat['stride%s' % stride],
kernel=3,
filter=conv_channel,
name="rpn_conv_3x3_%s" % stride,
no_bias=False,
weight=rpn_conv_weight,
bias=rpn_conv_bias
)
if p.normalizer.__name__ == "fix_bn":
pass
elif p.normalizer.__name__ == "sync_bn":
rpn_conv = p.normalizer(
rpn_conv,
gamma=rpn_conv_gamma,
beta=rpn_conv_beta,
moving_mean=rpn_conv_mmean,
moving_var=rpn_conv_mvar,
name="rpn_conv_3x3_bn_%s" % stride
)
elif p.normalizer.__name__ == "gn":
rpn_conv = p.normalizer(
rpn_conv,
gamma=rpn_conv_gamma,
beta=rpn_conv_beta,
name="rpn_conv_3x3_gn_%s" % stride
)
else:
raise NotImplementedError("Unsupported normalizer {}".format(p.normalizer.__name__))
rpn_relu = X.relu(rpn_conv, name='rpn_relu_%s' % stride)
if p.fp16:
rpn_relu = X.to_fp32(rpn_relu, name="rpn_relu_%s_fp32" % stride)
cls_logit = X.conv(
rpn_relu,
filter=2 * num_base_anchor,
name="rpn_cls_score_stride%s" % stride,
no_bias=False,
weight=rpn_conv_cls_weight,
bias=rpn_conv_cls_bias
)
bbox_delta = X.conv(
rpn_relu,
filter=4 * num_base_anchor,
name="rpn_bbox_pred_stride%s" % stride,
no_bias=False,
weight=rpn_conv_bbox_weight,
bias=rpn_conv_bbox_bias
)
cls_logit_dict[stride] = cls_logit
bbox_delta_dict[stride] = bbox_delta
self.cls_logit_dict = cls_logit_dict
self.bbox_delta_dict = bbox_delta_dict
return self.cls_logit_dict, self.bbox_delta_dict
def __init__(self, pHead):
self.p = patch_config_as_nothrow(pHead)
num_points = self.p.point_generate.num_points
self.dcn_kernel = int(math.sqrt(num_points))
self.dcn_pad = int((self.dcn_kernel - 1) / 2)
assert self.dcn_kernel * self.dcn_kernel == num_points, \
"The points number should be square."
assert self.dcn_kernel % 2 == 1, "The dcn kernel size should be odd."
# init moment method
dtype = "float16" if self.p.fp16 else "float32"
self.moment_transfer = X.var(name="moment_transfer",
shape=(2, ),
init=X.zero_init(),
lr_mult=0.01,
dtype=dtype)
# init bias for cls
prior_prob = 0.01
pi = -math.log((1 - prior_prob) / prior_prob)
# shared classification weight and bias
self.cls_conv1_weight = X.var("cls_conv1_weight",
init=X.gauss(std=0.01))
self.cls_conv1_bias = X.var("cls_conv1_bias", init=X.zero_init())
self.cls_conv2_weight = X.var("cls_conv2_weight",
init=X.gauss(std=0.01))
self.cls_conv2_bias = X.var("cls_conv2_bias", init=X.zero_init())
self.cls_conv3_weight = X.var("cls_conv3_weight",
init=X.gauss(std=0.01))
self.cls_conv3_bias = X.var("cls_conv3_bias", init=X.zero_init())
self.cls_conv_weight = X.var("cls_conv_weight", init=X.gauss(std=0.01))
self.cls_conv_bias = X.var("cls_conv_bias", init=X.zero_init())
self.cls_out_weight = X.var("cls_out_weight", init=X.gauss(std=0.01))
self.cls_out_bias = X.var("cls_out_bias", init=X.constant(pi))
# shared regression weight and bias
self.reg_conv1_weight = X.var("reg_conv1_weight",
init=X.gauss(std=0.01))
self.reg_conv1_bias = X.var("reg_conv1_bias", init=X.zero_init())
self.reg_conv2_weight = X.var("reg_conv2_weight",
init=X.gauss(std=0.01))
self.reg_conv2_bias = X.var("reg_conv2_bias", init=X.zero_init())
self.reg_conv3_weight = X.var("reg_conv3_weight",
init=X.gauss(std=0.01))
self.reg_conv3_bias = X.var("reg_conv3_bias", init=X.zero_init())
self.pts_init_conv_weight = X.var("pts_init_conv_weight",
init=X.gauss(std=0.01))
self.pts_init_conv_bias = X.var("pts_init_conv_bias",
init=X.zero_init())
self.pts_init_out_weight = X.var("pts_init_out_weight",
init=X.gauss(std=0.01))
self.pts_init_out_bias = X.var("pts_init_out_bias", init=X.zero_init())
self.pts_refine_conv_weight = X.var("pts_refine_conv_weight",
init=X.gauss(std=0.01))
self.pts_refine_conv_bias = X.var("pts_refine_conv_bias",
init=X.zero_init())
self.pts_refine_out_weight = X.var("pts_refine_out_weight",
init=X.gauss(std=0.01))
self.pts_refine_out_bias = X.var("pts_refine_out_bias",
init=X.zero_init())
self._pts_out_inits = None
self._pts_out_refines = None
self._cls_outs = None
def get_fused_P_feature(self, stage, dim_reduced, init, norm):
prefix = "S{}_".format(stage)
level_list = [2, 3, 4, 5, 6]
feature_list = []
self.feature_grids.append(feature_list)
with mx.name.Prefix(prefix):
for index, level in enumerate(level_list):
fusion_list = []
# bottom feature (Same Up)
bottom_ind_x = stage
bottom_ind_y = index - 1
if bottom_ind_x >= 0 and bottom_ind_y >= 0 and bottom_ind_y < len(
level_list):
fusion_list.append(
self.same_up(bottom_ind_x, bottom_ind_y, dim_reduced,
init, norm))
# bottom left feature (Across Up)
bottom_ind_x = stage - 1
bottom_ind_y = index - 1
if bottom_ind_x >= 0 and bottom_ind_y >= 0 and bottom_ind_y < len(
level_list):
fusion_list.append(
self.across_up(bottom_ind_x, bottom_ind_y, dim_reduced,
init, norm))
# left feature (Across Same)
bottom_ind_x = stage - 1
bottom_ind_y = index
if bottom_ind_x >= 0 and bottom_ind_y >= 0 and bottom_ind_y < len(
level_list):
fusion_list.append(
self.across_same(bottom_ind_x, bottom_ind_y,
dim_reduced, init, norm))
# upper left feature (Across Down)
bottom_ind_x = stage - 1
bottom_ind_y = index + 1
if bottom_ind_x >= 0 and bottom_ind_y >= 0 and bottom_ind_y < len(
level_list):
fusion_list.append(
self.across_down(bottom_ind_x, bottom_ind_y,
dim_reduced, init, norm))
# stage 0 feature (Across Skip)
bottom_ind_x = 0
bottom_ind_y = index
if bottom_ind_x >= 0 and bottom_ind_y >= 0 and bottom_ind_y < len(
level_list):
fusion_list.append(
self.across_skip(bottom_ind_x, bottom_ind_y, stage,
dim_reduced, init, norm))
name = "S%s_P%s" % (stage, level)
fusion_feature = X.merge_sum(fusion_list, name='sum_' + name)
feature_grid = X.conv(
data=fusion_feature,
filter=dim_reduced,
kernel=3,
pad=1,
stride=1,
no_bias=False,
weight=X.var(name=name + "_weight", init=init),
bias=X.var(name=name + "_bias", init=X.zero_init()),
name=name + '_conv',
)
self.feature_grids[stage].append(feature_grid)
def SEPCFPN(inputs, out_channels=256, pconv_deform=False, lcconv_deform=None, ibn=None, Pconv_num=4,
start_level=1, norm=None, bilinear_upsample=None, feat_sizes=None):
assert feat_sizes is not None
Pconvs_list = []
for i in range(Pconv_num):
Pconvs_list.append(partial(
PConvModule, out_channels=out_channels, ibn=ibn, part_deform=pconv_deform,
PConv_idx=i, start_level=start_level, norm=norm, bilinear_upsample=bilinear_upsample, feat_sizes=feat_sizes))
if lcconv_deform is not None:
assert lcconv_deform in [False, True]
lconv_weight, lconv_bias = X.var(name='LConv_weight', init=X.gauss(std=0.01)), X.var(name='LConv_bias',init=X.zero_init())
cconv_weight, cconv_bias = X.var(name='CConv_weight', init=X.gauss(std=0.01)), X.var(name='CConv_bias',init=X.zero_init())
lconv_offset_weight, lconv_offset_bias = None, None
cconv_offset_weight, cconv_offset_bias = None, None
if lcconv_deform:
lconv_offset_weight, lconv_offset_bias=X.var(name='LConv_offset_weight', init=X.zero_init()), X.var(name='LConv_offset_bias', init=X.zero_init())
cconv_offset_weight, cconv_offset_bias=X.var(name='CConv_offset_weight', init=X.zero_init()), X.var(name='CConv_offset_bias', init=X.zero_init())
lconv_func = partial(sepc_conv, name='LConv{}_',out_channels=out_channels, kernel_size=3, stride=1, padding=1,
dilation=1, groups=1, deformable_groups=1, part_deform=lcconv_deform, start_level=start_level,
weight=lconv_weight, bias=lconv_bias, weight_offset=lconv_offset_weight, bias_offset=lconv_offset_bias)
cconv_func = partial(sepc_conv, name='CConv{}_', out_channels=out_channels, kernel_size=3, stride=1, padding=1,
dilation=1, groups=1, deformable_groups=1, part_deform=lcconv_deform, start_level=start_level,
weight=cconv_weight, bias=cconv_bias, weight_offset=cconv_offset_weight, bias_offset=cconv_offset_bias)
if ibn:
assert norm is not None
lbn = partial(norm, name='lconv_ibn')
cbn = partial(norm, name='cconv_ibn')
x = inputs
for pconv in Pconvs_list:
x = pconv(x)
if lcconv_deform is None:
return x
cls_outs = [cconv_func(i=level, x=item) for level, item in enumerate(x)]
loc_outs = [lconv_func(i=level, x=item) for level, item in enumerate(x)]
if ibn:
cls_outs = ibn_func(cls_outs, cbn, feat_sizes)
loc_outs = ibn_func(loc_outs, lbn, feat_sizes)
outs = [mx.sym.Concat(*[relu(s), relu(l)], num_args=2, dim=1) for s, l in zip(cls_outs, loc_outs)]
return outs
def get_retinanet_neck(data):
c2, c3, c4, c5 = data
import mxnet as mx
xavier_init = mx.init.Xavier(factor_type="in",
rnd_type="uniform",
magnitude=3)
# P5
p5 = X.conv(data=c5,
filter=256,
no_bias=False,
weight=X.var(name="P5_lateral_weight", init=xavier_init),
bias=X.var(name="P5_lateral_bias", init=X.zero_init()),
name="P5_lateral")
p5_conv = X.conv(data=p5,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P5_conv_weight", init=xavier_init),
bias=X.var(name="P5_conv_bias", init=X.zero_init()),
name="P5_conv")
# P4
p5_up = mx.sym.UpSampling(p5,
scale=2,
sample_type="nearest",
name="P5_upsampling",
num_args=1)
p4_la = X.conv(data=c4,
filter=256,
no_bias=False,
weight=X.var(name="P4_lateral_weight",
init=xavier_init),
bias=X.var(name="P4_lateral_bias", init=X.zero_init()),
name="P4_lateral")
p5_clip = mx.sym.Crop(*[p5_up, p4_la], name="P4_clip")
p4 = mx.sym.ElementWiseSum(*[p5_clip, p4_la], name="P4_sum")
p4_conv = X.conv(data=p4,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P4_conv_weight", init=xavier_init),
bias=X.var(name="P4_conv_bias", init=X.zero_init()),
name="P4_conv")
# P3
p4_up = mx.sym.UpSampling(p4,
scale=2,
sample_type="nearest",
name="P4_upsampling",
num_args=1)
p3_la = X.conv(data=c3,
filter=256,
no_bias=False,
weight=X.var(name="P3_lateral_weight",
init=xavier_init),
bias=X.var(name="P3_lateral_bias", init=X.zero_init()),
name="P3_lateral")
p4_clip = mx.sym.Crop(*[p4_up, p3_la], name="P3_clip")
p3 = mx.sym.ElementWiseSum(*[p4_clip, p3_la], name="P3_sum")
p3_conv = X.conv(data=p3,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P3_conv_weight", init=xavier_init),
bias=X.var(name="P3_conv_bias", init=X.zero_init()),
name="P3_conv")
# P6
P6 = X.conv(data=c5,
kernel=3,
stride=2,
filter=256,
no_bias=False,
weight=X.var(name="P6_conv_weight", init=xavier_init),
bias=X.var(name="P6_conv_bias", init=X.zero_init()),
name="P6_conv")
# P7
P6_relu = X.relu(data=P6, name="P6_relu")
P7 = X.conv(data=P6_relu,
kernel=3,
stride=2,
filter=256,
no_bias=False,
weight=X.var(name="P7_conv_weight", init=xavier_init),
bias=X.var(name="P7_conv_bias", init=X.zero_init()),
name="P7_conv")
return p3_conv, p4_conv, p5_conv, P6, P7
def get_output(self, conv_feat):
if self._cls_logit_list is not None and self._bbox_delta_list is not None:
return self._cls_logit_list, self._bbox_delta_list
p = self.p
stride = p.anchor_generate.stride
if not isinstance(stride, tuple):
stride = (stride)
conv_channel = p.head.conv_channel
num_base_anchor = len(p.anchor_generate.ratio) * len(
p.anchor_generate.scale)
num_class = p.num_class
prior_prob = 0.01
pi = -math.log((1 - prior_prob) / prior_prob)
# shared classification weight and bias
self.cls_conv1_weight = X.var("cls_conv1_weight",
init=X.gauss(std=0.01))
self.cls_conv1_bias = X.var("cls_conv1_bias", init=X.zero_init())
self.cls_conv2_weight = X.var("cls_conv2_weight",
init=X.gauss(std=0.01))
self.cls_conv2_bias = X.var("cls_conv2_bias", init=X.zero_init())
self.cls_conv3_weight = X.var("cls_conv3_weight",
init=X.gauss(std=0.01))
self.cls_conv3_bias = X.var("cls_conv3_bias", init=X.zero_init())
self.cls_conv4_weight = X.var("cls_conv4_weight",
init=X.gauss(std=0.01))
self.cls_conv4_bias = X.var("cls_conv4_bias", init=X.zero_init())
self.cls_pred_weight = X.var("cls_pred_weight", init=X.gauss(std=0.01))
self.cls_pred_bias = X.var("cls_pred_bias", init=X.constant(pi))
# shared regression weight and bias
self.bbox_conv1_weight = X.var("bbox_conv1_weight",
init=X.gauss(std=0.01))
self.bbox_conv1_bias = X.var("bbox_conv1_bias", init=X.zero_init())
self.bbox_conv2_weight = X.var("bbox_conv2_weight",
init=X.gauss(std=0.01))
self.bbox_conv2_bias = X.var("bbox_conv2_bias", init=X.zero_init())
self.bbox_conv3_weight = X.var("bbox_conv3_weight",
init=X.gauss(std=0.01))
self.bbox_conv3_bias = X.var("bbox_conv3_bias", init=X.zero_init())
self.bbox_conv4_weight = X.var("bbox_conv4_weight",
init=X.gauss(std=0.01))
self.bbox_conv4_bias = X.var("bbox_conv4_bias", init=X.zero_init())
self.bbox_pred_weight = X.var("bbox_pred_weight",
init=X.gauss(std=0.01))
self.bbox_pred_bias = X.var("bbox_pred_bias", init=X.zero_init())
cls_logit_list = []
bbox_delta_list = []
for i, s in enumerate(stride):
cls_logit = self._cls_subnet(conv_feat=conv_feat[i],
conv_channel=conv_channel,
num_base_anchor=num_base_anchor,
num_class=num_class)
bbox_delta = self._bbox_subnet(conv_feat=conv_feat[i],
conv_channel=conv_channel,
num_base_anchor=num_base_anchor,
num_class=num_class)
cls_logit_list.append(cls_logit)
bbox_delta_list.append(bbox_delta)
self._cls_logit_list = cls_logit_list
self._bbox_delta_list = bbox_delta_list
return self._cls_logit_list, self._bbox_delta_list
def fpn_conv_down(self, data):
if self.fpn_feat:
return self.fpn_feat
c2, c3, c4, c5 = data
if self.p.fp16:
c2 = X.to_fp32(c2, name="c2_to_fp32")
c3 = X.to_fp32(c3, name="c3_to_fp32")
c4 = X.to_fp32(c4, name="c4_to_fp32")
c5 = X.to_fp32(c5, name="c5_to_fp32")
xavier_init = mx.init.Xavier(factor_type="in",
rnd_type="uniform",
magnitude=3)
# P5
p5 = X.conv(data=c5,
filter=256,
no_bias=False,
weight=X.var(name="P5_lateral_weight", init=xavier_init),
bias=X.var(name="P5_lateral_bias", init=X.zero_init()),
name="P5_lateral")
p5_conv = X.conv(data=p5,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P5_conv_weight", init=xavier_init),
bias=X.var(name="P5_conv_bias", init=X.zero_init()),
name="P5_conv")
# P4
p5_up = mx.sym.UpSampling(p5,
scale=2,
sample_type="nearest",
name="P5_upsampling",
num_args=1)
p4_la = X.conv(data=c4,
filter=256,
no_bias=False,
weight=X.var(name="P4_lateral_weight",
init=xavier_init),
bias=X.var(name="P4_lateral_bias", init=X.zero_init()),
name="P4_lateral")
p5_clip = mx.sym.Crop(*[p5_up, p4_la], name="P4_clip")
p4 = mx.sym.ElementWiseSum(*[p5_clip, p4_la], name="P4_sum")
p4_conv = X.conv(data=p4,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P4_conv_weight", init=xavier_init),
bias=X.var(name="P4_conv_bias", init=X.zero_init()),
name="P4_conv")
# P3
p4_up = mx.sym.UpSampling(p4,
scale=2,
sample_type="nearest",
name="P4_upsampling",
num_args=1)
p3_la = X.conv(data=c3,
filter=256,
no_bias=False,
weight=X.var(name="P3_lateral_weight",
init=xavier_init),
bias=X.var(name="P3_lateral_bias", init=X.zero_init()),
name="P3_lateral")
p4_clip = mx.sym.Crop(*[p4_up, p3_la], name="P3_clip")
p3 = mx.sym.ElementWiseSum(*[p4_clip, p3_la], name="P3_sum")
p3_conv = X.conv(data=p3,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P3_conv_weight", init=xavier_init),
bias=X.var(name="P3_conv_bias", init=X.zero_init()),
name="P3_conv")
# P2
p3_up = mx.sym.UpSampling(p3,
scale=2,
sample_type="nearest",
name="P3_upsampling",
num_args=1)
p2_la = X.conv(data=c2,
filter=256,
no_bias=False,
weight=X.var(name="P2_lateral_weight",
init=xavier_init),
bias=X.var(name="P2_lateral_bias", init=X.zero_init()),
name="P2_lateral")
p3_clip = mx.sym.Crop(*[p3_up, p2_la], name="P2_clip")
p2 = mx.sym.ElementWiseSum(*[p3_clip, p2_la], name="P2_sum")
p2_conv = X.conv(data=p2,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P2_conv_weight", init=xavier_init),
bias=X.var(name="P2_conv_bias", init=X.zero_init()),
name="P2_conv")
# P6
p6 = X.pool(p5_conv,
name="P6_subsampling",
kernel=1,
stride=2,
pad=0,
pool_type='max')
if self.p.fp16:
p6 = X.to_fp16(p6, name="p6_to_fp16")
p5_conv = X.to_fp16(p5_conv, name="p5_conv_to_fp16")
p4_conv = X.to_fp16(p4_conv, name="p4_conv_to_fp16")
p3_conv = X.to_fp16(p3_conv, name="p3_conv_to_fp16")
p2_conv = X.to_fp16(p2_conv, name="p2_conv_to_fp16")
conv_fpn_feat = dict()
conv_fpn_feat.update({
"stride64": p6,
"stride32": p5_conv,
"stride16": p4_conv,
"stride8": p3_conv,
"stride4": p2_conv
})
self.fpn_feat = conv_fpn_feat
return self.fpn_feat
def get_P0_features_likeretina(c_features, p_names, dim_reduced, init,
norm):
c3, c4, c5, c6, c7 = c_features
p_features = {}
# p7
p7 = X.conv(data=c7,
kernel=3,
filter=dim_reduced,
no_bias=False,
weight=X.var(name="S0_P7_weight", init=init),
bias=X.var(name="S0_P7_bias", init=X.zero_init()),
name="S0_P7")
p7 = norm(p7, name="S0_P7_bn")
# p6
p6 = X.conv(data=c6,
kernel=3,
filter=dim_reduced,
no_bias=False,
weight=X.var(name="S0_P6_weight", init=init),
bias=X.var(name="S0_P6_bias", init=X.zero_init()),
name="S0_P6")
p6 = norm(p6, name="S0_P6_bn")
# p5
p5_1x1 = X.conv(data=c5,
filter=dim_reduced,
no_bias=False,
weight=X.var(name="S0_P5_1x1_weight", init=init),
bias=X.var(name="S0_P5_1x1_bias", init=X.zero_init()),
name="S0_P5_1x1")
p5_1x1 = norm(p5_1x1, name="S0_P5_1x1_bn")
p5 = X.conv(data=p5_1x1,
kernel=3,
filter=dim_reduced,
no_bias=False,
weight=X.var(name="S0_P5_weight", init=init),
bias=X.var(name="S0_P5_bias", init=X.zero_init()),
name="S0_P5")
p5 = norm(p5, name="S0_P5_bn")
# p4
p4_1x1 = X.conv(data=c4,
filter=dim_reduced,
no_bias=False,
weight=X.var(name="S0_P4_1x1_weight", init=init),
bias=X.var(name="S0_P4_1x1_bias", init=X.zero_init()),
name="S0_P4_1x1")
p4_1x1 = norm(p4_1x1, name="S0_P4_1x1_bn")
p5_to_p4 = mx.sym.UpSampling(p5_1x1,
scale=2,
sample_type="nearest",
name="S0_P5_to_P4",
num_args=1)
p5_to_p4 = mx.sym.slice_like(p5_to_p4, p4_1x1)
p4_1x1 = mx.sym.add_n(p5_to_p4, p4_1x1, name="S0_sum_P5_P4")
p4 = X.conv(data=p4_1x1,
kernel=3,
filter=dim_reduced,
no_bias=False,
weight=X.var(name="S0_P4_weight", init=init),
bias=X.var(name="S0_P4_bias", init=X.zero_init()),
name="S0_P4")
p4 = norm(p4, name="S0_P4_bn")
# p3
p3_1x1 = X.conv(data=c3,
filter=dim_reduced,
no_bias=False,
weight=X.var(name="S0_P3_1x1_weight", init=init),
bias=X.var(name="S0_P3_1x1_bias", init=X.zero_init()),
name="S0_P3_1x1")
p3_1x1 = norm(p3_1x1, name="S0_P3_1x1_bn")
p4_to_p3 = mx.sym.UpSampling(p4_1x1,
scale=2,
sample_type="nearest",
name="S0_P5_to_P4",
num_args=1)
p4_to_p3 = mx.sym.slice_like(p4_to_p3, p3_1x1)
p3_1x1 = mx.sym.add_n(p4_to_p3, p3_1x1, name="S0_sum_P4_P3")
p3 = X.conv(data=p3_1x1,
kernel=3,
filter=dim_reduced,
no_bias=False,
weight=X.var(name="S0_P3_weight", init=init),
bias=X.var(name="S0_P3_bias", init=X.zero_init()),
name="S0_P3")
p3 = norm(p3, name="S0_P3_bn")
p_features = {
'S0_P3': p3,
'S0_P4': p4,
'S0_P5': p5,
'S0_P6': p6,
'S0_P7': p7
}
return p_features
def get_retinanet_neck(self, data):
norm = self.p.normalizer
c2, c3, c4, c5 = data
import mxnet as mx
xavier_init = mx.init.Xavier(factor_type="avg",
rnd_type="uniform",
magnitude=3)
# P5
p5 = X.conv(data=c5,
filter=256,
no_bias=False,
weight=X.var(name="P5_lateral_weight", init=xavier_init),
bias=X.var(name="P5_lateral_bias", init=X.zero_init()),
name="P5_lateral")
p5_conv = X.conv(data=p5,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P5_conv_weight", init=xavier_init),
bias=X.var(name="P5_conv_bias", init=X.zero_init()),
name="P5_conv")
# P4
p5_up = mx.sym.UpSampling(p5,
scale=2,
sample_type="nearest",
name="P5_upsampling",
num_args=1)
p4_la = X.conv(data=c4,
filter=256,
no_bias=False,
weight=X.var(name="P4_lateral_weight",
init=xavier_init),
bias=X.var(name="P4_lateral_bias", init=X.zero_init()),
name="P4_lateral")
p5_clip = mx.sym.slice_like(p5_up, p4_la, name="P4_clip")
p4 = mx.sym.add_n(p5_clip, p4_la, name="P4_sum")
p4_conv = X.conv(data=p4,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P4_conv_weight", init=xavier_init),
bias=X.var(name="P4_conv_bias", init=X.zero_init()),
name="P4_conv")
# P3
p4_up = mx.sym.UpSampling(p4,
scale=2,
sample_type="nearest",
name="P4_upsampling",
num_args=1)
p3_la = X.conv(data=c3,
filter=256,
no_bias=False,
weight=X.var(name="P3_lateral_weight",
init=xavier_init),
bias=X.var(name="P3_lateral_bias", init=X.zero_init()),
name="P3_lateral")
p4_clip = mx.sym.slice_like(p4_up, p3_la, name="P3_clip")
p3 = mx.sym.add_n(p4_clip, p3_la, name="P3_sum")
p3_conv = X.conv(data=p3,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P3_conv_weight", init=xavier_init),
bias=X.var(name="P3_conv_bias", init=X.zero_init()),
name="P3_conv")
# P6
P6 = X.conv(data=c5,
kernel=3,
stride=2,
filter=256,
no_bias=False,
weight=X.var(name="P6_conv_weight", init=xavier_init),
bias=X.var(name="P6_conv_bias", init=X.zero_init()),
name="P6_conv")
# P7
P6_relu = X.relu(data=P6, name="P6_relu")
P7 = X.conv(data=P6_relu,
kernel=3,
stride=2,
filter=256,
no_bias=False,
weight=X.var(name="P7_conv_weight", init=xavier_init),
bias=X.var(name="P7_conv_bias", init=X.zero_init()),
name="P7_conv")
p3_conv = norm(p3_conv, name="P3_conv_bn")
p4_conv = norm(p4_conv, name="P4_conv_bn")
p5_conv = norm(p5_conv, name="P5_conv_bn")
P6 = norm(P6, name="P6_conv_bn")
P7 = norm(P7, name="P7_conv_bn")
return p3_conv, p4_conv, p5_conv, P6, P7
def get_output(self, conv_fpn_feat):
p = self.p
centerness_logit_dict = {}
cls_logit_dict = {}
offset_logit_dict = {}
# heads are shared across stages
shared_conv1_w = X.var(name="shared_conv1_3x3_weight", init=X.gauss(0.01))
shared_conv1_b = X.var(name="shared_conv1_3x3_bias", init=X.zero_init(), lr_mult=2, wd_mult=0)
shared_conv2_w = X.var(name="shared_conv2_3x3_weight", init=X.gauss(0.01))
shared_conv2_b = X.var(name="shared_conv2_3x3_bias", init=X.zero_init(), lr_mult=2, wd_mult=0)
shared_conv3_w = X.var(name="shared_conv3_3x3_weight", init=X.gauss(0.01))
shared_conv3_b = X.var(name="shared_conv3_3x3_bias", init=X.zero_init(), lr_mult=2, wd_mult=0)
shared_conv4_w = X.var(name="shared_conv4_3x3_weight", init=X.gauss(0.01))
shared_conv4_b = X.var(name="shared_conv4_3x3_bias", init=X.zero_init(), lr_mult=2, wd_mult=0)
centerness_conv_w = X.var(name="centerness_conv_3x3_weight", init=X.gauss(0.01))
centerness_conv_b = X.var(name="centerness_conv_3x3_bias", init=X.zero_init(), lr_mult=2, wd_mult=0)
cls_conv_w = X.var(name="cls_conv_3x3_weight", init=X.gauss(0.01))
cls_conv_b = X.var(name="cls_conv_3x3_bias", init=X.constant(-math.log(99)), lr_mult=2, wd_mult=0) # init with -log((1-0.01)/0.01)
offset_conv1_w = X.var(name="offset_conv1_3x3_weight", init=X.gauss(0.01))
offset_conv1_b = X.var(name="offset_conv1_3x3_bias", init=X.zero_init(), lr_mult=2, wd_mult=0)
offset_conv2_w = X.var(name="offset_conv2_3x3_weight", init=X.gauss(0.01))
offset_conv2_b = X.var(name="offset_conv2_3x3_bias", init=X.zero_init(), lr_mult=2, wd_mult=0)
offset_conv3_w = X.var(name="offset_conv3_3x3_weight", init=X.gauss(0.01))
offset_conv3_b = X.var(name="offset_conv3_3x3_bias", init=X.zero_init(), lr_mult=2, wd_mult=0)
offset_conv4_w = X.var(name="offset_conv4_3x3_weight", init=X.gauss(0.01))
offset_conv4_b = X.var(name="offset_conv4_3x3_bias", init=X.zero_init(), lr_mult=2, wd_mult=0)
offset_conv5_w = X.var(name="offset_conv5_3x3_weight", init=X.gauss(0.01))
offset_conv5_b = X.var(name="offset_conv5_3x3_bias", init=X.zero_init(), lr_mult=2, wd_mult=0)
for stride in p.FCOSParam.stride:
# centerness & cls shared layer
shared_conv1 = X.conv(
conv_fpn_feat['stride%s' % stride],
kernel=3, filter=256, no_bias=False,
name="shared_conv1_3x3_%s" % stride,
weight=shared_conv1_w,
bias=shared_conv1_b,
)
shared_gn1 = X.gn(shared_conv1, name='shared_gn1_3x3_%s' % stride, num_group=32)
shared_relu1 = X.relu(shared_gn1, name='shared_relu1_3x3_%s' % stride)
shared_conv2 = X.conv(
shared_relu1,
kernel=3, filter=256, no_bias=False,
name="shared_conv2_3x3_%s" % stride,
weight=shared_conv2_w,
bias=shared_conv2_b,
)
shared_gn2 = X.gn(shared_conv2, name='shared_gn2_3x3_%s' % stride, num_group=32)
shared_relu2 = X.relu(shared_gn2, name='shared_relu2_3x3_%s' % stride)
shared_conv3 = X.conv(
shared_relu2,
kernel=3, filter=256, no_bias=False,
name="shared_conv3_3x3_%s" % stride,
weight=shared_conv3_w,
bias=shared_conv3_b,
)
shared_gn3 = X.gn(shared_conv3, name='shared_gn3_3x3_%s' % stride, num_group=32)
shared_relu3 = X.relu(shared_gn3, name='shared_relu3_3x3_%s' % stride)
shared_conv4 = X.conv(
shared_relu3,
kernel=3, filter=256, no_bias=False,
name="shared_conv4_3x3_%s" % stride,
weight=shared_conv4_w,
bias=shared_conv4_b,
)
shared_gn4 = X.gn(shared_conv4, name='shared_gn4_3x3_%s' % stride, num_group=32)
shared_relu4 = X.relu(shared_gn4, name='shared_relu4_3x3_%s' % stride)
# centerness head
center_logit = X.conv(
shared_relu4,
kernel=3,
filter=1,
name="center_conv_3x3_%s" % stride,
no_bias=False,
weight=centerness_conv_w,
bias=centerness_conv_b,
)
# cls head
cls_logit = X.conv(
shared_relu4,
kernel=3,
filter=p.FCOSParam.num_classifier, # remove bg channel
name="cls_conv_3x3_%s" % stride,
no_bias=False,
weight=cls_conv_w,
bias=cls_conv_b,
)
# offset head
offset_conv1 = X.conv(
conv_fpn_feat['stride%s' % stride],
kernel=3,
filter=256,
name="offset_conv1_3x3_%s" % stride,
no_bias=False,
weight=offset_conv1_w,
bias=offset_conv1_b,
)
offset_gn1 = X.gn(offset_conv1, name='offset_gn1_3x3_%s' % stride, num_group=32)
offset_relu1 = X.relu(offset_gn1, name='offset_relu1_3x3_%s' % stride)
offset_conv2 = X.conv(
offset_relu1,
kernel=3,
filter=256,
name="offset_conv2_3x3_%s" % stride,
no_bias=False,
weight=offset_conv2_w,
bias=offset_conv2_b,
)
offset_gn2 = X.gn(offset_conv2, name='offset_gn2_3x3_%s' % stride, num_group=32)
offset_relu2 = X.relu(offset_gn2, name='offset_relu2_3x3_%s' % stride)
offset_conv3 = X.conv(
offset_relu2,
kernel=3,
filter=256,
name="offset_conv3_3x3_%s" % stride,
no_bias=False,
weight=offset_conv3_w,
bias=offset_conv3_b,
)
offset_gn3 = X.gn(offset_conv3, name='offset_gn3_3x3_%s' % stride, num_group=32)
offset_relu3 = X.relu(offset_gn3, name='offset_relu3_3x3_%s' % stride)
offset_conv4 = X.conv(
offset_relu3,
kernel=3,
filter=256,
name="offset_conv1_3x3_%s" % stride,
no_bias=False,
weight=offset_conv4_w,
bias=offset_conv4_b,
)
offset_gn4 = X.gn(offset_conv4, name='offset_gn4_3x3_%s' % stride, num_group=32)
offset_relu4 = X.relu(offset_gn4, name='offset_relu4_3x3_%s' % stride)
offset_logit = X.conv(
offset_relu4,
kernel=3,
filter=4,
name="offset_conv5_3x3_%s" % stride,
no_bias=False,
weight=offset_conv5_w,
bias=offset_conv5_b,
)
offset_logit = mx.sym.broadcast_mul(lhs=offset_logit, rhs=X.var(name="offset_scale_%s_w" % stride, init=X.constant(1), shape=(1,1,1,1)))
offset_logit = mx.sym.exp(offset_logit)
centerness_logit_dict[stride] = center_logit
cls_logit_dict[stride] = cls_logit
offset_logit_dict[stride] = offset_logit
self.centerness_logit_dict = centerness_logit_dict
self.cls_logit_dict = cls_logit_dict
self.offset_logit_dict = offset_logit_dict
return self.centerness_logit_dict, self.cls_logit_dict, self.offset_logit_dict
def get_retinanet_neck(self, data):
if self.neck is not None:
return self.neck
c2, c3, c4, c5 = data
import mxnet as mx
xavier_init = mx.init.Xavier(factor_type="in",
rnd_type="uniform",
magnitude=3)
# P5
p5 = X.conv(data=c5,
filter=256,
no_bias=False,
weight=X.var(name="P5_lateral_weight", init=xavier_init),
bias=X.var(name="P5_lateral_bias", init=X.zero_init()),
name="P5_lateral")
p5_conv = X.conv(data=p5,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P5_conv_weight", init=xavier_init),
bias=X.var(name="P5_conv_bias", init=X.zero_init()),
name="P5_conv")
# P4
p5_up = mx.sym.UpSampling(p5,
scale=2,
sample_type="nearest",
name="P5_upsampling",
num_args=1)
p4_la = X.conv(data=c4,
filter=256,
no_bias=False,
weight=X.var(name="P4_lateral_weight",
init=xavier_init),
bias=X.var(name="P4_lateral_bias", init=X.zero_init()),
name="P4_lateral")
p5_clip = mx.sym.slice_like(p5_up, p4_la, name="P4_clip")
p4 = mx.sym.add_n(p5_clip, p4_la, name="P4_sum")
p4_conv = X.conv(data=p4,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P4_conv_weight", init=xavier_init),
bias=X.var(name="P4_conv_bias", init=X.zero_init()),
name="P4_conv")
# P3
p4_up = mx.sym.UpSampling(p4,
scale=2,
sample_type="nearest",
name="P4_upsampling",
num_args=1)
p3_la = X.conv(data=c3,
filter=256,
no_bias=False,
weight=X.var(name="P3_lateral_weight",
init=xavier_init),
bias=X.var(name="P3_lateral_bias", init=X.zero_init()),
name="P3_lateral")
p4_clip = mx.sym.slice_like(p4_up, p3_la, name="P3_clip")
p3 = mx.sym.add_n(p4_clip, p3_la, name="P3_sum")
p3_conv = X.conv(data=p3,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P3_conv_weight", init=xavier_init),
bias=X.var(name="P3_conv_bias", init=X.zero_init()),
name="P3_conv")
# P6
p6 = X.conv(data=c5,
kernel=3,
stride=2,
filter=256,
no_bias=False,
weight=X.var(name="P6_conv_weight", init=xavier_init),
bias=X.var(name="P6_conv_bias", init=X.zero_init()),
name="P6_conv")
# P7
p6_relu = X.relu(data=p6, name="P6_relu")
p7 = X.conv(data=p6_relu,
kernel=3,
stride=2,
filter=256,
no_bias=False,
weight=X.var(name="P7_conv_weight", init=xavier_init),
bias=X.var(name="P7_conv_bias", init=X.zero_init()),
name="P7_conv")
self.neck = dict(stride8=p3_conv,
stride16=p4_conv,
stride32=p5_conv,
stride64=p6,
stride128=p7)
return self.neck
def fpn_neck(self, data):
if self.fpn_feat is not None:
return self.fpn_feat
c2, c3, c4, c5 = data
xavier_init = mx.init.Xavier(factor_type="in",
rnd_type="uniform",
magnitude=3)
# P5
p5 = X.conv(data=c5,
filter=256,
no_bias=False,
weight=X.var(name="P5_lateral_weight", init=xavier_init),
bias=X.var(name="P5_lateral_bias", init=X.zero_init()),
name="P5_lateral")
p5 = self.add_norm(p5)
p5_conv = X.conv(data=p5,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P5_conv_weight", init=xavier_init),
bias=X.var(name="P5_conv_bias", init=X.zero_init()),
name="P5_conv")
p5_conv = self.add_norm(p5_conv)
# P4
p5_up = mx.sym.UpSampling(p5,
scale=2,
sample_type="nearest",
name="P5_upsampling",
num_args=1)
p4_la = X.conv(data=c4,
filter=256,
no_bias=False,
weight=X.var(name="P4_lateral_weight",
init=xavier_init),
bias=X.var(name="P4_lateral_bias", init=X.zero_init()),
name="P4_lateral")
p4_la = self.add_norm(p4_la)
p5_clip = mx.sym.slice_like(p5_up, p4_la, name="P4_clip")
p4 = mx.sym.add_n(p5_clip, p4_la, name="P4_sum")
p4_conv = X.conv(data=p4,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P4_conv_weight", init=xavier_init),
bias=X.var(name="P4_conv_bias", init=X.zero_init()),
name="P4_conv")
p4_conv = self.add_norm(p4_conv)
# P3
p4_up = mx.sym.UpSampling(p4,
scale=2,
sample_type="nearest",
name="P4_upsampling",
num_args=1)
p3_la = X.conv(data=c3,
filter=256,
no_bias=False,
weight=X.var(name="P3_lateral_weight",
init=xavier_init),
bias=X.var(name="P3_lateral_bias", init=X.zero_init()),
name="P3_lateral")
p3_la = self.add_norm(p3_la)
p4_clip = mx.sym.slice_like(p4_up, p3_la, name="P3_clip")
p3 = mx.sym.add_n(p4_clip, p3_la, name="P3_sum")
p3_conv = X.conv(data=p3,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P3_conv_weight", init=xavier_init),
bias=X.var(name="P3_conv_bias", init=X.zero_init()),
name="P3_conv")
p3_conv = self.add_norm(p3_conv)
# P2
p3_up = mx.sym.UpSampling(p3,
scale=2,
sample_type="nearest",
name="P3_upsampling",
num_args=1)
p2_la = X.conv(data=c2,
filter=256,
no_bias=False,
weight=X.var(name="P2_lateral_weight",
init=xavier_init),
bias=X.var(name="P2_lateral_bias", init=X.zero_init()),
name="P2_lateral")
p2_la = self.add_norm(p2_la)
p3_clip = mx.sym.slice_like(p3_up, p2_la, name="P2_clip")
p2 = mx.sym.add_n(p3_clip, p2_la, name="P2_sum")
p2_conv = X.conv(data=p2,
kernel=3,
filter=256,
no_bias=False,
weight=X.var(name="P2_conv_weight", init=xavier_init),
bias=X.var(name="P2_conv_bias", init=X.zero_init()),
name="P2_conv")
p2_conv = self.add_norm(p2_conv)
# P6
p6 = X.max_pool(
p5_conv,
name="P6_subsampling",
kernel=1,
stride=2,
)
conv_fpn_feat = dict(stride64=p6,
stride32=p5_conv,
stride16=p4_conv,
stride8=p3_conv,
stride4=p2_conv)
self.fpn_feat = conv_fpn_feat
return self.fpn_feat
def PConvModule(x, out_channels=256, kernel_size=[3, 3, 3], dilation=[1, 1, 1], groups=[1, 1, 1], ibn=None,
part_deform=False, PConv_idx=-1, start_level=1, norm=None, bilinear_upsample=None, feat_sizes=None):
assert PConv_idx > -1 and feat_sizes is not None
name_pref = 'PConv{}_sepc'.format(PConv_idx)
sepc0_weight, sepc0_bias = X.var(name=name_pref+'0_weight', init=X.gauss(std=0.01)), X.var(name=name_pref+'0_bias', init=X.zero_init())
sepc1_weight, sepc1_bias = X.var(name=name_pref+'1_weight', init=X.gauss(std=0.01)), X.var(name=name_pref+'1_bias', init=X.zero_init())
sepc2_weight, sepc2_bias = X.var(name=name_pref+'2_weight', init=X.gauss(std=0.01)), X.var(name=name_pref+'2_bias', init=X.zero_init())
sepc0_offset_weight, sepc0_offset_bias = None, None
sepc1_offset_weight, sepc1_offset_bias = None, None
sepc2_offset_weight, sepc2_offset_bias = None, None
if part_deform:
# NOTE zero_init for offset's weight and bias
sepc0_offset_weight, sepc0_offset_bias = X.var(name=name_pref+'0_offset_weight', init=X.zero_init()), X.var(name=name_pref+'0_offset_bias', init=X.zero_init())
sepc1_offset_weight, sepc1_offset_bias = X.var(name=name_pref+'1_offset_weight', init=X.zero_init()), X.var(name=name_pref+'1_offset_bias', init=X.zero_init())
sepc2_offset_weight, sepc2_offset_bias = X.var(name=name_pref+'2_offset_weight', init=X.zero_init()), X.var(name=name_pref+'2_offset_bias', init=X.zero_init())
norm_func = []
if ibn:
assert norm is not None
norm_func = partial(norm, name=name_pref+'_ibn')
sepc_conv0_func = partial(
sepc_conv, name='PConv{}_sepc0_'.format(PConv_idx), out_channels=out_channels,
kernel_size=kernel_size[0], stride=1, padding=(kernel_size[0]+(dilation[0]-1)*2)//2,
dilation=dilation[0], groups=groups[0], deformable_groups=1, part_deform=part_deform, start_level=start_level,
weight=sepc0_weight, bias=sepc0_bias, weight_offset=sepc0_offset_weight, bias_offset=sepc0_offset_bias)
sepc_conv1_func = partial(
sepc_conv, name='PConv{}_sepc1_'.format(PConv_idx), out_channels=out_channels,
kernel_size=kernel_size[1], stride=1, padding=(kernel_size[1]+(dilation[1]-1)*2)//2,
dilation=dilation[1], groups=groups[1], deformable_groups=1, part_deform=part_deform, start_level=start_level,
weight=sepc1_weight, bias=sepc1_bias, weight_offset=sepc1_offset_weight, bias_offset=sepc1_offset_bias)
sepc_conv2_func = partial(
sepc_conv, name='PConv{}_sepc2_'.format(PConv_idx), out_channels=out_channels,
kernel_size=kernel_size[2], stride=2, padding=(kernel_size[2]+(dilation[2]-1)*2)//2,
dilation=dilation[2], groups=groups[2], deformable_groups=1, part_deform=part_deform, start_level=start_level,
weight=sepc2_weight, bias=sepc2_bias, weight_offset=sepc2_offset_weight, bias_offset=sepc2_offset_bias)
next_x = []
for level, feature in enumerate(x):
temp_fea = sepc_conv1_func(i=level, x=feature)
if level > 0:
tmp = sepc_conv2_func(i=level, x=x[level - 1])
temp_fea = temp_fea + tmp
if level < len(x) - 1:
tmp_x = sepc_conv0_func(i=level,x=x[level+1])
if bilinear_upsample:
tmp_x = mx.contrib.symbol.BilinearResize2D(tmp_x, scale_height=2, scale_width=2,
name='PConv{}_upsampling_level{}'.format(PConv_idx,level))
else:
tmp_x = mx.sym.UpSampling(tmp_x, scale=2, sample_type='nearest', num_args=1,
name='PConv{}_upsampling_level{}'.format(PConv_idx,level))
tmp_x = mx.sym.slice_like(tmp_x, temp_fea)
temp_fea = temp_fea + tmp_x
next_x.append(temp_fea)
if ibn:
next_x = ibn_func(next_x, norm_func, feat_sizes)
next_x = [relu(item, name='PConv{}_level{}_relu'.format(PConv_idx, level)) for level,item in enumerate(next_x)]
return next_x
