def resnet_factory(cls,
depth,
use_3x3_conv0,
use_bn_preprocess,
num_branch,
branch_dilates,
branch_ids,
branch_bn_shared,
branch_conv_shared,
branch_deform,
norm_type="local",
norm_mom=0.9,
ndev=None,
fp16=False):
num_c2_unit, num_c3_unit, num_c4_unit, num_c5_unit = TridentResNetV2Builder.depth_config[
depth]
data = X.var("data")
if fp16:
data = X.to_fp16(data, "data_fp16")
c1 = cls.resnet_c1(data, use_3x3_conv0, use_bn_preprocess, norm_type,
norm_mom, ndev)
c2 = cls.resnet_c2(c1, num_c2_unit, 1, 1, norm_type, norm_mom, ndev)
c3 = cls.resnet_c3(c2, num_c3_unit, 2, 1, norm_type, norm_mom, ndev)
c4 = cls.resnet_trident_c4(c3, num_c4_unit, 2, branch_dilates,
norm_type, norm_mom, ndev, num_branch,
branch_ids, branch_bn_shared,
branch_conv_shared, branch_deform)
# stack branch features and merge into batch dim
c4 = cls.stack_branch_symbols(c4)
c5 = cls.resnet_c5(c4, num_c5_unit, 1, 2, norm_type, norm_mom, ndev)
return c1, c2, c3, c4, c5
def get_roi_feature(self, conv_fpn_feat, rois, trans, image_rois,
batch_image):
p = self.p
rcnn_stride = p.stride
roi_canonical_scale = p.roi_canonical_scale
roi_canonical_level = p.roi_canonical_level
_trans = mx.sym.reshape(trans, [-1, image_rois, 2])
roi_group, offset_group = fpn_roi_assign_offset(
mx.symbol, rois, _trans, rcnn_stride, roi_canonical_scale,
roi_canonical_level)
rois_fpn = dict()
offset_fpn = dict()
for i, stride in enumerate(rcnn_stride):
rois_fpn["stride%s" % stride] = mx.sym.reshape(
roi_group[i], [-1, 4])
offset_fpn["stride%s" % stride] = mx.sym.tile(
mx.sym.reshape(offset_group[i], [-1, 2, 1, 1]),
(1, 1, p.out_size, p.out_size))
if p.fp16:
for stride in rcnn_stride:
conv_fpn_feat["stride%s" % stride] = X.to_fp32(
conv_fpn_feat["stride%s" % stride],
name="fpn_stride%s_to_fp32")
batch_pad = mx.sym.reshape(
mx.sym.repeat(mx.sym.arange(batch_image),
repeats=image_rois,
axis=0), [-1, 1])
fpn_roi_feats = list()
for stride in rcnn_stride:
feat_lvl = conv_fpn_feat["stride%s" % stride]
rois_lvl = rois_fpn["stride%s" % stride]
offset_lvl = offset_fpn["stride%s" % stride]
rois_lvl = mx.sym.concat(batch_pad, rois_lvl, dim=1)
roi_feat = mx.sym.contrib.DeformablePSROIPooling(
data=feat_lvl,
rois=rois_lvl,
trans=offset_lvl,
spatial_scale=1. / stride,
output_dim=256,
group_size=1,
pooled_size=p.out_size,
part_size=0,
sample_per_part=4,
trans_std=0.1,
no_trans=False,
name='delta_r_pooled_feat_stride%s' % stride)
fpn_roi_feats.append(roi_feat)
roi_feat = X.add_n(*fpn_roi_feats)
if p.fp16:
roi_feat = X.to_fp16(roi_feat, name="delta_r_roi_feat_to_fp16")
return roi_feat
def get_roi_feature(self, conv_fpn_feat, proposal):
p = self.p
rcnn_stride = p.stride
roi_canonical_scale = p.roi_canonical_scale
roi_canonical_level = p.roi_canonical_level
group = mx.symbol.Custom(
op_type="assign_layer_fpn",
rois=proposal,
rcnn_stride=rcnn_stride,
roi_canonical_scale=roi_canonical_scale,
roi_canonical_level=roi_canonical_level,
name="assign_layer_fpn"
)
proposal_fpn = dict()
for i, stride in enumerate(rcnn_stride):
proposal_fpn["stride%s" % stride] = group[i]
if p.fp16:
for stride in rcnn_stride:
conv_fpn_feat["stride%s" % stride] = X.to_fp32(
conv_fpn_feat["stride%s" % stride],
name="fpn_stride%s_to_fp32"
)
fpn_roi_feats = list()
for stride in rcnn_stride:
feat_lvl = conv_fpn_feat["stride%s" % stride]
proposal_lvl = proposal_fpn["stride%s" % stride]
roi_feat = X.roi_align(
feat_lvl,
rois=proposal_lvl,
out_size=p.out_size,
stride=stride,
name="roi_align"
)
roi_feat = X.reshape(
data=roi_feat,
shape=(-3, -2),
name='roi_feat_reshape'
)
fpn_roi_feats.append(roi_feat)
roi_feat = X.add_n(*fpn_roi_feats)
if p.fp16:
roi_feat = X.to_fp16(roi_feat, name="roi_feat_to_fp16")
return roi_feat
def get_roi_feature(self, rcnn_feat, proposal):
p = self.p
if p.fp16:
rcnn_feat = X.to_fp32(rcnn_feat, "rcnn_feat_to_fp32")
roi_feat = X.roi_align(rcnn_feat,
rois=proposal,
out_size=p.out_size,
stride=p.stride,
name="roi_align")
if p.fp16:
roi_feat = X.to_fp16(roi_feat, "roi_feat_to_fp16")
roi_feat = X.reshape(roi_feat, (-3, -2))
return roi_feat
def get_roi_feature(self, conv_fpn_feat, proposal):
p = self.p
rcnn_stride = p.stride
group = mx.symbol.Custom(rois=proposal, op_type='assign_layer_fpn')
proposal_fpn = dict()
proposal_fpn["stride4"] = group[1]
proposal_fpn["stride8"] = group[2]
proposal_fpn["stride16"] = group[3]
proposal_fpn["stride32"] = group[4]
if p.fp16:
for stride in rcnn_stride:
conv_fpn_feat["stride%s" % stride] = X.to_fp32(
conv_fpn_feat["stride%s" % stride],
name="fpn_stride%s_to_fp32")
fpn_roi_feats = list()
for stride in rcnn_stride:
feat_lvl = conv_fpn_feat["stride%s" % stride]
proposal_lvl = proposal_fpn["stride%s" % stride]
roi_feat = X.roi_align(feat_lvl,
rois=proposal_lvl,
out_size=p.out_size,
stride=stride,
name="roi_align")
roi_feat = X.reshape(data=roi_feat,
shape=(-3, -2),
name='roi_feat_reshape')
fpn_roi_feats.append(roi_feat)
roi_feat = X.add_n(*fpn_roi_feats)
if p.fp16:
roi_feat = X.to_fp16(roi_feat, name="roi_feat_to_fp16")
return roi_feat
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
