def bneck(s, skippable):
"""Construct a spec for an inverted bottleneck layer."""
possible_filter_multipliers = [3.0, 6.0]
possible_kernel_sizes = [3, 5, 7]
choices = []
if collapse_shared_ops:
kernel_size = schema.OneOf(possible_kernel_sizes,
basic_specs.OP_TAG)
expansion_filters = schema.OneOf([
basic_specs.FilterMultiplier(multiplier)
for multiplier in possible_filter_multipliers
], basic_specs.FILTERS_TAG)
choices.append(
DepthwiseBottleneckSpec(kernel_size=kernel_size,
expansion_filters=expansion_filters,
use_squeeze_and_excite=False,
strides=s,
activation=RELU))
else:
for multiplier in possible_filter_multipliers:
for kernel_size in possible_kernel_sizes:
choices.append(
DepthwiseBottleneckSpec(
kernel_size=kernel_size,
expansion_filters=basic_specs.FilterMultiplier(
multiplier),
use_squeeze_and_excite=False,
strides=s,
activation=RELU))
if skippable:
choices.append(basic_specs.ZeroSpec())
return schema.OneOf(choices, basic_specs.OP_TAG)
def test_scale_conv_tower_spec_filter_multipliers(self):
model_spec = basic_specs.ConvTowerSpec(blocks=[
basic_specs.block(layers=[
schema.OneOf([
basic_specs.FilterMultiplier(3.0),
basic_specs.FilterMultiplier(6.0)
], basic_specs.FILTERS_TAG)
],
filters=48)
],
filters_base=8)
scaled_spec = search_space_utils.scale_conv_tower_spec(
model_spec, multipliers=(0.5, 1, 2), base=8)
# FilterMultiplier objects should not be affected by the scaling function.
self.assertEqual(scaled_spec.blocks[0].layers[0].choices, [
basic_specs.FilterMultiplier(3.0),
basic_specs.FilterMultiplier(6.0),
])
# However, absolute filter sizes should still be scaled.
self.assertEqual(scaled_spec.blocks[0].filters.choices, [24, 48, 96])
def bneck(kernel, input_size, exp_size, se, s, act):
if use_relative_filter_sizes:
# The expanded filter size will be computed relative to the input filter
# size. Separate logic in the model builder code ensures that the expanded
# filter size will be an integer multiple of `model_spec.filters_base`.
filters = basic_specs.FilterMultiplier(exp_size / input_size)
else:
filters = exp_size
return DepthwiseBottleneckSpec(kernel_size=kernel,
expansion_filters=choose_filters(
[filters]),
use_squeeze_and_excite=se,
strides=s,
activation=act)
def bneck(input_size, se, s, act):
"""Construct a DepthwiseBottleneckSpec namedtuple."""
if use_relative_expansion_filters:
expansion_filters = sorted({
basic_specs.FilterMultiplier(expansion)
for expansion in expansion_multipliers
})
else:
expansion_filters = sorted({
search_space_utils.scale_filters(input_size, expansion, base=8)
for expansion in expansion_multipliers
})
if search_squeeze_and_excite:
# Replace the default value of the argument 'se' with a OneOf node.
se = schema.OneOf([False, True], basic_specs.OP_TAG)
return DepthwiseBottleneckSpec(
kernel_size=schema.OneOf([3, 5, 7], basic_specs.OP_TAG),
expansion_filters=choose_filters(expansion_filters),
use_squeeze_and_excite=se,
strides=s,
activation=act)
