def __init__(self,
channels,
init_block_channels,
cardinality,
bottleneck_width,
bn_use_global_stats=False,
in_channels=3,
in_size=(32, 32),
classes=10,
**kwargs):
super(CIFARResNeXt, self).__init__(**kwargs)
self.in_size = in_size
self.classes = classes
with self.name_scope():
self.features = nn.HybridSequential(prefix="")
self.features.add(
conv3x3_block(in_channels=in_channels,
out_channels=init_block_channels,
bn_use_global_stats=bn_use_global_stats))
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels):
stage = nn.HybridSequential(prefix="stage{}_".format(i + 1))
with stage.name_scope():
for j, out_channels in enumerate(channels_per_stage):
strides = 2 if (j == 0) and (i != 0) else 1
stage.add(
ResNeXtUnit(
in_channels=in_channels,
out_channels=out_channels,
strides=strides,
cardinality=cardinality,
bottleneck_width=bottleneck_width,
bn_use_global_stats=bn_use_global_stats))
in_channels = out_channels
self.features.add(stage)
self.features.add(nn.AvgPool2D(pool_size=8, strides=1))
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Flatten())
self.output.add(nn.Dense(units=classes, in_units=in_channels))
def __init__(self,
channels,
init_block_channels,
width,
scale,
bn_use_global_stats=False,
in_channels=3,
in_size=(224, 224),
classes=1000,
**kwargs):
super(Res2Net, self).__init__(**kwargs)
self.in_size = in_size
self.classes = classes
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(
ResInitBlock(in_channels=in_channels,
out_channels=init_block_channels,
bn_use_global_stats=bn_use_global_stats))
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels):
stage = nn.HybridSequential(prefix="stage{}_".format(i + 1))
with stage.name_scope():
for j, out_channels in enumerate(channels_per_stage):
strides = 2 if (j == 0) and (i != 0) else 1
stage.add(
Res2NetUnit(
in_channels=in_channels,
out_channels=out_channels,
strides=strides,
width=width,
scale=scale,
bn_use_global_stats=bn_use_global_stats))
in_channels = out_channels
self.features.add(stage)
self.features.add(nn.AvgPool2D(pool_size=7, strides=1))
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Flatten())
self.output.add(nn.Dense(units=classes, in_units=in_channels))
def __init__(self,
channels,
block_names,
merge_types,
dropout_rate=0.0001,
multi_blocks=2,
groups=2,
in_channels=3,
in_size=(224, 224),
classes=1000,
**kwargs):
super(ChannelNet, self).__init__(**kwargs)
self.in_size = in_size
self.classes = classes
with self.name_scope():
self.features = nn.HybridSequential(prefix="")
for i, channels_per_stage in enumerate(channels):
stage = nn.HybridSequential(prefix="stage{}_".format(i + 1))
with stage.name_scope():
for j, out_channels in enumerate(channels_per_stage):
strides = 2 if (j == 0) else 1
stage.add(
ChannetUnit(in_channels=in_channels,
out_channels_list=out_channels,
strides=strides,
multi_blocks=multi_blocks,
groups=groups,
dropout_rate=dropout_rate,
block_names=block_names[i][j],
merge_type=merge_types[i][j]))
if merge_types[i][j] == "cat":
in_channels = sum(out_channels)
else:
in_channels = out_channels[-1]
self.features.add(stage)
self.features.add(nn.AvgPool2D(pool_size=7, strides=1))
self.output = nn.HybridSequential(prefix="")
self.output.add(nn.Flatten())
self.output.add(nn.Dense(units=classes, in_units=in_channels))
def __init__(self, num_classes, verbose=False, **kwargs):
super(ResNet, self).__init__(**kwargs)
self.verbose = verbose
# add name_scope on the outermost Sequential
with self.name_scope():
# block 1
b1 = nn.Conv2D(64, kernel_size=7, strides=2)
# block 2
b2 = nn.Sequential()
b2.add(
nn.MaxPool2D(pool_size=3, strides=2),
Residual(64),
Residual(64)
)
# block 3
b3 = nn.Sequential()
b3.add(
Residual(128, same_shape=False),
Residual(128)
)
# block 4
b4 = nn.Sequential()
b4.add(
Residual(256, same_shape=False),
Residual(256)
)
# block 5
b5 = nn.Sequential()
b5.add(
Residual(512, same_shape=False),
Residual(512)
)
# block 6
b6 = nn.Sequential()
b6.add(
nn.AvgPool2D(pool_size=3),
nn.Dense(num_classes)
)
# chain all blocks together
self.net = nn.Sequential()
self.net.add(b1, b2, b3, b4, b5, b6)
def __init__(self, num_classes, verbose=False, *args, **kwargs):
super(GoogleNet, self).__init__(*args, **kwargs)
self.verbose = verbose
with self.name_scope():
b1 = nn.Sequential()
b1.add(
nn.Conv2D(64,
kernel_size=7,
strides=2,
padding=3,
activation='relu'),
nn.MaxPool2D(pool_size=3, strides=2))
b2 = nn.Sequential()
b2.add(nn.Conv2D(64, kernel_size=1),
nn.Conv2D(192, kernel_size=3, padding=1),
nn.MaxPool2D(pool_size=3, strides=2))
b3 = nn.Sequential()
b3.add(Inception(64, 96, 128, 16, 32, 32),
Inception(128, 128, 192, 32, 96, 64),
nn.MaxPool2D(pool_size=3, strides=2))
b4 = nn.Sequential()
b4.add(Inception(192, 96, 208, 16, 48, 64),
Inception(160, 112, 224, 24, 64, 64),
Inception(128, 128, 256, 24, 64, 64),
Inception(112, 144, 288, 32, 64, 64),
Inception(256, 160, 320, 32, 128, 128),
nn.MaxPool2D(pool_size=3, strides=2))
b5 = nn.Sequential()
b5.add(Inception(256, 160, 320, 32, 128, 128),
Inception(384, 192, 384, 48, 128, 128),
nn.AvgPool2D(pool_size=2))
b6 = nn.Sequential()
b6.add(nn.Flatten(), nn.Dense(num_classes))
self.net = nn.Sequential()
self.net.add(b1, b2, b3, b4, b5, b6)
def test_pool():
layers1d = [
nn.MaxPool1D(),
nn.MaxPool1D(3),
nn.MaxPool1D(3, 2),
nn.AvgPool1D(),
nn.GlobalAvgPool1D(),
]
for layer in layers1d:
check_layer_forward(layer, (1, 2, 10))
layers2d = [
nn.MaxPool2D(),
nn.MaxPool2D((3, 3)),
nn.MaxPool2D(3, 2),
nn.AvgPool2D(),
nn.GlobalAvgPool2D(),
]
for layer in layers2d:
check_layer_forward(layer, (1, 2, 10, 10))
layers3d = [
nn.MaxPool3D(),
nn.MaxPool3D((3, 3, 3)),
nn.MaxPool3D(3, 2),
nn.AvgPool3D(),
nn.GlobalAvgPool3D(),
]
for layer in layers3d:
check_layer_forward(layer, (1, 2, 10, 10, 10))
# test ceil_mode
x = mx.nd.zeros((2, 2, 10, 10))
layer = nn.MaxPool2D(3, ceil_mode=False)
layer.collect_params().initialize()
assert (layer(x).shape == (2, 2, 3, 3))
layer = nn.MaxPool2D(3, ceil_mode=True)
layer.collect_params().initialize()
assert (layer(x).shape == (2, 2, 4, 4))
def __init__(self, version, classes=1000, **kwargs):
super(SqueezeNet, self).__init__(**kwargs)
assert version in ['1.0', '1.1'], ("Unsupported SqueezeNet version {version}:"
"1.0 or 1.1 expected".format(version=version))
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
if version == '1.0':
self.features.add(nn.Conv2D(96, kernel_size=7, strides=2))
self.features.add(nn.Activation('relu'))
self.features.add(nn.MaxPool2D(pool_size=3, strides=2, ceil_mode=True))
self.features.add(_make_fire(16, 64, 64))
self.features.add(_make_fire(16, 64, 64))
self.features.add(_make_fire(32, 128, 128))
self.features.add(nn.MaxPool2D(pool_size=3, strides=2, ceil_mode=True))
self.features.add(_make_fire(32, 128, 128))
self.features.add(_make_fire(48, 192, 192))
self.features.add(_make_fire(48, 192, 192))
self.features.add(_make_fire(64, 256, 256))
self.features.add(nn.MaxPool2D(pool_size=3, strides=2, ceil_mode=True))
self.features.add(_make_fire(64, 256, 256))
else:
self.features.add(nn.Conv2D(64, kernel_size=3, strides=2))
self.features.add(nn.Activation('relu'))
self.features.add(nn.MaxPool2D(pool_size=3, strides=2, ceil_mode=True))
self.features.add(_make_fire(16, 64, 64))
self.features.add(_make_fire(16, 64, 64))
self.features.add(nn.MaxPool2D(pool_size=3, strides=2, ceil_mode=True))
self.features.add(_make_fire(32, 128, 128))
self.features.add(_make_fire(32, 128, 128))
self.features.add(nn.MaxPool2D(pool_size=3, strides=2, ceil_mode=True))
self.features.add(_make_fire(48, 192, 192))
self.features.add(_make_fire(48, 192, 192))
self.features.add(_make_fire(64, 256, 256))
self.features.add(_make_fire(64, 256, 256))
self.features.add(nn.Dropout(0.5))
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Conv2D(classes, kernel_size=1))
self.output.add(nn.Activation('relu'))
self.output.add(nn.AvgPool2D(13))
self.output.add(nn.Flatten())
def __init__(self,
in_channels,
out_channels,
strides,
bn_use_global_stats,
binarized=False,
**kwargs):
super(PreResUnit1bit, self).__init__(**kwargs)
self.resize_identity = (strides != 1)
with self.name_scope():
self.body = PreResBlock1bit(
in_channels=in_channels,
out_channels=out_channels,
strides=strides,
bn_use_global_stats=bn_use_global_stats,
binarized=binarized)
if self.resize_identity:
self.identity_pool = nn.AvgPool2D(pool_size=3,
strides=2,
padding=1)
def dense_net():
net = nn.Sequential()
with net.name_scope():
# first block
net.add(nn.Conv2D(init_channels, kernel_size=7, strides=2, padding=3),
nn.BatchNorm(), nn.Activation('relu'),
nn.MaxPool2D(pool_size=3, strides=2, padding=1))
# dense blocks
channels = init_channels
for i, layers in enumerate(block_layers):
net.add(DenseBlock(layers, growth_rate))
channels += layers * growth_rate
if i != len(block_layers) - 1:
net.add(transition_block(channels // 2))
# last block
net.add(nn.BatchNorm(), nn.Activation('relu'),
nn.AvgPool2D(pool_size=1), nn.Flatten(), nn.Dense(num_classes))
return net
def __init__(self, block, layers, channels, drop_rate, classes=10, **kwargs):
super(CIFARWideResNet, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(nn.BatchNorm(scale=False, center=False))
self.features.add(nn.Conv2D(channels[0], 3, 1, 1, use_bias=False))
self.features.add(nn.BatchNorm())
in_channels = channels[0]
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(block, num_layer, channels[i+1], drop_rate,
stride, i+1, in_channels=in_channels))
in_channels = channels[i+1]
self.features.add(nn.BatchNorm())
self.features.add(nn.Activation('relu'))
self.features.add(nn.AvgPool2D(8))
self.features.add(nn.Flatten())
self.output = nn.Dense(classes)
def __init__(self,
channels,
init_block_channels,
side_channels,
groups,
in_channels=3,
classes=1000,
**kwargs):
super(MENet, self).__init__(**kwargs)
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(MEInitBlock(
in_channels=in_channels,
out_channels=init_block_channels))
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels):
stage = nn.HybridSequential(prefix='stage{}_'.format(i + 1))
with stage.name_scope():
for j, out_channels in enumerate(channels_per_stage):
downsample = (j == 0)
ignore_group = (i == 0) and (j == 0)
stage.add(MEUnit(
in_channels=in_channels,
out_channels=out_channels,
side_channels=side_channels,
groups=groups,
downsample=downsample,
ignore_group=ignore_group))
in_channels = out_channels
self.features.add(stage)
self.features.add(nn.AvgPool2D(
pool_size=7,
strides=1))
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Flatten())
self.output.add(nn.Dense(
units=classes,
in_units=in_channels))
def __init__(self,
channels,
init_block_channels,
final_block_channels,
in_channels=3,
in_size=(224, 224),
classes=1000,
**kwargs):
super(SqueezeNext, self).__init__(**kwargs)
self.in_size = in_size
self.classes = classes
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(
SqnxtInitBlock(in_channels=in_channels,
out_channels=init_block_channels))
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels):
stage = nn.HybridSequential(prefix='stage{}_'.format(i + 1))
with stage.name_scope():
for j, out_channels in enumerate(channels_per_stage):
strides = 2 if (j == 0) and (i != 0) else 1
stage.add(
SqnxtUnit(in_channels=in_channels,
out_channels=out_channels,
strides=strides))
in_channels = out_channels
self.features.add(stage)
self.features.add(
SqnxtConv(in_channels=in_channels,
out_channels=final_block_channels,
kernel_size=1,
strides=1))
in_channels = final_block_channels
self.features.add(nn.AvgPool2D(pool_size=7, strides=1))
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Flatten())
self.output.add(nn.Dense(units=classes, in_units=in_channels))
def __init__(self,
channels,
init_block_channels,
bn_use_global_stats=False,
in_channels=3,
in_size=(32, 32),
classes=10,
**kwargs):
super(CIFAR10WRN, self).__init__(**kwargs)
self.in_size = in_size
self.classes = classes
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(
conv3x3(in_channels=in_channels,
out_channels=init_block_channels))
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels):
stage = nn.HybridSequential(prefix='stage{}_'.format(i + 1))
with stage.name_scope():
for j, out_channels in enumerate(channels_per_stage):
strides = 2 if (j == 0) and (i != 0) else 1
stage.add(
PreResUnit(in_channels=in_channels,
out_channels=out_channels,
strides=strides,
bn_use_global_stats=bn_use_global_stats,
bottleneck=False,
conv1_stride=False))
in_channels = out_channels
self.features.add(stage)
self.features.add(
PreResActivation(in_channels=in_channels,
bn_use_global_stats=bn_use_global_stats))
self.features.add(nn.AvgPool2D(pool_size=8, strides=1))
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Flatten())
self.output.add(nn.Dense(units=classes, in_units=in_channels))
def __init__(self, classes=1000, additional_stage=False, **kwargs):
"""
Input size is 448
:param classes: Output classes
:param additional_stage: If False means Attention56, True means Attention92
:param kwargs:
"""
self.additional_stage = additional_stage
super(ResidualAttentionModel_448input, self).__init__(**kwargs)
with self.name_scope():
self.conv1 = nn.HybridSequential()
with self.conv1.name_scope():
self.conv1.add(nn.Conv2D(64, kernel_size=7, strides=2, padding=3, use_bias=False))
self.conv1.add(nn.BatchNorm())
self.conv1.add(nn.Activation('relu'))
self.mpool1 = nn.MaxPool2D(pool_size=3, strides=2, padding=1)
# 112 x 112
self.residual_block0 = ResidualBlock(128, in_channels=64)
self.attention_module0 = AttentionModule_stage0(128)
self.residual_block1 = ResidualBlock(256, in_channels=128, stride=2)
# 56 x 56
self.attention_module1 = AttentionModule_stage1(256)
self.residual_block2 = ResidualBlock(512, in_channels=256, stride=2)
self.attention_module2 = AttentionModule_stage2(512)
if additional_stage:
self.attention_module2_2 = AttentionModule_stage2(512)
self.residual_block3 = ResidualBlock(1024, in_channels=512, stride=2)
self.attention_module3 = AttentionModule_stage3(1024)
if additional_stage:
self.attention_module3_2 = AttentionModule_stage3(1024)
self.attention_module3_3 = AttentionModule_stage3(1024)
self.residual_block4 = ResidualBlock(2048, in_channels=1024, stride=2)
self.residual_block5 = ResidualBlock(2048)
self.residual_block6 = ResidualBlock(2048)
self.mpool2 = nn.HybridSequential()
with self.mpool2.name_scope():
self.mpool2.add(nn.BatchNorm())
self.mpool2.add(nn.Activation('relu'))
self.mpool2.add(nn.AvgPool2D(pool_size=7, strides=1))
self.fc = nn.Conv2D(classes, kernel_size=1)
def __init__(self, in_channels, out_channels, side_channels, groups,
downsample, ignore_group, **kwargs):
super(MEUnit, self).__init__(**kwargs)
self.downsample = downsample
mid_channels = out_channels // 4
if downsample:
out_channels -= in_channels
with self.name_scope():
# residual branch
self.compress_conv1 = group_conv1x1(
in_channels=in_channels,
out_channels=mid_channels,
groups=(1 if ignore_group else groups))
self.compress_bn1 = nn.BatchNorm(in_channels=mid_channels)
self.c_shuffle = ChannelShuffle(channels=mid_channels,
groups=groups)
self.dw_conv2 = depthwise_conv3x3(
channels=mid_channels, strides=(2 if self.downsample else 1))
self.dw_bn2 = nn.BatchNorm(in_channels=mid_channels)
self.expand_conv3 = group_conv1x1(in_channels=mid_channels,
out_channels=out_channels,
groups=groups)
self.expand_bn3 = nn.BatchNorm(in_channels=out_channels)
if downsample:
self.avgpool = nn.AvgPool2D(pool_size=3, strides=2, padding=1)
self.activ = nn.Activation('relu')
# fusion branch
self.s_merge_conv = conv1x1(in_channels=mid_channels,
out_channels=side_channels)
self.s_merge_bn = nn.BatchNorm(in_channels=side_channels)
self.s_conv = conv3x3(in_channels=side_channels,
out_channels=side_channels,
strides=(2 if self.downsample else 1))
self.s_conv_bn = nn.BatchNorm(in_channels=side_channels)
self.s_evolve_conv = conv1x1(in_channels=side_channels,
out_channels=mid_channels)
self.s_evolve_bn = nn.BatchNorm(in_channels=mid_channels)
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)
return transition
def __init__(self,
channels,
odd_pointwise,
avg_pool_size,
cls_activ,
bn_use_global_stats=False,
in_channels=3,
classes=1000,
**kwargs):
super(DarkNet, self).__init__(**kwargs)
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
for i, channels_per_stage in enumerate(channels):
stage = nn.HybridSequential(prefix='stage{}_'.format(i + 1))
with stage.name_scope():
for j, out_channels in enumerate(channels_per_stage):
stage.add(dark_convYxY(
in_channels=in_channels,
out_channels=out_channels,
bn_use_global_stats=bn_use_global_stats,
pointwise=(len(channels_per_stage) > 1) and not(((j + 1) % 2 == 1) ^ odd_pointwise)))
in_channels = out_channels
if i != len(channels) - 1:
stage.add(nn.MaxPool2D(
pool_size=2,
strides=2))
self.features.add(stage)
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Conv2D(
channels=classes,
kernel_size=1,
in_channels=in_channels))
if cls_activ:
self.output.add(nn.LeakyReLU(alpha=0.1))
self.output.add(nn.AvgPool2D(
pool_size=avg_pool_size,
strides=1))
self.output.add(nn.Flatten())
def __init__(self,
channels,
init_block_channels,
cardinality,
bottleneck_width,
bn_use_global_stats=False,
in_channels=3,
classes=1000,
**kwargs):
super(SENet, self).__init__(**kwargs)
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(
SEInitBlock(in_channels=in_channels,
out_channels=init_block_channels,
bn_use_global_stats=bn_use_global_stats))
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels):
stage = nn.HybridSequential(prefix='stage{}_'.format(i + 1))
identity_conv3x3 = (i != 0)
with stage.name_scope():
for j, out_channels in enumerate(channels_per_stage):
strides = 2 if (j == 0) and (i != 0) else 1
stage.add(
SENetUnit(in_channels=in_channels,
out_channels=out_channels,
strides=strides,
cardinality=cardinality,
bottleneck_width=bottleneck_width,
bn_use_global_stats=bn_use_global_stats,
identity_conv3x3=identity_conv3x3))
in_channels = out_channels
self.features.add(stage)
self.features.add(nn.AvgPool2D(pool_size=7, strides=1))
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Flatten())
self.output.add(nn.Dropout(rate=0.2))
self.output.add(nn.Dense(units=classes, in_units=in_channels))
def __init__(self,
channels,
first_stage_stride,
bn_use_global_stats=False,
in_channels=3,
in_size=(224, 224),
classes=1000,
**kwargs):
super(MobileNet, self).__init__(**kwargs)
self.in_size = in_size
self.classes = classes
with self.name_scope():
self.features = nn.HybridSequential(prefix="")
init_block_channels = channels[0][0]
self.features.add(
conv3x3_block(in_channels=in_channels,
out_channels=init_block_channels,
strides=2,
bn_use_global_stats=bn_use_global_stats))
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels[1:]):
stage = nn.HybridSequential(prefix="stage{}_".format(i + 1))
with stage.name_scope():
for j, out_channels in enumerate(channels_per_stage):
strides = 2 if (j == 0) and (
(i != 0) or first_stage_stride) else 1
stage.add(
dwsconv3x3_block(
in_channels=in_channels,
out_channels=out_channels,
strides=strides,
bn_use_global_stats=bn_use_global_stats))
in_channels = out_channels
self.features.add(stage)
self.features.add(nn.AvgPool2D(pool_size=7, strides=1))
self.output = nn.HybridSequential(prefix="")
self.output.add(nn.Flatten())
self.output.add(nn.Dense(units=classes, in_units=in_channels))
def _make_layer(self, stage_index, block, layers, planes, strides=1, norm_layer=None, last_gamma=False):
down_sample = None
if strides != 1 or self.inplanes != planes * block.expansion:
# down_sample
down_sample = nn.HybridSequential(prefix='down{}_'.format(stage_index))
down_sample.add(nn.AvgPool2D(pool_size=3, strides=strides, padding=1), # down sample
nn.Conv2D(planes * block.expansion, kernel_size=1, strides=1, use_bias=False))
down_sample.add(norm_layer(**self.norm_kwargs))
layer = nn.HybridSequential(prefix='layer{}_'.format(stage_index))
with layer.name_scope():
layer.add(block(planes=planes, strides=strides, down_sample=down_sample,
norm_layer=norm_layer, norm_kwargs=self.norm_kwargs,
last_gamma=last_gamma))
for _ in range(0, layers - 1):
layer.add(block(planes=planes, norm_layer=norm_layer,
norm_kwargs=self.norm_kwargs, last_gamma=last_gamma))
return layer
def __init__(self,
dropout_rate=0.0,
bn_use_global_stats=False,
in_channels=3,
in_size=(299, 299),
classes=1000,
**kwargs):
super(InceptionV4, self).__init__(**kwargs)
self.in_size = in_size
self.classes = classes
layers = [4, 8, 4]
normal_units = [InceptionAUnit, InceptionBUnit, InceptionCUnit]
reduction_units = [ReductionAUnit, ReductionBUnit]
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(
InceptInitBlock(in_channels=in_channels,
bn_use_global_stats=bn_use_global_stats))
for i, layers_per_stage in enumerate(layers):
stage = nn.HybridSequential(prefix="stage{}_".format(i + 1))
with stage.name_scope():
for j in range(layers_per_stage):
if (j == 0) and (i != 0):
unit = reduction_units[i - 1]
else:
unit = normal_units[i]
stage.add(
unit(bn_use_global_stats=bn_use_global_stats))
self.features.add(stage)
self.features.add(nn.AvgPool2D(pool_size=8, strides=1))
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Flatten())
if dropout_rate > 0.0:
self.output.add(nn.Dropout(rate=dropout_rate))
self.output.add(nn.Dense(units=classes, in_units=1536))
def __init__(self,
channels,
in_size,
fixed_size,
bn_use_global_stats=False,
bn_cudnn_off=False,
**kwargs):
super(StridedDiceRightBranch, self).__init__(**kwargs)
with self.name_scope():
self.pool = nn.AvgPool2D(pool_size=3, strides=2, padding=1)
self.dice = DiceBlock(in_channels=channels,
out_channels=channels,
in_size=(in_size[0] // 2, in_size[1] // 2),
fixed_size=fixed_size,
bn_use_global_stats=bn_use_global_stats,
bn_cudnn_off=bn_cudnn_off)
self.conv = conv1x1_block(
in_channels=channels,
out_channels=channels,
bn_use_global_stats=bn_use_global_stats,
bn_cudnn_off=bn_cudnn_off,
activation=(lambda: PReLU2(in_channels=channels)))
def __init__(self,
in_channels,
out_channels,
downscale,
dw_use_bn,
dw_activation,
bn_use_global_stats=False,
bn_cudnn_off=False,
**kwargs):
super(RegNetVUnit, self).__init__(**kwargs)
self.downscale = downscale
with self.name_scope():
self.conv1 = conv1x1_block(
in_channels=in_channels,
out_channels=out_channels,
bn_use_global_stats=bn_use_global_stats,
bn_cudnn_off=bn_cudnn_off)
if self.downscale:
self.pool = nn.AvgPool2D(
pool_size=3,
strides=2,
padding=1)
self.conv2 = dwsconv3x3_block(
in_channels=out_channels,
out_channels=out_channels,
dw_use_bn=dw_use_bn,
bn_use_global_stats=bn_use_global_stats,
bn_cudnn_off=bn_cudnn_off,
dw_activation=dw_activation,
pw_activation=None)
if self.downscale:
self.identity_block = DownBlock(
in_channels=in_channels,
out_channels=out_channels,
strides=2,
bn_use_global_stats=bn_use_global_stats,
bn_cudnn_off=bn_cudnn_off)
self.activ = nn.Activation("relu")
def __init__(self, layers, cardinality, bottleneck_width,
classes=1000, use_se=False, **kwargs):
super(ResNext, self).__init__(**kwargs)
self.cardinality = cardinality
self.bottleneck_width = bottleneck_width
channels = 64
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(nn.Conv2D(channels, 7, 2, 3, use_bias=False))
self.features.add(nn.BatchNorm())
self.features.add(nn.Activation('relu'))
self.features.add(nn.MaxPool2D(3, 2, 1))
for i, num_layer in enumerate(layers):
stride = 1 if i == 0 else 2
self.features.add(self._make_layer(channels, num_layer, stride, use_se, i+1))
channels *= 2
self.features.add(nn.AvgPool2D(7))
self.output = nn.Dense(classes)
def __init__(self,
num_blocks_list=None,
channels_list=None,
strides_list=None,
num_classes=10,
use_backbone=False,
**kwargs):
super(ResNet, self).__init__(**kwargs)
self.use_backbone = use_backbone
with self.name_scope():
self.conv = nn.HybridSequential()
self.body = nn.HybridSequential()
self.pool = nn.HybridSequential()
self.conv.add(nn.Conv2D(64, 3, 1, padding=1))
self.conv.add(nn.Activation('relu'))
for n, c, s in zip(num_blocks_list, channels_list, strides_list):
self.body.add(ConvLayer(n, c, s))
self.pool.add(nn.MaxPool2D((3, 3), strides=s, padding=1))
if not use_backbone:
self.fc = nn.HybridSequential()
self.fc.add(nn.AvgPool2D())
self.fc.add(nn.Dense(num_classes, use_bias=False))
def __init__(self,
channels,
init_block_channels,
final_block_channels,
use_se=False,
use_residual=False,
in_channels=3,
classes=1000,
**kwargs):
super(ShuffleNetV2, self).__init__(**kwargs)
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(
ShuffleInitBlock(in_channels=in_channels,
out_channels=init_block_channels))
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels):
stage = nn.HybridSequential(prefix='stage{}_'.format(i + 1))
with stage.name_scope():
for j, out_channels in enumerate(channels_per_stage):
downsample = (j == 0)
stage.add(
ShuffleUnit(in_channels=in_channels,
out_channels=out_channels,
downsample=downsample,
use_se=use_se,
use_residual=use_residual))
in_channels = out_channels
self.features.add(stage)
self.features.add(
shuffle_conv1x1(in_channels=in_channels,
out_channels=final_block_channels))
in_channels = final_block_channels
self.features.add(nn.AvgPool2D(pool_size=7, strides=1))
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Flatten())
self.output.add(nn.Dense(units=classes, in_units=in_channels))
def __init__(self,
channels,
init_block_channels,
bottleneck,
conv1_stride,
use_se,
bn_use_global_stats=False,
in_channels=3,
classes=1000,
**kwargs):
super(ResNet, self).__init__(**kwargs)
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(
ResInitBlock(in_channels=in_channels,
out_channels=init_block_channels,
bn_use_global_stats=bn_use_global_stats))
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels):
stage = nn.HybridSequential(prefix='stage{}_'.format(i + 1))
with stage.name_scope():
for j, out_channels in enumerate(channels_per_stage):
strides = 2 if (j == 0) and (i != 0) else 1
stage.add(
ResUnit(in_channels=in_channels,
out_channels=out_channels,
strides=strides,
bn_use_global_stats=bn_use_global_stats,
bottleneck=bottleneck,
conv1_stride=conv1_stride,
use_se=use_se))
in_channels = out_channels
self.features.add(stage)
self.features.add(nn.AvgPool2D(pool_size=7, strides=1))
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Flatten())
self.output.add(nn.Dense(units=classes, in_units=in_channels))
def __init__(self, **kwargs):
super(ResidualAttentionModel_56, self).__init__(**kwargs)
"""
input size 224
"""
with self.name_scope():
self.conv1 = nn.HybridSequential()
with self.conv1.name_scope():
self.conv1.add(
nn.Conv2D(64,
kernel_size=7,
strides=2,
padding=3,
use_bias=False))
self.conv1.add(nn.BatchNorm())
self.conv1.add(nn.Activation('relu'))
self.mpool1 = nn.MaxPool2D(pool_size=3, strides=2, padding=1)
self.residual_block1 = ResidualBlock(256, in_channels=64)
self.attention_module1 = AttentionModule_stage1(256)
self.residual_block2 = ResidualBlock(512,
in_channels=256,
stride=2)
self.attention_module2 = AttentionModule_stage2(512)
self.residual_block3 = ResidualBlock(1024,
in_channels=512,
stride=2)
self.attention_module3 = AttentionModule_stage3(1024)
self.residual_block4 = ResidualBlock(2048,
in_channels=1024,
stride=2)
self.residual_block5 = ResidualBlock(2048)
self.residual_block6 = ResidualBlock(2048)
self.mpool2 = nn.HybridSequential()
with self.mpool2.name_scope():
self.mpool2.add(nn.BatchNorm())
self.mpool2.add(nn.Activation('relu'))
self.mpool2.add(nn.AvgPool2D(pool_size=7, strides=1))
self.fc = nn.Conv2D(10, kernel_size=1)
def __init__(self,
channels,
init_block_channels,
groups,
bn_use_global_stats=False,
in_channels=3,
classes=1000,
**kwargs):
super(CondenseNet, self).__init__(**kwargs)
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(
CondenseInitBlock(in_channels=in_channels,
out_channels=init_block_channels))
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels):
stage = nn.HybridSequential(prefix='stage{}_'.format(i + 1))
with stage.name_scope():
if i != 0:
stage.add(TransitionBlock())
for j, out_channels in enumerate(channels_per_stage):
stage.add(
CondenseUnit(
in_channels=in_channels,
out_channels=out_channels,
groups=groups,
bn_use_global_stats=bn_use_global_stats))
in_channels = out_channels
self.features.add(stage)
self.features.add(
PostActivation(in_channels=in_channels,
bn_use_global_stats=bn_use_global_stats))
self.features.add(nn.AvgPool2D(pool_size=7, strides=1))
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Flatten())
self.output.add(CondenseDense(units=classes, in_units=in_channels))
def __init__(self,
channels,
init_block_channels,
growth_rate,
bn_use_global_stats=False,
dropout_rate=0.0,
in_channels=3,
in_size=(224, 224),
classes=1000,
**kwargs):
super(SparseNet, self).__init__(**kwargs)
self.in_size = in_size
self.classes = classes
with self.name_scope():
self.features = nn.HybridSequential(prefix='')
self.features.add(
PreResInitBlock(in_channels=in_channels,
out_channels=init_block_channels,
bn_use_global_stats=bn_use_global_stats))
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels):
stage = SparseStage(in_channels=in_channels,
channels_per_stage=channels_per_stage,
growth_rate=growth_rate,
bn_use_global_stats=bn_use_global_stats,
dropout_rate=dropout_rate,
do_transition=(i != 0))
in_channels = channels_per_stage[-1]
self.features.add(stage)
self.features.add(
PreResActivation(in_channels=in_channels,
bn_use_global_stats=bn_use_global_stats))
self.features.add(nn.AvgPool2D(pool_size=7, strides=1))
self.output = nn.HybridSequential(prefix='')
self.output.add(nn.Flatten())
self.output.add(nn.Dense(units=classes, in_units=in_channels))
