class _PolicyHeadAlphaZero(HybridBlock):
def __init__(self, name, channels=2, n_labels=4992, 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 bn_mom: Batch normalization momentum parameter
:param act_type: Activation type to use
"""
super(_PolicyHeadAlphaZero, 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=n_labels))
def hybrid_forward(self, F, x):
"""
Compute forward pass
:param F: Handle
:param x: Input data to the block
:return: Activation maps of the block
"""
out = self.body(x)
return out
class EncoderDecoderUnit(HybridBlock):
"""Return a recursive pair of encoder - decoder"""
def __init__(self,
opts,
num_filters,
stage,
inner_block=None,
innermost=False):
super(EncoderDecoderUnit, self).__init__()
factor = 2 if stage == 0 else 1
encoder = EncoderBlock(opts,
opts.units[stage],
num_filters,
trans_block=False if stage == 0 else True)
decoder = DecoderBlock(opts,
num_filters,
res_block=(not innermost),
factor=factor)
if innermost:
model = [encoder, decoder]
else:
model = [encoder, inner_block, decoder]
self.net = HybridSequential()
for block in model:
self.net.add(block)
def hybrid_forward(self, F, x, *args, **kwargs):
"""Forward"""
out = F.concat(x, self.net(x))
return out
def __init__(self, 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)
class Res_Block(HybridBlock):
def __init__(self, outer_channels, use_bias=False):
super(Res_Block, self).__init__()
with self.name_scope():
conv1 = Conv2D(channels=outer_channels,
kernel_size=3,
strides=1,
padding=1,
in_channels=outer_channels,
use_bias=use_bias)
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 hybrid_forward(self, F, x):
residual = x
x = self.res(x)
x = x + residual
return x
def test_autolog_persists_manually_created_run():
kiwi.gluon.autolog()
data = DataLoader(LogsDataset(), batch_size=128, last_batch="discard")
with kiwi.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": .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)
assert kiwi.active_run().info.run_id == run.info.run_id
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 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 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 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
class VGGAtrousBase(HybridBlock):
def __init__(self, layers, filters):
super(VGGAtrousBase, self).__init__()
with self.name_scope():
'''
# caffe에서 가져온 pre-trained weights를 사용하기 때문에, 아래와 같은 init_scale가 필요하다고 함
-> caffe의 pre-trained model은 입력 scale이 0 ~ 255임
'''
init_scale = mx.nd.array([0.229, 0.224, 0.225]).reshape(
(1, 3, 1, 1)) * 255
self.init_scale = self.params.get_constant('init_scale',
init_scale)
# layers : [2, 2, 3, 3, 3], filters [64, 128, 256, 512, 512])
self.stages = HybridSequential()
for layer, filter in zip(layers, filters):
stage = HybridSequential(prefix='')
with stage.name_scope():
for _ in range(layer):
stage.add(
Conv2D(filter,
kernel_size=3,
padding=1,
weight_initializer=mx.init.Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=3),
bias_initializer='zeros'))
stage.add(Activation('relu'))
self.stages.add(stage)
# fc6, fc7 to dilated convolution layer - hybrid_forward에서 pooling 진행
stage = HybridSequential(prefix='dilated_')
with stage.name_scope():
# conv6(fc6) - dilated
stage.add(
Conv2D(1024,
kernel_size=3,
padding=6,
dilation=6,
weight_initializer=mx.init.Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=3),
bias_initializer='zeros'))
stage.add(Activation('relu'))
# conv7(fc7)
stage.add(
Conv2D(1024,
kernel_size=1,
weight_initializer=mx.init.Xavier(
rnd_type='gaussian',
factor_type='out',
magnitude=3),
bias_initializer='zeros'))
stage.add(Activation('relu'))
self.stages.add(stage)
self.norm4 = Normalize(n_channel=filters[3], initial=20, eps=1e-5)
def 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)
class AttentionalAggregator(RelationalAggregator):
def __init__(self, in_units, activation=LeakyReLU(0.2), **kwargs):
super().__init__(**kwargs)
with self.name_scope():
self.coefficient_net = HybridSequential()
dense = Dense(in_units=in_units,
units=1,
use_bias=False,
flatten=False)
self.coefficient_net.add(dense)
self.coefficient_net.add(activation)
self.softmax = MaskedSoftmax(axis=1, keepdims=True)
def hybrid_forward(self, F, X, Z, M):
""" X is the concatenation of source, edge, and target
features of an edge. Z is the fused representation.
M is a mask over the neighborhood.
"""
coefficient = self.coefficient_net(X)
attention_weight = self.softmax(coefficient, M)
return F.sum(attention_weight * Z, axis=1)
def get_args(self, X, Z, M, *args):
return X, Z, M
class _RiseResidualBlock(HybridBlock): # Too many arguments (7/5)
"""
Definition of a residual block without any pooling operation
"""
def __init__(self, channels, bn_mom, act_type, unit_name, use_se=True, res_scale_fac=0.2):
"""
:param channels: Number of channels used in the conv-operations
:param bn_mom: Batch normalization momentum
:param act_type: Activation function to use
:param unit_name: Unit name of the residual block (only used for description (string))
"""
super(_RiseResidualBlock, self).__init__(unit_name)
self.act_type = act_type
self.unit_name = unit_name
self.res_scale_fac = res_scale_fac
self.use_se = use_se
# branch 0
self.body = HybridSequential()
self.body.add(
Conv2D(channels=channels, kernel_size=(3, 3), padding=(1, 1), use_bias=False, prefix="%s_conv0" % unit_name)
)
self.body.add(BatchNorm(momentum=bn_mom, prefix="%s_bn0" % self.unit_name))
self.body.add(get_act(act_type, prefix="%s_%s0" % (unit_name, act_type)))
self.body.add(
Conv2D(channels=channels, kernel_size=(3, 3), padding=(1, 1), use_bias=False, prefix="%s_conv1" % unit_name)
)
self.body.add(BatchNorm(momentum=bn_mom, prefix="%s_bn1" % self.unit_name))
self.act0 = get_act(act_type, prefix="%s_%s1" % (unit_name, act_type))
if use_se:
self.se0 = _ChannelSqueezeExcitation("%s_se0" % unit_name, channels, 16, act_type)
def hybrid_forward(self, F, x):
"""
Compute forward pass
:param F: Handle
:param x: Input data to the block
:return: Activation maps of the block
"""
shortcut = x
out = self.body(shortcut)
# if self.shortcut is True:
# scale down the output of the residual block activations to stabilize training
if self.res_scale_fac:
out = out.__mul__(self.res_scale_fac)
# connect the shortcut with the residual activations
out = F.broadcast_add(shortcut, out, name=self.unit_name)
# apply batchnormalization and activation
# out = self.bn0(out)
out = self.act0(out)
# apply squeeze excitation
if self.use_se:
out = self.se0(out)
return out
class AnchorOffstNet(HybridBlock):
def __init__(self,
net=None,
version=None,
anchors=None,
target_size=None,
ctx=mx.cpu()):
super(AnchorOffstNet, self).__init__()
self._net = net
features = []
strides = []
darknet_output = get_darknet(version,
pretrained=False,
ctx=mx.cpu(),
dummy=True)(mx.nd.random_uniform(
low=0,
high=1,
shape=(1, 3, target_size[0],
target_size[1]),
ctx=mx.cpu()))
for out in darknet_output: # feature_14, feature_24, feature_28
out_height, out_width = out.shape[2:]
features.append([out_width, out_height])
strides.append(
[target_size[1] // out_width, target_size[0] // out_height])
features = features[::-1]
strides = strides[::-1] # deep -> middle -> shallow 순으로 !!!
anchors = OrderedDict(anchors)
anchors = list(anchors.values())[::-1]
self._numoffst = len(anchors)
with self.name_scope():
self._anchor_generators = HybridSequential()
for i, anchor, feature, stride in zip(range(len(features)),
anchors, features, strides):
self._anchor_generators.add(
YoloAnchorGenerator(i, anchor, feature, stride))
self._anchor_generators.initialize(ctx=ctx)
def hybrid_forward(self, F, x):
output82, output94, output106 = self._net(x)
anchors = []
offsets = []
strides = []
for i in range(self._numoffst):
anchor, offset, stride = self._anchor_generators[i](x)
anchors.append(anchor)
offsets.append(offset)
strides.append(stride)
return output82, output94, output106, \
anchors[0], anchors[1], anchors[2], \
offsets[0], offsets[1], offsets[2], \
strides[0], strides[1], strides[2]
class AlphaZeroResnet(HybridBlock):
def __init__(self,
n_labels=2272,
channels=256,
num_res_blocks=19,
value_fc_size=256,
bn_mom=0.9,
act_type="relu",
**kwargs):
"""
Creates the alpha zero gluon net description based on the given parameters.
:param n_labels: Number of labels the for the policy
:param channels: Used for all convolution operations. (Except the last 2)
:param num_res_blocks: Number of residual blocks to stack. In the paper they used 19 or 39 residual blocks
:param value_fc_size: Fully Connected layer size. Used for the value output
:param bn_mom: Batch normalization momentum
:return: gluon net description
"""
super(AlphaZeroResnet, self).__init__(**kwargs, prefix="")
self.body = HybridSequential(prefix="")
with self.name_scope():
self.body.add(
_StemAlphaZero(name="stem",
channels=channels,
bn_mom=bn_mom,
act_type=act_type))
for i in range(num_res_blocks):
unit_name = "unit%d" % (i + 1)
self.body.add(
ResidualBlock(channels, bn_mom, act_type, unit_name=unit_name))
# create the two heads which will be used in the hybrid fwd pass
self.value_head = _ValueHeadAlphaZero("value", 1, value_fc_size,
bn_mom, act_type)
self.policy_head = _PolicyHeadAlphaZero("policy", 2, n_labels, bn_mom,
act_type)
def hybrid_forward(self, F, x):
"""
Implemntation of the forward pass of the full network
Uses a broadcast add operation for the shortcut and the output of the residual block
:param F: Abstract Function handle which works for gluon & mxnet
:param x: Input to the ResidualBlock
:return: Value & Policy Output
"""
out = self.body(x)
value = self.value_head(out)
policy = self.policy_head(out)
return [value, policy]
class ResidualBlock(HybridBlock):
"""
Definition of a residual block without any pooling operation
"""
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 hybrid_forward(self, F, x):
"""
Implemntation of the forward pass of the residual block.
Uses a broadcast add operation for the shortcut and the output of the residual block
:param F: Abstract Function handle which works for gluon & mxnet
:param x: Input to the ResidualBlock
:return: Sum of the shortcut and the computed residual block computation
"""
shortcut = x
out = self.body(shortcut)
out = F.Activation(shortcut + out,
act_type=self.act_type,
name="%s_BroadcastAdd_%s" %
(self.unit_name, self.act_type))
return out
class DefaultRouter(HybridBlock):
def __init__(self, num_experts):
super(DefaultRouter, self).__init__()
with self.name_scope():
self.body = HybridSequential(prefix='')
self.body.add(GlobalAvgPool2D())
# self.body.add(Dense(num_experts//4, activation='relu'))
self.body.add(Dense(num_experts, activation='sigmoid'))
def hybrid_forward(self, F, x):
return self.body(x)
def features(A, in_units, hidden_layer):
features = HybridSequential()
with features.name_scope():
for i, (layer_size, activation_func) in enumerate(hidden_layer):
layer = GraphConvolution(A,
in_units=in_units,
out_units=layer_size,
activation=activation_func)
features.add(layer)
in_units = layer_size
return features, in_units
class FirstBlock(HybridBlock):
"""Return FirstBlock for building DenseNet"""
def __init__(self, opts):
super(FirstBlock, self).__init__()
self.fblock = HybridSequential()
self.fblock.add(Conv3D(channels=opts.init_channels, kernel_size=(opts.zKernelSize, 7, 7),
strides=(opts.zStride, 1, 1), padding=(opts.zPad, 3, 3), use_bias=opts.use_bias))
# self.fblock.add(BatchNorm())
# self.fblock.add(Activation(opts.activation))
def hybrid_forward(self, F, x, *args, **kwargs):
return self.fblock(x)
class UnetSkipUnit(HybridBlock):
def __init__(self, inner_channels, outer_channels, inner_block=None, innermost=False, outermost=False,
use_dropout=False, use_bias=False):
super(UnetSkipUnit, self).__init__()
with self.name_scope():
self.outermost = outermost
en_conv = Conv2D(channels=inner_channels, kernel_size=4, strides=2, padding=1,
in_channels=outer_channels, use_bias=use_bias)
en_relu = LeakyReLU(alpha=0.2)
en_norm = BatchNorm(momentum=0.1, in_channels=inner_channels)
de_relu = Activation(activation='relu')
de_norm = BatchNorm(momentum=0.1, in_channels=outer_channels)
if innermost:
de_conv = Conv2DTranspose(channels=outer_channels, kernel_size=4, strides=2, padding=1,
in_channels=inner_channels, use_bias=use_bias)
encoder = [en_relu, en_conv]
decoder = [de_relu, de_conv, de_norm]
model = encoder + decoder
elif outermost:
de_conv = Conv2DTranspose(channels=outer_channels, kernel_size=4, strides=2, padding=1,
in_channels=inner_channels * 2)
encoder = [en_conv]
decoder = [de_relu, de_conv, Activation(activation='tanh')]
model = encoder + [inner_block] + decoder
else:
de_conv = Conv2DTranspose(channels=outer_channels, kernel_size=4, strides=2, padding=1,
in_channels=inner_channels * 2, use_bias=use_bias)
encoder = [en_relu, en_conv, en_norm]
decoder = [de_relu, de_conv, de_norm]
model = encoder + [inner_block] + decoder
if use_dropout:
model += [Dropout(rate=0.5)]
self.model = HybridSequential()
with self.model.name_scope():
for block in model:
self.model.add(block)
def hybrid_forward(self, F, x): # 是不是HybridBlock对应的是hybrid_forward前项函数
"""
:param F: 这里F指mx.nd 或者是mx.sym的一个变量
:param x: 输入数据
:return:
"""
if self.outermost:
return self.model(x)
else:
return F.concat(self.model(x), x, dim=1) # 将输入的特征与网络得到的特征进行拼接，参考unet的网络结构
class _ChannelSqueezeExcitation(HybridBlock):
def __init__(self, name, nb_act_maps, ratio=16, act_type="relu"):
super(_ChannelSqueezeExcitation, 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():
self.body.add(AvgPool2D(pool_size=8))
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 hybrid_forward(self, F, x):
"""
Compute forward pass
:param F: Handle
:param x: Input data to the block
:return: Activation maps of the block
"""
feature_scaling = self.body(x)
out = F.broadcast_mul(
x,
F.reshape(data=feature_scaling,
shape=(-1, self.nb_act_maps, 1, 1)))
return out
class TransitionBlock(HybridBlock):
"""Return TransitionBlock Unit for building DenseNet
Parameters
----------
num_stage : int
Number of stage
num_filters : int
Number of output channels
"""
def __init__(self, opts, num_filters, pool_type='avg'):
super(TransitionBlock, self).__init__()
self.pool_type = pool_type
self.tblock = HybridSequential()
self.tblock.add(BatchNorm(momentum=opts.bn_mom, epsilon=opts.bn_eps))
self.tblock.add(Activation(opts.activation))
self.tblock.add(
Conv2D(channels=int(num_filters * opts.reduction),
kernel_size=(1, 1),
strides=(1, 1),
use_bias=opts.use_bias,
padding=(0, 0)))
if opts.drop_out > 0:
self.tblock.add(Dropout(opts.drop_out))
def hybrid_forward(self, F, x, *args, **kwargs):
"""Forward"""
return F.Pooling(self.tblock(x),
global_pool=False,
kernel=(2, 2),
stride=(2, 2),
pool_type=self.pool_type)
class AnchorNet(HybridBlock):
def __init__(self, net=None, version=None, target_size=None,
anchor_sizes=[32, 64, 128, 256, 512],
anchor_size_ratios=[1, pow(2, 1 / 3), pow(2, 2 / 3)],
anchor_aspect_ratios=[0.5, 1, 2],
box_offset=(0.5, 0.5),
anchor_box_clip=True, ctx=mx.cpu()):
super(AnchorNet, self).__init__()
self._net = net
if version not in [0, 1, 2, 3, 4, 5, 6]:
raise ValueError
feature_sizes = []
bifpn = get_bifpn(version, ctx=mx.cpu(), dummy=True)(
mx.nd.random_uniform(low=0, high=1, shape=(1, 3, target_size[0], target_size[1]), ctx=mx.cpu()))
for bif in bifpn:
feature_sizes.append(bif.shape[2:]) # h, w
# get_fpn_resnet 외부에서 보내지 않으면. 무조건 forward 한번 시켜야 하는데,
# 네트워크를 정확히 정의 해놓지 않아서...(default init) 쓸데 없는 코드를
# 넣어야 한다.
with self.name_scope():
# 아래 두줄은 self.name_scope()안에 있어야 한다. - 새롭게 anchor만드는 네크워크를 생성하는 것이므로.!!!
# self.name_scope() 밖에 있으면 기존의 self._net 과 이름이 겹친다.
self._bifpn = get_bifpn(version, ctx=ctx, dummy=True)
self._bifpn.forward(mx.nd.ones(shape=(1, 3) + target_size, ctx=ctx))
self._anchor_generators = HybridSequential()
for index, feature_size, anchor_size in zip(range(len(feature_sizes)), feature_sizes, anchor_sizes):
self._anchor_generators.add(EfficientAnchorGenerator(index=index,
input_size=target_size,
feature_size=feature_size,
anchor_size=anchor_size,
anchor_size_ratios=anchor_size_ratios,
anchor_aspect_ratios=anchor_aspect_ratios,
box_offset=box_offset,
box_clip=anchor_box_clip))
self._anchor_generators.initialize(ctx=ctx)
def hybrid_forward(self, F, x):
cls_preds, box_preds = self._net(x)
anchors = [anchor_generator(bifpn_feature) for bifpn_feature, anchor_generator in
zip(self._bifpn(x), self._anchor_generators)]
anchors = F.reshape(F.concat(*anchors, dim=0), shape=(1, -1, 4))
return cls_preds, box_preds, anchors
class decoder(HybridBlock):
def __init__(self,in_channel, out_channel):
super(decoder,self).__init__()
with self.name_scope():
de_conv=Conv2DTranspose(channels=out_channel, kernel_size=4, strides=2, padding=1,
in_channels=in_channel)
norm = BatchNorm(momentum=0.1, in_channels=out_channel)
relu = LeakyReLU(alpha=0.2)
decode=[de_conv,norm,relu]
self.decoder = HybridSequential()
with self.decoder.name_scope():
for block in decode:
self.decoder.add(block)
def hybrid_forward(self,F,x):
return self.decoder(x)
def build_model(A, X):
model = HybridSequential()
with model.name_scope():
features, out_units = build_features(A, X)
model.add(features)
logger.info("GCN Summary: \n{}".format(model))
classifier = LogisticRegressor(out_units)
model.add(classifier)
logger.info("GCN + LR Summary: \n{}".format(model))
model.hybridize()
model.initialize(Uniform(1))
return model, features
class label_Discriminator(HybridBlock):
def __init__(self, in_channels, ndf=1, n_layers=3, use_sigmoid=False, use_bias=False):
super(label_Discriminator, self).__init__()
with self.name_scope():
self.model = HybridSequential()
kernel_size = 70
padding = 24
self.model.add(Conv2D(channels=ndf, kernel_size=kernel_size, strides=8,
padding=padding, in_channels=in_channels, use_bias=use_bias))
if use_sigmoid:
self.model.add(Activation(activation='sigmoid'))
def hybrid_forward(self, F, x):
out = self.model(x)
return out
def build_model(A, X):
model = HybridSequential()
hidden_layer_specs = [(4, 'tanh'), (2, 'tanh')]
in_units = in_units = X.shape[1]
with model.name_scope():
features, out_units = build_features(A, X)
model.add(features)
classifier = LogisticRegressor(out_units)
model.add(classifier)
model.hybridize()
model.initialize(Uniform(1))
return model, features
def build_features(A, X):
hidden_layer_specs = [(4, 'tanh'), (2, 'tanh')
] # Format: (units in layer, activation function)
in_units = in_units = X.shape[1]
features = HybridSequential()
with features.name_scope():
for i, (layer_size, activation_func) in enumerate(hidden_layer_specs):
layer = SpectralRule(A,
in_units=in_units,
out_units=layer_size,
activation=activation_func)
features.add(layer)
in_units = layer_size
return features, in_units
class UnetSkipUnit(HybridBlock):
def __init__(self, inner_channels, outer_channels, inner_blocks=None, inner_most=False, outer_most=False,
use_dropout=False, use_bias=False):
super(UnetSkipUnit, self).__init__()
with self.name_scope():
self.outer_most = outer_most
en_conv = Conv2D(channels=inner_channels, in_channels=outer_channels, kernel_size=4, strides=2, padding=1,
use_bias=use_bias)
en_relu = LeakyReLU(0.2)
en_norm = BatchNorm(momentum=.1, in_channels=inner_channels)
de_relu = Activation('relu')
de_norm = BatchNorm(momentum=.1, in_channels=outer_channels)
if inner_most:
de_conv = Conv2DTranspose(channels=outer_channels, in_channels=inner_channels, kernel_size=4, strides=2,
padding=1, use_bias=use_bias)
encoder = [en_relu, en_conv]
decoder = [de_relu, de_conv]
model = encoder + decoder
elif outer_most:
de_conv = Conv2DTranspose(channels=outer_channels, in_channels=inner_channels * 2, kernel_size=4,
strides=2, padding=1, use_bias=use_bias)
encoder = [en_conv]
decoder = [de_relu, de_conv, Activation('tanh')]
model = encoder + [inner_blocks] + decoder
else:
de_conv = Conv2DTranspose(channels=outer_channels, in_channels=inner_channels * 2, kernel_size=4,
strides=2, padding=1, use_bias=use_bias)
encoder = [en_relu, en_conv, en_norm]
decoder = [de_relu, de_conv, de_norm]
model = encoder + [inner_blocks] + decoder
if use_dropout:
model += [Dropout(0.5)]
self.model = HybridSequential()
with self.model.name_scope():
for block in model:
self.model.add(block)
def hybrid_forward(self, F, x, *args, **kwargs):
if self.outer_most:
return self.model(x)
else:
return F.concat(self.model(x), x, dim=1)
class CNN(HybridBlock):
def __init__(self, training=False, **kwargs):
super(CNN, self).__init__(**kwargs)
self.cnn = HybridSequential()
self.cnn.add( # We don't need pooling, since local information matters
Conv2D(channels=384, kernel_size=3, padding=1, activation='relu'), # Sees 3*3
Conv2D(channels=256, kernel_size=3, padding=1, activation='relu'), # Sees 5*5
Dense(units=1024, activation='relu'),
Dropout(0.2 if training else 0.0),
Dense(units=512, activation='relu'),
Dropout(0.2 if training else 0.0),
Dense(units=256, activation='relu'),
Dense(1))
self.cnn.hybridize()
def hybrid_forward(self, F, x):
return self.cnn(x)
class UnetSkipUnit(HybridBlock):
def __init__(self, inner_channels, outer_channels, inner_block=None, innermost=False, outermost=False,
use_dropout=False, use_bias=False):
super(UnetSkipUnit, self).__init__()
with self.name_scope():
self.outermost = outermost
en_conv = Conv2D(channels=inner_channels, kernel_size=4, strides=2, padding=1,
in_channels=outer_channels, use_bias=use_bias)
en_relu = LeakyReLU(alpha=0.2)
en_norm = BatchNorm(momentum=0.1, in_channels=inner_channels)
de_relu = Activation(activation='relu')
de_norm = BatchNorm(momentum=0.1, in_channels=outer_channels)
if innermost:
de_conv = Conv2DTranspose(channels=outer_channels, kernel_size=4, strides=2, padding=1,
in_channels=inner_channels, use_bias=use_bias)
encoder = [en_relu, en_conv]
decoder = [de_relu, de_conv, de_norm]
model = encoder + decoder
elif outermost:
de_conv = Conv2DTranspose(channels=outer_channels, kernel_size=4, strides=2, padding=1,
in_channels=inner_channels * 2)
encoder = [en_conv]
decoder = [de_relu, de_conv, Activation(activation='tanh')]
model = encoder + [inner_block] + decoder
else:
de_conv = Conv2DTranspose(channels=outer_channels, kernel_size=4, strides=2, padding=1,
in_channels=inner_channels * 2, use_bias=use_bias)
encoder = [en_relu, en_conv, en_norm]
decoder = [de_relu, de_conv, de_norm]
model = encoder + [inner_block] + decoder
if use_dropout:
model += [Dropout(rate=0.5)]
self.model = HybridSequential()
with self.model.name_scope():
for block in model:
self.model.add(block)
def hybrid_forward(self, F, x):
if self.outermost:
return self.model(x)
else:
return F.concat(self.model(x), x, dim=1)
