def create_block_list(self):
self.clear_list()
if (self.scale < 0.99) or (self.scale > 1.001):
up = Upsample(scale_factor=self.scale, mode='nearest')
self.add_block_list(up.get_name(), up, self.data_channel)
stage1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.out_channels[0],
kernel_size=3,
stride=2,
padding=1,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(stage1.get_name(), stage1, self.out_channels[0])
for index, number in enumerate(self.repeats):
self.make_layers(number, self.out_channels[index],
self.out_channels[index + 1],
self.kernel_sizes[index], self.strides[index],
self.expands[index])
activate = ActivationLayer(activation_name=self.activation_name)
self.add_block_list(activate.get_name(), activate,
self.block_out_channels[-1])
stage9 = ConvBNActivationBlock(in_channels=self.out_channels[7],
out_channels=self.out_channels[8],
kernel_size=1,
stride=1,
padding=0,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(stage9.get_name(), stage9, self.out_channels[8])
def create_block_list(self):
self.clear_list()
if self.head_type == 0:
layer1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.first_output,
kernel_size=3,
stride=1,
padding=1,
bnName=self.bnName,
activationName=self.activationName)
self.add_block_list(layer1.get_name(), layer1, self.first_output)
elif self.head_type == 1:
layer1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.first_output,
kernel_size=7,
stride=2,
padding=3,
bnName=self.bnName,
activationName=self.activationName)
self.add_block_list(layer1.get_name(), layer1, self.first_output)
layer2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.add_block_list(LayerType.MyMaxPool2d, layer2,
self.first_output)
elif self.head_type == 2:
layer1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.first_output,
kernel_size=3,
stride=2,
padding=1,
bnName=self.bnName,
activationName=self.activationName)
self.add_block_list(layer1.get_name(), layer1, self.first_output)
layer11 = ConvBNActivationBlock(in_channels=self.first_output,
out_channels=self.first_output,
kernel_size=3,
stride=1,
padding=1,
bnName=self.bnName,
activationName=self.activationName)
self.add_block_list(layer11.get_name(), layer11, self.first_output)
layer12 = ConvBNActivationBlock(in_channels=self.first_output,
out_channels=self.first_output,
kernel_size=3,
stride=1,
padding=1,
bnName=self.bnName,
activationName=self.activationName)
self.add_block_list(layer12.get_name(), layer12, self.first_output)
self.in_channels = self.first_output
for index, num_block in enumerate(self.num_blocks):
self.make_resnet_block(self.out_channels[index],
self.num_blocks[index], self.strides[index],
self.dilations[index], self.bnName,
self.activationName, self.block_flag)
self.in_channels = self.block_out_channels[-1]
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.clear_list()
# building first layer
output_channel = self.make_divisible(16 * self.width_mult, 8)
layer1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=output_channel,
kernel_size=3,
stride=2,
padding=1,
bias=False,
bnName=self.bn_name,
activationName=ActivationType.HSwish)
self.add_block_list(layer1.get_name(), layer1, output_channel)
input_channel = output_channel
output_channel = self.make_layer(input_channel, InvertedResidual,
self.cfgs)
# building last several layers
input_channel = self.block_out_channels[-1]
layer2 = ConvBNActivationBlock(in_channels=input_channel,
out_channels=output_channel,
kernel_size=1,
stride=1,
padding=0,
bias=False,
bnName=self.bn_name,
activationName=ActivationType.HSwish)
self.add_block_list(layer2.get_name(), layer2, output_channel)
if self.mode == 'small':
layer3 = SEBlock(in_channel=output_channel, reduction=4)
self.add_block_list(layer3.get_name(), layer3, output_channel)
def create_block_list(self):
self.clear_list()
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=self.first_output,
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, self.first_output)
for index, num_block in enumerate(self.num_blocks):
self._make_layer(num_block, self.out_channels[index], self.strides[index])
def create_block_list(self):
self.clear_list()
# building first layer
output_channel = self.make_divisible(16 * self.width_mult, 4)
layer1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=output_channel,
kernel_size=3,
stride=2,
padding=1,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(layer1.get_name(), layer1, output_channel)
input_channel = output_channel
output_channel = self.make_layer(input_channel, GhostBottleneck,
self.cfgs)
# building last several layers
input_channel = self.block_out_channels[-1]
layer2 = ConvBNActivationBlock(in_channels=input_channel,
out_channels=output_channel,
kernel_size=1,
stride=1,
padding=0,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(layer2.get_name(), layer2, output_channel)
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 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 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 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 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 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 make_conv_block(self, input_channel, output_channel):
conv1 = ConvBNActivationBlock(input_channel, 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, output_channel)
temp_input_channel = self.block_out_channels[-1]
temp_output_channel = output_channel * 2
conv2 = ConvBNActivationBlock(temp_input_channel, temp_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, temp_output_channel)
temp_input_channel = self.block_out_channels[-1]
temp_output_channel = output_channel
conv3 = ConvBNActivationBlock(temp_input_channel, temp_output_channel,
kernel_size=1, stride=1, padding=0,
bnName=self.bn_name, activationName=self.activation_name)
self.add_block_list(conv3.get_name(), conv3, temp_output_channel)
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 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, 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)
def create_block_list(self):
self.clear_list()
layer1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.first_output,
kernel_size=3,
stride=2,
padding=1,
bnName=self.bnName,
activationName=self.activationName)
self.add_block_list(layer1.get_name(), layer1, self.first_output)
for index, num_block in enumerate(self.num_blocks):
self.make_darknet_layer(self.out_channels[index],
self.num_blocks[index],
self.strides[index], self.dilations[index],
self.bnName, self.activationName)
self.in_channel = self.block_out_channels[-1]
def create_block_list(self):
self.block_out_channels = []
self.index = 0
layer1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.first_output,
kernel_size=3,
stride=1,
padding=1,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(layer1.get_name(), layer1, self.first_output)
for index, num_block in enumerate(self.num_blocks):
self.make_layer(self.in_planes[index], self.out_channels[index],
num_block, self.dense_depths[index],
self.strides[index])
def create_block_list(self):
self.clear_list()
backbone = self.factory.get_base_model(BackboneName.ResNet101)
base_out_channels = backbone.get_outchannel_list()
self.add_block_list(BlockType.BaseNet, backbone, base_out_channels[-1])
if self.is_jpu:
jup = JPUBlock(layers='4,8,31,34',
in_planes=(512, 1024, 2048),
width=512,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(jup.get_name(), jup, 512 + 512 + 512 + 512)
scale_factor = 8
else:
scale_factor = 32
psp = PyramidPooling(2048,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(psp.get_name(), psp, 2048 * 2)
conv1 = ConvBNActivationBlock(in_channels=2048 * 2,
out_channels=512,
kernel_size=3,
padding=1,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(conv1.get_name(), conv1, 512)
dropout = nn.Dropout(0.1)
self.add_block_list(LayerType.Dropout, dropout,
self.block_out_channels[-1])
conv2 = nn.Conv2d(512, self.class_number, 1)
self.add_block_list(LayerType.Convolutional, conv2, self.class_number)
layer = Upsample(scale_factor=scale_factor, mode='bilinear')
self.add_block_list(layer.get_name(), layer,
self.block_out_channels[-1])
self.create_loss()
def create_block_list(self):
self.clear_list()
conv1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.first_output,
kernel_size=7,
stride=2,
padding=3,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(conv1.get_name(), conv1, self.first_output)
maxpool = nn.MaxPool2d(3, 2, 1)
self.add_block_list(LayerType.MyMaxPool2d, maxpool, 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])
def learning_to_downsample(self):
conv = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=32,
kernel_size=3,
stride=2,
padding=0,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(conv.get_name(), conv, 32)
dsconv1 = SeparableConv2dBNActivation(32, 48, stride=2, relu_first=False,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(dsconv1.get_name(), dsconv1, 48)
dsconv2 = SeparableConv2dBNActivation(48, self.first_output, stride=2, relu_first=False,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(dsconv2.get_name(), dsconv2, self.first_output)
def create_block_list(self):
self.clear_list()
layer1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.num_init_features,
kernel_size=7,
stride=2,
padding=3,
bnName=self.bnName,
activationName=self.activationName)
self.add_block_list(layer1.get_name(), layer1, self.num_init_features)
layer2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.add_block_list(LayerType.MyMaxPool2d, layer2,
self.num_init_features)
self.in_channels = self.num_init_features
for index, num_block in enumerate(self.num_blocks):
self.make_densenet_layer(num_block, self.dilations[index],
self.bn_size, self.growth_rate,
self.drop_rate, self.bnName,
self.activationName)
self.in_channels = self.block_out_channels[-1]
if index != len(self.num_blocks) - 1:
trans = TransitionBlock(in_channel=self.in_channels,
output_channel=self.in_channels // 2,
stride=1,
bnName=self.bnName,
activationName=self.activationName)
self.add_block_list(trans.get_name(), trans,
self.in_channels // 2)
avg_pool = nn.AvgPool2d(kernel_size=2, stride=2)
self.add_block_list(LayerType.GlobalAvgPool, avg_pool,
self.block_out_channels[-1])
self.in_channels = self.block_out_channels[-1]
layer3 = NormalizeLayer(bn_name=self.bnName,
out_channel=self.in_channels)
self.add_block_list(layer3.get_name(), layer3, self.in_channels)
layer4 = ActivationLayer(self.activationName, False)
self.add_block_list(layer4.get_name(), layer4, self.in_channels)
def create_block_list(self):
self.block_out_channels = []
self.index = 0
layer1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.first_output,
kernel_size=3,
stride=1,
padding=1,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(layer1.get_name(), layer1, self.first_output)
self.make_layer(self.first_output, self.num_cells)
self.downsample(self.first_output * 2)
self.make_layer(self.first_output * 2, self.num_cells)
self.downsample(self.first_output * 4)
self.make_layer(self.first_output * 4, self.num_cells)
def create_block_list(self):
self.block_out_channels = []
self.index = 0
conv1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=8,
kernel_size=3,
stride=2,
padding=1,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(conv1.get_name(), conv1, 8)
self.make_layer(8, 48, 4)
self.make_layer(48, 96, 6)
self.make_layer(96, 192, 4)
fca = FCAttention(192,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(fca.get_name(), fca, 192)
def create_block_list(self):
self.block_out_channels = []
self.index = 0
stem = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.first_output,
kernel_size=3,
padding=1,
bias=False,
bnName=self.bn_name,
activationName=ActivationType.Linear)
self.add_block_list(stem.get_name(), stem, self.first_output)
for i in range(self.reduction_num):
self.make_normal(NormalCell, self.repeat_cell_num, self.filters)
self.filters *= 2
self.make_reduction(ReductionCell, self.filters)
self.make_normal(NormalCell, self.repeat_cell_num, self.filters)
relu = ActivationLayer(activation_name=self.activation_name,
inplace=False)
self.add_block_list(relu.get_name(), relu, self.filters * 6)
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):
# down
if mod_id <= 4:
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=1,
dilation=1,
bn_name=self.bn_name,
activation=self.activation_name)
def entry_flow(self, entry_block3_stride):
# Entry flow
conv1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=32,
kernel_size=3,
stride=2,
padding=1,
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=64,
kernel_size=3,
stride=1,
padding=1,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(conv2.get_name(), conv2, 64)
block1 = XceptionConvBlock([64, 128, 128, 128],
stride=2,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(block1.get_name(), block1, 128)
double_sep_conv1 = DoubleSeparableConv2dBlock(
[128, 256, 256],
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(double_sep_conv1.get_name(), double_sep_conv1, 256)
sep_conv1 = SeparableConv2dBNActivation(
inplanes=256,
planes=256,
dilation=1,
stride=2,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(sep_conv1.get_name(), sep_conv1, 256)
layer1 = RouteLayer('-3')
output_channel = sum(
[self.block_out_channels[i] for i in layer1.layers])
self.add_block_list(layer1.get_name(), layer1, output_channel)
conv3 = ConvBNActivationBlock(in_channels=128,
out_channels=256,
kernel_size=1,
stride=2,
bias=False,
bnName=self.bn_name,
activationName=ActivationType.Linear)
self.add_block_list(conv3.get_name(), conv3, 256)
layer2 = AddLayer('-3,-1')
output_channel = 256
self.add_block_list(layer2.get_name(), layer2, output_channel)
double_sep_conv2 = DoubleSeparableConv2dBlock(
[256, 728, 728],
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(double_sep_conv2.get_name(), double_sep_conv2, 728)
sep_conv2 = SeparableConv2dBNActivation(
inplanes=728,
planes=728,
dilation=1,
stride=entry_block3_stride,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(sep_conv2.get_name(), sep_conv2, 728)
layer3 = RouteLayer('-3')
output_channel = sum(
[self.block_out_channels[i] for i in layer3.layers])
self.add_block_list(layer3.get_name(), layer3, output_channel)
conv4 = ConvBNActivationBlock(in_channels=256,
out_channels=728,
kernel_size=1,
stride=entry_block3_stride,
bias=False,
bnName=self.bn_name,
activationName=ActivationType.Linear)
self.add_block_list(conv4.get_name(), conv4, 728)
layer4 = AddLayer('-3,-1')
output_channel = 728
self.add_block_list(layer4.get_name(), layer4, output_channel)
def create_block_list(self):
self.clear_list()
spatial_path = SpatialPath(self.data_channel,
128,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(spatial_path.get_name(), spatial_path, 128)
backbone = self.factory.get_base_model(BackboneName.ResNet18)
base_out_channels = backbone.get_outchannel_list()
self.add_block_list(BlockType.BaseNet, backbone, base_out_channels[-1])
inter_channels = 128
global_context = GlobalAvgPooling(512,
inter_channels,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(global_context.get_name(), global_context,
base_out_channels[-1])
layer1 = RouteLayer('9')
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)
context_path1 = ContextPath(512,
inter_channels,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(context_path1.get_name(), context_path1,
inter_channels)
layer2 = RouteLayer('7')
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)
context_path2 = ContextPath(256,
inter_channels,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(context_path2.get_name(), context_path2,
inter_channels)
ffm = FeatureFusionBlock(256,
256,
4,
bn_name=self.bn_name,
activation_name=self.activation_name)
self.add_block_list(ffm.get_name(), ffm, 256)
conv1 = ConvBNActivationBlock(in_channels=256,
out_channels=64,
kernel_size=3,
padding=1,
bias=False,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(conv1.get_name(), conv1, 64)
dropout = nn.Dropout(0.1)
self.add_block_list(LayerType.Dropout, dropout,
self.block_out_channels[-1])
conv2 = nn.Conv2d(64, self.class_number, 1)
self.add_block_list(LayerType.Convolutional, conv2, self.class_number)
layer = Upsample(scale_factor=8, mode='bilinear')
self.add_block_list(layer.get_name(), layer,
self.block_out_channels[-1])
self.create_loss()
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,
dilation=1,
bnName=self.bnName,
activationName=self.activationName)
self.add_block_list(layer1.get_name(), layer1, self.first_output)
self.input_channel = self.first_output
planes = (64, 96, 128, 16, 32, 32)
layer2 = InceptionBlock(self.input_channel,
planes,
bnName=self.bnName,
activationName=self.activationName)
output_channel = planes[0] + planes[2] + planes[4] + planes[5]
self.add_block_list(layer2.get_name(), layer2, output_channel)
self.input_channel = self.block_out_channels[-1]
planes = (128, 128, 192, 32, 96, 64)
layer3 = InceptionBlock(self.input_channel,
planes,
bnName=self.bnName,
activationName=self.activationName)
output_channel = planes[0] + planes[2] + planes[4] + planes[5]
self.add_block_list(layer3.get_name(), layer3, output_channel)
maxpool1 = nn.MaxPool2d(2, stride=2, padding=0)
self.add_block_list(LayerType.MyMaxPool2d, maxpool1,
self.block_out_channels[-1])
self.input_channel = self.block_out_channels[-1]
planes = (192, 96, 208, 16, 48, 64)
layer4 = InceptionBlock(self.input_channel,
planes,
bnName=self.bnName,
activationName=self.activationName)
output_channel = planes[0] + planes[2] + planes[4] + planes[5]
self.add_block_list(layer4.get_name(), layer4, output_channel)
self.input_channel = self.block_out_channels[-1]
planes = (160, 112, 224, 24, 64, 64)
layer5 = InceptionBlock(self.input_channel,
planes,
bnName=self.bnName,
activationName=self.activationName)
output_channel = planes[0] + planes[2] + planes[4] + planes[5]
self.add_block_list(layer5.get_name(), layer5, output_channel)
self.input_channel = self.block_out_channels[-1]
planes = (128, 128, 256, 24, 64, 64)
layer6 = InceptionBlock(self.input_channel,
planes,
bnName=self.bnName,
activationName=self.activationName)
output_channel = planes[0] + planes[2] + planes[4] + planes[5]
self.add_block_list(layer6.get_name(), layer6, output_channel)
self.input_channel = self.block_out_channels[-1]
planes = (112, 144, 288, 32, 64, 64)
layer7 = InceptionBlock(self.input_channel,
planes,
bnName=self.bnName,
activationName=self.activationName)
output_channel = planes[0] + planes[2] + planes[4] + planes[5]
self.add_block_list(layer7.get_name(), layer7, output_channel)
self.input_channel = self.block_out_channels[-1]
planes = (256, 160, 320, 32, 128, 128)
layer8 = InceptionBlock(self.input_channel,
planes,
bnName=self.bnName,
activationName=self.activationName)
output_channel = planes[0] + planes[2] + planes[4] + planes[5]
self.add_block_list(layer8.get_name(), layer8, output_channel)
maxpool2 = nn.MaxPool2d(2, stride=2, padding=0)
self.add_block_list(LayerType.MyMaxPool2d, maxpool2,
self.block_out_channels[-1])
self.input_channel = self.block_out_channels[-1]
planes = (256, 160, 320, 32, 128, 128)
layer9 = InceptionBlock(self.input_channel,
planes,
bnName=self.bnName,
activationName=self.activationName)
output_channel = planes[0] + planes[2] + planes[4] + planes[5]
self.add_block_list(layer9.get_name(), layer9, output_channel)
self.input_channel = self.block_out_channels[-1]
planes = (384, 192, 384, 48, 128, 128)
layer10 = InceptionBlock(self.input_channel,
planes,
bnName=self.bnName,
activationName=self.activationName)
output_channel = planes[0] + planes[2] + planes[4] + planes[5]
self.add_block_list(layer10.get_name(), layer10, output_channel)
def create_block_list(self):
self.block_out_channels = []
self.index = 0
backbone = self.factory.get_base_model(BackboneName.Vgg16)
base_out_channels = backbone.get_outchannel_list()
self.add_block_list(BlockType.BaseNet, backbone, base_out_channels[-1])
layer1 = ConvBNActivationBlock(in_channels=base_out_channels[-1],
out_channels=4096,
kernel_size=7,
padding=3,
bias=True,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(layer1.get_name(), layer1, 4096)
dropout1 = nn.Dropout()
self.add_block_list(LayerType.Dropout, dropout1, 4096)
layer2 = ConvBNActivationBlock(in_channels=4096,
out_channels=4096,
kernel_size=1,
padding=0,
bias=True,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(layer2.get_name(), layer2, 4096)
dropout2 = nn.Dropout()
self.add_block_list(LayerType.Dropout, dropout2, 4096)
layer3 = nn.Conv2d(4096, self.class_number, kernel_size=1)
self.add_block_list(LayerType.Convolutional, layer3, self.class_number)
upsample1 = Upsample(scale_factor=2, mode='bilinear')
self.add_block_list(LayerType.Upsample, upsample1,
self.block_out_channels[-1])
layer4 = RouteLayer('13')
output_channel = sum([
base_out_channels[i] if i >= 0 else self.block_out_channels[i]
for i in layer4.layers
])
self.add_block_list(layer4.get_name(), layer4, output_channel)
layer5 = nn.Conv2d(512, self.class_number, kernel_size=1)
self.add_block_list(LayerType.Convolutional, layer5, self.class_number)
layer6 = AddLayer('-1,-3')
index = layer6.layers[0]
output_channel = base_out_channels[
index] if index >= 0 else self.block_out_channels[index]
self.add_block_list(layer6.get_name(), layer6, output_channel)
layer7 = RouteLayer('9')
output_channel = sum([
base_out_channels[i] if i >= 0 else self.block_out_channels[i]
for i in layer7.layers
])
self.add_block_list(layer7.get_name(), layer7, output_channel)
layer8 = nn.Conv2d(256, self.class_number, kernel_size=1)
self.add_block_list(LayerType.Convolutional, layer8, self.class_number)
layer9 = RouteLayer('-3')
output_channel = sum([
base_out_channels[i] if i >= 0 else self.block_out_channels[i]
for i in layer7.layers
])
self.add_block_list(layer9.get_name(), layer9, output_channel)
upsample2 = Upsample(scale_factor=2, mode='bilinear')
self.add_block_list(LayerType.Upsample, upsample2,
self.block_out_channels[-1])
layer10 = AddLayer('-1,-3')
index = layer10.layers[0]
output_channel = base_out_channels[
index] if index >= 0 else self.block_out_channels[index]
self.add_block_list(layer10.get_name(), layer10, output_channel)
upsample3 = Upsample(scale_factor=8, mode='bilinear')
self.add_block_list(LayerType.Upsample, upsample3,
self.block_out_channels[-1])
self.create_loss()