def __call__(self, model):
"""Run constructor."""
del model
n_nodes = self.n_nodes
n_states = n_nodes - 2
n_edges = n_nodes * (n_nodes - 1) // 2
_ = [Categorical([0, 1]) for i in range(n_edges)]
_ = [
Categorical([CONV1X1, CONV3X3, MAXPOOL3X3])
for i in range(n_states)
]
def __call__(self, model):
"""Run constructor."""
del model
for k, v in self.params:
if isinstance(v, list) and len(v) == 1 and isinstance(v[0], list):
_ = Numeric(low=v[0][0], high=v[0][1], name=k)
elif isinstance(v, list):
_ = Categorical(choices=v, name=k)
else:
raise ValueError(
'support categorical and numeric hparams only')
def add_spa_group(self, slot, ent, expansion_range):
"""Create a elastic spatial group from a MBV2 block."""
max_exp = slot.kwargs['expansion']
max_width = slot.chn_in * max_exp
if any([e > max_exp for e in expansion_range]):
raise ValueError('invalid expansion_range: {} max: {}'.format(
expansion_range, max_exp))
num_blocks = len(ent)
if num_blocks != 8:
# not tested
last_conv = self.last_conv
last_bn = self.last_bn
dw_conv = ent[0]
dw_bn = ent[1]
pw_conv = ent[3]
pw_bn = ent[4]
else:
last_conv = ent[0]
last_bn = ent[1]
dw_conv = ent[3]
dw_bn = ent[4]
pw_conv = ent[6]
pw_bn = ent[7]
if self.rank_fn is None or self.rank_fn == 'none':
rank_fn = None
elif self.rank_fn == 'l1_fan_in':
rank_fn = partial(conv2d_rank_weight_l1norm_fan_in, pw_conv)
elif self.rank_fn == 'l1_fan_out':
rank_fn = partial(conv2d_rank_weight_l1norm_fan_out, pw_conv)
elif self.rank_fn == 'bn_l1':
rank_fn = partial(batchnorm2d_rank_weight_l1norm, pw_bn)
else:
raise ValueError('unsupported rank function')
g = ElasticSpatialGroup([last_conv, last_bn, dw_conv, dw_bn],
[pw_conv],
max_width=max_width,
rank_fn=rank_fn)
if self.is_search:
def on_update_handler(chn_in, param):
g.set_width(chn_in * param.value())
param_choice = [e for e in expansion_range]
_ = Categorical(param_choice,
name='spa',
on_update=partial(on_update_handler, slot.chn_in))
self.last_conv = pw_conv
self.last_bn = pw_bn
self.spa_group_cnt += 1
def add_seq_group(self, bottleneck, repeat_range):
"""Create a elastic sequential group from MBV2 stage modules."""
blocks = list(bottleneck)
max_stage_depth = len(blocks)
g = ElasticSequentialGroup(*blocks)
if any([r > max_stage_depth for r in repeat_range]):
raise ValueError('invalid repeat_range: {} max: {}'.format(
repeat_range, max_stage_depth))
if self.is_search:
def on_update_handler(group, param):
group.set_depth(param.value())
_ = Categorical(repeat_range,
name='seq',
on_update=partial(on_update_handler, g))
def __call__(self, model):
"""Construct search space."""
del model
_ = [Categorical(list(range(self.dim))) for _ in range(self.n_params)]
def __init__(self, candidates, arch_param=None):
if arch_param is None:
arch_param = Categorical(list(candidates.keys()))
super().__init__(candidates, arch_param)
self.last_samples = list(range(len(self.candidates())))