def __init__(
self,
width_choice=(4, 5, 6),
depth_choice=(4, 5, 6),
kernel_choice=(3, 5, 7),
num_cell_groups=[1, 4, 4, 4, 4, 4],
expansions=[1, 6, 6, 6, 6, 6],
schedule_cfg=None,
):
super(MNasNetOFASearchSpace, self).__init__(schedule_cfg)
self.genotype_type_name = "MnasnetOFAGenotype"
self.num_cell_groups = num_cell_groups
self.expansions = expansions
self.block_names = sum(
[["cell_{}".format(i) for i in range(len(num_cell_groups))]]
+ [
[
"cell_{}_block_{}".format(i, j)
for j in range(self.num_cell_groups[i])
]
for i in range(len(num_cell_groups))
],
[],
)
self.genotype_type = utils.namedtuple_with_defaults(
self.genotype_type_name, self.block_names, []
)
self.width_choice = width_choice
self.depth_choice = depth_choice
self.kernel_choice = kernel_choice
def __init__(self,
num_dense_blocks=3,
first_ratio=2,
stem_channel=None,
bc_mode=True,
bc_ratio=4,
reduction=0.5,
transition_channels=None,
dynamic_transition=False):
super(DenseSearchSpace, self).__init__()
expect(
(first_ratio is None) + (stem_channel is None) == 1,
"One and only one of `first_ratio` and `stem_channel` should be specified.",
ConfigException)
expect(
dynamic_transition
or (transition_channels is None) + (reduction is None) == 1,
"One and only one of `transition_channels` and `reduction` should be specified.",
ConfigException)
if dynamic_transition:
expect(
reduction is None and transition_channels is None,
"When `dynamic_transition` is true, note that `reduction` and "
"`transition_channels` should not be specified",
ConfigException)
self.num_dense_blocks = num_dense_blocks
self.first_ratio = first_ratio
self.stem_channel = stem_channel
self.bc_mode = bc_mode
self.bc_ratio = bc_ratio
self.reduction = reduction
self.transition_channels = transition_channels
self.dynamic_transition = dynamic_transition
self.genotype_type_name = "DenseGenotype"
self.block_names = sum(
[["stem"]] + \
[["block_{}".format(i), "transition_{}".format(i)] if i != self.num_dense_blocks - 1
else ["block_{}".format(i)] for i in range(self.num_dense_blocks)],
[])
self.genotype_type = utils.namedtuple_with_defaults(
self.genotype_type_name, self.block_names, [])
def __init__(
self,
width_choice=(4, 5, 6),
depth_choice=(2, 3, 4),
kernel_choice=(3, 5, 7),
image_size_choice=[512, 384, 320, 256, 192],
head_width_choice=(0.25, 0.5, 0.75),
head_kernel_choice=[3],
num_cell_groups=[1, 4, 4, 4, 4, 4],
expansions=[1, 6, 6, 6, 6, 6],
num_head=4,
schedule_cfg=None,
):
super().__init__(width_choice, depth_choice, kernel_choice,
image_size_choice, num_cell_groups, expansions,
schedule_cfg)
self.head_width_choice = head_width_choice
self.head_kernel_choice = head_kernel_choice
self.num_head = num_head
self.num_cell_groups = num_cell_groups
self.block_names += ["head_{}".format(i) for i in range(num_head)]
self.genotype_type = utils.namedtuple_with_defaults(
self.genotype_type_name, self.block_names, [])
def __setstate__(self, state):
super(MNasNetOFASearchSpace, self).__setstate__(state)
self.genotype_type = utils.namedtuple_with_defaults(
self.genotype_type_name, self.block_names, []
)
def __setstate__(self, state):
super(CellSearchSpace, self).__setstate__(state)
self.genotype_type = utils.namedtuple_with_defaults(
self.genotype_type_name, self.cell_group_names +
[n + "_concat" for n in self.cell_group_names],
self._default_concats)
def __init__(
self,
# meta arch
num_cell_groups=2,
num_init_nodes=2,
num_layers=8,
cell_layout=None,
reduce_cell_groups=(1, ),
# cell arch
num_steps=4,
num_node_inputs=2,
# concat for output
concat_op="concat",
concat_nodes=None,
loose_end=False,
shared_primitives=("none", "max_pool_3x3", "avg_pool_3x3",
"skip_connect", "sep_conv_3x3", "sep_conv_5x5",
"dil_conv_3x3", "dil_conv_5x5"),
cell_shared_primitives=None,
derive_without_none_op=False):
super(CNNSearchSpace, self).__init__()
## inner-cell
# number of nodes in every cell
self.num_steps = num_steps
# number of input nodes for every node in the cell
self.num_node_inputs = num_node_inputs
# primitive single-operand operations
self.shared_primitives = shared_primitives
# for now, fixed `concat_op` will not be in the rollout
self.concat_op = concat_op
self.concat_nodes = concat_nodes
self.loose_end = loose_end
if loose_end:
expect(
self.concat_nodes is None,
"When `loose_end` is given, `concat_nodes` will be automatically determined, "
"should not be explicitly specified.", ConfigException)
## overall structure/meta-arch: how to arrange cells
# number of cell groups, different cell groups has different structure
self.num_cell_groups = num_cell_groups
# number of cell layers
# if (by default) `num_layers` == 8: the cells of 2 cell groups 0(normal), 1(reduce)
# will be arranged in order [0, 0, 1, 0, 1, 0, 0, 0]
self.num_layers = num_layers
# cell layout
expect(
self.num_cell_groups == 2 or cell_layout is not None,
"`cell_layout` need to be explicitly specified when `num_cell_groups` != 2.",
ConfigException)
if cell_layout is not None:
expect(
len(cell_layout) == self.num_layers,
"Length of `cell_layout` should equal `num_layers`")
expect(
np.max(cell_layout) == self.num_cell_groups - 1,
"Max of elements of `cell_layout` should equal `num_cell_groups-1`"
)
self.cell_layout = cell_layout
elif self.num_cell_groups == 2:
# by default: cell 0: normal cel, cell 1: reduce cell
self.cell_layout = [0] * self.num_layers
self.cell_layout[self.num_layers // 3] = 1
self.cell_layout[(2 * self.num_layers) // 3] = 1
expect(
self.num_cell_groups == 2 or reduce_cell_groups is not None,
"`reduce_cell_groups` need to be explicitly specified when `num_cell_groups` != 2.",
ConfigException)
self.reduce_cell_groups = reduce_cell_groups
if self.reduce_cell_groups is None:
# by default, 2 cell groups, the cell group 1 is the reduce cell group
self.reduce_cell_groups = (1, )
self.cell_group_names = ["{}_{}".format(
"reduce" if i in self.reduce_cell_groups else "normal", i)\
for i in range(self.num_cell_groups)]
# different layerwise primitives
if cell_shared_primitives is not None:
expect(
len(cell_shared_primitives) == self.num_cell_groups,
"When `cell_shared_primitives` is specified, "
"it length should equal `num_cell_groups`", ConfigException)
self.cell_shared_primitives = cell_shared_primitives
self.logger.info("`cell_shared_primitives` specified, "
"will ignore `shared_primitives` configuration.")
self.shared_primitives = None # avoid accidentally access this to cause subtle bugs
self.cellwise_primitives = True
self._num_primitives_list = [
len(cps) for cps in self.cell_shared_primitives
]
else:
self.cell_shared_primitives = [self.shared_primitives
] * self.num_cell_groups
self.cellwise_primitives = False
self._num_primitives = len(self.shared_primitives)
# check concat node
if self.concat_nodes is not None:
if isinstance(self.concat_nodes[0], int):
# same concat node specification for every cell groups
_concat_nodes = [self.concat_nodes] * self.num_cell_groups
for i_cg in range(self.num_cell_groups):
_num_steps = self.get_num_steps(i_cg)
expect(np.max(_concat_nodes[i_cg]) < num_init_nodes + _num_steps,
"`concat_nodes` {} should be in range(0, {}+{}) for cell group {}"\
.format(_concat_nodes[i_cg], num_init_nodes, _num_steps, i_cg))
self.genotype_type_name = "CNNGenotype"
if self.concat_nodes is None and not self.loose_end:
# For backward compatiblity, when concat all steps as output
# specificy default concats
self._default_concats = [
list(
range(num_init_nodes,
num_init_nodes + self.get_num_steps(i_cg)))
for i_cg in range(self.num_cell_groups)
]
else:
# concat_nodes specified or loose end
self._default_concats = []
self.genotype_type = utils.namedtuple_with_defaults(
self.genotype_type_name, self.cell_group_names +
[n + "_concat" for n in self.cell_group_names],
self._default_concats)
# init nodes(meta arch: connect from the last `num_init_nodes` cell's output)
self.num_init_nodes = num_init_nodes
self.derive_without_none_op = derive_without_none_op
