def __init__(self, feat_sizes, config, name='fpn_cell'):
super(FPNCell, self).__init__(name=name)
self.feat_sizes = feat_sizes
self.config = config
if config.fpn_config:
fpn_config = config.fpn_config
else:
fpn_config = legacy_arch.get_fpn_config(config.fpn_name,
config.min_level,
config.max_level,
config.fpn_weight_method)
self.fpn_config = fpn_config
self.fnodes = []
for i, fnode_cfg in enumerate(fpn_config.nodes):
logging.info('fnode %d : %s', i, fnode_cfg)
fnode = FNode(feat_sizes[fnode_cfg['feat_level']]['height'],
feat_sizes[fnode_cfg['feat_level']]['width'],
fnode_cfg['inputs_offsets'],
config.fpn_num_filters,
config.apply_bn_for_resampling,
config.is_training_bn,
config.conv_after_downsample,
config.conv_bn_act_pattern,
config.separable_conv,
config.act_type,
strategy=config.strategy,
weight_method=fpn_config.weight_method,
data_format=config.data_format,
name='fnode{}'.format(i))
self.fnodes.append(fnode)
def build_bifpn_layer(feats, feat_sizes, config):
"""Builds a feature pyramid given previous feature pyramid and config."""
p = config # use p to denote the network config.
if p.fpn_config:
fpn_config = p.fpn_config
else:
fpn_config = legacy_arch.get_fpn_config(p.fpn_name, p.min_level,
p.max_level, p.fpn_weight_method)
for i, fnode in enumerate(fpn_config.nodes):
logging.info('fnode %d : %s', i, fnode)
feats = FNode(feat_sizes[fnode['feat_level']]['height'],
feat_sizes[fnode['feat_level']]['width'],
fnode['inputs_offsets'],
p.fpn_num_filters,
p.apply_bn_for_resampling,
p.is_training_bn,
p.conv_after_downsample,
p.use_native_resize_op,
p.pooling_type,
p.conv_bn_act_pattern,
p.separable_conv,
p.act_type,
strategy=p.strategy,
weight_method=fpn_config.weight_method,
data_format=config.data_format,
name='fnode{}'.format(i))(feats)
output_feats = {}
for l in range(p.min_level, p.max_level + 1):
for i, fnode in enumerate(reversed(fpn_config.nodes)):
if fnode['feat_level'] == l:
output_feats[l] = feats[-1 - i]
break
return output_feats
def test_fnode_compile(self):
config = hparams_config.get_efficientdet_config("efficientdet-d0")
fpn_config = legacy_arch.get_fpn_config(config.fpn_name,
config.min_level,
config.max_level,
config.fpn_weight_method)
feat_sizes = utils.get_feat_sizes(config.image_size, config.max_level)
i = 0
fnode_cfg = fpn_config.nodes[i]
examples = [[
tf2.ones([1, 512, 512, 3]),
tf2.ones([1, 256, 256, 16]),
tf2.ones([1, 128, 128, 24]),
tf2.ones([1, 64, 64, 40]),
tf2.ones([1, 32, 32, 112]),
tf2.ones([1, 16, 16, 320])
]]
inputs = [
tf2.keras.Input(shape=[512, 512, 3]),
tf2.keras.Input(shape=[256, 256, 16]),
tf2.keras.Input(shape=[128, 128, 24]),
tf2.keras.Input(shape=[64, 64, 40]),
tf2.keras.Input(shape=[32, 32, 112]),
tf2.keras.Input(shape=[16, 16, 320])
]
x = efficientdet_arch_keras.ResampleFeatureAdder(config)(inputs)
outputs = efficientdet_arch_keras.FNode(
feat_sizes[fnode_cfg['feat_level']]['height'],
feat_sizes[fnode_cfg['feat_level']]['width'],
fnode_cfg['inputs_offsets'],
config.fpn_num_filters,
config.apply_bn_for_resampling,
config.is_training_bn,
config.conv_after_downsample,
config.conv_bn_act_pattern,
config.separable_conv,
config.act_type,
strategy=config.strategy,
weight_method=fpn_config.weight_method,
data_format=config.data_format,
name='fnode{}'.format(i))(x)
model = tf2.keras.Model(inputs=inputs, outputs=outputs)
preds = model(examples)
self.assertEqual(
len(preds),
6,
msg=
"Expected that FNode will add one more node (P6') to initial 5 (P3 - P7)"
)
self.assertEqual(feat_sizes[fnode_cfg['feat_level']]['height'],
preds[5].shape[1])
self.assertEqual(feat_sizes[fnode_cfg['feat_level']]['width'],
preds[5].shape[2])
def __init__(self, feat_sizes, config, name='fpn_cells'):
super(FPNCells, self).__init__(name=name)
self.feat_sizes = feat_sizes
self.config = config
if config.fpn_config:
self.fpn_config = config.fpn_config
else:
self.fpn_config = legacy_arch.get_fpn_config(
config.fpn_name, config.min_level, config.max_level,
config.fpn_weight_method)
self.cells = [
FPNCell(self.feat_sizes, self.config, name='cell_{}'.format(rep))
for rep in range(self.config.fpn_cell_repeats)
]
def __init__(self, config, name='fpn_cells'):
super().__init__(name=name)
self.config = config
self.feat_sizes = utils.get_feat_sizes(config.image_size,
config.max_level)
if config.fpn_config:
self.fpn_config = config.fpn_config
else:
self.fpn_config = legacy_arch.get_fpn_config(
config.fpn_name, config.min_level, config.max_level,
config.fpn_weight_method)
self.cells = [
FPNCell(self.feat_sizes, self.config, name='cell_%d' % rep)
for rep in range(self.config.fpn_cell_repeats)
]
