def __init__(self, num_experts):
super(DefaultRouter, self).__init__()
with self.name_scope():
self.body = HybridSequential(prefix='')
self.body.add(GlobalAvgPool2D())
# self.body.add(Dense(num_experts//4, activation='relu'))
self.body.add(Dense(num_experts, activation='sigmoid'))
def __init__(self, in_channels, ndf=64, n_layers=3, use_sigmoid=False, use_bias=False):
super(Discriminator, self).__init__()
with self.name_scope():
self.model = HybridSequential()
kernel_size = 4
padding = int(np.ceil((kernel_size - 1)/2))
self.model.add(Conv2D(channels=ndf, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=in_channels))
self.model.add(LeakyReLU(alpha=0.2))
nf_mult = 1
for n in range(1, n_layers):
nf_mult_prev = nf_mult
nf_mult = min(2 ** n, 8)
self.model.add(Conv2D(channels=ndf * nf_mult, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf * nf_mult_prev,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult))
self.model.add(LeakyReLU(alpha=0.2))
nf_mult_prev = nf_mult
nf_mult = min(2 ** n_layers, 8)
self.model.add(Conv2D(channels=ndf * nf_mult, kernel_size=kernel_size, strides=1,
padding=padding, in_channels=ndf * nf_mult_prev,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Conv2D(channels=1, kernel_size=kernel_size, strides=1,
padding=padding, in_channels=ndf * nf_mult))
if use_sigmoid:
self.model.add(Activation(activation='sigmoid'))
def __init__(self, opts):
super(BasicBlock, self).__init__()
self.bblock = HybridSequential()
if opts.bottle_neck:
self.bblock.add(
BatchNorm(momentum=opts.bn_mom, epsilon=opts.bn_eps))
if not opts.trans_block:
self.bblock.add(LeakyReLU(alpha=.2))
else:
self.bblock.add(Activation(opts.activation))
self.bblock.add(
Conv2D(channels=int(opts.growth_rate * 4),
kernel_size=(1, 1),
strides=(1, 1),
use_bias=opts.use_bias,
padding=(0, 0)))
if opts.drop_out > 0:
self.bblock.add(Dropout(opts.drop_out))
self.bblock.add(BatchNorm(momentum=opts.bn_mom, epsilon=opts.bn_eps))
self.bblock.add(Activation(activation=opts.activation))
self.bblock.add(
Conv2D(channels=int(opts.growth_rate),
kernel_size=(3, 3),
strides=(1, 1),
use_bias=opts.use_bias,
padding=(1, 1)))
if opts.drop_out > 0:
self.bblock.add(Dropout(opts.drop_out))
def __init__(self, channels, bn_mom, act_type, unit_name):
"""
:param channels: Number of channels used in the conv-operations
:param bn_mom: Batch normalization momentum
:param act_type: Activation function to use
:param unit_name: Unit name of the residual block (only used for description (string))
"""
super(ResidualBlock, self).__init__()
self.act_type = act_type
self.unit_name = unit_name
self.body = HybridSequential()
self.body.add(
Conv2D(channels=channels,
kernel_size=(3, 3),
padding=(1, 1),
use_bias=False,
prefix="%s_conv0" % unit_name))
self.body.add(
BatchNorm(momentum=bn_mom, prefix="%s_bn0" % self.unit_name))
self.body.add(
Activation(self.act_type,
prefix="%s_%s0" % (self.unit_name, self.act_type)))
self.body.add(
Conv2D(channels=channels,
kernel_size=(3, 3),
padding=(1, 1),
use_bias=False,
prefix="%s_conv1" % unit_name))
self.body.add(
BatchNorm(momentum=bn_mom, prefix="%s_bn1" % self.unit_name))
def __init__(self, opts):
super(BasicBlock, self).__init__()
self.bblock = HybridSequential()
if opts.bottle_neck:
if opts.norm_type is 'batch':
self.bblock.add(NormLayer())
elif opts.norm_type is 'group':
self.bblock.add(GroupNorm())
elif opts.norm_type is 'instance':
self.bblock.add(InstanceNorm())
if opts.activation in ['leaky']:
self.bblock.add(LeakyReLU(alpha=opts.alpha))
else:
self.bblock.add(Activation(opts.activation))
self.bblock.add(Conv3D(channels=int(opts.growth_rate * 4), kernel_size=(opts.zKernelSize, 1, 1),
strides=(opts.zStride, 1, 1), use_bias=opts.use_bias, padding=(opts.zPad, 0, 0)))
if opts.drop_out > 0:
self.bblock.add(Dropout(opts.drop_out))
if opts.norm_type is 'batch':
self.bblock.add(NormLayer())
elif opts.norm_type is 'group':
self.bblock.add(GroupNorm(in_channels=int(opts.growth_rate * 4)))
elif opts.norm_type is 'instance':
self.bblock.add(InstanceNorm())
if opts.activation in ['leaky']:
self.bblock.add(LeakyReLU(opts.alpha))
else:
self.bblock.add(Activation(opts.activation))
self.bblock.add(Conv3D(channels=int(opts.growth_rate), kernel_size=(opts.zKernelSize, 3, 3),
strides=(opts.zStride, 1, 1), use_bias=opts.use_bias, padding=(opts.zPad, 1, 1)))
if opts.drop_out > 0:
self.bblock.add(Dropout(opts.drop_out))
class EncoderDecoderUnit(HybridBlock):
"""Return a recursive pair of encoder - decoder"""
def __init__(self,
opts,
num_filters,
stage,
inner_block=None,
innermost=False):
super(EncoderDecoderUnit, self).__init__()
factor = 2 if stage == 0 else 1
encoder = EncoderBlock(opts,
opts.units[stage],
num_filters,
trans_block=False if stage == 0 else True)
decoder = DecoderBlock(opts,
num_filters,
res_block=(not innermost),
factor=factor)
if innermost:
model = [encoder, decoder]
else:
model = [encoder, inner_block, decoder]
self.net = HybridSequential()
for block in model:
self.net.add(block)
def hybrid_forward(self, F, x, *args, **kwargs):
"""Forward"""
out = F.concat(x, self.net(x))
return out
def __init__(self, block, layers, channels, **kwargs):
super(ResNetV2, self).__init__(**kwargs)
assert len(layers) == len(channels) - 1
with self.name_scope():
# pretrained weight 사용하려면, self.features = nn.HybridSequential(prefix='상관없음')을 사용하는 수밖에 없다.
self.features = HybridSequential(prefix='')
self.features.add(BatchNorm(
scale=False, center=False)) # 의문점 하나 : 맨 앞에 왜 batch norm을???
self.features.add(Conv2D(channels[0], 7, 2, 3, use_bias=False))
self.features.add(BatchNorm())
self.features.add(Activation('relu'))
self.features.add(MaxPool2D(3, 2, 1)) # 4번째
in_channels = channels[0]
# 5(c2),6(c3),7(c4),8
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],
stride,
i + 1,
in_channels=in_channels))
in_channels = channels[i + 1]
self.features.add(BatchNorm())
self.features.add(Activation('relu')) # 10(c5)
def __init__(self, channels, bn_mom, act_type, unit_name, use_se=True, res_scale_fac=0.2):
"""
:param channels: Number of channels used in the conv-operations
:param bn_mom: Batch normalization momentum
:param act_type: Activation function to use
:param unit_name: Unit name of the residual block (only used for description (string))
"""
super(_RiseResidualBlock, self).__init__(unit_name)
self.act_type = act_type
self.unit_name = unit_name
self.res_scale_fac = res_scale_fac
self.use_se = use_se
# branch 0
self.body = HybridSequential()
self.body.add(Conv2D(channels=channels, kernel_size=(3, 3), padding=(1, 1), use_bias=False,
prefix='%s_conv0' % unit_name))
self.body.add(BatchNorm(momentum=bn_mom, prefix='%s_bn0' % self.unit_name))
self.body.add(get_act(act_type, prefix='%s_%s0' % (unit_name, act_type)))
self.body.add(Conv2D(channels=channels, kernel_size=(3, 3), padding=(1, 1), use_bias=False,
prefix='%s_conv1' % unit_name))
self.body.add(BatchNorm(momentum=bn_mom, prefix='%s_bn1' % self.unit_name))
self.act0 = get_act(act_type, prefix='%s_%s1' % (unit_name, act_type))
if use_se is True:
self.se0 = _SqueezeExcitation('%s_se0' % unit_name, channels, 16, act_type)
def __init__(self,
channels,
in_channels,
num_dev=1,
pre_relu=True,
down=True,
**kwargs):
super(XceptionModule, self).__init__(**kwargs)
with self.name_scope():
self.body = HybridSequential(prefix='body_')
if pre_relu:
self.body.add(nn.Activation('relu'))
self.body.add(_make_separable_conv3(channels, in_channels))
self.body.add(SyncBatchNorm(num_devices=num_dev))
self.body.add(nn.Activation('relu'))
self.body.add(_make_separable_conv3(channels, channels))
self.body.add(SyncBatchNorm(num_devices=num_dev))
if down:
self.body.add(nn.MaxPool2D(pool_size=3, strides=2, padding=1))
self.downsample = HybridSequential(prefix='downsample_')
with self.downsample.name_scope():
self.downsample.add(
nn.Conv2D(channels,
kernel_size=1,
strides=2,
use_bias=False))
self.downsample.add(SyncBatchNorm(num_devices=num_dev))
else:
self.body.add(nn.Activation('relu'))
self.body.add(_make_separable_conv3(channels, channels))
self.body.add(SyncBatchNorm(num_devices=num_dev))
self.downsample = None
def __init__(self, name, nb_act_maps, ratio=16, act_type="relu"):
super(_GatherExcitePlus, self).__init__(prefix=name)
self.nb_act_maps = nb_act_maps
self.body = HybridSequential(prefix="")
nb_units_hidden = nb_act_maps // ratio
with self.name_scope():
# depthwise convolution
# gather step
self.body.add(Conv2D(nb_act_maps, kernel_size=3, padding=1, groups=nb_act_maps, strides=2, use_bias=False))
self.body.add(get_act(act_type))
self.body.add(BatchNorm())
self.body.add(Conv2D(nb_act_maps, kernel_size=3, padding=1, groups=nb_act_maps, strides=2, use_bias=False))
self.body.add(get_act(act_type))
self.body.add(BatchNorm())
self.body.add(Conv2D(nb_act_maps, kernel_size=3, padding=1, groups=nb_act_maps, strides=2, use_bias=False))
self.body.add(get_act(act_type))
self.body.add(BatchNorm())
# get excitement parameters
self.body.add(Dense(nb_units_hidden))
self.body.add(get_act(act_type))
self.body.add(Dense(nb_act_maps))
self.body.add(get_act("sigmoid"))
def __init__(self, num_dev, num_classes=1000, **kwargs):
super(Xception, self).__init__(**kwargs)
with self.name_scope():
self.features = HybridSequential(prefix='')
# entry flow
for i in range(2):
self.features.add(
nn.Conv2D(channels=32 * (i + 1),
kernel_size=3,
padding=0,
strides=2 if i == 0 else 1,
use_bias=False))
self.features.add(SyncBatchNorm(num_devices=num_dev))
self.features.add(nn.Activation('relu'))
channels = [64, 128, 256, 728]
for i in range(len(channels) - 1):
self.features.add(
XceptionModule(channels=channels[i + 1],
in_channels=channels[i],
num_dev=num_dev,
pre_relu=(i != 0),
down=True,
prefix='block{}_'.format(i + 2)))
# middle flow
for i in range(8):
self.features.add(
XceptionModule(channels=728,
in_channels=728,
num_dev=num_dev,
pre_relu=True,
down=False,
prefix='block{}_'.format(i + 5)))
# exit flow
self.features.add(
XceptionExitModule(out_channels=1024,
mid_channels=728,
in_channels=728,
num_dev=num_dev,
pre_relu=True,
down=True,
prefix='block13_'))
self.features.add(
XceptionExitModule(out_channels=2048,
mid_channels=1536,
in_channels=1024,
num_dev=num_dev,
pre_relu=False,
down=False,
prefix='block14_'))
self.features.add(nn.Activation('relu'))
self.output = HybridSequential(prefix='')
self.output.add(nn.GlobalAvgPool2D())
self.output.add(nn.Flatten())
self.output.add(nn.Dense(num_classes))
def __init__(self, in_channels, ndf=64, n_layers=3, use_bias=False, istest=False,latent=256, usetanh = False ):
super(Encoder, self).__init__()
self.model = HybridSequential()
kernel_size = 5
padding = 0 #int(np.ceil((kernel_size - 1) / 2))
self.model.add(Conv2D(channels=32, kernel_size=5, strides=2,
padding=2, in_channels=in_channels))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Conv2D(channels=64, kernel_size=5, strides=2,
padding=2, in_channels=32))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Conv2D(channels=64, kernel_size=5, strides=2,
padding=2, in_channels=64))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Conv2D(channels=64, kernel_size=5, strides=2,
padding=2, in_channels=64))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Conv2D(channels=128, kernel_size=5, strides=2,
padding=2, in_channels=64))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Conv2D(channels=128, kernel_size=5, strides=2,
padding=2, in_channels=128))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(gluon.nn.Dense(latent))
self.model.add(LeakyReLU(alpha=0.2))
def __init__(self, in_channels, ndf=64, n_layers=3, use_sigmoid=False, use_bias=False, istest = False, isthreeway = False):
super(Discriminator, self).__init__()
with self.name_scope():
self.model = HybridSequential()
kernel_size = 5
padding = 0 #int(np.ceil((kernel_size - 1) / 2))
self.model.add(Conv2D(channels=32, kernel_size=5, strides=2,
padding=2, in_channels=in_channels))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Conv2D(channels=64, kernel_size=5, strides=2,
padding=2, in_channels=32))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Conv2D(channels=64, kernel_size=5, strides=2,
padding=2, in_channels=64))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Conv2D(channels=64, kernel_size=5, strides=2,
padding=2, in_channels=64))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Conv2D(channels=128, kernel_size=5, strides=2,
padding=2, in_channels=64))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Conv2D(channels=128, kernel_size=5, strides=2,
padding=2, in_channels=128))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(gluon.nn.Dense(1))
if isthreeway:
self.model.add(gluon.nn.Dense(3))
# elif use_sigmoid:
self.model.add(Activation(activation='sigmoid'))
class AttentionalAggregator(RelationalAggregator):
def __init__(self, in_units, activation=LeakyReLU(0.2), **kwargs):
super().__init__(**kwargs)
with self.name_scope():
self.coefficient_net = HybridSequential()
dense = Dense(in_units=in_units,
units=1,
use_bias=False,
flatten=False)
self.coefficient_net.add(dense)
self.coefficient_net.add(activation)
self.softmax = MaskedSoftmax(axis=1, keepdims=True)
def hybrid_forward(self, F, X, Z, M):
""" X is the concatenation of source, edge, and target
features of an edge. Z is the fused representation.
M is a mask over the neighborhood.
"""
coefficient = self.coefficient_net(X)
attention_weight = self.softmax(coefficient, M)
return F.sum(attention_weight * Z, axis=1)
def get_args(self, X, Z, M, *args):
return X, Z, M
def __init__(self, net=None, version=None, anchors=None, target_size=None,
ctx=mx.cpu()):
super(AnchorOffstNet, self).__init__()
self._net = net
features = []
strides = []
darknet_output = get_darknet(version, pretrained=False, ctx=mx.cpu(), dummy=True)(
mx.nd.random_uniform(low=0, high=1, shape=(1, 3, target_size[0], target_size[1]), ctx=mx.cpu()))
for out in darknet_output: # feature_14, feature_24, feature_28
out_height, out_width = out.shape[2:]
features.append([out_width, out_height])
strides.append([target_size[1] // out_width, target_size[0] // out_height])
features = features[::-1]
strides = strides[::-1] # deep -> middle -> shallow 순으로 !!!
anchors = OrderedDict(anchors)
anchors = list(anchors.values())[::-1]
self._numoffst = len(anchors)
with self.name_scope():
self._anchor_generators = HybridSequential()
for i, anchor, feature, stride in zip(range(len(features)), anchors, features, strides):
self._anchor_generators.add(YoloAnchorGenerator(i, anchor, feature, stride))
self._anchor_generators.initialize(ctx=ctx)
def __init__(self,
inner_channels,
outer_channels,
inner_block=None,
innermost=False,
outermost=False,
use_dropout=False,
use_bias=False,
final_out=3):
super(UnetSkipUnit, self).__init__()
with self.name_scope():
self.outermost = outermost
en_conv = Conv2D(channels=inner_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=outer_channels,
use_bias=use_bias)
en_relu = LeakyReLU(alpha=0.2)
en_norm = BatchNorm(momentum=0.1, in_channels=inner_channels)
de_relu = Activation(activation='relu')
de_norm = BatchNorm(momentum=0.1, in_channels=outer_channels)
if innermost:
de_conv = Conv2DTranspose(channels=outer_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels,
use_bias=use_bias)
encoder = [en_relu, en_conv]
decoder = [de_relu, de_conv, de_norm]
model = encoder + decoder
elif outermost:
de_conv = Conv2DTranspose(channels=final_out,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels * 2)
encoder = [en_conv]
decoder = [de_relu, de_conv, Activation(activation='tanh')]
model = encoder + [inner_block] + decoder
else:
de_conv = Conv2DTranspose(channels=outer_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels * 2,
use_bias=use_bias)
encoder = [en_relu, en_conv, en_norm]
decoder = [de_relu, de_conv, de_norm]
model = encoder + [inner_block] + decoder
if use_dropout:
model += [Dropout(rate=0.5)]
self.model = HybridSequential()
with self.model.name_scope():
for block in model:
self.model.add(block)
def __init__(self, outer_channels, use_bias=False):
super(Res_Block, self).__init__()
with self.name_scope():
conv1 = Conv2D(channels=outer_channels, kernel_size=3, strides=1, padding=1,
in_channels=outer_channels, use_bias=use_bias)
norm1 = BatchNorm(momentum=0.1, in_channels=outer_channels)
relu1 = LeakyReLU(alpha=0.2)
conv2 = Conv2D(channels=outer_channels, kernel_size=3, strides=1, padding=1,
in_channels=outer_channels, use_bias=use_bias)
norm2 = BatchNorm(momentum=0.1, in_channels=outer_channels)
relu2 = LeakyReLU(alpha=0.2)
conv3 = Conv2D(channels=outer_channels, kernel_size=3, strides=1, padding=1,
in_channels=outer_channels, use_bias=use_bias)
norm3 = BatchNorm(momentum=0.1, in_channels=outer_channels)
relu3 = LeakyReLU(alpha=0.2)
res_block = [conv1, norm1, relu1, conv2, norm2, relu2,conv3, norm3, relu3]
self.se = nn.HybridSequential(prefix='')
self.se.add(nn.Dense(outer_channels // 16, use_bias=False))
self.se.add(nn.Activation('relu'))
self.se.add(nn.Dense(outer_channels, use_bias=False))
self.se.add(nn.Activation('sigmoid'))
self.res = HybridSequential()
with self.res.name_scope():
for block in res_block:
self.res.add(block)
class Res_Block(HybridBlock):
def __init__(self, outer_channels, use_bias=False):
super(Res_Block, self).__init__()
with self.name_scope():
conv1 = Conv2D(channels=outer_channels, kernel_size=3, strides=1, padding=1,
in_channels=outer_channels, use_bias=use_bias)
norm1 = BatchNorm(momentum=0.1, in_channels=outer_channels)
relu1 = LeakyReLU(alpha=0.2)
conv2 = Conv2D(channels=outer_channels, kernel_size=3, strides=1, padding=1,
in_channels=outer_channels, use_bias=use_bias)
norm2 = BatchNorm(momentum=0.1, in_channels=outer_channels)
relu2 = LeakyReLU(alpha=0.2)
conv3 = Conv2D(channels=outer_channels, kernel_size=3, strides=1, padding=1,
in_channels=outer_channels, use_bias=use_bias)
norm3 = BatchNorm(momentum=0.1, in_channels=outer_channels)
relu3 = LeakyReLU(alpha=0.2)
res_block = [conv1, norm1, relu1, conv2, norm2, relu2, conv3, norm3, relu3]
self.res = HybridSequential()
with self.res.name_scope():
for block in res_block:
self.res.add(block)
def hybrid_forward(self, F, x):
residual = x
x = self.res(x)
x = x + residual
return x
def __init__(self, name, channels=1, fc0=256, bn_mom=0.9, act_type="relu"):
"""
Definition of the value head proposed by the alpha zero authors
:param name: name prefix for all blocks
:param channels: Number of channels for 1st conv operation in branch 0
:param fc0: Number of units in Dense/Fully-Connected layer
:param bn_mom: Batch normalization momentum parameter
:param act_type: Activation type to use
"""
super(_ValueHeadAlphaZero, self).__init__(prefix=name + "_")
self.body = HybridSequential(prefix="")
with self.name_scope():
self.body.add(
Conv2D(channels=channels, kernel_size=(1, 1), use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
self.body.add(Flatten())
self.body.add(Dense(units=fc0))
self.body.add(get_act(act_type))
self.body.add(Dense(units=1))
self.body.add(get_act("tanh"))
def __init__(self, opts):
super(DenseMultipathNet, self).__init__()
opts.units = opts.units[:opts.num_stage]
assert (len(opts.units) == opts.num_stage)
num_filters = opts.init_channels
num_filters_list = []
for stage in range(opts.num_stage):
num_filters += opts.units[stage] * opts.growth_rate
num_filters = int(floor(num_filters * opts.reduction))
num_filters_list.append(num_filters)
self.net = HybridSequential()
with self.net.name_scope():
self.blocks = EncoderDecoderUnit(opts, num_filters_list[opts.num_stage-1], opts.num_stage-1, innermost=True)
for stage in range(opts.num_stage-2, -1, -1):
self.blocks = EncoderDecoderUnit(opts, num_filters_list[stage], stage, inner_block=self.blocks)
self.net.add(FirstBlock(opts))
self.net.add(self.blocks)
self.net.add(ResDBlock(opts, num_filters=16))
if opts.norm_type is 'batch':
self.net.add(NormLayer())
elif opts.norm_type is 'group':
self.net.add(GroupNorm())
elif opts.norm_type is 'instance':
self.net.add(InstanceNorm())
if opts.activation in ['leaky']:
self.net.add(LeakyReLU(opts.alpha))
else:
self.net.add(Activation(opts.activation))
self.net.add(Conv3D(kernel_size=(1, 1, 1), channels=2, use_bias=opts.use_bias))
self.net.add(Softmax())
def __init__(self, in_channels, ndf=64, n_layers=3, use_bias=False, istest=False,latent=256, usetanh = False ):
super(Encoder, self).__init__()
usetanh = True
self.model = HybridSequential()
kernel_size = 5
padding = 0 #int(np.ceil((kernel_size - 1) / 2))
self.model.add(Conv2D(channels=ndf, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=in_channels))
self.model.add(LeakyReLU(alpha=0.2))
nf_mult = 2;
nf_mult_prev = 1;
nf_mult = 1
for n in range(1, n_layers):
nf_mult_prev = nf_mult
nf_mult = 2 ** n
self.model.add(Conv2D(channels=ndf * nf_mult, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf * nf_mult_prev,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult, use_global_stats=istest))
self.model.add(LeakyReLU(alpha=0.2))
nf_mult_prev = nf_mult
nf_mult = 2 ** n_layers
self.model.add(Conv2D(channels=latent, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf * nf_mult_prev,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels =latent, use_global_stats=istest))
if usetanh:
self.model.add(Activation(activation='tanh'))
else:
self.model.add(LeakyReLU(alpha=0.2))
def __init__(self,
opts,
num_filters,
stage,
inner_block=None,
innermost=False):
super(EncoderDecoderUnit, self).__init__()
factor = 2 if stage == 0 else 1
encoder = EncoderBlock(opts,
opts.units[stage],
num_filters,
trans_block=False if stage == 0 else True)
decoder = DecoderBlock(opts,
num_filters,
res_block=(not innermost),
factor=factor)
if innermost:
model = [encoder, decoder]
else:
model = [encoder, inner_block, decoder]
self.net = HybridSequential()
for block in model:
self.net.add(block)
def __init__(self, in_channels, ndf=64, n_layers=3, use_bias=False, istest=False, latent=256, usetanh = False ):
super(Decoder, self).__init__()
self.model = HybridSequential()
kernel_size = 5
padding = 0
nf_mult = 2 ** n_layers
self.model.add(Conv2DTranspose(channels=ndf * nf_mult/2, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=latent,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult / 2, use_global_stats=istest))
#self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Activation(activation='relu'))
for n in range(1, n_layers):
nf_mult = nf_mult / 2
self.model.add(Conv2DTranspose(channels=ndf * nf_mult / 2, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf * nf_mult,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult / 2, use_global_stats=istest))
#self.model.add(LeakyReLU(alpha=0.2))
if n==2:
self.model.add(Dropout(rate=0.5))
self.model.add(Activation(activation='relu'))
self.model.add(Conv2DTranspose(channels=in_channels, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf))
#self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Activation(activation='tanh'))
def __init__(self, outer_channels, use_bias=False):
super(Res_Block, self).__init__()
with self.name_scope():
conv1 = Conv2D(channels=outer_channels,
kernel_size=3,
strides=1,
padding=1,
in_channels=outer_channels,
use_bias=use_bias)
relu1 = LeakyReLU(alpha=0.2)
norm1 = BatchNorm(momentum=0.1, in_channels=outer_channels)
conv2 = Conv2D(channels=outer_channels,
kernel_size=3,
strides=1,
padding=1,
in_channels=outer_channels,
use_bias=use_bias)
norm2 = BatchNorm(momentum=0.1, in_channels=outer_channels)
relu2 = LeakyReLU(alpha=0.2)
res_block = [conv1, norm1, relu1, conv2, norm2, relu2]
self.res = HybridSequential()
with self.res.name_scope():
for block in res_block:
self.res.add(block)
def __init__(self,
name,
channels,
bn_mom=0.9,
act_type="relu",
se_type=None):
"""
Definition of the stem proposed by the alpha zero authors
:param name: name prefix for all blocks
:param channels: Number of channels for 1st conv operation
:param bn_mom: Batch normalization momentum parameter
:param act_type: Activation type to use
"""
super(_StemRise, self).__init__(prefix=name + "_")
self.body = HybridSequential(prefix="")
with self.name_scope():
# add all layers to the stem
self.body.add(
Conv2D(channels=channels,
kernel_size=(3, 3),
padding=(1, 1),
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
def __init__(self, channels, strides, in_channels=0):
super(Bottleneck, self).__init__()
self.body = HybridSequential(prefix="")
self.body.add(
nn.Conv2D(channels=channels // 4, kernel_size=1, strides=1))
self.body.add(nn.BatchNorm())
self.body.add(nn.Activation('relu'))
self.body.add(
nn.Conv2D(channels=channels // 4,
kernel_size=3,
strides=strides,
padding=1,
use_bias=False,
in_channels=channels // 4))
self.body.add(nn.BatchNorm())
self.body.add(nn.Activation('relu'))
self.body.add(nn.Conv2D(channels, kernel_size=1, strides=1))
self.body.add(nn.BatchNorm())
self.downsample = nn.HybridSequential()
self.downsample.add(
nn.Conv2D(channels=channels,
kernel_size=1,
strides=strides,
use_bias=False,
in_channels=in_channels))
self.downsample.add(nn.BatchNorm())
def __init__(self, name, channels=1, fc0=256, bn_mom=0.9, act_type="relu"):
"""
Definition of the value head. Same as alpha zero authors but changed order Batch-Norm with RElu.
:param name: name prefix for all blocks
:param channels: Number of channels for 1st conv operation in branch 0
:param fc0: Number of units in Dense/Fully-Connected layer
:param bn_mom: Batch normalization momentum parameter
:param act_type: Activation type to use
:param se_type: SqueezeExcitation type choose either [None, "cSE", "sSE", csSE"] for no squeeze excitation,
channelwise squeeze excitation, channel-spatial-squeeze-excitation, respectively
"""
super(_ValueHeadRise, self).__init__(prefix=name + "_")
self.body = HybridSequential(prefix="")
with self.name_scope():
self.body.add(
Conv2D(channels=channels, kernel_size=(1, 1), use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
self.body.add(Flatten())
self.body.add(Dense(units=fc0))
self.body.add(get_act(act_type))
self.body.add(Dense(units=1))
self.body.add(get_act("tanh"))
def __init__(self,
base=18,
heads=OrderedDict(),
head_conv_channel=64,
pretrained=True,
root=os.path.join(os.getcwd(), 'models'),
use_dcnv2=False,
ctx=mx.cpu()):
super(CenterNet, self).__init__()
with self.name_scope():
self._base_network = get_upconv_resnet(base=base,
pretrained=pretrained,
root=root,
use_dcnv2=use_dcnv2,
ctx=ctx)
self._heads = HybridSequential('heads')
for name, values in heads.items():
head = HybridSequential(name)
num_output = values['num_output']
bias = values.get('bias', 0.0)
head.add(
Conv2D(head_conv_channel,
kernel_size=(3, 3),
padding=(1, 1),
use_bias=True))
head.add(Activation('relu'))
head.add(
Conv2D(num_output,
kernel_size=(1, 1),
use_bias=True,
bias_initializer=mx.init.Constant(bias)))
self._heads.add(head)
self._heads.initialize(ctx=ctx)
class VGGAtrousBase(HybridBlock):
def __init__(self, layers, filters):
super(VGGAtrousBase, self).__init__()
with self.name_scope():
'''
# caffe에서 가져온 pre-trained weights를 사용하기 때문에, 아래와 같은 init_scale가 필요하다고 함
-> caffe의 pre-trained model은 입력 scale이 0 ~ 255임
'''
init_scale = mx.nd.array([0.229, 0.224, 0.225]).reshape(
(1, 3, 1, 1)) * 255
self.init_scale = self.params.get_constant('init_scale',
init_scale)
# layers : [2, 2, 3, 3, 3], filters [64, 128, 256, 512, 512])
self.stages = HybridSequential()
for layer, filter in zip(layers, filters):
stage = HybridSequential(prefix='')
with stage.name_scope():
for _ in range(layer):
stage.add(
Conv2D(filter,
kernel_size=3,
padding=1,
weight_initializer=mx.init.Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=3),
bias_initializer='zeros'))
stage.add(Activation('relu'))
self.stages.add(stage)
# fc6, fc7 to dilated convolution layer - hybrid_forward에서 pooling 진행
stage = HybridSequential(prefix='dilated_')
with stage.name_scope():
# conv6(fc6) - dilated
stage.add(
Conv2D(1024,
kernel_size=3,
padding=6,
dilation=6,
weight_initializer=mx.init.Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=3),
bias_initializer='zeros'))
stage.add(Activation('relu'))
# conv7(fc7)
stage.add(
Conv2D(1024,
kernel_size=1,
weight_initializer=mx.init.Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=3),
bias_initializer='zeros'))
stage.add(Activation('relu'))
self.stages.add(stage)
self.norm4 = Normalize(n_channel=filters[3], initial=20, eps=1e-5)
def __init__(self, n_labels=2272, channels=256, num_res_blocks=19, value_fc_size=256, bn_mom=0.9, act_type='relu', **kwargs):
"""
Creates the alpha zero gluon net description based on the given parameters.
:param n_labels: Number of labels the for the policy
:param channels: Used for all convolution operations. (Except the last 2)
:param num_res_blocks: Number of residual blocks to stack. In the paper they used 19 or 39 residual blocks
:param value_fc_size: Fully Connected layer size. Used for the value output
:param bn_mom: Batch normalization momentum
:return: gluon net description
"""
super(AlphaZeroResnet, self).__init__(**kwargs, prefix='')
self.body = HybridSequential(prefix='')
with self.name_scope():
self.body.add(_StemAlphaZero(name='stem', channels=channels, bn_mom=bn_mom, act_type=act_type))
for i in range(num_res_blocks):
unit_name = 'unit%d' % (i + 1)
self.body.add(ResidualBlock(channels, bn_mom, act_type, unit_name=unit_name))
# create the two heads which will be used in the hybrid fwd pass
self.value_head = _ValueHeadAlphaZero('value', 1, value_fc_size, bn_mom, act_type)
self.policy_head = _PolicyHeadAlphaZero('policy', 2, n_labels, bn_mom, act_type)
class UnetSkipUnit(HybridBlock):
def __init__(self, inner_channels, outer_channels, inner_block=None, innermost=False, outermost=False,
use_dropout=False, use_bias=False):
super(UnetSkipUnit, self).__init__()
with self.name_scope():
self.outermost = outermost
en_conv = Conv2D(channels=inner_channels, kernel_size=4, strides=2, padding=1,
in_channels=outer_channels, use_bias=use_bias)
en_relu = LeakyReLU(alpha=0.2)
en_norm = BatchNorm(momentum=0.1, in_channels=inner_channels)
de_relu = Activation(activation='relu')
de_norm = BatchNorm(momentum=0.1, in_channels=outer_channels)
if innermost:
de_conv = Conv2DTranspose(channels=outer_channels, kernel_size=4, strides=2, padding=1,
in_channels=inner_channels, use_bias=use_bias)
encoder = [en_relu, en_conv]
decoder = [de_relu, de_conv, de_norm]
model = encoder + decoder
elif outermost:
de_conv = Conv2DTranspose(channels=outer_channels, kernel_size=4, strides=2, padding=1,
in_channels=inner_channels * 2)
encoder = [en_conv]
decoder = [de_relu, de_conv, Activation(activation='tanh')]
model = encoder + [inner_block] + decoder
else:
de_conv = Conv2DTranspose(channels=outer_channels, kernel_size=4, strides=2, padding=1,
in_channels=inner_channels * 2, use_bias=use_bias)
encoder = [en_relu, en_conv, en_norm]
decoder = [de_relu, de_conv, de_norm]
model = encoder + [inner_block] + decoder
if use_dropout:
model += [Dropout(rate=0.5)]
self.model = HybridSequential()
with self.model.name_scope():
for block in model:
self.model.add(block)
def hybrid_forward(self, F, x):
if self.outermost:
return self.model(x)
else:
return F.concat(self.model(x), x, dim=1)
