def get_active_subnet(self, in_channel, preserve_weight=True):
# build the new layer
sub_layer = set_layer_from_config(self.get_active_subnet_config(in_channel))
sub_layer = sub_layer.to(get_net_device(self))
if not preserve_weight:
return sub_layer
# copy weight from current layer
sub_layer.conv1.conv.weight.data.copy_(
self.conv1.conv.get_active_filter(self.active_middle_channels, in_channel).data)
copy_bn(sub_layer.conv1.bn, self.conv1.bn.bn)
sub_layer.conv2.conv.weight.data.copy_(
self.conv2.conv.get_active_filter(self.active_middle_channels, self.active_middle_channels).data)
copy_bn(sub_layer.conv2.bn, self.conv2.bn.bn)
sub_layer.conv3.conv.weight.data.copy_(
self.conv3.conv.get_active_filter(self.active_out_channel, self.active_middle_channels).data)
copy_bn(sub_layer.conv3.bn, self.conv3.bn.bn)
if not isinstance(self.downsample, IdentityLayer):
sub_layer.downsample.conv.weight.data.copy_(
self.downsample.conv.get_active_filter(self.active_out_channel, in_channel).data)
copy_bn(sub_layer.downsample.bn, self.downsample.bn.bn)
return sub_layer
def build_from_config(config):
first_conv = set_layer_from_config(config['first_conv'])
feature_mix_layer = set_layer_from_config(config['feature_mix_layer'])
classifier = set_layer_from_config(config['classifier'])
blocks = []
for block_config in config['blocks']:
blocks.append(ResidualBlock.build_from_config(block_config))
net = ProxylessNASNets(first_conv, blocks, feature_mix_layer,
classifier)
if 'bn' in config:
net.set_bn_param(**config['bn'])
else:
net.set_bn_param(momentum=0.1, eps=1e-3)
return net
def build_from_config(config):
classifier = set_layer_from_config(config['classifier'])
input_stem = []
for layer_config in config['input_stem']:
input_stem.append(set_layer_from_config(layer_config))
blocks = []
for block_config in config['blocks']:
blocks.append(set_layer_from_config(block_config))
net = ResNets(input_stem, blocks, classifier)
if 'bn' in config:
net.set_bn_param(**config['bn'])
else:
net.set_bn_param(momentum=0.1, eps=1e-5)
return net
def get_active_subnet(self, in_channel, preserve_weight=True):
sub_layer = set_layer_from_config(self.get_active_subnet_config(in_channel))
sub_layer = sub_layer.to(get_net_device(self))
if not preserve_weight:
return sub_layer
sub_layer.conv.weight.data.copy_(self.conv.get_active_filter(self.active_out_channel, in_channel).data)
if self.use_bn:
copy_bn(sub_layer.bn, self.bn.bn)
return sub_layer
def my_set_layer_from_config(layer_config):
if layer_config is None:
return None
name2layer = {
LiteResidualModule.__name__: LiteResidualModule,
ReducedMBConvLayer.__name__: ReducedMBConvLayer,
}
layer_name = layer_config.pop('name')
if layer_name in name2layer:
layer = name2layer[layer_name]
return layer.build_from_config(layer_config)
else:
return set_layer_from_config({'name': layer_name, **layer_config})
def get_active_subnet(self, in_channel, preserve_weight=True):
# build the new layer
sub_layer = set_layer_from_config(
self.get_active_subnet_config(in_channel))
sub_layer = sub_layer.to(get_net_device(self))
if not preserve_weight:
return sub_layer
middle_channel = self.active_middle_channel(in_channel)
# copy weight from current layer
if sub_layer.inverted_bottleneck is not None:
sub_layer.inverted_bottleneck.conv.weight.data.copy_(
self.inverted_bottleneck.conv.get_active_filter(
middle_channel, in_channel).data, )
copy_bn(sub_layer.inverted_bottleneck.bn,
self.inverted_bottleneck.bn.bn)
sub_layer.depth_conv.conv.weight.data.copy_(
self.depth_conv.conv.get_active_filter(
middle_channel, self.active_kernel_size).data)
copy_bn(sub_layer.depth_conv.bn, self.depth_conv.bn.bn)
if self.use_se:
se_mid = make_divisible(middle_channel // SEModule.REDUCTION,
divisor=MyNetwork.CHANNEL_DIVISIBLE)
sub_layer.depth_conv.se.fc.reduce.weight.data.copy_(
self.depth_conv.se.get_active_reduce_weight(
se_mid, middle_channel).data)
sub_layer.depth_conv.se.fc.reduce.bias.data.copy_(
self.depth_conv.se.get_active_reduce_bias(se_mid).data)
sub_layer.depth_conv.se.fc.expand.weight.data.copy_(
self.depth_conv.se.get_active_expand_weight(
se_mid, middle_channel).data)
sub_layer.depth_conv.se.fc.expand.bias.data.copy_(
self.depth_conv.se.get_active_expand_bias(middle_channel).data)
sub_layer.point_linear.conv.weight.data.copy_(
self.point_linear.conv.get_active_filter(self.active_out_channel,
middle_channel).data)
copy_bn(sub_layer.point_linear.bn, self.point_linear.bn.bn)
return sub_layer
