def dsn_head(self, base_out_channels):
route = RouteLayer('14')
output_channel = sum([
base_out_channels[i] if i >= 0 else self.block_out_channels[i]
for i in route.layers
])
self.add_block_list(route.get_name(), route, output_channel)
conv1 = ConvBNActivationBlock(in_channels=output_channel,
out_channels=512,
kernel_size=3,
stride=1,
padding=1,
bias=True,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(conv1.get_name(), conv1, 512)
dropout = nn.Dropout2d(0.1)
self.add_block_list(LayerType.Dropout, dropout,
self.block_out_channels[-1])
out_conv = nn.Conv2d(512,
self.class_number,
kernel_size=1,
stride=1,
padding=0,
bias=True)
self.add_block_list(LayerType.Convolutional, out_conv,
self.class_number)
up1 = Upsample(scale_factor=16, mode='bilinear')
self.add_block_list(up1.get_name(), up1, self.block_out_channels[-1])
def create_block_list(self):
self.clear_list()
layer1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.first_output,
kernel_size=3,
stride=1,
padding=1,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(layer1.get_name(), layer1, self.first_output)
for mod_id, num in enumerate(self.num_blocks):
if mod_id == 4:
drop = partial(nn.Dropout, p=0.3)
elif mod_id == 5:
drop = partial(nn.Dropout, p=0.5)
else:
drop = None
if mod_id < 2:
maxpool = nn.MaxPool2d(3, stride=2, padding=1)
self.add_block_list(LayerType.MyMaxPool2d, maxpool,
self.block_out_channels[-1])
self.make_block(self.out_channels[mod_id],
num,
stride=self.strides[mod_id],
dilation=self.dilations[mod_id],
drop=drop,
bn_name=self.bn_name,
activation=self.activation_name)
def make_layers(self, cfg):
in_channels = self.data_channel
for v in cfg:
if v == 'M':
temp_layer = nn.MaxPool2d(kernel_size=2,
stride=2,
ceil_mode=False)
self.add_block_list(LayerType.MyMaxPool2d, temp_layer,
in_channels)
else:
if self.is_norm:
conv2d = ConvBNActivationBlock(
in_channels=in_channels,
out_channels=v,
kernel_size=3,
stride=1,
padding=1,
dilation=1,
bnName=self.bnName,
activationName=self.activationName)
self.add_block_list(conv2d.get_name(), conv2d, v)
else:
conv2d = ConvActivationBlock(
in_channels=in_channels,
out_channels=v,
kernel_size=3,
stride=1,
padding=1,
dilation=1,
activationName=self.activationName)
self.add_block_list(conv2d.get_name(), conv2d, v)
in_channels = v
def create_block_list(self):
self.block_out_channels = []
self.index = 0
block1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.in_channels[0],
kernel_size=3,
padding=1,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(block1.get_name(), block1, self.in_channels[0])
self.make_stage(self.in_channels[0], self.out_channels[0],
self.num_blocks[0], AttentionModule1)
self.make_stage(self.in_channels[1], self.out_channels[1],
self.num_blocks[1], AttentionModule2)
self.make_stage(self.in_channels[2], self.out_channels[2],
self.num_blocks[2], AttentionModule3)
output_channle = 2048
bottleneck_channels = int(output_channle / 4)
block2 = PreActBottleNeck(self.out_channels[2], bottleneck_channels, 2)
self.add_block_list(block2.get_name(), block2, output_channle)
block3 = PreActBottleNeck(output_channle, bottleneck_channels, 1)
self.add_block_list(block3.get_name(), block3, output_channle)
block4 = PreActBottleNeck(output_channle, bottleneck_channels, 1)
self.add_block_list(block4.get_name(), block4, output_channle)
def __init__(self,
F_g,
F_l,
F_int,
bn_name=NormalizationType.BatchNormalize2d):
super().__init__(UNetBlockName.AttentionBlock)
self.W_g = ConvBNActivationBlock(in_channels=F_g,
out_channels=F_int,
kernel_size=1,
padding=0,
bias=True,
bnName=bn_name,
activationName=ActivationType.Linear)
self.W_x = ConvBNActivationBlock(in_channels=F_l,
out_channels=F_int,
kernel_size=1,
padding=0,
bias=True,
bnName=bn_name,
activationName=ActivationType.Linear)
self.psi = nn.Sequential(
ConvBNActivationBlock(in_channels=F_int,
out_channels=1,
kernel_size=1,
padding=0,
bias=True,
bnName=bn_name,
activationName=ActivationType.Linear),
nn.Sigmoid())
self.relu = nn.ReLU(inplace=True)
def __init__(self,
in_channels,
out_channels,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(BiSeNetBlockName.SpatialPath)
inter_channels = 64
self.conv7x7 = ConvBNActivationBlock(in_channels=in_channels,
out_channels=inter_channels,
kernel_size=7,
stride=2,
padding=3,
bnName=bn_name,
activationName=activation_name)
self.conv3x3_1 = ConvBNActivationBlock(in_channels=inter_channels,
out_channels=inter_channels,
kernel_size=3,
stride=2,
padding=1,
bnName=bn_name,
activationName=activation_name)
self.conv3x3_2 = ConvBNActivationBlock(in_channels=inter_channels,
out_channels=inter_channels,
kernel_size=3,
stride=2,
padding=1,
bnName=bn_name,
activationName=activation_name)
self.conv1x1 = ConvBNActivationBlock(in_channels=inter_channels,
out_channels=out_channels,
kernel_size=1,
stride=1,
padding=0,
bnName=bn_name,
activationName=activation_name)
def __init__(self,
in_channels,
out_channels,
stride=1,
M=2,
r=16,
L=32,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(SKNetBlockName.SKConvBlock)
d = max(in_channels // r, L)
self.M = M
self.out_channels = out_channels
self.conv = nn.ModuleList()
for index in range(M):
self.conv.append(
ConvBNActivationBlock(in_channels=in_channels,
out_channels=out_channels,
kernel_size=3,
stride=stride,
padding=1 + index,
dilation=1 + index,
groups=32,
bias=False,
bnName=bn_name,
activationName=activation_name))
self.global_pool = nn.AdaptiveAvgPool2d(1)
self.fc1 = ConvBNActivationBlock(in_channels=out_channels,
out_channels=d,
kernel_size=1,
bias=False,
bnName=bn_name,
activationName=activation_name)
self.fc2 = nn.Conv2d(d, out_channels * M, 1, 1, bias=False)
self.softmax = nn.Softmax(dim=1)
def __init__(self,
input_channel,
out_channels,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(InceptionBlockName.InceptionResNetReductionA)
self.branch3x3stack = nn.Sequential(
ConvBNActivationBlock(input_channel,
out_channels[0],
kernel_size=1,
bnName=bn_name,
activationName=activation_name),
ConvBNActivationBlock(out_channels[0],
out_channels[1],
kernel_size=3,
padding=1,
bnName=bn_name,
activationName=activation_name),
ConvBNActivationBlock(out_channels[1],
out_channels[2],
kernel_size=3,
stride=2,
bnName=bn_name,
activationName=activation_name))
self.branch3x3 = ConvBNActivationBlock(input_channel,
out_channels[3],
kernel_size=3,
stride=2,
bnName=bn_name,
activationName=activation_name)
self.branchpool = nn.MaxPool2d(kernel_size=3, stride=2)
self.output_channel = input_channel + out_channels[2] + out_channels[3]
def __init__(self,
in_channels,
out_channels,
reduction=1,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(BiSeNetBlockName.FeatureFusionBlock)
self.conv1x1 = ConvBNActivationBlock(in_channels=in_channels,
out_channels=out_channels,
kernel_size=1,
stride=1,
padding=0,
bnName=bn_name,
activationName=activation_name)
self.channel_attention = nn.Sequential(
nn.AdaptiveAvgPool2d(1),
ConvBNActivationBlock(in_channels=out_channels,
out_channels=out_channels // reduction,
kernel_size=1,
stride=1,
padding=0,
bnName=bn_name,
activationName=activation_name),
ConvBNActivationBlock(in_channels=out_channels // reduction,
out_channels=out_channels,
kernel_size=1,
stride=1,
padding=0,
bnName=bn_name,
activationName=activation_name),
nn.Sigmoid())
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(SKNetBlockName.SKBlock)
self.conv1 = ConvBNActivationBlock(in_channels=inplanes,
out_channels=planes,
kernel_size=1,
stride=1,
padding=0,
bias=False,
bnName=bn_name,
activationName=activation_name)
self.conv2 = SKConv(planes, planes, stride)
self.conv3 = ConvBNActivationBlock(
in_channels=planes,
out_channels=planes * self.expansion,
kernel_size=1,
stride=1,
padding=0,
bias=False,
bnName=bn_name,
activationName=ActivationType.Linear)
self.relu = nn.ReLU(inplace=True)
self.downsample = downsample
def __init__(self,
inp,
oup,
kernel_size=1,
ratio=2,
dw_size=3,
stride=1,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(GhostNetBlockName.GhostBlock)
self.oup = oup
init_channels = math.ceil(oup / ratio)
new_channels = init_channels * (ratio - 1)
self.primary_conv = ConvBNActivationBlock(
in_channels=inp,
out_channels=init_channels,
kernel_size=kernel_size,
stride=stride,
padding=kernel_size // 2,
bias=False,
bnName=bn_name,
activationName=activation_name)
self.cheap_operation = ConvBNActivationBlock(
in_channels=init_channels,
out_channels=new_channels,
kernel_size=dw_size,
stride=1,
padding=dw_size // 2,
groups=init_channels,
bias=False,
bnName=bn_name,
activationName=activation_name)
def make_darknet_layer(self, out_channel, num_block, stride, dilation,
bnName, activationName):
#downsample
if dilation > 1:
if stride == 2:
stride = 1
dilation = dilation // 2
down_layers = ConvBNActivationBlock(in_channels=self.in_channel,
out_channels=out_channel,
kernel_size=3,
stride=stride,
padding=dilation,
dilation=dilation,
bnName=bnName,
activationName=activationName)
name = "down_%s" % down_layers.get_name()
self.add_block_list(name, down_layers, out_channel)
planes = [self.in_channel, out_channel]
for _ in range(0, num_block):
layer = BasicBlock(out_channel,
planes,
stride=1,
dilation=dilation,
bnName=bnName,
activationName=activationName)
self.add_block_list(layer.get_name(), layer, out_channel)
def __init__(self, in_channels, out_channels, stride=1, dilation=1,
bnName=NormalizationType.BatchNormalize2d, activationName=ActivationType.ReLU, split_ratio=0.5):
super().__init__(ShuffleNetBlockName.BasicBlock)
self.split = SplitBlock(split_ratio)
in_channels = int(in_channels * split_ratio)
self.convBnReLU1 = ConvBNActivationBlock(in_channels=in_channels,
out_channels=in_channels,
kernel_size=1,
bnName=bnName,
activationName=activationName)
self.convBn2 = ConvBNActivationBlock(in_channels=in_channels,
out_channels=in_channels,
kernel_size=3,
stride=stride,
padding=dilation,
dilation=dilation,
groups=in_channels,
bnName=bnName,
activationName=ActivationType.Linear)
self.convBnReLU3 = ConvBNActivationBlock(in_channels=in_channels,
out_channels=in_channels,
kernel_size=1,
bnName=bnName,
activationName=activationName)
self.shuffle = ShuffleBlock(groups=2)
def __init__(self,
low_channels,
high_channels,
out_channels,
scale,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(ICNetBlockName.CascadeFeatureFusion)
self.up = Upsample(scale_factor=scale, mode='bilinear')
self.conv_low = ConvBNActivationBlock(
in_channels=low_channels,
out_channels=out_channels,
kernel_size=3,
padding=2,
dilation=2,
bias=False,
bnName=bn_name,
activationName=ActivationType.Linear)
self.conv_high = ConvBNActivationBlock(
in_channels=high_channels,
out_channels=out_channels,
kernel_size=1,
bias=False,
bnName=bn_name,
activationName=ActivationType.Linear)
self.activation = ActivationLayer(activation_name=activation_name,
inplace=False)
def __init__(self,
in_channels,
planes,
stride=1,
dilation=1,
bnName=NormalizationType.BatchNormalize2d,
activationName=ActivationType.ReLU):
super().__init__(DarknetBlockName.BasicBlock)
self.conv1 = ConvBNActivationBlock(in_channels=in_channels,
out_channels=planes[0],
kernel_size=3,
stride=stride,
padding=dilation,
dilation=dilation,
bnName=bnName,
activationName=activationName)
self.conv2 = ConvBNActivationBlock(in_channels=planes[0],
out_channels=planes[1],
kernel_size=3,
stride=stride,
padding=dilation,
dilation=dilation,
bnName=bnName,
activationName=activationName)
def __init__(self,
in_channels=2048,
out_channels=256,
output_stride=16,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(DeepLabBlockName.ASPP)
if output_stride == 16:
dilations = [6, 12, 18]
elif output_stride == 8:
dilations = [12, 24, 36]
elif output_stride == 32:
dilations = [6, 12, 18]
else:
raise NotImplementedError
self.image_pooling = GlobalAvgPooling(in_channels,
out_channels,
bn_name=bn_name,
activation_name=activation_name)
self.aspp0 = ConvBNActivationBlock(in_channels=in_channels,
out_channels=out_channels,
kernel_size=1,
bias=False,
bnName=bn_name,
activationName=activation_name)
self.aspp1 = SeparableConv2dBNActivation(
in_channels,
out_channels,
dilation=dilations[0],
relu_first=False,
bn_name=bn_name,
activation_name=activation_name)
self.aspp2 = SeparableConv2dBNActivation(
in_channels,
out_channels,
dilation=dilations[1],
relu_first=False,
bn_name=bn_name,
activation_name=activation_name)
self.aspp3 = SeparableConv2dBNActivation(
in_channels,
out_channels,
dilation=dilations[2],
relu_first=False,
bn_name=bn_name,
activation_name=activation_name)
self.conv = ConvBNActivationBlock(in_channels=out_channels * 5,
out_channels=out_channels,
kernel_size=1,
bias=False,
bnName=bn_name,
activationName=activation_name)
self.dropout = nn.Dropout2d(p=0.1)
def create_block_list(self):
self.block_out_channels = []
self.index = 0
c1_channels = 24
c4_channels = 320
backbone = self.factory.get_base_model(BackboneName.MobileNetV2_1_0)
base_out_channels = backbone.get_outchannel_list()
self.add_block_list(BlockType.BaseNet, backbone, base_out_channels[-1])
aspp = ASPP(c4_channels, 256, bn_name=self.bn_name,
activation_name=self.activation_name)
out_channel = 256
self.add_block_list(aspp.get_name(), aspp, out_channel)
up1 = Upsample(scale_factor=8, mode='bilinear')
self.add_block_list(up1.get_name(), up1, self.block_out_channels[-1])
layer1 = RouteLayer('3')
output_channel = sum([base_out_channels[i] if i >= 0
else self.block_out_channels[i] for i in layer1.layers])
self.add_block_list(layer1.get_name(), layer1, output_channel)
conv1 = ConvBNActivationBlock(in_channels=c1_channels,
out_channels=48,
kernel_size=1,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(conv1.get_name(), conv1, 48)
layer2 = RouteLayer('-3, -1')
output_channel = sum([base_out_channels[i] if i >= 0
else self.block_out_channels[i] for i in layer2.layers])
self.add_block_list(layer2.get_name(), layer2, output_channel)
block1 = SeparableConv2dBNActivation(output_channel, 256, 3, relu_first=False,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(block1.get_name(), block1, 256)
block2 = SeparableConv2dBNActivation(256, 256, 3, relu_first=False,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(block2.get_name(), block2, 256)
conv2 = nn.Conv2d(256, self.class_number, 1)
self.add_block_list(LayerType.Convolutional, conv2, self.class_number)
layer3 = Upsample(scale_factor=4, mode='bilinear')
self.add_block_list(layer3.get_name(), layer3, self.block_out_channels[-1])
self.create_loss()
def __init__(self,
in_channel,
out_channel,
stride,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(ResNextBlockName.ResNextBottleNeckC)
C = ResNextBottleNeck.CARDINALITY
#"""We note that the input/output width of the template is fixed as
#256-d (Fig. 3), We note that the input/output width of the template
#is fixed as 256-d (Fig. 3), and all widths are dou- bled each time
#when the feature map is subsampled (see Table 1)."""
# number of channels per group
D = int(ResNextBottleNeck.DEPTH * out_channel /
ResNextBottleNeck.BASEWIDTH)
self.split_transforms = nn.Sequential(
ConvBNActivationBlock(in_channels=in_channel,
out_channels=C * D,
kernel_size=1,
groups=C,
bias=False,
bnName=bn_name,
activationName=activation_name),
ConvBNActivationBlock(in_channels=C * D,
out_channels=C * D,
kernel_size=3,
stride=stride,
groups=C,
padding=1,
bias=False,
bnName=bn_name,
activationName=activation_name),
ConvBNActivationBlock(in_channels=C * D,
out_channels=out_channel * 4,
kernel_size=1,
bias=False,
bnName=bn_name,
activationName=ActivationType.Linear))
self.shortcut = nn.Sequential()
if stride != 1 or in_channel != out_channel * 4:
self.shortcut = ConvBNActivationBlock(
in_channels=in_channel,
out_channels=out_channel * 4,
kernel_size=1,
stride=stride,
bias=False,
bnName=bn_name,
activationName=ActivationType.Linear)
self.relu = ActivationLayer(activation_name=activation_name,
inplace=False)
def __init__(self,
features,
inner_features=512,
out_features=512,
dilations=(12, 24, 36),
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(DeepLabBlockName.ASPP)
self.image_pooling = GlobalAvgPooling(features,
inner_features,
bn_name=bn_name,
activation_name=activation_name)
self.conv2 = ConvBNActivationBlock(in_channels=features,
out_channels=inner_features,
kernel_size=1,
padding=0,
dilation=1,
bias=False,
bnName=bn_name,
activationName=activation_name)
self.conv3 = ConvBNActivationBlock(in_channels=features,
out_channels=inner_features,
kernel_size=3,
padding=dilations[0],
dilation=dilations[0],
bias=False,
bnName=bn_name,
activationName=activation_name)
self.conv4 = ConvBNActivationBlock(in_channels=features,
out_channels=inner_features,
kernel_size=3,
padding=dilations[1],
dilation=dilations[1],
bias=False,
bnName=bn_name,
activationName=activation_name)
self.conv5 = ConvBNActivationBlock(in_channels=features,
out_channels=inner_features,
kernel_size=3,
padding=dilations[2],
dilation=dilations[2],
bias=False,
bnName=bn_name,
activationName=activation_name)
self.bottleneck = nn.Sequential(
ConvBNActivationBlock(in_channels=inner_features * 5,
out_channels=out_features,
kernel_size=1,
bias=False,
bnName=bn_name,
activationName=activation_name),
nn.Dropout2d(p=0.1))
def create_block_list(self):
self.clear_list()
block1 = InputDownSample()
self.add_block_list(block1.get_name(), block1, self.data_channel)
conv1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=32,
kernel_size=3,
padding=1,
stride=2,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(conv1.get_name(), conv1, 32)
conv2 = ConvBNActivationBlock(in_channels=32,
out_channels=32,
kernel_size=3,
padding=1,
stride=2,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(conv2.get_name(), conv2, 32)
conv3 = ConvBNActivationBlock(in_channels=32,
out_channels=64,
kernel_size=3,
padding=1,
stride=2,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(conv3.get_name(), conv3, 64)
backbone1 = self.factory.get_base_model(BackboneName.ResNet50, data_channel=self.data_channel)
base_out_channels1 = backbone1.get_outchannel_list()
self.add_block_list(BlockType.BaseNet, backbone1, base_out_channels1[-1])
layer1 = RouteLayer('8')
output_channel = sum([base_out_channels1[i] if i >= 0
else self.block_out_channels[i] for i in layer1.layers])
self.add_block_list(layer1.get_name(), layer1, output_channel)
backbone2 = self.factory.get_base_model(BackboneName.ResNet50, data_channel=self.data_channel)
base_out_channels2 = backbone2.get_outchannel_list()
self.add_block_list(BlockType.BaseNet, backbone2, base_out_channels2[-1])
layer2 = RouteLayer('17')
output_channel = sum([base_out_channels2[i] if i >= 0
else self.block_out_channels[i] for i in layer2.layers])
self.add_block_list(layer2.get_name(), layer2, output_channel)
self.create_head()
self.create_loss()
def __init__(self,
in_planes,
out_planes,
stride=1,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(PNASNetBlockName.CellB)
self.stride = stride
# Left branch
self.sep_conv1 = SeparableConv(in_planes,
out_planes,
kernel_size=7,
stride=stride,
bn_name=bn_name)
self.sep_conv2 = SeparableConv(in_planes,
out_planes,
kernel_size=3,
stride=stride,
bn_name=bn_name)
# Right branch
self.sep_conv3 = SeparableConv(in_planes,
out_planes,
kernel_size=5,
stride=stride,
bn_name=bn_name)
if stride == 2:
self.conv1 = ConvBNActivationBlock(
in_channels=in_planes,
out_channels=out_planes,
kernel_size=1,
stride=1,
padding=0,
bias=False,
bnName=bn_name,
activationName=ActivationType.Linear)
self.activate1 = ActivationLayer(activation_name, inplace=False)
self.activate2 = ActivationLayer(activation_name, inplace=False)
# Reduce channels
self.conv2 = ConvBNActivationBlock(in_channels=2 * out_planes,
out_channels=out_planes,
kernel_size=1,
stride=1,
padding=0,
bias=False,
bnName=bn_name,
activationName=activation_name)
def __init__(self, channel_list, stride=1, dilation=1, relu_first=True,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(XceptionBlockName.XceptionConvBlock)
assert len(channel_list) == 4
self.conv = ConvBNActivationBlock(in_channels=channel_list[0],
out_channels=channel_list[-1],
kernel_size=1,
stride=stride,
bias=False,
bnName=bn_name,
activationName=ActivationType.Linear)
self.double_sep_conv = DoubleSeparableConv2dBlock(channel_list=channel_list[:3],
dilation=dilation,
relu_first=relu_first,
bn_name=bn_name,
activation_name=activation_name)
self.sep_conv = SeparableConv2dBNActivation(inplanes=channel_list[2],
planes=channel_list[3],
dilation=dilation,
stride=stride,
relu_first=relu_first,
bn_name=bn_name,
activation_name=activation_name)
self.last_inp_channels = channel_list[3]
def __init__(self,
in_channels,
nclass,
ncodes=32,
se_loss=True,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(EncNetBlockName.EncBlock)
self.se_loss = se_loss
self.encoding = nn.Sequential(
ConvBNActivationBlock(in_channels=in_channels,
out_channels=in_channels,
kernel_size=1,
bias=False,
bnName=bn_name,
activationName=activation_name),
Encoding(D=in_channels, K=ncodes),
NormalizeLayer(NormalizationType.BatchNormalize1d, ncodes),
ActivationLayer(activation_name), MeanLayer(dim=1))
self.fc = nn.Sequential(nn.Linear(in_channels, in_channels),
nn.Sigmoid())
self.activate = ActivationLayer(activation_name)
if self.se_loss:
self.se_layer = nn.Linear(in_channels, nclass)
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride=1,
padding=0,
dilation=1,
bias=True,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(EncNetBlockName.SeperableConv2dNActivation)
self.depthwise = nn.Conv2d(in_channels,
in_channels,
kernel_size,
stride,
padding,
dilation,
in_channels,
bias=bias)
self.norm_layer = NormalizeLayer(bn_name, in_channels)
self.pointwise = ConvBNActivationBlock(in_channels=in_channels,
out_channels=out_channels,
kernel_size=1,
bias=bias,
bnName=bn_name,
activationName=activation_name)
def create_block_list(self):
self.block_out_channels = []
self.index = 0
block1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.first_output,
kernel_size=3,
padding=1,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(block1.get_name(), block1, self.first_output)
for index, num_block in enumerate(self.num_blocks):
self.make_layer(self.block, num_block, self.out_channels[index],
self.strides[index])
self.in_channel = self.out_channels[index] * self.block.expansion
def make_layer(self, block, nums_block, planes, stride=1):
downsample = None
if stride != 1 or self.in_channel != planes * block.expansion:
downsample = ConvBNActivationBlock(
in_channels=self.in_channel,
out_channels=planes * block.expansion,
kernel_size=1,
stride=stride,
bias=False,
bnName=self.bn_name,
activationName=ActivationType.Linear)
down_block = block(self.in_channel,
planes,
stride,
downsample,
bn_name=self.bn_name,
activation_name=self.activation_name)
out_channels = planes * block.expansion
self.add_block_list(down_block.get_name(), down_block, out_channels)
self.in_channel = out_channels
for _ in range(1, nums_block):
temp_block = block(self.in_channel,
planes,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(temp_block.get_name(), temp_block,
out_channels)
def __init__(self,
last_planes,
in_planes,
out_planes,
dense_depth,
stride,
first_layer,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(DPNBlockName.Bottleneck)
self.out_planes = out_planes
self.dense_depth = dense_depth
self.conv1 = ConvBNActivationBlock(in_channels=last_planes,
out_channels=in_planes,
kernel_size=1,
bias=False,
bnName=bn_name,
activationName=activation_name)
self.conv2 = ConvBNActivationBlock(in_channels=in_planes,
out_channels=in_planes,
kernel_size=3,
stride=stride,
padding=1,
groups=32,
bias=False,
bnName=bn_name,
activationName=activation_name)
self.conv3 = ConvBNActivationBlock(
in_channels=in_planes,
out_channels=out_planes + dense_depth,
kernel_size=1,
bias=False,
bnName=bn_name,
activationName=ActivationType.Linear)
self.shortcut = nn.Sequential()
if first_layer:
self.shortcut = ConvBNActivationBlock(
in_channels=last_planes,
out_channels=out_planes + dense_depth,
kernel_size=1,
stride=stride,
bias=False,
bnName=bn_name,
activationName=ActivationType.Linear)
def __init__(self,
in_channels,
out_channels,
stride=1,
expand_ratio=1,
dilation=1,
bnName=NormalizationType.BatchNormalize2d,
activationName=ActivationType.ReLU6):
super().__init__(BlockType.InvertedResidual)
assert stride in [1, 2]
self.use_res_connect = stride == 1 and in_channels == out_channels
layers = OrderedDict()
inter_channels = int(round(in_channels * expand_ratio))
if expand_ratio != 1:
# pw
convBNReLU1 = ConvBNActivationBlock(in_channels=in_channels,
out_channels=inter_channels,
kernel_size=1,
bnName=bnName,
activationName=activationName)
layer_name = "%s_1" % BlockType.ConvBNActivationBlock
layers[layer_name] = convBNReLU1
# dw
convBNReLU2 = ConvBNActivationBlock(in_channels=inter_channels,
out_channels=inter_channels,
kernel_size=3,
stride=stride,
padding=dilation,
dilation=dilation,
groups=inter_channels,
bnName=bnName,
activationName=activationName)
# pw-linear
convBNReLU3 = ConvBNActivationBlock(
in_channels=inter_channels,
out_channels=out_channels,
kernel_size=1,
bnName=bnName,
activationName=ActivationType.Linear)
layer_name = "%s_2" % BlockType.ConvBNActivationBlock
layers[layer_name] = convBNReLU2
layer_name = "%s_3" % BlockType.ConvBNActivationBlock
layers[layer_name] = convBNReLU3
self.block = nn.Sequential(layers)
def create_block_list(self):
self.block_out_channels = []
self.index = 0
basic_model = self.factory.get_base_model("./cfg/det3d/complex-darknet19.cfg")
base_out_channels = basic_model.get_outchannel_list()
self.add_block_list(BlockType.BaseNet, basic_model, base_out_channels[-1])
input_channel = self.block_out_channels[-1]
output_channel = 1024
conv1 = ConvBNActivationBlock(input_channel, output_channel,
kernel_size=3, stride=1, padding=1,
bnName=self.bn_name, activationName=self.activation_name)
self.add_block_list(conv1.get_name(), conv1, output_channel)
input_channel = self.block_out_channels[-1]
output_channel = 1024
conv2 = ConvBNActivationBlock(input_channel, output_channel,
kernel_size=3, stride=1, padding=1,
bnName=self.bn_name, activationName=self.activation_name)
self.add_block_list(conv2.get_name(), conv2, output_channel)
layer1 = RouteLayer('12')
output_channel = sum([base_out_channels[i] if i >= 0 else self.block_out_channels[i] for i in layer1.layers])
self.add_block_list(layer1.get_name(), layer1, output_channel)
reorg = ReorgBlock()
output_channel = reorg.stride * reorg.stride * self.out_channels[-1]
self.add_block_list(reorg.get_name(), reorg, output_channel)
layer2 = RouteLayer('-3,-1')
output_channel = sum([base_out_channels[i] if i >= 0 else self.block_out_channels[i] for i in layer2.layers])
self.add_block_list(layer2.get_name(), layer2, output_channel)
input_channel = self.block_out_channels[-1]
output_channel = 1024
conv3 = ConvBNActivationBlock(input_channel, output_channel,
kernel_size=3, stride=1, padding=1,
bnName=self.bn_name, activationName=self.activation_name)
self.add_block_list(conv3.get_name(), conv3, output_channel)
input_channel = self.block_out_channels[-1]
output_channel = 75
conv4 = nn.Conv2d(in_channels=input_channel,
out_channels=output_channel,
kernel_size=1,
stride=1,
padding=0,
bias=True)
self.add_block_list(LayerType.Convolutional, conv4, output_channel)
def make_layer(self, base_out_channels, conv_output_channel, scale_factor, route_layer_indexs):
layer1 = Upsample(scale_factor=scale_factor, mode='bilinear')
self.add_block_list(layer1.get_name(), layer1, self.block_out_channels[-1])
layer2 = RouteLayer(route_layer_indexs)
output_channel = sum([base_out_channels[i] if i >= 0
else self.block_out_channels[i] for i in layer2.layers])
self.add_block_list(layer2.get_name(), layer2, output_channel)
conv1 = ConvBNActivationBlock(self.block_out_channels[-1], conv_output_channel,
kernel_size=1, stride=1, padding=0,
bnName=self.bn_name, activationName=self.activation_name)
self.add_block_list(conv1.get_name(), conv1, conv_output_channel)
layer3 = RouteLayer('-1,-3')
output_channel = sum([base_out_channels[i] if i >= 0 else
self.block_out_channels[i] for i in layer3.layers])
self.add_block_list(layer3.get_name(), layer3, output_channel)