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)