def __init__(self,
in_channels,
out_channels,
num_outs,
activation=None,
start_level=0,
end_level=-1,
add_extra_convs=None,
extra_convs_on_inputs=None,
relu_before_extra_convs=None):
"""Init FPN.
:param desc: config dict
"""
super(FPN, self).__init__()
self.num_ins = len(in_channels)
self.num_outs = num_outs
self.start_level = start_level
self.add_extra_convs = add_extra_convs
self.extra_convs_on_inputs = extra_convs_on_inputs
self.relu_before_extra_convs = relu_before_extra_convs
if end_level == -1:
self.backbone_end_level = self.num_ins
assert self.num_outs >= self.num_ins - self.start_level
else:
self.backbone_end_level = end_level
assert end_level <= len(self.in_channels)
assert self.num_outs == end_level - self.start_level
self.lateral_convs = ops.MoudleList()
self.fpn_convs = ops.MoudleList()
for i in range(self.start_level, self.backbone_end_level):
l_conv = ConvModule(in_channels[i],
out_channels,
1,
activation=activation,
inplace=False)
fpn_conv = ConvModule(out_channels,
out_channels,
3,
padding=1,
activation=activation,
inplace=False)
self.lateral_convs.append(l_conv)
self.fpn_convs.append(fpn_conv)
extra_levels = self.num_outs - self.backbone_end_level + self.start_level
if self.add_extra_convs and extra_levels >= 1:
for i in range(extra_levels):
if i == 0 and self.extra_convs_on_inputs:
in_channels = in_channels[self.backbone_end_level - 1]
else:
in_channels = out_channels
extra_fpn_conv = ConvModule(in_channels,
out_channels,
3,
stride=2,
padding=1,
activation=activation,
inplace=False)
self.fpn_convs.append(extra_fpn_conv)
def __init__(self, InChannel, OutChannel, growRate, nConvLayers, kSize=3):
"""Initialize Block.
:param InChannel: channel number of input
:type InChannel: int
:param OutChannel: channel number of output
:type OutChannel: int
:param growRate: growth rate of block
:type growRate: int
:param nConvLayers: the number of convlution layer
:type nConvLayers: int
:param kSize: kernel size of convolution operation
:type kSize: int
"""
super(Cont_RDB, self).__init__()
self.InChan = InChannel
self.OutChan = OutChannel
self.G = growRate
self.C = nConvLayers
if self.InChan != self.G:
self.InConv = ops.Conv2d(self.InChan,
self.G,
1,
padding=0,
stride=1)
if self.OutChan != self.G and self.OutChan != self.InChan:
self.OutConv = ops.Conv2d(self.InChan,
self.OutChan,
1,
padding=0,
stride=1)
self.pool = ops.AvgPool2d(2, 2)
self.shup = ops.PixelShuffle(2)
self.Convs = ops.MoudleList()
self.ShrinkConv = ops.MoudleList()
for i in range(self.C):
self.Convs.append(
Sequential(
ops.Conv2d(self.G,
self.G,
kSize,
padding=(kSize - 1) // 2,
stride=1), ops.Relu()))
if i < (self.C - 1):
self.ShrinkConv.append(
ops.Conv2d((2 + i) * self.G,
self.G,
1,
padding=0,
stride=1))
else:
self.ShrinkConv.append(
ops.Conv2d(int((2 + i) * self.G / 4),
self.OutChan,
1,
padding=0,
stride=1))
def __init__(self, op_names, config, inp, repeats=1, concat=False):
"""Construct ContextualCell_v1 class.
:param op_names: list of operation indices
:param config: list of config numbers
:param inp: input channel
:param repeats: number of repeated times
:param concat: concat the result if set to True, otherwise add the result
"""
super(ContextualCell_v1, self).__init__()
self.ops = ops.MoudleList()
self._pos = []
self._collect_inds = [0]
self._pools = ['x']
for ind, op in enumerate(config):
# first op is always applied on x
if ind == 0:
pos = 0
op_id = op
self._collect_inds.remove(pos)
op_name = op_names[op_id]
# turn-off scaling in batch norm
self.ops.append(OPS[op_name](inp, 1, True, repeats))
self._pos.append(pos)
self._collect_inds.append(ind + 1)
self._pools.append('{}({})'.format(op_name, self._pools[pos]))
else:
pos1, pos2, op_id1, op_id2 = op
# drop op_id from loose ends
for ind2, (pos, op_id) in enumerate(
zip([pos1, pos2], [op_id1, op_id2])):
if pos in self._collect_inds:
self._collect_inds.remove(pos)
op_name = op_names[op_id]
# turn-off scaling in batch norm
self.ops.append(OPS[op_name](inp, 1, True, repeats))
self._pos.append(pos)
# self._collect_inds.append(ind * 3 + ind2 - 1) # Do not collect intermediate
self._pools.append('{}({})'.format(op_name,
self._pools[pos]))
# summation
op_name = 'sum'
self.ops.append(
AggregateCell(size_1=None,
size_2=None,
agg_size=inp,
pre_transform=False,
concat=concat)) # turn-off convbnrelu
self._pos.append([ind * 3 - 1, ind * 3])
self._collect_inds.append(ind * 3 + 1)
self._pools.append('{}({},{})'.format(op_name,
self._pools[ind * 3 - 1],
self._pools[ind * 3]))
def __init__(self, arch, G0, kSize):
"""Create ERDBLayer.
:param arch: arch
:type arch: dict
:param G0: G0
:type G0: G0
:param kSize: kSize
:type kSize: int
"""
super(ERDBLayer, self).__init__()
self.SFENet2 = ops.Conv2d(G0,
G0,
kSize,
padding=(kSize - 1) // 2,
stride=1)
b_in_chan = G0
b_out_chan = 0
Conc_all = 0
ERDBs = ops.MoudleList()
for i in range(len(arch)):
name = arch[i]
key = name.split('_')
if i > 0:
b_in_chan = b_out_chan
b_conv_num = int(key[1])
b_grow_rat = int(key[2])
b_out_chan = int(key[3])
Conc_all += b_out_chan
if key[0] == 'S':
ERDBs.append(
Shrink_RDB(InChannel=b_in_chan,
OutChannel=b_out_chan,
growRate=b_grow_rat,
nConvLayers=b_conv_num))
elif key[0] == 'G':
ERDBs.append(
Group_RDB(InChannel=b_in_chan,
OutChannel=b_out_chan,
growRate=b_grow_rat,
nConvLayers=b_conv_num))
elif key[0] == 'C':
ERDBs.append(
Cont_RDB(InChannel=b_in_chan,
OutChannel=b_out_chan,
growRate=b_grow_rat,
nConvLayers=b_conv_num))
self.ERBD = ERDBs
self.GFF = Sequential(
ops.Conv2d(Conc_all, G0, 1, padding=0, stride=1),
ops.Conv2d(G0, G0, kSize, padding=(kSize - 1) // 2, stride=1))
def __init__(self,
in_channels=[64, 128, 256, 512],
out_channels=256,
num_outs=5,
activation=None,
start_level=0,
end_level=-1):
"""Init FPN.
:param desc: config dict
"""
super(FPN, self).__init__()
self.num_ins = len(in_channels)
self.num_outs = num_outs
self.start_level = start_level
if end_level == -1:
self.backbone_end_level = self.num_ins
assert self.num_outs >= self.num_ins - self.start_level
else:
self.backbone_end_level = end_level
assert end_level <= len(self.in_channels)
assert self.num_outs == end_level - self.start_level
self.lateral_convs = ops.MoudleList()
self.fpn_convs = ops.MoudleList()
for i in range(self.start_level, self.backbone_end_level):
l_conv = ConvModule(in_channels[i],
out_channels,
1,
activation=activation,
inplace=False)
fpn_conv = ConvModule(out_channels,
out_channels,
3,
padding=1,
activation=activation,
inplace=False)
self.lateral_convs.append(l_conv)
self.fpn_convs.append(fpn_conv)