def __init__(self, out_channels, cfg, *args, **kwargs):
super().__init__(cfg=cfg, *args, **kwargs)
self.normalizer_fn, self.norm_params = odt.get_norm(
self.cfg.MODEL.FPN.NORM, self.is_training)
self.activation_fn = odt.get_activation_fn(
self.cfg.MODEL.FPN.ACTIVATION_FN)
self.out_channels = out_channels
def __init__(self, cfg, *args, **kwargs):
super().__init__(cfg, *args, **kwargs)
self.out_channels = self.cfg.MODEL.SHUFFLENETS.OUT_CHANNELS
self.normalizer_fn, self.norm_params = odt.get_norm(
self.cfg.MODEL.SHUFFLENETS.NORM, self.is_training)
self.activation_fn = odt.get_activation_fn(
self.cfg.MODEL.SHUFFLENETS.ACTIVATION_FN)
def forward(self, features, batched_inputs):
normalizer_fn, normalizer_params = odt.get_norm(
self.cfg.NORM, self.is_training)
activation_fn = odt.get_activation_fn(self.cfg.ACTIVATION_FN)
with tf.variable_scope("FusionBackboneHookV2"):
del batched_inputs
end_points = list(features.items())
k0, v0 = end_points[0]
mfeatures = []
shape0 = wmlt.combined_static_and_dynamic_shape(v0)
for k, v in end_points[1:]:
net = tf.image.resize_bilinear(v, shape0[1:3])
mfeatures.append(net)
net = tf.add_n(mfeatures) / float(len(mfeatures))
'''
与v2相比，使用sum代替concat
'''
net = v0 + net
level0 = int(k0[1:])
net = slim.conv2d(net,
v0.get_shape().as_list()[-1], [3, 3],
activation_fn=activation_fn,
normalizer_fn=normalizer_fn,
normalizer_params=normalizer_params,
scope=f"smooth{level0}")
res = features
res[f'F{level0}'] = net
return res
def __init__(self, cfg, parent, *args, **kwargs):
'''
:param cfg: only the child part
:param parent:
:param args:
:param kwargs:
'''
super().__init__(cfg, *args, parent=parent, **kwargs)
# Detectron2默认没有使用normalizer, 但在测试数据集上发现不使用normalizer网络不收敛
self.normalizer_fn, self.norm_params = odtk.get_norm(
self.cfg.NORM, is_training=self.is_training)
self.activation_fn = odtk.get_activation_fn(self.cfg.ACTIVATION_FN)
self.norm_scope_name = odtk.get_norm_scope_name(self.cfg.NORM)
'''self.left_pool = tfop.left_pool
self.right_pool = tfop.right_pool
self.bottom_pool = tfop.bottom_pool
self.top_pool = tfop.top_pool'''
'''self.left_pool = partial(wnnl.cnn_self_hattenation,scope="left_pool")
self.right_pool = partial(wnnl.cnn_self_hattenation,scope="right_pool")
self.bottom_pool = partial(wnnl.cnn_self_vattenation,scope="bottom_pool")
self.top_pool = partial(wnnl.cnn_self_vattenation,scope="top_pool")'''
self.left_pool = left_pool
self.right_pool = right_pool
self.bottom_pool = bottom_pool
self.top_pool = top_pool
def __init__(self, cfg, is_mini=False, **kwargs):
super().__init__(cfg, **kwargs)
self.normalizer_fn, self.norm_params = odt.get_norm(
self.cfg.MODEL.HRNET.NORM, self.is_training)
self.activation_fn = odt.get_activation_fn(
self.cfg.MODEL.HRNET.ACTIVATION_FN)
self.is_mini = is_mini
def forward(self, x):
res = collections.OrderedDict()
batch_norm_decay = self.cfg.MODEL.MOBILENETS.batch_norm_decay #0.999
activation_fn = get_activation_fn(
self.cfg.MODEL.MOBILENETS.ACTIVATION_FN)
if not self.is_training:
train_bn = False
elif self.cfg.MODEL.MOBILENETS.FROZEN_BN:
print("Frozen bn.")
train_bn = False
else:
train_bn = True
MINOR_VERSION = self.cfg.MODEL.MOBILENETS.MINOR_VERSION
with slim.arg_scope(
mobilenet_v3.training_scope(bn_decay=batch_norm_decay,
is_training=train_bn)):
if MINOR_VERSION == "LARGE":
conv_defs = mobilenet_v3.V3_LARGE
keys = [
"layer_2", "layer_4", "layer_7", "layer_13", "layer_17"
]
elif MINOR_VERSION == "LARGE_DETECTION":
conv_defs = mobilenet_v3.V3_LARGE_DETECTION
keys = [
"layer_2", "layer_4", "layer_7", "layer_13", "layer_17"
]
elif MINOR_VERSION == "SMALL":
conv_defs = mobilenet_v3.get_V3_SMALL(activation_fn)
keys = ["layer_1", "layer_2", "layer_4", "layer_9", "layer_13"]
elif MINOR_VERSION == "SMALL_DETECTION":
conv_defs = mobilenet_v3.get_V3_SMALL_DETECTION(activation_fn)
keys = ["layer_1", "layer_2", "layer_4", "layer_9", "layer_13"]
else:
conv_defs = None
print(f"ERROR MobileNet Minor version {MINOR_VERSION}")
if activation_fn is not None:
defs = copy.deepcopy(conv_defs)
for d in defs['spec']:
if 'activation_fn' in d.params:
d.params.update({'activation_fn': activation_fn})
with slim.arg_scope(
mobilenet_v3.training_scope(bn_decay=batch_norm_decay,
is_training=train_bn)):
_, end_points = mobilenet_v3.mobilenet(x['image'],
output_stride=None,
base_only=True,
num_classes=None,
conv_defs=defs)
self.end_points = end_points
res.update(end_points)
for i in range(1, 6):
res[f"C{i}"] = end_points[keys[i - 1]]
return res
def __init__(self,cfg,*args,**kwargs):
if cfg.MODEL.PREPROCESS != "subimagenetmean":
print("--------------------WARNING--------------------")
print(f"Preprocess for resnet should be subimagenetmean not {cfg.MODEL.PREPROCESS}.")
print("------------------END WARNING------------------")
super().__init__(cfg,*args,**kwargs)
self.normalizer_fn, self.norm_params = odt.get_norm(self.cfg.MODEL.RESNETS.NORM, self.is_training)
self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.RESNETS.ACTIVATION_FN)
self.out_channels = cfg.MODEL.RESNETS.OUT_CHANNELS
self.scope_name = "50"
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.rcnn_anchor_boxes = tf.reshape(
tf.convert_to_tensor(self.cfg.MODEL.ANCHOR_GENERATOR.SIZES,
dtype=tf.float32), [1, -1])
self.normalizer_fn, self.norm_params = odt.get_norm(
self.cfg.MODEL.ROI_BOX_HEAD.NORM, self.is_training)
self.activation_fn = odt.get_activation_fn(
self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)
self.norm_scope_name = odt.get_norm_scope_name(
self.cfg.MODEL.ROI_BOX_HEAD.NORM)
def __init__(self, cfg, **kwargs):
"""
The following attributes are parsed from config:
num_conv: the number of conv layers
conv_dim: the dimension of the conv layers
norm: normalization for the conv layers
"""
super(HighResolutionMaskHead, self).__init__(cfg, **kwargs)
self.normalizer_fn, self.norm_params = odt.get_norm(
self.cfg.MODEL.ROI_MASK_HEAD.NORM, self.is_training)
self.activation_fn = odt.get_activation_fn(
self.cfg.MODEL.ROI_MASK_HEAD.ACTIVATION_FN)
def __init__(self, cfg, parent, *args, **kwargs):
'''
:param cfg: only child part
:param parent:
:param args:
:param kwargs:
'''
super().__init__(cfg, parent=parent, *args, **kwargs)
self.normalizer_fn, self.norm_params = odtk.get_norm(
self.cfg.NORM, is_training=self.is_training)
self.activation_fn = odtk.get_activation_fn(self.cfg.ACTIVATION_FN)
def __init__(self,
cfg,
bottom_up,
in_features,
out_channels,
fuse_type="sum",
parent=None,
*args,
**kwargs):
"""
Args:
bottom_up (Backbone): module representing the bottom up subnetwork.
Must be a subclass of :class:`Backbone`. The multi-scale feature
maps generated by the bottom up network, and listed in `in_features`,
are used to generate WeightedFPN levels.
in_features (list[str]): names of the input feature maps coming
from the backbone to which WeightedFPN is attached. For example, if the
backbone produces ["res2", "res3", "res4"], any *contiguous* sublist
of these may be used; order must be from high to low resolution.
out_channels (int): number of channels in the output feature maps.
norm (str): the normalization to use.
fuse_type (str): types for fusing the top down features and the lateral
ones. It can be "sum" (default), which sums up element-wise; or "avg",
which takes the element-wise mean of the two.
"""
stage = int(in_features[-1][1:])
super(WeightedFPN, self).__init__(cfg, parent=parent, *args, **kwargs)
assert isinstance(bottom_up, Backbone)
# Place convs into top-down order (from low to high resolution)
# to make the top-down computation in forward clearer.
self.in_features = in_features
self.bottom_up = bottom_up
self.out_channels = out_channels
self._fuse_type = fuse_type
self.scope = "WeightedFPN"
self.use_depthwise = False
self.interpolate_op = tf.image.resize_nearest_neighbor
self.stage = stage
#Detectron2默认没有使用normalizer, 但在测试数据集上发现不使用normalizer网络不收敛
self.normalizer_fn, self.normalizer_params = odt.get_norm(
self.cfg.MODEL.TWOWAYFPN.NORM, self.is_training)
self.hook0_before, self.hook0_after = build_backbone_hook_by_name(
cfg.MODEL.TWOWAYFPN.BACKBONE_HOOK, cfg, parent=self)
if len(cfg.MODEL.TWOWAYFPN.BACKBONE_HOOK) >= 4:
self.hook1_before, self.hook1_after = build_backbone_hook_by_name(
cfg.MODEL.TWOWAYFPN.BACKBONE_HOOK[2:], cfg, parent=self)
else:
self.hook1_before, self.hook1_after = build_backbone_hook_by_name(
["", ""], cfg, parent=self)
self.activation_fn = odt.get_activation_fn(
self.cfg.MODEL.TWOWAYFPN.ACTIVATION_FN)
def __init__(self, cfg, parent, *args, **kwargs):
'''
:param cfg: only the child part
:param parent:
:param args:
:param kwargs:
'''
super().__init__(cfg, *args, parent=parent, **kwargs)
self.normalizer_fn, self.norm_params = odtk.get_norm(
self.cfg.NORM, is_training=self.is_training)
self.activation_fn = odtk.get_activation_fn(self.cfg.ACTIVATION_FN)
self.norm_scope_name = odtk.get_norm_scope_name(self.cfg.NORM)
self.head_conv_dim = self.cfg.HEAD_CONV_DIM
def __init__(self, cfg, **kwargs):
"""
The following attributes are parsed from config:
num_conv: the number of conv layers
conv_dim: the dimension of the conv layers
norm: normalization for the conv layers
"""
super(MaskRCNNConvUpsampleHead, self).__init__(cfg, **kwargs)
#Detectron2默认没有使用normalizer, 使用测试数据发现是否使用normalizer并没有什么影响
self.normalizer_fn, self.norm_params = odt.get_norm(
self.cfg.MODEL.ROI_MASK_HEAD.NORM, self.is_training)
self.activation_fn = odt.get_activation_fn(
self.cfg.MODEL.ROI_MASK_HEAD.ACTIVATION_FN)
def __init__(
self, cfg,bottom_up, in_features, out_channels, top_block=None, fuse_type="sum",
parent=None,*args,**kwargs
):
"""
Args:
bottom_up (Backbone): module representing the bottom up subnetwork.
Must be a subclass of :class:`Backbone`. The multi-scale feature
maps generated by the bottom up network, and listed in `in_features`,
are used to generate FPN levels.
in_features (list[str]): names of the input feature maps coming
from the backbone to which FPN is attached. For example, if the
backbone produces ["res2", "res3", "res4"], any *contiguous* sublist
of these may be used; order must be from high to low resolution.
out_channels (int): number of channels in the output feature maps.
norm (str): the normalization to use.
top_block (nn.Module or None): if provided, an extra operation will
be performed on the output of the last (smallest resolution)
FPN output, and the result will extend the result list. The top_block
further downsamples the feature map. It must have an attribute
"num_levels", meaning the number of extra FPN levels added by
this block, and "in_feature", which is a string representing
its input feature (e.g., p5).
fuse_type (str): types for fusing the top down features and the lateral
ones. It can be "sum" (default), which sums up element-wise; or "avg",
which takes the element-wise mean of the two.
"""
stage = int(in_features[-1][-1:])
super(FPNV2, self).__init__(cfg,parent=parent,*args,**kwargs)
assert isinstance(bottom_up, Backbone)
def get_feature_name(x):
p = x.find(":")
if p<0:
return x
else:
return x[:p]
# Place convs into top-down order (from low to high resolution)
# to make the top-down computation in forward clearer.
self.top_block = top_block
self.in_features = [get_feature_name(x) for x in in_features]
self.bottom_up = bottom_up
self.out_channels = out_channels
self._fuse_type = fuse_type
self.scope = "FPN"
self.use_depthwise = self.cfg.MODEL.FPN.USE_DEPTHWISE
self.interpolate_op=tf.image.resize_nearest_neighbor
self.stage = stage
#Detectron2默认没有使用normalizer, 但在测试数据集上发现不使用normalizer网络不收敛
self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.FPN.NORM,self.is_training)
self.hook_before,self.hook_after = build_backbone_hook(cfg.MODEL.FPN,parent=self)
self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.FPN.ACTIVATION_FN)
def __init__(self, num_keypoints, cfg, parent, *args, **kwargs):
'''
:param cfg: only the child part
:param parent:
:param args:
:param kwargs:
'''
super().__init__(cfg, *args, parent=parent, **kwargs)
self.num_keypoints = num_keypoints
self.normalizer_fn, self.norm_params = odtk.get_norm(
self.cfg.NORM, is_training=self.is_training)
self.activation_fn = odtk.get_activation_fn(self.cfg.ACTIVATION_FN)
self.norm_scope_name = odtk.get_norm_scope_name(self.cfg.NORM)
self.pred_paf_maps_outputs = []
self.pred_conf_maps_outputs = []
def __init__(
self, cfg,bottom_up, in_features,
parent=None,*args,**kwargs
):
"""
Args:
bottom_up (Backbone): module representing the bottom up subnetwork.
Must be a subclass of :class:`Backbone`. The multi-scale feature
maps generated by the bottom up network, and listed in `in_features`,
are used to generate DLA levels.
in_features (list[str]): names of the input feature maps coming
from the backbone to which DLA is attached. For example, if the
backbone produces ["res2", "res3", "res4"], any *contiguous* sublist
of these may be used; order must be from high to low resolution.
norm (str): the normalization to use.
"""
stage = int(in_features[-1][-1:])
super(DLA, self).__init__(cfg,parent=parent,*args,**kwargs)
assert isinstance(bottom_up, Backbone)
def get_feature_name(x):
p = x.find(":")
if p<0:
return x
else:
return x[:p]
# Place convs into top-down order (from low to high resolution)
# to make the top-down computation in forward clearer.
self.in_features = [get_feature_name(x) for x in in_features]
self.bottom_up = bottom_up
self.scope = "DLA"
self.interpolate_op=tf.image.resize_nearest_neighbor
self.stage = stage
#Detectron2默认没有使用normalizer, 但在测试数据集上发现不使用normalizer网络不收敛
self.normalizer_fn,self.norm_params = odt.get_norm(self.cfg.MODEL.DLA.NORM,self.is_training)
self.hook_before,self.hook_after = build_backbone_hook(cfg.MODEL.DLA,parent=self)
self.activation_fn = odt.get_activation_fn(self.cfg.MODEL.DLA.ACTIVATION_FN)
self.out_channels = [ 64,64,128,256]
self.conv_op = functools.partial(slim.conv2d,normalizer_fn=self.normalizer_fn,
activation_fn=self.activation_fn,
normalizer_params=self.norm_params)
self.upsample_op = functools.partial(slim.conv2d_transpose,
kernel_size=4,
stride=2,
activation_fn=self.activation_fn,
normalizer_fn=self.normalizer_fn,
normalizer_params=self.norm_params)
def __init__(self, cfg, parent, *args, **kwargs):
super().__init__(cfg, parent, *args, **kwargs)
self.anchor_generator = build_anchor_generator(cfg,
parent=self,
*args,
**kwargs)
num_cell_anchors = self.anchor_generator.num_cell_anchors
assert len(set(num_cell_anchors)
) == 1, "all levers cell anchors num must be equal."
self.num_cell_anchors = num_cell_anchors[0]
self.box_dim = self.anchor_generator.box_dim
self.normalizer_fn, self.norm_params = odtk.get_norm(
self.cfg.MODEL.RPN.NORM, is_training=self.is_training)
self.activation_fn = odtk.get_activation_fn(
self.cfg.MODEL.RPN.ACTIVATION_FN)
self.hook = build_hook_by_name(self.cfg.MODEL.RPN.HOOK,
self.cfg,
parent=self)
def __init__(self, num_anchors, cfg, parent, *args, **kwargs):
'''
:param num_anchors:
:param cfg: only the child part
:param parent:
:param args:
:param kwargs:
'''
super().__init__(cfg, *args, parent=parent, **kwargs)
assert (
len(set(num_anchors)) == 1
), "Using different number of anchors between levels is not currently supported!"
self.num_anchors = num_anchors[0]
self.normalizer_fn, self.norm_params = odtk.get_norm(
self.cfg.NORM, is_training=self.is_training)
self.activation_fn = odtk.get_activation_fn(self.cfg.ACTIVATION_FN)
self.norm_scope_name = odtk.get_norm_scope_name(self.cfg.NORM)
self.logits_pre_outputs = []
self.bbox_reg_pre_outputs = []
def __init__(self,
cfg,
bottom_up,
in_features,
out_channels,
parent=None,
*args,
**kwargs):
"""
Args:
bottom_up (Backbone): module representing the bottom up subnetwork.
Must be a subclass of :class:`Backbone`. The multi-scale feature
maps generated by the bottom up network, and listed in `in_features`,
are used to generate BIFPN levels.
in_features (list[str]): names of the input feature maps coming
from the backbone to which BIFPN is attached. For example, if the
backbone produces ["res2", "res3", "res4"], any *contiguous* sublist
of these may be used; order must be from high to low resolution.
out_channels (int): number of channels in the output feature maps.
"""
stage = int(in_features[-1][1:])
super(BIFPN, self).__init__(cfg, parent=parent, *args, **kwargs)
assert isinstance(bottom_up, Backbone)
# Place convs into top-down order (from low to high resolution)
# to make the top-down computation in forward clearer.
self.in_features = in_features
self.bottom_up = bottom_up
self.out_channels = out_channels
self.scope = "BIFPN"
self.use_depthwise = False
self.interpolate_op = tf.image.resize_nearest_neighbor
self.stage = stage
self.normalizer_fn, self.norm_params = odt.get_norm(
self.cfg.MODEL.BIFPN.NORM, self.is_training)
self.hook_before, self.hook_after = build_backbone_hook(
cfg.MODEL.BIFPN, parent=self)
self.activation_fn = odt.get_activation_fn(
self.cfg.MODEL.BIFPN.ACTIVATION_FN)
def __init__(self, cfg, parent, *args, **kwargs):
super().__init__(cfg, parent, *args, **kwargs)
self.normalizer_fn, self.norm_params = odt.get_norm(
self.cfg.MODEL.ROI_BOX_HEAD.NORM, self.is_training)
self.activation_fn = odt.get_activation_fn(
self.cfg.MODEL.ROI_BOX_HEAD.ACTIVATION_FN)
