def retinanet_spinenet_mobile_coco() -> cfg.ExperimentConfig:
"""Generates a config for COCO OD RetinaNet for mobile with QAT."""
config = retinanet.retinanet_spinenet_mobile_coco()
task = RetinaNetTask.from_args(quantization=common.Quantization(),
**config.task.as_dict())
task.model.backbone = backbones.Backbone(
type='spinenet_mobile',
spinenet_mobile=backbones.SpineNetMobile(
model_id='49',
stochastic_depth_drop_rate=0.2,
min_level=3,
max_level=7,
use_keras_upsampling_2d=True))
config.task = task
return config
def test_builder(self, backbone_type, input_size, has_attribute_heads):
num_classes = 2
input_specs = tf.keras.layers.InputSpec(
shape=[None, input_size[0], input_size[1], 3])
if has_attribute_heads:
attribute_heads_config = [
retinanet_cfg.AttributeHead(name='att1'),
retinanet_cfg.AttributeHead(name='att2',
type='classification',
size=2),
]
else:
attribute_heads_config = None
model_config = retinanet_cfg.RetinaNet(
num_classes=num_classes,
backbone=backbones.Backbone(
type=backbone_type,
spinenet_mobile=backbones.SpineNetMobile(
model_id='49',
stochastic_depth_drop_rate=0.2,
min_level=3,
max_level=7,
use_keras_upsampling_2d=True)),
head=retinanet_cfg.RetinaNetHead(
attribute_heads=attribute_heads_config))
l2_regularizer = tf.keras.regularizers.l2(5e-5)
quantization_config = common.Quantization()
model = factory.build_retinanet(input_specs=input_specs,
model_config=model_config,
l2_regularizer=l2_regularizer)
_ = qat_factory.build_qat_retinanet(model=model,
quantization=quantization_config,
model_config=model_config)
if has_attribute_heads:
self.assertEqual(model_config.head.attribute_heads[0].as_dict(),
dict(name='att1', type='regression', size=1))
self.assertEqual(model_config.head.attribute_heads[1].as_dict(),
dict(name='att2', type='classification', size=2))
def test_builder(self, backbone_type, decoder_type, input_size,
quantize_detection_head, quantize_detection_decoder):
num_classes = 2
input_specs = tf.keras.layers.InputSpec(
shape=[None, input_size[0], input_size[1], 3])
if backbone_type == 'spinenet_mobile':
backbone_config = backbones.Backbone(
type=backbone_type,
spinenet_mobile=backbones.SpineNetMobile(
model_id='49',
stochastic_depth_drop_rate=0.2,
min_level=3,
max_level=7,
use_keras_upsampling_2d=True))
elif backbone_type == 'mobilenet':
backbone_config = backbones.Backbone(type=backbone_type,
mobilenet=backbones.MobileNet(
model_id='MobileNetV2',
filter_size_scale=1.0))
else:
raise ValueError(
'backbone_type {} is not supported'.format(backbone_type))
if decoder_type == 'identity':
decoder_config = decoders.Decoder(type=decoder_type)
elif decoder_type == 'fpn':
decoder_config = decoders.Decoder(type=decoder_type,
fpn=decoders.FPN(
num_filters=128,
use_separable_conv=True,
use_keras_layer=True))
else:
raise ValueError(
'decoder_type {} is not supported'.format(decoder_type))
model_config = retinanet_cfg.RetinaNet(
num_classes=num_classes,
input_size=[input_size[0], input_size[1], 3],
backbone=backbone_config,
decoder=decoder_config,
head=retinanet_cfg.RetinaNetHead(attribute_heads=None,
use_separable_conv=True))
l2_regularizer = tf.keras.regularizers.l2(5e-5)
# Build the original float32 retinanet model.
model = factory.build_retinanet(input_specs=input_specs,
model_config=model_config,
l2_regularizer=l2_regularizer)
# Call the model with dummy input to build the head part.
dummpy_input = tf.zeros([1] + model_config.input_size)
model(dummpy_input, training=True)
# Build the QAT model from the original model with quantization config.
qat_model = qat_factory.build_qat_retinanet(
model=model,
quantization=common.Quantization(
quantize_detection_decoder=quantize_detection_decoder,
quantize_detection_head=quantize_detection_head),
model_config=model_config)
if quantize_detection_head:
# head become a RetinaNetHeadQuantized when we apply quantization.
self.assertIsInstance(
qat_model.head,
qat_dense_prediction_heads.RetinaNetHeadQuantized)
else:
# head is a RetinaNetHead if we don't apply quantization on head part.
self.assertIsInstance(qat_model.head,
dense_prediction_heads.RetinaNetHead)
self.assertNotIsInstance(
qat_model.head,
qat_dense_prediction_heads.RetinaNetHeadQuantized)
if decoder_type == 'FPN':
if quantize_detection_decoder:
# FPN decoder become a general keras functional model after applying
# quantization.
self.assertNotIsInstance(qat_model.decoder, fpn.FPN)
else:
self.assertIsInstance(qat_model.decoder, fpn.FPN)
def retinanet_spinenet_mobile_coco() -> cfg.ExperimentConfig:
"""COCO object detection with mobile RetinaNet."""
train_batch_size = 256
eval_batch_size = 8
steps_per_epoch = COCO_TRAIN_EXAMPLES // train_batch_size
input_size = 384
config = cfg.ExperimentConfig(
runtime=cfg.RuntimeConfig(mixed_precision_dtype='float32'),
task=RetinaNetTask(
annotation_file=os.path.join(COCO_INPUT_PATH_BASE,
'instances_val2017.json'),
model=RetinaNet(
backbone=backbones.Backbone(
type='spinenet_mobile',
spinenet_mobile=backbones.SpineNetMobile(
model_id='49',
stochastic_depth_drop_rate=0.2,
min_level=3,
max_level=7,
use_keras_upsampling_2d=False)),
decoder=decoders.Decoder(type='identity',
identity=decoders.Identity()),
head=RetinaNetHead(num_filters=48, use_separable_conv=True),
anchor=Anchor(anchor_size=3),
norm_activation=common.NormActivation(use_sync_bn=True,
activation='swish'),
num_classes=91,
input_size=[input_size, input_size, 3],
min_level=3,
max_level=7),
losses=Losses(l2_weight_decay=3e-5),
train_data=DataConfig(input_path=os.path.join(
COCO_INPUT_PATH_BASE, 'train*'),
is_training=True,
global_batch_size=train_batch_size,
parser=Parser(aug_rand_hflip=True,
aug_scale_min=0.1,
aug_scale_max=2.0)),
validation_data=DataConfig(input_path=os.path.join(
COCO_INPUT_PATH_BASE, 'val*'),
is_training=False,
global_batch_size=eval_batch_size)),
trainer=cfg.TrainerConfig(
train_steps=600 * steps_per_epoch,
validation_steps=COCO_VAL_EXAMPLES // eval_batch_size,
validation_interval=steps_per_epoch,
steps_per_loop=steps_per_epoch,
summary_interval=steps_per_epoch,
checkpoint_interval=steps_per_epoch,
optimizer_config=optimization.OptimizationConfig({
'optimizer': {
'type': 'sgd',
'sgd': {
'momentum': 0.9
}
},
'learning_rate': {
'type': 'stepwise',
'stepwise': {
'boundaries':
[575 * steps_per_epoch, 590 * steps_per_epoch],
'values': [
0.32 * train_batch_size / 256.0,
0.032 * train_batch_size / 256.0,
0.0032 * train_batch_size / 256.0
],
}
},
'warmup': {
'type': 'linear',
'linear': {
'warmup_steps': 2000,
'warmup_learning_rate': 0.0067
}
}
})),
restrictions=[
'task.train_data.is_training != None',
'task.validation_data.is_training != None',
])
return config