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,
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,
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,
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)
if opts.dense_forward:
self.dense_forward = HybridSequential()
self.dense_forward.add(DenseBlock(opts, opts.units[stage]))
else:
self.dense_forward = None
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, 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,
name,
in_ch,
ch_0_0=192,
ch_1_0=128,
ch_1_1=224,
ch_1_2=256,
ch=2144,
bn_mom=0.9,
act_type="relu",
res_scale_fac=0.2,
use_se=True,
shortcut=True,
):
"""
Definition of the InceptionResnetC block
:param name: name prefix for all blocks
:param ch_0_0: Number of channels for 1st conv operation in branch 0
:param ch_1_0: Number of channels for 1st conv operation in branch 1
:param ch_1_1: Number of channels for 2nd conv operation in branch 1
:param ch_1_2: Number of channels for 3rd conv operation in branch 1
:param ch: Number of channels for conv operation after concatenating branches (no act is applied here)
:param bn_mom: Batch normalization momentum parameter
:param act_type: Activation type to use
:param res_scale_fac: Constant multiply scalar which is applied to the residual activations maps
"""
super(_InceptionResnetC, self).__init__(name, ch, res_scale_fac, act_type, bn_mom, use_se, shortcut)
self.res_scale_fac = res_scale_fac
self.block_name = name
self.body = HybridSequential(prefix="")
self.branches = HybridConcurrent(axis=1, prefix="") # entry point for all branches
# branch 0 of block type C
self.b_0 = HybridSequential()
self.b_0.add(Conv2D(channels=ch_0_0, kernel_size=(1, 1), prefix="%s_0_conv0" % name, in_channels=in_ch))
self.b_0.add(get_act(act_type, prefix="%s_0_%s0" % (name, act_type)))
# branch 2 of block type C
self.b_1 = HybridSequential()
self.b_1.add(Conv2D(channels=ch_1_0, kernel_size=(1, 1), prefix="%s_1_conv0" % name, in_channels=in_ch))
self.b_1.add(get_act(act_type, prefix="%s_2_%s0" % (name, act_type)))
self.b_1.add(
Conv2D(channels=ch_1_1, kernel_size=(1, 3), padding=(0, 1), prefix="%s_1_conv1" % name, in_channels=ch_1_0)
)
self.b_1.add(get_act(act_type, prefix="%s_2_%s1" % (name, act_type)))
self.b_1.add(
Conv2D(channels=ch_1_2, kernel_size=(3, 1), padding=(1, 0), prefix="%s_1_conv2" % name, in_channels=ch_1_1)
)
self.b_1.add(get_act(act_type, prefix="%s_1_%s2" % (name, act_type)))
# concatenate all branches and add them to the body
self.branches.add(self.b_0)
self.branches.add(self.b_1)
self.body.add(self.branches)
# apply a single CNN layer without activation function
self.body.add(
Conv2D(
channels=ch, kernel_size=(1, 1), prefix="%s_conv0" % name, in_channels=ch_0_0 + ch_1_2, use_bias=False
)
)
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, training=False, **kwargs):
super(MLP, self).__init__(**kwargs)
self.layer1 = HybridSequential()
self.layer1.add(Dense(1024, in_units=25*25, activation="relu"),
Dropout(0.1 if training else 0.0))
self.layer2 = HybridSequential()
self.layer2.add(Dense(512, activation="relu"),
Dropout(0.1 if training else 0.0))
self.layer3 = Dense(256, activation="relu")
self.output = Dense(1)
self.hybridize()
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):
super(net2,self).__init__()
self.net=HybridSequential()
with self.net.name_scope():
self.net.add(encoder(3,16))
self.net.add(encoder(16,32))
self.att= CA_M2(32)
self.net1=HybridSequential()
with self.net1.name_scope():
self.net1.add(encoder(32,64))
self.net1.add(decoder(64,32))
self.net1.add(decoder(32,16))
self.net1.add(decoder(16,1))
def __init__(self, name, in_ch, ch, res_scale_fac, act_type, bn_mom, use_se, shortcut, pool_type):
super(_RiseBlockB, self).__init__(name, ch, res_scale_fac, act_type, bn_mom, use_se, shortcut)
self.body = HybridSequential(prefix='')
# entry point for all branches
self.branches = HybridConcurrent(axis=1, prefix='')
ch_0_0 = 32
ch_0_1 = 96
ch_0_2 = 96
ch_1_0 = 32
ch_1_1 = 96
ch_1_2 = 96
ch_2_0 = 192
with self.name_scope():
# branch 0
self.b_0 = HybridSequential()
self.b_0.add(get_pool(pool_type, pool_size=(2, 2), strides=(2, 2)))
self.b_0.add(Conv2D(channels=ch_0_0, kernel_size=(1, 1), in_channels=in_ch))
self.b_0.add(get_act(act_type))
self.b_0.add(
Conv2D(channels=ch_0_1, kernel_size=(3, 1), padding=(0, 1), in_channels=ch_0_0, use_bias=False))
self.b_0.add(
Conv2D(channels=ch_0_2, kernel_size=(1, 3), padding=(1, 0), in_channels=ch_0_1, use_bias=False))
self.b_0.add(_UpsampleBlock('upsample0', scale=2))
# branch 1
self.b_1 = HybridSequential()
self.b_1.add(Conv2D(channels=ch_1_0, kernel_size=(1, 1), in_channels=in_ch))
self.b_1.add(get_act(act_type))
self.b_1.add(
Conv2D(channels=ch_1_1, kernel_size=(3, 1), padding=(0, 1), in_channels=ch_1_0, use_bias=False))
self.b_1.add(
Conv2D(channels=ch_1_2, kernel_size=(1, 3), padding=(1, 0), in_channels=ch_1_1, use_bias=False))
# branch 2
self.b_2 = HybridSequential()
self.b_2.add(Conv2D(channels=ch_2_0, kernel_size=(1, 1), in_channels=in_ch, use_bias=False))
# concatenate all branches and add them to the body
self.branches.add(self.b_0)
self.branches.add(self.b_1)
self.branches.add(self.b_2)
self.body.add(self.branches)
def test_autolog_ends_auto_created_run():
mlflow.gluon.autolog()
data = DataLoader(LogsDataset(), batch_size=128, last_batch="discard")
model = HybridSequential()
model.add(Dense(64, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(model.collect_params(),
"adam",
optimizer_params={
"learning_rate": 0.001,
"epsilon": 1e-07
})
est = estimator.Estimator(net=model,
loss=SoftmaxCrossEntropyLoss(),
trainer=trainer,
**get_metrics())
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(data, epochs=3)
assert mlflow.active_run() is None
def gluon_model(model_data):
train_data, train_label, _ = model_data
train_data_loader = DataLoader(list(zip(train_data, train_label)),
batch_size=128,
last_batch="discard")
model = HybridSequential()
model.add(Dense(128, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(model.collect_params(),
"adam",
optimizer_params={
"learning_rate": .001,
"epsilon": 1e-07
})
est = estimator.Estimator(net=model,
loss=SoftmaxCrossEntropyLoss(),
metrics=Accuracy(),
trainer=trainer)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(train_data_loader, epochs=3)
return model
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 gluon_model(model_data):
train_data, train_label, _ = model_data
train_data_loader = DataLoader(list(zip(train_data, train_label)),
batch_size=128,
last_batch="discard")
model = HybridSequential()
model.add(Dense(128, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(model.collect_params(),
"adam",
optimizer_params={
"learning_rate": 0.001,
"epsilon": 1e-07
})
# `metrics` was renamed in mxnet 1.6.0: https://github.com/apache/incubator-mxnet/pull/17048
arg_name = ("metrics"
if LooseVersion(mx.__version__) < LooseVersion("1.6.0") else
"train_metrics")
est = estimator.Estimator(net=model,
loss=SoftmaxCrossEntropyLoss(),
trainer=trainer,
**{arg_name: Accuracy()})
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(train_data_loader, epochs=3)
return model
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 test_autolog_registering_model():
registered_model_name = "test_autolog_registered_model"
mlflow.gluon.autolog(registered_model_name=registered_model_name)
data = DataLoader(LogsDataset(), batch_size=128, last_batch="discard")
model = HybridSequential()
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(model.collect_params(),
"adam",
optimizer_params={
"learning_rate": 0.001,
"epsilon": 1e-07
})
est = get_estimator(model, trainer)
with mlflow.start_run(), warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(data, epochs=3)
registered_model = MlflowClient().get_registered_model(
registered_model_name)
assert registered_model.name == registered_model_name
def gluon_random_data_run():
mlflow.gluon.autolog()
with mlflow.start_run() as run:
data = DataLoader(LogsDataset(), batch_size=128, last_batch="discard")
validation = DataLoader(LogsDataset(),
batch_size=128,
last_batch="discard")
model = HybridSequential()
model.add(Dense(64, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(model.collect_params(),
"adam",
optimizer_params={
"learning_rate": .001,
"epsilon": 1e-07
})
est = estimator.Estimator(net=model,
loss=SoftmaxCrossEntropyLoss(),
metrics=Accuracy(),
trainer=trainer)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(data, epochs=3, val_data=validation)
return client.get_run(run.info.run_id)
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, 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, 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, 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, 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 test_autolog_persists_manually_created_run():
mlflow.gluon.autolog()
data = DataLoader(LogsDataset(), batch_size=128, last_batch="discard")
with mlflow.start_run() as run:
model = HybridSequential()
model.add(Dense(64, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(
model.collect_params(),
"adam",
optimizer_params={
"learning_rate": 0.001,
"epsilon": 1e-07
},
)
est = get_estimator(model, trainer)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(data, epochs=3)
assert mlflow.active_run().info.run_id == run.info.run_id
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 get_gluon_random_data_run(log_models=True):
mlflow.gluon.autolog(log_models)
with mlflow.start_run() as run:
data = DataLoader(LogsDataset(), batch_size=128, last_batch="discard")
validation = DataLoader(LogsDataset(),
batch_size=128,
last_batch="discard")
model = HybridSequential()
model.add(Dense(64, activation="relu"))
model.add(Dense(64, activation="relu"))
model.add(Dense(10))
model.initialize()
model.hybridize()
trainer = Trainer(
model.collect_params(),
"adam",
optimizer_params={
"learning_rate": 0.001,
"epsilon": 1e-07
},
)
est = get_estimator(model, trainer)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
est.fit(data, epochs=3, val_data=validation)
client = mlflow.tracking.MlflowClient()
return client.get_run(run.info.run_id)
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, 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, 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'))
