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, 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 __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, 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,
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,
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,
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,
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,
name,
channels=1,
fc0=256,
bn_mom=0.9,
act_type="relu",
se_type=None):
"""
Definition of the value head proposed by the alpha zero authors
:param name: name prefix for all blocks
:param channels: Number of channels for 1st conv operation in branch 0
:param fc0: Number of units in Dense/Fully-Connected layer
:param bn_mom: Batch normalization momentum parameter
:param act_type: Activation type to use
:param se_type: SqueezeExcitation type choose either [None, "cSE", "sSE", csSE"] for no squeeze excitation,
channelwise squeeze excitation, channel-spatial-squeeze-excitation, respectively
"""
super(_ValueHeadAlphaZero, self).__init__(prefix=name + "_")
self.body = HybridSequential(prefix="")
with self.name_scope():
self.body.add(
Conv2D(channels=channels, kernel_size=(1, 1), use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
if se_type:
if se_type == "cSE":
# apply squeeze excitation
self.body.add(
_ChannelSqueezeExcitation("se0", channels, 16,
act_type))
elif se_type == "sSE":
self.body.add(_SpatialSqueezeExcitation("se0"))
elif se_type == "csSE":
self.body.add(
_SpatialChannelSqueezeExcitation(
"se0", channels, 1, act_type))
else:
raise Exception(
'Unsupported Squeeze Excitation Module: Choose either [None, "cSE", "sSE", "csSE"'
)
self.body.add(get_act(act_type))
self.body.add(Flatten())
self.body.add(Dense(units=fc0))
self.body.add(get_act(act_type))
self.body.add(Dense(units=1))
self.body.add(get_act("tanh"))
def __init__(self, name, nb_act_maps, ratio=16, act_type='relu'):
super(_SqueezeExcitation, 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 __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, 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 __init__(self, name):
super(_SpatialSqueezeExcitation, self).__init__(prefix=name)
self.body = HybridSequential(prefix="")
with self.name_scope():
self.body.add(Conv2D(1, kernel_size=1, padding=0, use_bias=True))
self.body.add(get_act("sigmoid"))
def __init__(self,
unit_name,
cardinality,
channels,
bn_mom,
act_type,
res_scale_fac,
use_se=True):
"""
:param channels: Number of channels used in the conv-operations
:param bn_mom: Batch normalization momentum
:param act_type: Activation function to use
:param unit_name: Unit name of the residual block (only used for description (string))
"""
super(ResidualBlockX, self).__init__(unit_name + "_")
self.act_type = act_type
self.unit_name = unit_name
self.res_scale_fac = res_scale_fac
self.body = HybridSequential(prefix="")
with self.name_scope():
self.body.add(
Conv2D(channels=channels,
kernel_size=3,
padding=1,
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(self.act_type))
self.body.add(
Conv2D(channels=channels,
kernel_size=3,
padding=1,
groups=cardinality,
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
if use_se is True:
# apply squeeze excitation
self.body.add(_SqueezeExcitation("se0", channels, 16,
act_type))
self.act0 = get_act(act_type)
def __init__(self, name, ch, res_scale_fac=0.2, act_type="relu", bn_mom=0.9, use_se=True, shortcut=True):
super(_InceptionResnetBlock, self).__init__(prefix=name)
self.shortcut = shortcut
self.body = HybridSequential(prefix="")
self.bn0 = self.act0 = self.se0 = None
self.block_name = name
self.res_scale_fac = res_scale_fac
self.use_se = use_se
self.bn0 = BatchNorm(momentum=bn_mom, prefix="%s_bn0" % name, in_channels=ch)
self.act0 = get_act(act_type, prefix="%s_%s0" % (name, act_type))
if use_se:
self.se0 = _ChannelSqueezeExcitation("%s_se0" % name, ch, 16, act_type)
def __init__(self, name, ch, res_scale_fac=0.2, act_type='relu', bn_mom=0.9, use_se=True, shortcut=True):
super(_InceptionResnetBlock, self).__init__(prefix=name)
self.shortcut = shortcut
self.body = None
self.bn0 = None
self.act0 = None
self.se0 = None
self.block_name = name
self.res_scale_fac = res_scale_fac
self.use_se = use_se
self.bn0 = BatchNorm(momentum=bn_mom, prefix='%s_bn0' % name, in_channels=ch)
self.act0 = get_act(act_type, prefix='%s_%s0' % (name, act_type))
if use_se is True:
self.se0 = _SqueezeExcitation('%s_se0' % name, ch, 16, act_type)
def __init__(
self,
name,
in_ch,
ch_0_0=32,
ch_1_0=32,
ch_1_1=32,
ch_2_0=32,
ch_2_1=48,
ch_2_2=64,
ch=384,
bn_mom=0.9,
act_type="relu",
res_scale_fac=0.2,
use_se=True,
shortcut=True,
): # Too many local variables (16/15)
"""
Definition of the InceptionResnetA 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_2_0: Number of channels for 1st conv operation in branch 2
:param ch_2_1: Number of channels for 2nd conv operation in branch 2
:param ch_2_2: Number of channels for 3rd conv operation in branch 2
: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
:param shortcut: Decide weather to enable a shortcut connection
"""
super(_InceptionResnetA,
self).__init__(name, ch, res_scale_fac, act_type, bn_mom, use_se,
shortcut)
self.body = HybridSequential(prefix="")
self.branches = HybridConcurrent(
axis=1, prefix="") # entry point for all branches
# branch 0 of block type A
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 1 of block type A
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_1_%s0" % (name, act_type)))
self.b_1.add(
Conv2D(channels=ch_1_1,
kernel_size=(3, 3),
padding=(1, 1),
prefix="%s_1_conv1" % name,
in_channels=ch_1_0))
self.b_1.add(get_act(act_type, prefix="%s_1_%s1" % (name, act_type)))
# branch 2 of block type A
self.b_2 = HybridSequential()
self.b_2.add(
Conv2D(channels=ch_2_0,
kernel_size=(1, 1),
prefix="%s_2_conv0" % name,
in_channels=in_ch))
self.b_2.add(get_act(act_type, prefix="%s_2_%s0" % (name, act_type)))
self.b_2.add(
Conv2D(channels=ch_2_1,
kernel_size=(3, 3),
padding=(1, 1),
prefix="%s_2_conv1" % name,
in_channels=ch_2_0))
self.b_2.add(get_act(act_type, prefix="%s_2_%s1" % (name, act_type)))
self.b_2.add(
Conv2D(channels=ch_2_2,
kernel_size=(3, 3),
padding=(1, 1),
prefix="%s_2_conv2" % name,
in_channels=ch_2_1))
self.b_2.add(get_act(act_type, prefix="%s_2_%s2" % (name, act_type)))
# self.b_2.add(PReLU(prefix='%s_2_%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.branches.add(self.b_2)
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_1 + ch_2_2,
use_bias=False,
))
def __init__(self, name, in_ch, ch, res_scale_fac, act_type, bn_mom,
use_se, shortcut, pool_type):
"""
IN 8x8: 256 TOTAL
BRANCH 0
b_0 b_0 b_0_0
-> 24 Conv 1x1 -> POOL2D 2x2 -> 32 Conv 3x3
-> 24-> 32
BRANCH 1
b_0 b_0 b_0_0
-> 24 Conv 1x1 -> POOL2D 4x4 -> 32 Conv 2x2
-> 24-> 32
BRANCH 2
-> 24 Conv 1x1 -> 32 Conv 3x3
-> 24 -> 32
BRANCH 3
-> 24 Conv 1x1 -> 24 Conv 3x1
-> 24 Conv 1x3
-> 24 -> 48
BRANCH 4
-> 24 Conv 1x1 -> 24 Conv 5x1
-> 24 Conv 1x5
-> 24 -> 48
BRANCH 5
-> 24 Conv 1x1 -> 24 Conv 3x1 -> 32 Conv 1x3
-> 24 Conv 1x3 -> 32 Conv 3x1
-> 24 -> 64
"""
super(_RiseBlockA, 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 = 42
ch_0_1 = 64
ch_1_0 = 32
ch_1_1 = 32
ch_2_0 = 64
ch_2_1 = 96
ch_2_2 = 128
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, 3),
padding=(1, 1),
in_channels=ch_0_0,
use_bias=True))
self.b_0.add(get_act(act_type))
self.b_0.add(_UpsampleBlock("upsample0", scale=2))
# branch 1
self.b_1 = HybridSequential()
self.b_1.add(get_pool(pool_type, pool_size=(4, 4), strides=(4, 4)))
self.b_1.add(
Conv2D(channels=ch_1_0,
kernel_size=(1, 1),
in_channels=in_ch,
use_bias=True))
self.b_1.add(get_act(act_type))
self.b_1.add(
Conv2D(channels=ch_1_1,
kernel_size=(3, 3),
padding=(1, 1),
in_channels=ch_1_0,
use_bias=True))
self.b_1.add(get_act(act_type))
self.b_1.add(_UpsampleBlock("upsample0", scale=4))
# branch 1
# self.b_1 = HybridSequential()
# self.b_1.add(Conv2D(channels=ch_1_0, kernel_size=(1, 1), in_channels=in_ch, use_bias=False))
# self.b_1.add(get_act(act_type))
# branch 2
self.b_2 = HybridSequential()
self.b_2.add(
Conv2D(channels=ch_2_0, kernel_size=(1, 1), in_channels=in_ch))
self.b_2.add(get_act(act_type))
self.b_2.add(
Conv2D(channels=ch_2_1,
kernel_size=(3, 3),
padding=(1, 1),
in_channels=ch_2_0,
use_bias=True))
self.b_2.add(get_act(act_type))
self.b_2.add(
Conv2D(channels=ch_2_2,
kernel_size=(3, 3),
padding=(1, 1),
in_channels=ch_2_1,
use_bias=True))
self.b_2.add(get_act(act_type))
# 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.branches.add(self.b_3)
# self.branches.add(self.b_4)
self.body.add(self.branches)
self.body.add(
Conv2D(
channels=ch,
kernel_size=(1, 1),
prefix="%s_conv0" % name,
in_channels=ch_0_1 + ch_1_1 + ch_2_2,
use_bias=False,
)) # +ch_3_2+ch_4_2
def __init__(self,
name,
nb_in_channels,
groups=2,
se_type="cSE",
use_residual=True,
act_type="relu",
**kwargs):
"""
Constructor
:param name: Layer name
:param nb_in_channels: Number of input channels
:param groups: Number of groups to use for shuffling
:param se_type: Squeez excitation type
:param use_residual: True, if a residual connection shall be used
:param act_type: Type for the activation function
:param kwargs:
"""
super(_ShuffleBlockNeck, self).__init__(prefix=name + "_")
self.in_channels = nb_in_channels
self.nb_right_channels = nb_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=1,
strides=1,
padding=0,
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=1,
strides=1,
padding=0,
groups=3,
use_bias=False))
self.body.add(BatchNorm())
self.body.add(get_act(act_type))
if se_type:
if se_type == "cSE":
self.body.add(
_ChannelSqueezeExcitation("se0",
self.nb_right_channels, 2,
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,
unit_name,
cardinality,
channels,
bn_mom=0.9,
act_type="relu",
use_se=True,
res_scale_fac=0.2,
dim_match=True,
):
"""
:param channels: Number of channels used in the conv-operations
:param bn_mom: Batch normalization momentum
:param act_type: Activation function to use
:param unit_name: Unit name of the residual block (only used for description (string))
"""
super(_ResidualBlockXBottleneck, self).__init__(prefix=unit_name + "_")
self.unit_name = unit_name
self.res_scale_fac = res_scale_fac
self.use_se = use_se
self.dim_match = dim_match
self.body = HybridSequential(prefix="")
with self.name_scope():
self.body.add(get_act(act_type))
self.body.add(
Conv2D(int(channels // 2),
kernel_size=1,
padding=0,
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
self.body.add(
Conv2D(int(channels // 2),
kernel_size=3,
padding=1,
groups=cardinality,
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
# add a 1x1 branch after concatenation
self.body.add(
Conv2D(channels=channels, kernel_size=1, use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
if use_se is True:
# apply squeeze excitation
self.body.add(_SqueezeExcitation("se0", channels, 16,
act_type))
self.act0 = get_act(act_type, prefix="%s1" % act_type)
if self.dim_match is False:
self.expander = HybridSequential(prefix="")
self.expander.add(
Conv2D(channels=channels,
kernel_size=1,
use_bias=False,
prefix="expander_conv"))
self.expander.add(BatchNorm())
def __init__(self,
unit_name,
channels,
bn_mom=0.9,
act_type="relu",
se_type="scSE",
dim_match=True):
"""
:param channels: Number of channels used in the conv-operations
:param bn_mom: Batch normalization momentum
:param act_type: Activation function to use
:param unit_name: Unit name of the residual block (only used for description (string))
"""
super(_ResidualBlockXBottleneck, self).__init__(prefix=unit_name + "_")
self.unit_name = unit_name
self.use_se = se_type
self.dim_match = dim_match
self.body = HybridSequential(prefix="")
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"'
)
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
self.body.add(
Conv2D(channels, kernel_size=1, padding=0, use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
self.body.add(
Conv2D(channels,
kernel_size=3,
padding=1,
groups=2,
use_bias=False))
self.body.add(BatchNorm(momentum=bn_mom))
self.body.add(get_act(act_type))
#
# # add a 1x1 branch after concatenation
self.body.add(
Conv2D(channels=channels,
kernel_size=1,
padding=0,
use_bias=False))
if not self.dim_match:
self.expander = HybridSequential(prefix="")
self.expander.add(
Conv2D(channels=channels,
kernel_size=1,
use_bias=False,
prefix="expander_conv"))
self.expander.add(BatchNorm())
