def __init__(self, in_channels, n_layers=3, ndf=64, use_sigmoid=False, use_bias=False):
super(Discriminator, self).__init__()
# 用下面一段代码来配置标准的2x 下采样卷积
kernel_size=4
padding = int(np.ceil((kernel_size-1)/2))
self.model = nn.HybridSequential()
# 先用一个卷积将输入转为第一层feature map
self.model.add(Conv2D(channels=ndf, kernel_size=kernel_size, strides=2, padding=padding, use_bias=use_bias, 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, use_bias=use_bias, in_channels=ndf*nf_mult_prev),
BatchNorm(momentum=0.1, in_channels=ndf*nf_mult),
LeakyReLU(alpha=0.2))
# 若layers较少，channel未达到512， 可以继续升一点维度
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, use_bias=use_bias, in_channels=ndf*nf_mult_prev),
BatchNorm(momentum=0.1, in_channels=ndf*nf_mult),
LeakyReLU(alpha=0.2))
# 输出： output channel为什么设为1？
self.model.add(Conv2D(channels=1, kernel_size=kernel_size, strides=1, padding=padding, use_bias=True, in_channels=ndf*nf_mult))
if use_sigmoid:
self.model.add(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__()
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, 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,
inplanes,
planes,
stride=1,
downsample=None,
last_relu=True,
**kwargs):
super(BottleneckV1, self).__init__(**kwargs)
self.body = nn.HybridSequential(prefix='')
self.body.add(
nn.Conv2D(planes // self.expansion,
kernel_size=1,
strides=1,
in_channels=inplanes))
self.body.add(BatchNorm(in_channels=planes // self.expansion)) # ->
self.body.add(nn.Activation('relu'))
self.body.add(
_conv3x3(planes // self.expansion, stride,
planes // self.expansion))
self.body.add(BatchNorm(in_channels=planes // self.expansion))
self.body.add(nn.Activation('relu'))
self.body.add(
nn.Conv2D(planes,
kernel_size=1,
strides=1,
in_channels=planes // self.expansion))
self.body.add(BatchNorm(in_channels=planes))
self.body.add(nn.Activation('relu'))
self.downsample = downsample
self.last_relu = last_relu
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,
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, 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, 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)
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, 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, 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, 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, count: int, depth: int) -> None:
super(HybridSequential, 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(0.2))
self.add(Conv2D(128, 4, 2, 1, use_bias=False, in_channels=64))
self.add(BatchNorm(momentum=0.1, in_channels=128))
self.add(LeakyReLU(0.2))
self.add(Conv2D(256, 4, 2, 1, use_bias=False, in_channels=128))
self.add(BatchNorm(momentum=0.1, in_channels=256))
self.add(LeakyReLU(0.2))
self.add(Conv2D(512, 4, padding=1, use_bias=False,
in_channels=256))
self.add(BatchNorm(momentum=0.1, in_channels=512))
self.add(LeakyReLU(0.2))
self.add(Conv2D(count, 3, 2, padding=1, in_channels=512))
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 build_generator(n_filters, n_channels, mx_ctx):
netG = HybridSequential()
with netG.name_scope():
# Input is Z
netG.add(Conv2DTranspose(n_filters * 8, kernel_size=4, strides=1, padding=0, use_bias=False))
netG.add(BatchNorm())
netG.add(Activation("relu"))
netG.add(Conv2DTranspose(n_filters * 4, kernel_size=4, strides=2, padding=1, use_bias=False))
netG.add(BatchNorm())
netG.add(Activation("relu"))
netG.add(Conv2DTranspose(n_filters * 2, kernel_size=4, strides=2, padding=1, use_bias=False))
netG.add(BatchNorm())
netG.add(Activation("relu"))
netG.add(Conv2DTranspose(n_filters, kernel_size=4, strides=2, padding=1, use_bias=False))
netG.add(BatchNorm())
netG.add(Activation("relu"))
netG.add(Conv2DTranspose(n_channels, kernel_size=4, strides=2, padding=1, use_bias=False))
netG.add(BatchNorm())
netG.add(Activation("tanh"))
netG.initialize(mx.init.Normal(0.02), ctx=mx_ctx)
netG.hybridize()
return netG
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,
name,
in_channels,
groups=2,
se_type="cSE",
use_residual=True,
act_type="relu",
**kwargs):
super(_ShuffleBlock, self).__init__(prefix=name + "_")
self.in_channels = in_channels
self.nb_right_channels = in_channels // 2
self.groups = groups
self.body = HybridSequential(prefix="")
self.use_residual = use_residual
with self.name_scope():
self.body.add(
Conv2D(channels=self.nb_right_channels,
kernel_size=3,
strides=1,
padding=1,
groups=1,
use_bias=False))
self.body.add(BatchNorm())
self.body.add(get_act(act_type))
self.body.add(
Conv2D(channels=self.nb_right_channels,
kernel_size=3,
strides=1,
padding=1,
groups=1,
use_bias=False))
self.body.add(BatchNorm())
if se_type:
if se_type == "cSE":
# apply squeeze excitation
self.body.add(
_ChannelSqueezeExcitation("se0",
self.nb_right_channels, 16,
act_type))
elif se_type == "sSE":
self.body.add(_SpatialSqueezeExcitation("se0"))
elif se_type == "scSE":
self.body.add(
_SpatialChannelSqueezeExcitation(
"se0", self.nb_right_channels, 2, act_type))
else:
raise Exception(
'Unsupported Squeeze Excitation Module: Choose either [None, "cSE", "sSE", "scSE"'
)
if self.use_residual:
self.act = get_act(act_type)
self.shufller = _ShuffleChannelsBlock(groups)
def __init__(self, in_channels, ndf=64, n_layers=3, use_bias=False, istest=False, usetanh = False ):
super(CEGeneratorP, 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=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=4096, 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 =128, use_global_stats=istest))
if usetanh:
self.model.add(Activation(activation='tanh'))
else:
self.model.add(LeakyReLU(alpha=0.2))
# Decoder
self.model.add(Conv2DTranspose(channels=ndf * nf_mult/2, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=4096,
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,
name,
channels,
bn_mom=0.9,
act_type='relu',
use_se=False):
"""
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=64,
kernel_size=(3, 3),
padding=(1, 1),
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
self.body.add(
Conv2D(channels=64,
kernel_size=(3, 3),
padding=(1, 1),
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
self.body.add(
Conv2D(channels=128,
kernel_size=(3, 3),
padding=(1, 1),
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
self.body.add(
Conv2D(channels=128,
kernel_size=(3, 3),
padding=(1, 1),
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
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,
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, 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,
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 // 2,
kernel_size=(3, 3),
padding=(1, 1),
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
if se_type:
if se_type == "cSE":
# apply squeeze excitation
# self.se = _ChannelSqueezeExcitation("se0", channels, 2, act_type)
self.body.add(
_ChannelSqueezeExcitation("se0", channels // 2, 16,
act_type))
elif se_type == "sSE":
self.body.add(_SpatialSqueezeExcitation("se0"))
elif se_type == "scSE":
self.body.add(
_SpatialChannelSqueezeExcitation(
"se0", channels // 2, 2, act_type))
else:
raise Exception(
'Unsupported Squeeze Excitation Module: Choose either [None, "cSE", "sSE", "scSE"'
)
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, unit_name, channels, bn_mom, act_type, se_type="scSE"):
"""
: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.body = HybridSequential(prefix="")
self.channels = channels
with self.name_scope():
if se_type:
if se_type == "cSE":
# apply squeeze excitation
self.body.add(
_ChannelSqueezeExcitation("se0", channels, 2,
act_type))
elif se_type == "sSE":
self.body.add(_SpatialSqueezeExcitation("se0"))
elif se_type == "scSE":
self.body.add(
_SpatialChannelSqueezeExcitation(
"se0", channels, 2, act_type))
elif se_type == "GE+":
self.body.add(
_GatherExcitePlus("ge0", channels, 2, act_type))
else:
raise Exception(
'Unsupported Squeeze Excitation Module: Choose either [None, "cSE", "sSE", "scSE",'
'"GE+')
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=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=1,
use_bias=False))
def __init__(self,
name,
channels=2,
n_labels=4992,
bn_mom=0.9,
act_type="relu",
select_policy_from_plane=False):
"""
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 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(_PolicyHeadAlphaZero, self).__init__(prefix=name + "_")
self.body = HybridSequential(prefix="")
self.select_policy_from_plane = select_policy_from_plane
with self.name_scope():
if self.select_policy_from_plane:
self.body.add(
Conv2D(channels=256,
padding=1,
kernel_size=(3, 3),
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
self.body.add(
Conv2D(channels=channels,
padding=1,
kernel_size=(3, 3),
use_bias=False))
self.body.add(Flatten())
else:
self.body.add(
Conv2D(channels=channels,
kernel_size=(1, 1),
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
# if not self.select_policy_from_plane:
self.body.add(get_act(act_type))
self.body.add(Flatten())
self.body.add(Dense(units=n_labels))
def __init__(self, in_channels, ndf=64, n_layers=3, use_bias=False):
super(CEGenerator, 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 = 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))
self.model.add(LeakyReLU(alpha=0.2))
nf_mult_prev = nf_mult
nf_mult = 2 ** n_layers
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))
# Decoder
self.model.add(Conv2DTranspose(channels=ndf * nf_mult / 2, kernel_size=kernel_size, strides=1,
padding=padding, in_channels=ndf * nf_mult,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult / 2))
self.model.add(LeakyReLU(alpha=0.2))
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))
self.model.add(LeakyReLU(alpha=0.2))
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))
def __init__(self, n_dims=128, **kwargs):
PersistentBlock.__init__(self, **kwargs)
if n_dims < 16:
raise ValueError('`n_dims` must be at least 16 (given: %d)' %
n_dims)
self.encoder = Sequential()
self.encoder.add(BatchNorm(), Conv2D(int(n_dims / 16), 6, (4, 3)),
Activation('relu'), Conv2D(int(n_dims / 8), 3),
Activation('relu'), Conv2D(int(n_dims / 2), 3),
BatchNorm(), MaxPool2D(), Activation('relu'),
Conv2D(int(n_dims),
3), MaxPool2D(), Activation('relu'),
Conv2D(int(n_dims), 3), MaxPool2D(),
Activation('relu'), Flatten())
def __init__(self, block, int_channels, out_channels, blocks, alpha, beta,
stride, hw):
super(BLModule, self).__init__()
self.hw = hw
self.big = blm_make_layer(block,
int_channels,
out_channels,
blocks - 1,
2,
last_relu=False)
self.little_e = nn.HybridSequential(prefix='')
self.little_e.add(
blm_make_layer(block, int_channels, out_channels // alpha,
max(1, blocks // beta - 1)))
self.little_e.add(
nn.Conv2D(out_channels,
kernel_size=1,
in_channels=out_channels // alpha))
self.little_e.add(BatchNorm(in_channels=out_channels))
self.relu = nn.Activation('relu')
self.fusion = blm_make_layer(block,
out_channels,
out_channels,
1,
stride=stride)
def blm_make_layer(block, inplanes, planes, blocks, stride=1, last_relu=True):
downsample = nn.HybridSequential(prefix='')
with downsample.name_scope():
if stride != 1:
downsample.add(nn.AvgPool2D(3, strides=2, padding=1))
if inplanes != planes:
downsample.add(
nn.Conv2D(planes,
kernel_size=1,
strides=1,
in_channels=inplanes))
downsample.add(BatchNorm(in_channels=planes))
layers = nn.HybridSequential(prefix='')
with layers.name_scope():
if blocks == 1:
layers.add(
block(inplanes, planes, stride=stride, downsample=downsample))
else:
layers.add(
block(inplanes, planes, stride=stride, downsample=downsample))
for i in range(1, blocks):
layers.add(
block(planes,
planes,
last_relu=last_relu if i == blocks - 1 else True))
return layers
def lateral_conv(channels, kernel_size, strides, padding):
lateral = HybridSequential()
with lateral.name_scope():
lateral.add(Conv2D(channels, kernel_size, strides, padding))
lateral.add(BatchNorm(momentum=0.9, epsilon=1e-5))
lateral.add(Activation('relu'))
return lateral
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, 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"))
