def _init(self):
self.body.add(
nn.activated_conv(self.channels,
kernel_size=3,
stride=self.stride,
padding=1,
in_channels=self.in_channels))
self.body.add(nn.BatchNorm())
self.body.add(
nn.activated_conv(self.channels,
kernel_size=3,
stride=1,
padding=1,
in_channels=self.channels))
self.body.add(nn.BatchNorm())
if self.downsample is not None:
self.downsample.add(
nn.activated_conv(self.channels,
kernel_size=1,
stride=self.stride,
padding=0,
in_channels=self.in_channels,
prefix="sc_qconv_"))
self.downsample.add(nn.BatchNorm())
def _init(self):
self.body.add(
nn.activated_conv(self.slice_width,
kernel_size=3,
stride=self.stride,
padding=1,
in_channels=self.in_channels))
self.body.add(nn.BatchNorm())
if self.downsample is not None:
conv_stride = self.stride
if self.use_pooling:
conv_stride = 1
self.downsample.add(
nn.AvgPool2D(pool_size=2, strides=2, padding=0))
if self.use_fp:
self.downsample.add(
nn.Conv2D(self.channels,
kernel_size=1,
strides=conv_stride,
use_bias=False,
groups=self.num_groups,
in_channels=self.in_channels,
prefix="sc_conv_"))
else:
self.downsample.add(
nn.activated_conv(self.channels,
kernel_size=1,
stride=conv_stride,
padding=0,
in_channels=self.in_channels,
prefix="sc_qconv_"))
self.downsample.add(nn.BatchNorm())
def _add_dense_block(self, dilation):
new_features = nn.HybridSequential(prefix='')
def _add_conv_block(layer):
new_features.add(nn.BatchNorm())
new_features.add(layer)
if self.dropout:
new_features.add(nn.Dropout(self.dropout))
if self.bn_size == 0:
# no bottleneck
_add_conv_block(
nn.activated_conv(self.growth_rate,
kernel_size=3,
padding=dilation,
dilation=dilation))
else:
# bottleneck design
_add_conv_block(
nn.activated_conv(self.bn_size * self.growth_rate,
kernel_size=1))
_add_conv_block(
nn.activated_conv(self.growth_rate, kernel_size=3, padding=1))
self.num_features += self.growth_rate
dense_block = HybridConcurrent(axis=1, prefix='')
dense_block.add(Identity())
dense_block.add(new_features)
self.current_stage.add(dense_block)
def _make_dense_layer(growth_rate, bn_size, dropout, dilation):
new_features = nn.HybridSequential(prefix='')
if bn_size == 0:
# no bottleneck
new_features.add(nn.BatchNorm())
new_features.add(
nn.activated_conv(growth_rate,
kernel_size=3,
padding=dilation,
dilation=dilation))
if dropout:
new_features.add(nn.Dropout(dropout))
else:
# bottleneck design
new_features.add(nn.BatchNorm())
new_features.add(
nn.activated_conv(bn_size * growth_rate, kernel_size=1))
if dropout:
new_features.add(nn.Dropout(dropout))
new_features.add(nn.BatchNorm())
new_features.add(
nn.activated_conv(growth_rate, kernel_size=3, padding=1))
if dropout:
new_features.add(nn.Dropout(dropout))
out = HybridConcurrent(axis=1, prefix='')
out.add(Identity())
out.add(new_features)
return out
def _make_transition(self, transition_num):
dilation = self.dilation[transition_num + 1]
num_out_features = self.num_features // self.reduction_rates[transition_num]
num_out_features = int(round(num_out_features / 32)) * 32
logging.info("Features in transition {}: {} -> {}".format(
transition_num + 1, self.num_features, num_out_features
))
self.num_features = num_out_features
transition = nn.HybridSequential(prefix='')
with transition.name_scope():
for layer in self.downsample_struct.split(","):
if layer == "bn":
transition.add(nn.BatchNorm())
elif layer == "relu":
transition.add(nn.Activation("relu"))
elif layer == "q_conv":
transition.add(nn.activated_conv(self.num_features, kernel_size=1))
elif "fp_conv" in layer:
groups = 1
if ":" in layer:
groups = int(layer.split(":")[1])
transition.add(nn.Conv2D(self.num_features, kernel_size=1, groups=groups, use_bias=False))
elif layer == "pool" and dilation == 1:
transition.add(nn.AvgPool2D(pool_size=2, strides=2))
elif layer == "max_pool" and dilation == 1:
transition.add(nn.MaxPool2D(pool_size=2, strides=2))
elif "cs" in layer:
groups = 16
if ":" in layer:
groups = int(layer.split(":")[1])
transition.add(ChannelShuffle(groups=groups))
self.get_layer(transition_num + 1).add(transition)
def __init__(self,
growth_rate,
dilation,
bn_size,
dropout,
replace_by_skip_connection=False,
**kwargs):
super().__init__(**kwargs)
self.growth_rate = growth_rate
self.dilation = dilation
self.bn_size = bn_size
self.dropout = dropout
new_feature_computation = nn.HybridSequential(prefix='')
self.replace_by_skip_connection = replace_by_skip_connection
if self.replace_by_skip_connection:
self._add_conv_block(
new_feature_computation,
nn.activated_conv(self.growth_rate, kernel_size=1, padding=0))
else:
if self.bn_size == 0:
# no bottleneck
self._add_conv_block(
new_feature_computation,
nn.activated_conv(self.growth_rate,
kernel_size=3,
padding=dilation,
dilation=dilation))
else:
# bottleneck design
self._add_conv_block(
new_feature_computation,
nn.activated_conv(self.bn_size * self.growth_rate,
kernel_size=1))
self._add_conv_block(
new_feature_computation,
nn.activated_conv(self.growth_rate,
kernel_size=3,
padding=1))
dense_block = HybridConcurrent(axis=1, prefix='')
dense_block.add(Identity())
dense_block.add(new_feature_computation)
self.dense_block = dense_block
def __init__(self, channels, in_channels, replace_by_skip_connection=False, dilation=1, **kwargs):
super().__init__(**kwargs)
self.replace_by_skip_connection = replace_by_skip_connection
if(not replace_by_skip_connection):
self.body = nn.HybridSequential(prefix='')
self.body.add(nn.BatchNorm())
self.body.add(nn.activated_conv(channels=channels, kernel_size=3, stride=1,
padding=dilation, in_channels=in_channels, dilation=dilation))
self.use_sliced_addition = channels != in_channels
if self.use_sliced_addition:
assert channels < in_channels
self.slices = [0, in_channels - channels, in_channels]
self.slices_add_x = [False, True]
def __init__(self, channels, in_channels, dilation=1, **kwargs):
super(ImprovementBlock, self).__init__(**kwargs)
self.body = nn.HybridSequential(prefix='')
self.body.add(nn.BatchNorm())
self.body.add(
nn.activated_conv(channels=channels,
kernel_size=3,
stride=1,
padding=dilation,
in_channels=in_channels,
dilation=dilation))
self.use_sliced_addition = channels != in_channels
if self.use_sliced_addition:
assert channels < in_channels
# 0,256,320
self.slices = [0, in_channels - channels, in_channels]
self.slices_add_x = [False, True]
def _make_transition(num_output_features,
use_fp=False,
use_relu=False,
structure='bn,relu?,conv,pool',
dilation=1):
out = nn.HybridSequential(prefix='')
for layer in structure.split(","):
if layer == "bn":
out.add(nn.BatchNorm())
elif layer == "relu?" and use_relu and use_fp:
out.add(nn.Activation("relu"))
elif layer == "conv":
if use_fp:
out.add(
nn.Conv2D(num_output_features,
kernel_size=1,
use_bias=False))
else:
out.add(nn.activated_conv(num_output_features, kernel_size=1))
elif layer == "pool" and dilation == 1:
out.add(nn.AvgPool2D(pool_size=2, strides=2))
elif layer == "max_pool" and dilation == 1:
out.add(nn.MaxPool2D(pool_size=2, strides=2))
return out
def test_binary_layer_config_scaling():
assert isinstance(nn.activated_conv(3), nn.BinaryConvolution)
with nn.set_binary_layer_config(approximation="xnor"):
assert isinstance(nn.activated_conv(3), nn.ScaledBinaryConv)
assert isinstance(nn.activated_conv(3), nn.BinaryConvolution)
