def __init__(self,
in_channels,
out_channels,
multi_scale_output=True,
name=None,
align_corners=False):
super(FuseLayers, self).__init__()
self._actual_ch = len(in_channels) if multi_scale_output else 1
self._in_channels = in_channels
self.align_corners = align_corners
self.residual_func_list = []
for i in range(self._actual_ch):
for j in range(len(in_channels)):
if j > i:
residual_func = self.add_sublayer(
"residual_{}_layer_{}_{}".format(name, i + 1, j + 1),
layers.ConvBN(
in_channels=in_channels[j],
out_channels=out_channels[i],
kernel_size=1,
padding='same',
bias_attr=False))
self.residual_func_list.append(residual_func)
elif j < i:
pre_num_filters = in_channels[j]
for k in range(i - j):
if k == i - j - 1:
residual_func = self.add_sublayer(
"residual_{}_layer_{}_{}_{}".format(
name, i + 1, j + 1, k + 1),
layers.ConvBN(
in_channels=pre_num_filters,
out_channels=out_channels[i],
kernel_size=3,
stride=2,
padding='same',
bias_attr=False))
pre_num_filters = out_channels[i]
else:
residual_func = self.add_sublayer(
"residual_{}_layer_{}_{}_{}".format(
name, i + 1, j + 1, k + 1),
layers.ConvBNReLU(
in_channels=pre_num_filters,
out_channels=out_channels[j],
kernel_size=3,
stride=2,
padding='same',
bias_attr=False))
pre_num_filters = out_channels[j]
self.residual_func_list.append(residual_func)
def __init__(self, in_dim, out_dim, expand):
super().__init__()
expand_dim = expand * in_dim
self.branch_1 = nn.Sequential(
layers.ConvBNReLU(in_dim, in_dim, 3),
layers.DepthwiseConvBN(in_dim, expand_dim, 3, stride=2),
layers.DepthwiseConvBN(expand_dim, expand_dim, 3),
layers.ConvBN(expand_dim, out_dim, 1))
self.branch_2 = nn.Sequential(
layers.DepthwiseConvBN(in_dim, in_dim, 3, stride=2),
layers.ConvBN(in_dim, out_dim, 1))
def __init__(self, high_in_channels, low_in_channels, out_channels):
super().__init__()
# Only depth-wise conv
self.dwconv = layers.ConvBNReLU(
in_channels=low_in_channels,
out_channels=out_channels,
kernel_size=3,
padding=1,
groups=128,
bias_attr=False)
self.conv_low_res = layers.ConvBN(out_channels, out_channels, 1)
self.conv_high_res = layers.ConvBN(high_in_channels, out_channels, 1)
def __init__(self,
num_channels,
num_filters,
has_se,
stride=1,
downsample=False,
name=None):
super(BottleneckBlock, self).__init__()
self.has_se = has_se
self.downsample = downsample
self.conv1 = layers.ConvBNReLU(
in_channels=num_channels,
out_channels=num_filters,
kernel_size=1,
padding='same',
bias_attr=False)
self.conv2 = layers.ConvBNReLU(
in_channels=num_filters,
out_channels=num_filters,
kernel_size=3,
stride=stride,
padding='same',
bias_attr=False)
self.conv3 = layers.ConvBN(
in_channels=num_filters,
out_channels=num_filters * 4,
kernel_size=1,
padding='same',
bias_attr=False)
if self.downsample:
self.conv_down = layers.ConvBN(
in_channels=num_channels,
out_channels=num_filters * 4,
kernel_size=1,
padding='same',
bias_attr=False)
if self.has_se:
self.se = SELayer(
num_channels=num_filters * 4,
num_filters=num_filters * 4,
reduction_ratio=16,
name=name + '_fc')
def __init__(self, in_channels, out_channels, expansion=6, stride=2):
super().__init__()
self.use_shortcut = stride == 1 and in_channels == out_channels
expand_channels = in_channels * expansion
self.block = nn.Sequential(
# pw
layers.ConvBNReLU(
in_channels=in_channels,
out_channels=expand_channels,
kernel_size=1,
bias_attr=False),
# dw
layers.ConvBNReLU(
in_channels=expand_channels,
out_channels=expand_channels,
kernel_size=3,
stride=stride,
padding=1,
groups=expand_channels,
bias_attr=False),
# pw-linear
layers.ConvBN(
in_channels=expand_channels,
out_channels=out_channels,
kernel_size=1,
bias_attr=False))
def __init__(self, in_dim, out_dim, expand):
super().__init__()
expand_dim = expand * in_dim
self.conv = nn.Sequential(
layers.ConvBNReLU(in_dim, in_dim, 3),
layers.DepthwiseConvBN(in_dim, expand_dim, 3),
layers.ConvBN(expand_dim, out_dim, 1))
def __init__(self, out_dim):
super().__init__()
self.db_branch_keep = nn.Sequential(
layers.DepthwiseConvBN(out_dim, out_dim, 3),
nn.Conv2D(out_dim, out_dim, 1))
self.db_branch_down = nn.Sequential(
layers.ConvBN(out_dim, out_dim, 3, stride=2),
nn.AvgPool2D(kernel_size=3, stride=2, padding=1))
self.sb_branch_keep = nn.Sequential(
layers.DepthwiseConvBN(out_dim, out_dim, 3),
nn.Conv2D(out_dim, out_dim, 1), layers.Activation(act='sigmoid'))
self.sb_branch_up = layers.ConvBN(out_dim, out_dim, 3)
self.conv = layers.ConvBN(out_dim, out_dim, 3)
def __init__(self,
num_channels,
num_filters,
stride=1,
has_se=False,
downsample=False,
name=None,
padding_same=True):
super(BasicBlock, self).__init__()
self.has_se = has_se
self.downsample = downsample
self.conv1 = layers.ConvBNReLU(
in_channels=num_channels,
out_channels=num_filters,
kernel_size=3,
stride=stride,
padding=1 if not padding_same else 'same',
bias_attr=False)
self.conv2 = layers.ConvBN(in_channels=num_filters,
out_channels=num_filters,
kernel_size=3,
padding=1 if not padding_same else 'same',
bias_attr=False)
if self.downsample:
self.conv_down = layers.ConvBNReLU(in_channels=num_channels,
out_channels=num_filters,
kernel_size=1,
bias_attr=False)
if self.has_se:
self.se = SELayer(num_channels=num_filters,
num_filters=num_filters,
reduction_ratio=16,
name=name + '_fc')
self.add = layers.Add()
self.relu = layers.Activation("relu")
def __init__(self,
low_in_channels,
high_in_channels,
out_channels,
key_channels,
value_channels,
dropout_prob,
repeat_sizes=([1]),
psp_size=(1, 3, 6, 8)):
super().__init__()
self.psp_size = psp_size
self.stages = nn.LayerList([
SelfAttentionBlock_AFNB(low_in_channels, high_in_channels,
key_channels, value_channels, out_channels,
size) for size in repeat_sizes
])
self.conv_bn = layers.ConvBN(in_channels=out_channels +
high_in_channels,
out_channels=out_channels,
kernel_size=1)
self.dropout = nn.Dropout(p=dropout_prob)
def __init__(self,
in_channels,
out_channels,
branches=4,
kernel_size_maximum=9,
shortcut=True):
super().__init__()
if out_channels < in_channels:
raise RuntimeError(
"The out_channes for DownSampler should be bigger than in_channels, but got in_channles={}, out_channels={}"
.format(in_channels, out_channels))
self.eesp = EESP(in_channels,
out_channels - in_channels,
stride=2,
branches=branches,
kernel_size_maximum=kernel_size_maximum,
down_method='avg')
self.avg = nn.AvgPool2D(kernel_size=3, padding=1, stride=2)
if shortcut:
self.shortcut_layer = nn.Sequential(
layers.ConvBNPReLU(3, 3, 3, stride=1, bias_attr=False),
layers.ConvBN(3, out_channels, 1, stride=1, bias_attr=False),
)
self._act = nn.PReLU()
def __init__(self,
num_classes,
in_channels,
backbone,
mlahead_channels=128,
aux_channels=256,
norm_layer=nn.BatchNorm2D,
pretrained=None,
**kwargs):
super(MLATransformer, self).__init__()
self.BatchNorm = norm_layer
self.mlahead_channels = mlahead_channels
self.num_classes = num_classes
self.in_channels = in_channels
self.backbone = backbone
self.mlahead = MLAHeads(mlahead_channels=self.mlahead_channels)
self.cls = nn.Conv2D(4 * self.mlahead_channels,
self.num_classes,
3,
padding=1)
self.conv0 = layers.ConvBNReLU(self.in_channels[0],
self.in_channels[0] * 2,
3,
padding=1,
bias_attr=False)
self.conv1 = layers.ConvBNReLU(self.in_channels[1],
self.in_channels[1],
3,
padding=1,
bias_attr=False)
self.conv21 = layers.ConvBNReLU(self.in_channels[2],
self.in_channels[2],
3,
padding=1,
bias_attr=False)
self.conv22 = layers.ConvBNReLU(self.in_channels[2],
self.in_channels[2] // 2,
3,
padding=1,
bias_attr=False)
self.conv31 = layers.ConvBNReLU(self.in_channels[3],
self.in_channels[3],
3,
padding=1,
bias_attr=False)
self.conv32 = layers.ConvBNReLU(self.in_channels[3],
self.in_channels[3] // 2,
3,
padding=1,
bias_attr=False)
self.conv33 = layers.ConvBNReLU(self.in_channels[3] // 2,
self.in_channels[3] // 4,
3,
padding=1,
bias_attr=False)
self.aux_head = nn.Sequential(
layers.ConvBN(in_channels=self.in_channels[2],
out_channels=aux_channels,
kernel_size=3,
padding=1,
bias_attr=False),
nn.Conv2D(
in_channels=aux_channels,
out_channels=self.num_classes,
kernel_size=1,
))
self.pretrained = pretrained
self.init_weight()
def __init__(self,
in_channels,
out_channels,
stride=1,
branches=4,
kernel_size_maximum=7,
down_method='esp'):
super(EESP, self).__init__()
if out_channels % branches != 0:
raise RuntimeError(
"The out_channes for EESP should be factorized by branches, but out_channels={} cann't be factorized by branches={}"
.format(out_channels, branches))
assert down_method in [
'avg', 'esp'
], "The down_method for EESP only support 'avg' or 'esp', but got down_method={}".format(
down_method)
self.in_channels = in_channels
self.stride = stride
in_branch_channels = int(out_channels / branches)
self.group_conv_in = layers.ConvBNPReLU(in_channels,
in_branch_channels,
1,
stride=1,
groups=branches,
bias_attr=False)
map_ksize_dilation = {
3: 1,
5: 2,
7: 3,
9: 4,
11: 5,
13: 6,
15: 7,
17: 8
}
self.kernel_sizes = []
for i in range(branches):
kernel_size = 3 + 2 * i
kernel_size = kernel_size if kernel_size <= kernel_size_maximum else 3
self.kernel_sizes.append(kernel_size)
self.kernel_sizes.sort()
self.spp_modules = nn.LayerList()
for i in range(branches):
dilation = map_ksize_dilation[self.kernel_sizes[i]]
self.spp_modules.append(
nn.Conv2D(in_branch_channels,
in_branch_channels,
kernel_size=3,
padding='same',
stride=stride,
dilation=dilation,
groups=in_branch_channels,
bias_attr=False))
self.group_conv_out = layers.ConvBN(out_channels,
out_channels,
kernel_size=1,
stride=1,
groups=branches,
bias_attr=False)
self.bn_act = BNPReLU(out_channels)
self._act = nn.PReLU()
self.down_method = True if down_method == 'avg' else False
