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, channels, kernel_size, strides=(1, 1), padding=(0, 0),
dilation=(1, 1), groups=1, radix=2, in_channels=None, r=2,
norm_layer=BatchNorm, norm_kwargs=None, drop_ratio=0,
*args, **kwargs):
super(SplitAttentionConv, self).__init__()
norm_kwargs = norm_kwargs if norm_kwargs is not None else {}
inter_channels = max(in_channels*radix//2//r, 32)
self.radix = radix
self.cardinality = groups
self.conv = Conv2D(channels*radix, kernel_size, strides, padding, dilation,
groups=groups*radix, *args, in_channels=in_channels, **kwargs)
self.use_bn = norm_layer is not None
if self.use_bn:
self.bn = norm_layer(in_channels=channels*radix, **norm_kwargs)
self.relu = Activation('relu')
self.fc1 = Conv2D(inter_channels, 1, in_channels=channels, groups=self.cardinality)
if self.use_bn:
self.bn1 = norm_layer(in_channels=inter_channels, **norm_kwargs)
self.relu1 = Activation('relu')
if drop_ratio > 0:
self.drop = nn.Dropout(drop_ratio)
else:
self.drop = None
self.fc2 = Conv2D(channels*radix, 1, in_channels=inter_channels, groups=self.cardinality)
self.channels = channels
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))
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 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, 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, 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, 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, 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, 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,
network,
add_filters,
norm_layer=BatchNorm,
norm_kwargs=None,
use_bn=False,
reduce_ratio=1.0,
min_depth=128,
**kwargs):
super(ResNetV1bSSD, self).__init__()
assert network.endswith('v1b')
if norm_kwargs is None:
norm_kwargs = {}
res = get_model(network, **kwargs)
weight_init = mx.init.Xavier(rnd_type='gaussian',
factor_type='out',
magnitude=2)
with self.name_scope():
self.stage1 = HybridSequential('stage1')
for l in ['conv1', 'bn1', 'relu', 'maxpool', 'layer1', 'layer2']:
self.stage1.add(getattr(res, l))
self.stage2 = HybridSequential('stage2')
self.stage2.add(res.layer3)
# set stride from (2, 2) -> (1, 1) in first conv of layer3
self.stage2[0][0].conv1._kwargs['stride'] = (1, 1)
# also the residuel path
self.stage2[0][0].downsample[0]._kwargs['stride'] = (1, 1)
self.stage2.add(res.layer4)
self.more_stages = HybridSequential('more_stages')
for i, num_filter in enumerate(add_filters):
stage = HybridSequential('more_stages_' + str(i))
num_trans = max(min_depth,
int(round(num_filter * reduce_ratio)))
stage.add(
Conv2D(channels=num_trans,
kernel_size=1,
use_bias=not use_bn,
weight_initializer=weight_init))
if use_bn:
stage.add(norm_layer(**norm_kwargs))
stage.add(Activation('relu'))
padding = 0 if i == len(add_filters) - 1 else 1
stage.add(
Conv2D(channels=num_filter,
kernel_size=3,
strides=2,
padding=padding,
use_bias=not use_bn,
weight_initializer=weight_init))
if use_bn:
stage.add(norm_layer(**norm_kwargs))
stage.add(Activation('relu'))
self.more_stages.add(stage)
def __init__(self, in_channels, ndf=64, n_layers=3, use_sigmoid=False, use_bias=False, istest = False, isthreeway = False):
super(LatentDiscriminator, self).__init__()
with self.name_scope():
self.model = HybridSequential()
self.model.add(gluon.nn.Dense(128))
self.model.add(Activation(activation='relu'))
self.model.add(gluon.nn.Dense(64))
self.model.add(Activation(activation='relu'))
self.model.add(gluon.nn.Dense(32))
self.model.add(Activation(activation='relu'))
self.model.add(gluon.nn.Dense(16))
self.model.add(Activation(activation='sigmoid'))
def __init__(self,
channels,
kernel_size,
strides=1,
padding=0,
dilation=1,
groups=1,
radix=2,
*args,
in_channels=None,
r=2,
norm_layer=BatchNorm,
norm_kwargs=None,
drop_ratio=0,
**kwargs):
super().__init__()
norm_kwargs = norm_kwargs if norm_kwargs is not None else {}
inter_channels = max(in_channels * radix // 2 // r, 32)
self.radix = radix
self.cardinality = groups
self.conv = Conv1D(channels * radix,
kernel_size,
strides,
padding,
dilation,
groups=groups * radix,
*args,
in_channels=in_channels,
**kwargs)
if USE_BN:
self.bn = norm_layer(in_channels=channels * radix, **norm_kwargs)
self.relu = Activation('relu')
self.fc1 = Conv1D(inter_channels,
1,
in_channels=channels,
groups=self.cardinality)
if USE_BN:
self.bn1 = norm_layer(in_channels=inter_channels, **norm_kwargs)
self.relu1 = Activation('relu')
if drop_ratio > 0:
self.drop = nn.Dropout(drop_ratio)
else:
self.drop = None
self.fc2 = Conv1D(channels * radix,
1,
in_channels=inter_channels,
groups=self.cardinality)
self.channels = channels
self.rsoftmax = rSoftMax(radix, groups)
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,
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)
def __init__(self,
entrylist,
gene_to_index,
entry_to_gene,
activation='relu',
**kwargs):
super().__init__(**kwargs)
with self.name_scope():
self.layer_list = nn.HybridSequential()
for index, value in enumerate(entrylist):
genelist = entry_to_gene[value].split(' ')
# w = self.params.get(value, shape=(1, len(genelist)))
self.layer_list.add(
FeaturesTransform_layer(index=get_dict_values(
gene_to_index, genelist),
value=value,
length=len(genelist)))
self.entry_b = self.params.get('entry_b',
shape=(len(entrylist), 1))
if activation == 'identity':
self.activation = lambda X: X
else:
self.activation = Activation(activation)
def preNeuralNet(fs, T, ctx, template_block, margin, learning_rate=0.003):
net = gluon.nn.Sequential()
with net.name_scope(
): # Used to disambiguate saving and loading net parameters
net.add(
MatchedFilteringLayer(
mod=fs * T,
fs=fs,
template_H1=template_block[:, :1], #.as_in_context(ctx),
template_L1=template_block[:, -1:] #.as_in_context(ctx)
))
net.add(CutHybridLayer(margin=margin))
net.add(Conv2D(channels=16, kernel_size=(1, 3), activation='relu'))
net.add(MaxPool2D(pool_size=(1, 4), strides=2))
net.add(Conv2D(channels=32, kernel_size=(1, 3), activation='relu'))
net.add(MaxPool2D(pool_size=(1, 4), strides=2))
net.add(Flatten())
net.add(Dense(32))
net.add(Activation('relu'))
net.add(Dense(2))
net.initialize(mx.init.Xavier(magnitude=2.24),
ctx=ctx[-1],
force_reinit=True) # Initialize parameters of all layers
net.summary(nd.random.randn(1, 2, 2, 1, fs * T, ctx=ctx[-1]))
net.initialize(mx.init.Xavier(magnitude=2.24), ctx=ctx,
force_reinit=True) # Initialize parameters of all layers
# 交叉熵损失函数
# loss = gloss.SoftmaxCrossEntropyLoss()
# The cross-entropy loss for binary classification.
bloss = gluon.loss.SigmoidBinaryCrossEntropyLoss()
trainer = gluon.Trainer(net.collect_params(), 'adam',
{'learning_rate': learning_rate})
return net, bloss, trainer
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, 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 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, 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,
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, 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 get_activation(activation):
if activation is None:
return Identity()
elif type(activation) is str:
return Activation(activation)
else:
return activation
def __init__(self, count: int, depth: int, frac = 100) -> None:
super(Network, self).__init__()
self._count = count
self._depth = depth
with self.name_scope():
self.add(Dense(int(1475/frac)))
self.add(LeakyReLU(alpha=0.2))
layer = Identity(512, 512)
layer = Skip(int(2949/frac), int(5898/frac), layer)
layer.block.add(Dropout(0.5))
# 48 x 48 x 64 = 147456
# 24 x 24 x 512 = 294912
# 48 x 48 x 512 = 1179648
layer = Skip(int(589824/frac), int(1179648/frac), layer)
layer = Skip(int(147456/frac), int(294912/frac), layer)
layer = Skip(int(36864/frac), int(73728/frac), layer)
self.add(layer)
self.add(Dense(int(27648)))
self.add(Activation("sigmoid"))
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, 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, 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, layers, filters, extras):
super(VGGAtrousExtractor, self).__init__(layers, filters)
'''
extra_spec = {
300: [((256, 1, 1, 0), (512, 3, 2, 1)),
((128, 1, 1, 0), (256, 3, 2, 1)),
((128, 1, 1, 0), (256, 3, 1, 0)),
((128, 1, 1, 0), (256, 3, 1, 0))],
512: [((256, 1, 1, 0), (512, 3, 2, 1)),
((128, 1, 1, 0), (256, 3, 2, 1)),
((128, 1, 1, 0), (256, 3, 2, 1)),
((128, 1, 1, 0), (256, 3, 2, 1)),
((128, 1, 1, 0), (256, 4, 1, 1))],
'''
# out_height = floor((height+2*padding[0]-dilation[0]*(kernel_size[0]-1)-1)/stride[0])+1
with self.name_scope():
self.extras = HybridSequential()
for i, config in enumerate(extras):
extra = HybridSequential(prefix='extra%d_' % (i))
with extra.name_scope():
for channels, kernel, strides, padding in config:
extra.add(
Conv2D(channels=channels,
kernel_size=kernel,
strides=strides,
padding=padding,
weight_initializer=mx.init.Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=3),
bias_initializer='zeros'))
extra.add(Activation('relu'))
self.extras.add(extra)
def __init__(self, **kwargs):
super(GeneratorV2, self).__init__(**kwargs)
with self.name_scope():
self.add(
# input (batch, channel, 1, 1)
gluon.nn.Conv2DTranspose(512,
kernel_size=4,
strides=1,
padding=0,
use_bias=False),
gluon.nn.BatchNorm(),
gluon.nn.Activation('relu'),
# output (batch, 512, 4, 4)
gluon.nn.Conv2DTranspose(256,
kernel_size=4,
strides=2,
padding=1,
use_bias=False),
gluon.nn.BatchNorm(),
gluon.nn.Activation('relu'),
# output (batch, 512, 8, 8)
gluon.nn.Conv2DTranspose(128,
kernel_size=4,
strides=2,
padding=1,
use_bias=False),
gluon.nn.BatchNorm(),
gluon.nn.Activation('relu'),
# output (batch, 256, 16, 16)
gluon.nn.Conv2DTranspose(128,
kernel_size=4,
strides=2,
padding=1,
use_bias=False),
gluon.nn.BatchNorm(),
gluon.nn.Activation('relu'),
# output (batch, 128, 32, 32)
gluon.nn.Conv2DTranspose(64,
kernel_size=4,
strides=2,
padding=1,
use_bias=False),
gluon.nn.BatchNorm(),
gluon.nn.Activation('relu'),
# output (batch, 64, 64, 64)
InceptionBlock(64, 32),
gluon.nn.Conv2DTranspose(32,
kernel_size=4,
strides=2,
padding=1,
use_bias=False),
gluon.nn.BatchNorm(),
gluon.nn.Activation('relu'),
InceptionBlock(32, 16),
gluon.nn.Conv2DTranspose(3,
kernel_size=4,
strides=2,
padding=1,
use_bias=False),
Activation('tanh'))
