def vgg_block(num_convs, num_channels):
blk = Sequential()
for _ in range(num_convs):
blk.add(Conv2D(num_channels, kernel_size=3,
padding=1, activation='relu'))
blk.add(MaxPool2D(pool_size=2, strides=2))
return blk
def test_Conv2D(use_bias, groups):
x = nd.uniform(shape=(2, 2, 5, 5))
my_conv = MyConv(10,
3,
1,
1,
in_channels=2,
groups=groups,
use_bias=use_bias)
my_conv.initialize()
ref_conv = Conv2D(10,
3,
1,
1,
in_channels=2,
groups=groups,
use_bias=use_bias,
bias_initializer=init.Constant(my_conv.bias.data())
if use_bias else 'zero',
weight_initializer=init.Constant(my_conv.weight.data()))
ref_conv.initialize()
return (my_conv(x) - ref_conv(x)).abs().sum().asscalar()
def __init__(self,
in_channels,
out_channels,
kernel_size,
strides=(1, 1),
padding=(0, 0),
dilation=(1, 1),
groups=1,
use_bias=False):
super(SplitAttentionConv, self).__init__()
radix = 2
reduction = 2
assert (in_channels == out_channels)
self.radix = radix
self.cardinality = groups
self.out_channels = out_channels
self.conv = Conv2D(
out_channels * radix,
kernel_size,
strides,
padding,
dilation,
groups=(groups * radix),
in_channels=in_channels,
use_bias=use_bias)
self.bn = BatchNorm(in_channels=out_channels * radix)
self.relu = Activation('relu')
self.sa = SABlock(
out_channels=out_channels,
groups=groups,
radix=radix)
def __init__(self, **kwargs):
super().__init__(**kwargs)
with self.name_scope():
self.conv1 = Conv2D(64, kernel_size=(7, 7), padding=(3, 3))
self.conv2 = Conv2D(64, kernel_size=(5, 5), padding=(2, 2))
self.conv3 = Conv2D(64, kernel_size=(5, 5), padding=(2, 2))
self.conv4 = Conv2D(64, kernel_size=(5, 5), padding=(2, 2))
self.conv5 = Conv2D(48, kernel_size=(5, 5), padding=(2, 2))
self.conv6 = Conv2D(48, kernel_size=(5, 5), padding=(2, 2))
self.conv7 = Conv2D(48, kernel_size=(5, 5), padding=(2, 2))
self.conv8 = Conv2D(32, kernel_size=(5, 5), padding=(2, 2))
self.conv9 = Conv2D(32, kernel_size=(5, 5), padding=(2, 2))
self.conv10 = Conv2D(32, kernel_size=(5, 5), padding=(2, 2))
self.flatten = Flatten()
self.dense1 = Dense(1024)
self.dense2 = Dense(19 * 19)
def __init__(self, count: int, depth: int) -> None:
super(Network, self).__init__()
self._count = count
self._depth = depth
with self.name_scope():
self.add(Conv2D(64, 4, 2, 1, in_channels=depth))
self.add(LeakyReLU(alpha=0.2))
layer = Identity(512, 512)
layer = Skip(512, 512, layer)
for _ in range(0):
layer = Skip(512, 512, layer)
layer.block.add(Dropout(0.5))
layer = Skip(256, 256, layer)
layer = Skip(128, 128, layer)
layer = Skip(64, 64, layer)
self.add(layer)
self.add(Conv2DTranspose(count, 4, 2, 1, in_channels=128))
self.add(Activation("sigmoid"))
for param in self.collect_params().values():
param.initialize()
if "bias" in param.name:
param.set_data(zeros(param.data().shape))
elif "gamma" in param.name:
param.set_data(random_normal(1, 0.02, param.data().shape))
elif "weight" in param.name:
param.set_data(random_normal(0, 0.02, param.data().shape))
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 __init__(self, nb_cls, **kwargs):
super(multilabel_attach, self).__init__(**kwargs)
self.nb_cls = nb_cls
self.conv1 = Conv2D(nb_cls, kernel_size=1, use_bias=False, prefix='tail')
self.fc1 = Dense(1024, flatten=False)
self.fc2 = Dense(1024, flatten=False)
self.out = Dense(1, flatten=False)
def create_model():
model = HybridSequential()
layers = [
Conv2D(6, kernel_size=5),
Reduce('b c (h h2) (w w2) -> b c h w', 'max', h2=2, w2=2),
Conv2D(16, kernel_size=5),
Reduce('b c (h h2) (w w2) -> b c h w', 'max', h2=2, w2=2),
Rearrange('b c h w -> b (c h w)'),
Dense(120),
LeakyReLU(alpha=0.0),
Dense(84),
LeakyReLU(alpha=0.0),
Dense(10),
]
for layer in layers:
model.add(layer)
model.initialize(mxnet.init.Xavier(), ctx=mxnet.cpu())
return model
def __init__(self, name):
super(_SpatialSqueezeExcitation, self).__init__(prefix=name)
self.body = HybridSequential(prefix="")
with self.name_scope():
self.body.add(Conv2D(1, kernel_size=1, padding=0, use_bias=True))
self.body.add(get_act("sigmoid"))
def __init__(self, opts):
super(FirstBlock, self).__init__()
self.fblock = HybridSequential()
self.fblock.add(
Conv2D(channels=opts.init_channels,
kernel_size=(3, 3),
strides=(1, 1),
padding=(1, 1),
use_bias=opts.use_bias))
def ConvBatchAct(channels=1, kernel=1, stride=1, pad=0, num_group=1, active=True):
net = HybridSequential()
with net.name_scope():
net.add(Conv2D(channels, kernel, stride, pad, groups=num_group, use_bias=False))
net.add(BatchNorm(momentum=0.9))
if active:
net.add(Activation('relu'))
# net.add(Swish())
return net
def __init__(self,
unit_name,
cardinality,
channels,
bn_mom,
act_type,
res_scale_fac,
use_se=True):
"""
: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(ResidualBlockX, self).__init__(unit_name + '_')
self.act_type = act_type
self.unit_name = unit_name
self.res_scale_fac = res_scale_fac
self.body = HybridSequential(prefix='')
with self.name_scope():
self.body.add(
Conv2D(channels=channels,
kernel_size=3,
padding=1,
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(self.act_type))
self.body.add(
Conv2D(channels=channels,
kernel_size=3,
padding=1,
groups=cardinality,
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
if use_se is True:
# apply squeeze excitation
self.body.add(_SqueezeExcitation('se0', channels, 16,
act_type))
self.act0 = get_act(act_type)
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:
self.se0 = _ChannelSqueezeExcitation("%s_se0" % unit_name,
channels, 16, act_type)
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,
innerblock=None,
outer_channels=32,
inner_channels=64,
use_bias=False):
super(middlelayer, self).__init__()
with self.name_scope():
res_block_1 = Res_Block(outer_channels=outer_channels)
res_block_2 = Res_Block(outer_channels=inner_channels)
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)
de_conv = Conv2DTranspose(channels=outer_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels,
use_bias=use_bias)
self.p_at = CA_M5(in_channel=inner_channels)
self.c_at = CA_M4()
res_block_3 = Res_Block(outer_channels=inner_channels)
res_block_4 = Res_Block(outer_channels=outer_channels)
res1 = res_block_1
encoder = [en_conv, en_norm, en_relu]
res2 = res_block_2
res3 = res_block_3
decoder = [de_conv, de_norm, de_relu]
res4 = res_block_4
self.encoder = HybridSequential()
with self.encoder.name_scope():
for block in encoder:
self.encoder.add(block)
self.inner_block = innerblock
self.res1 = res1
self.res2 = res2
self.res3 = res3
self.res4 = res4
self.decoder = HybridSequential()
with self.decoder.name_scope():
for block in decoder:
self.decoder.add(block)
def __init__(self, in_channels, ndf=1, n_layers=3, use_sigmoid=False, use_bias=False):
super(label_Discriminator, self).__init__()
with self.name_scope():
self.model = HybridSequential()
kernel_size = 70
padding = 24
self.model.add(Conv2D(channels=ndf, kernel_size=kernel_size, strides=8,
padding=padding, in_channels=in_channels, use_bias=use_bias))
if use_sigmoid:
self.model.add(Activation(activation='sigmoid'))
def __init__(self, **kwargs):
super(Net, self).__init__(**kwargs)
with self.name_scope():
# layers created in name_scope will inherit name space
# from parent layer.
############### Conv2D ###################
self.conv1 = Conv2D(20, kernel_size=(5, 5))
self.conv2 = Conv2D(50, kernel_size=(5, 5))
##########################################
################# DOConv2D ######################
# self.conv1 = DOConv2D(1, 20, kernel_size=(5, 5))
# self.conv2 = DOConv2D(20, 50, kernel_size=(5, 5))
###################################################
self.pool1 = nn.MaxPool2D(pool_size=(2, 2), strides=(2, 2))
self.pool2 = nn.MaxPool2D(pool_size=(2, 2), strides=(2, 2))
self.fc1 = nn.Dense(500)
self.fc2 = nn.Dense(10)
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 _conv2d(channel, kernel, padding, stride, norm_layer=BatchNorm):
"""A common conv-bn-leakyrelu cell"""
cell = HybridSequential(prefix='')
cell.add(
Conv2D(channel,
kernel_size=kernel,
strides=stride,
padding=padding,
use_bias=False))
cell.add(norm_layer(epsilon=1e-5, momentum=0.9))
cell.add(LeakyReLU(0.1))
return cell
def __init__(self, channels, momentum=0.9, epsilon=1e-5):
super(OutputFF, self).__init__()
with self.name_scope():
# self.weight1 = self.params.get('weight1', shape=(1,))
# self.weight2 = self.params.get('weight2', shape=(1,))
# self.weight3 = self.params.get('weight3', shape=(1,))
# depthwise separable convolution
self._dws = HybridSequential()
self._dws.add(
Conv2D(channels,
3,
strides=(1, 1),
padding=(1, 1),
groups=channels))
self._dws.add(BatchNorm(momentum=momentum, epsilon=epsilon))
self._dws.add(Activation('relu'))
self._dws.add(
Conv2D(channels, 1, strides=(1, 1), padding=(0, 0), groups=1))
self._dws.add(BatchNorm(momentum=momentum, epsilon=epsilon))
self._dws.add(Activation('relu'))
def __init__(self,in_channel, out_channel):
super(encoder,self).__init__()
with self.name_scope():
en_conv = Conv2D(channels=out_channel, kernel_size=4, strides=2,
padding=1,in_channels=in_channel)
norm = BatchNorm(momentum=0.1, in_channels=out_channel)
relu = LeakyReLU(alpha=0.2)
encode=[en_conv,norm,relu]
self.encoder = HybridSequential()
with self.encoder.name_scope():
for block in encode:
self.encoder.add(block)
def __init__(self, base=18,
deconv_channels=(256, 128, 64),
deconv_kernels=(4, 4, 4),
pretrained=True,
root=os.path.join(os.getcwd(), 'models'),
use_dcnv2=False,
ctx=mx.cpu()):
mxnet_version = float(mx.__version__[0:3])
if mxnet_version < 1.5:
logging.error("please upgrade mxnet version above 1.5.x")
raise EnvironmentError
super(UpConvResNet, self).__init__()
self._use_dcnv2 = use_dcnv2
self._resnet = get_resnet(base, pretrained=pretrained, root=root, ctx=ctx)
self._upconv = HybridSequential('')
with self._upconv.name_scope():
for channel, kernel in zip(deconv_channels, deconv_kernels):
kernel, padding, output_padding = self._get_conv_argument(kernel)
if self._use_dcnv2:
'''
in paper, we first change the channels of the three upsampling layers to
256, 128, 64, respectively, to save computation, we then add one 3 x 3 deformable convolutional layer
before each up-convolution layer with channel 256, 128, 64
'''
assert hasattr(contrib.cnn, 'ModulatedDeformableConvolution'), \
"No ModulatedDeformableConvolution found in mxnet, consider upgrade to mxnet 1.6.0..."
self._upconv.add(contrib.cnn.ModulatedDeformableConvolution(channels=channel,
kernel_size=3,
strides=1,
padding=1,
use_bias=False,
num_deformable_group=1))
else:
self._upconv.add(Conv2D(channels=channel,
kernel_size=3,
strides=1,
padding=1, use_bias=False))
self._upconv.add(BatchNorm(momentum=0.9))
self._upconv.add(Activation('relu'))
self._upconv.add(Conv2DTranspose(channels=channel,
kernel_size=kernel,
strides=2,
padding=padding,
output_padding=output_padding,
use_bias=False,
weight_initializer=mx.init.Bilinear()))
self._upconv.add(BatchNorm(momentum=0.9))
self._upconv.add(Activation('relu'))
self._upconv.initialize(ctx=ctx)
logging.info(f"{self.__class__.__name__} weight init 완료")
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'))
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,
name,
channels,
bn_mom=0.9,
act_type="relu",
nb_input_channels=34,
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
:param nb_input_channels: Number of input channels of the board representation
:param se_type: SqueezeExcitation type choose either [None, "cSE", "sSE", csSE"] for no squeeze excitation,
"""
super(_StemAlphaZero, self).__init__(prefix=name + "_")
self.body = HybridSequential(prefix="")
with self.name_scope():
if se_type:
# start with a proceeding batch norm layer
self.body.add(BatchNorm(momentum=bn_mom))
if se_type == "cSE":
# apply squeeze excitation
self.body.add(
_ChannelSqueezeExcitation("se0", nb_input_channels, 16,
act_type))
elif se_type == "sSE":
self.body.add(_SpatialSqueezeExcitation("se0"))
elif se_type == "csSE":
self.body.add(
_SpatialChannelSqueezeExcitation(
"se0", nb_input_channels, 1, act_type))
else:
raise Exception(
'Unsupported Squeeze Excitation Module: Choose either [None, "cSE", "sSE", "csSE"'
)
# 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,
name,
channels=1,
fc0=256,
bn_mom=0.9,
act_type="relu",
se_type=None):
"""
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
:param se_type: SqueezeExcitation type choose either [None, "cSE", "sSE", csSE"] for no squeeze excitation,
channelwise squeeze excitation, channel-spatial-squeeze-excitation, respectively
"""
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))
if se_type:
if se_type == "cSE":
# apply squeeze excitation
self.body.add(
_ChannelSqueezeExcitation("se0", channels, 16,
act_type))
elif se_type == "sSE":
self.body.add(_SpatialSqueezeExcitation("se0"))
elif se_type == "csSE":
self.body.add(
_SpatialChannelSqueezeExcitation(
"se0", channels, 1, act_type))
else:
raise Exception(
'Unsupported Squeeze Excitation Module: Choose either [None, "cSE", "sSE", "csSE"'
)
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, 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 __init__(self, innerblock=None):
super(outerpart, self).__init__()
with self.name_scope():
en_conv1 = Conv2D(channels=32,
kernel_size=4,
strides=2,
padding=1,
in_channels=3)
en_relu1 = LeakyReLU(alpha=0.2)
en_norm1 = BatchNorm(momentum=0.1,
in_channels=32,
prefix='en_norm1')
de_relu1 = Activation(activation='relu')
de_norm1 = BatchNorm(momentum=0.1,
in_channels=3,
prefix='de_norm1')
de_conv1 = Conv2DTranspose(channels=3,
kernel_size=4,
strides=2,
padding=1,
in_channels=32)
channel_trans = Conv2D(channels=1,
in_channels=3,
kernel_size=1,
prefix='')
encoder1 = [en_conv1, en_norm1, en_relu1]
decoder1 = [de_conv1, de_norm1, de_relu1, channel_trans]
self.encoder1 = HybridSequential()
with self.encoder1.name_scope():
for block in encoder1:
self.encoder1.add(block)
self.innerblock = innerblock
self.decoder1 = HybridSequential()
with self.decoder1.name_scope():
for block in decoder1:
self.decoder1.add(block)
def __init__(self, opts, num_filters, pool_type='avg'):
super(TransitionBlock, self).__init__()
self.pool_type = pool_type
self.tblock = HybridSequential()
self.tblock.add(BatchNorm(momentum=opts.bn_mom, epsilon=opts.bn_eps))
self.tblock.add(Activation(opts.activation))
self.tblock.add(
Conv2D(channels=int(num_filters * opts.reduction),
kernel_size=(1, 1),
strides=(1, 1),
use_bias=opts.use_bias,
padding=(0, 0)))
if opts.drop_out > 0:
self.tblock.add(Dropout(opts.drop_out))
def build_discriminator(n_filters, n_channels, mx_ctx):
netD = HybridSequential()
with netD.name_scope():
# Input is n_channels * 64 * 64
netD.add(Conv2D(n_filters, kernel_size=4, strides=2, padding=1, use_bias=False))
netD.add(LeakyReLU(0.2))
netD.add(Conv2D(n_filters * 2, kernel_size=4, strides=2, padding=1, use_bias=False))
netD.add(BatchNorm())
netD.add(LeakyReLU(0.2))
netD.add(Conv2D(n_filters * 4, kernel_size=4, strides=2, padding=1, use_bias=False))
netD.add(BatchNorm())
netD.add(LeakyReLU(0.2))
netD.add(Conv2D(n_filters * 8, kernel_size=4, strides=2, padding=1, use_bias=False))
netD.add(BatchNorm())
netD.add(LeakyReLU(0.2))
netD.add(Conv2D(1, 4, 1, 0, use_bias=False))
netD.initialize(mx.init.Normal(0.02), ctx=mx_ctx)
netD.hybridize()
