def create_block_list(self): self.clear_list() backbone = self.factory.get_base_model(BackboneName.GhostNet, self.data_channel) base_out_channels = backbone.get_outchannel_list() self.add_block_list(BlockType.BaseNet, backbone, base_out_channels[-1]) avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.add_block_list(LayerType.GlobalAvgPool, avgpool, base_out_channels[-1]) output_channel = 1280 layer1 = FcLayer(base_out_channels[-1], output_channel) self.add_block_list(layer1.get_name(), layer1, output_channel) layer2 = NormalizeLayer(bn_name=NormalizationType.BatchNormalize1d, out_channel=output_channel) self.add_block_list(layer2.get_name(), layer2, output_channel) layer3 = ActivationLayer(self.activation_name, inplace=False) self.add_block_list(layer3.get_name(), layer3, output_channel) layer4 = nn.Dropout(0.2) self.add_block_list(LayerType.Dropout, layer4, output_channel) layer5 = nn.Linear(output_channel, self.class_number) self.add_block_list(LayerType.FcLinear, layer5, self.class_number) self.create_loss()
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() backbone = PointNet(data_channel=self.data_channel, feature_transform=self.feature_transform, bn_name=self.bn_name, activation_name=self.activation_name) base_out_channels = backbone.get_outchannel_list() self.add_block_list(BlockType.BaseNet, backbone, base_out_channels[-1]) input_channel = self.block_out_channels[-1] fc1 = FcBNActivationBlock(input_channel, 512, bnName=self.bn_name, activationName=self.activation_name) self.add_block_list(fc1.get_name(), fc1, 512) input_channel = 512 fc2 = nn.Linear(input_channel, 256) self.add_block_list(LayerType.FcLinear, fc2, 256) input_channel = 256 dropout = nn.Dropout(p=0.3) self.add_block_list(LayerType.Dropout, dropout, input_channel) normalize = NormalizeLayer(self.bn_name, input_channel) self.add_block_list(normalize.get_name(), normalize, input_channel) activate = ActivationLayer(self.activation_name, inplace=False) self.add_block_list(activate.get_name(), activate, input_channel) fc3 = nn.Linear(input_channel, self.class_number) self.add_block_list(LayerType.FcLinear, fc3, self.class_number) self.create_loss()
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_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, 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_channel, reduction=16, activate_name=ActivationType.ReLU): super().__init__(BlockType.SEBlock) # self.avg_pool = GlobalAvgPool2d() self.avg_pool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Sequential(nn.Linear(in_channel, in_channel // reduction), ActivationLayer(activate_name), nn.Linear(in_channel // reduction, in_channel), nn.Sigmoid())
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 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.clear_list() backbone = self.factory.get_base_model(BackboneName.Vgg19, self.data_channel) base_out_channels = backbone.get_outchannel_list() self.add_block_list(BlockType.BaseNet, backbone, base_out_channels[-1]) # avgpool = nn.AdaptiveAvgPool2d((7, 7)) layer1 = FcLayer(base_out_channels[-1], 4096) self.add_block_list(layer1.get_name(), layer1, 4096) layer2 = ActivationLayer(self.activation_name, inplace=False) self.add_block_list(layer2.get_name(), layer2, 4096) layer3 = nn.Dropout() self.add_block_list(LayerType.Dropout, layer3, 4096) layer4 = nn.Linear(4096, 4096) self.add_block_list(LayerType.FcLinear, layer4, 4096) layer5 = ActivationLayer(self.activation_name, inplace=False) self.add_block_list(layer5.get_name(), layer5, 4096) layer6 = nn.Dropout() self.add_block_list(LayerType.Dropout, layer6, 4096) layer7 = nn.Linear(4096, self.class_number) self.add_block_list(LayerType.FcLinear, layer7, self.class_number) self.create_loss()
def __init__(self, in_planes, out_planes, stages, activation_name=ActivationType.ReLU): super().__init__(RefineNetBlockName.RefineNetBlock) self.activate = ActivationLayer(activation_name, inplace=False) self.mflow = CRPBlock(in_planes, out_planes, stages) self.conv1 = nn.Conv2d(out_planes, 256, 1, bias=False) self.up = Upsample(scale_factor=2, mode='bilinear') self.conv2 = nn.Conv2d(256, 256, 1, bias=False)
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 __init__(self, in_channel, kernel_size, padding=0, stride=1, dilation=1, bias=False, bn_name=NormalizationType.BatchNormalize2d, activation_name=ActivationType.ReLU): super().__init__(BlockType.DepthwiseConv2dBlock) conv = nn.Conv2d(in_channel, in_channel, kernel_size, padding=padding, stride=stride, dilation=dilation, groups=in_channel, bias=bias) normal = NormalizeLayer(bn_name, in_channel) activation = ActivationLayer(activation_name) self.block = nn.Sequential(OrderedDict([ (LayerType.Convolutional, conv), (bn_name, normal), (activation_name, activation) ]))
def __init__(self, input_channel, bn_name=NormalizationType.BatchNormalize2d, activation_name=ActivationType.ReLU): super().__init__(InceptionBlockName.InceptionResNetA) self.branch3x3stack = nn.Sequential( ConvBNActivationBlock(input_channel, 32, kernel_size=1, bnName=bn_name, activationName=activation_name), ConvBNActivationBlock(32, 48, kernel_size=3, padding=1, bnName=bn_name, activationName=activation_name), ConvBNActivationBlock(48, 64, kernel_size=3, padding=1, bnName=bn_name, activationName=activation_name)) self.branch3x3 = nn.Sequential( ConvBNActivationBlock(input_channel, 32, kernel_size=1, bnName=bn_name, activationName=activation_name), ConvBNActivationBlock(32, 32, kernel_size=3, padding=1, bnName=bn_name, activationName=activation_name)) self.branch1x1 = ConvBNActivationBlock(input_channel, 32, kernel_size=1, bnName=bn_name, activationName=activation_name) self.reduction1x1 = nn.Conv2d(128, 384, kernel_size=1) self.shortcut = nn.Conv2d(input_channel, 384, kernel_size=1) self.bn = NormalizeLayer(bn_name=bn_name, out_channel=384) self.relu = ActivationLayer(activation_name=activation_name, inplace=False)
def create_layer(self, module_def): if module_def['type'] == LayerType.MyMaxPool2d: kernel_size = int(module_def['size']) stride = int(module_def['stride']) maxpool = MyMaxPool2d(kernel_size, stride) self.addBlockList(LayerType.MyMaxPool2d, maxpool, self.filters) self.input_channels = self.filters elif module_def['type'] == LayerType.GlobalAvgPool: globalAvgPool = GlobalAvgPool2d() self.addBlockList(LayerType.GlobalAvgPool, globalAvgPool, self.filters) self.input_channels = self.filters elif module_def['type'] == LayerType.FcLayer: num_output = int(module_def['num_output']) self.filters = num_output layer = FcLayer(self.input_channels, num_output) self.addBlockList(LayerType.FcLayer, layer, num_output) self.input_channels = num_output elif module_def['type'] == LayerType.Upsample: scale = int(module_def['stride']) mode = module_def.get('model', 'bilinear') upsample = Upsample(scale_factor=scale, mode=mode) self.addBlockList(LayerType.Upsample, upsample, self.filters) self.input_channels = self.filters elif module_def['type'] == LayerType.MultiplyLayer: layer = MultiplyLayer(module_def['layers']) self.addBlockList(LayerType.MultiplyLayer, layer, self.filters) self.input_channels = self.filters elif module_def['type'] == LayerType.AddLayer: layer = AddLayer(module_def['layers']) self.addBlockList(LayerType.AddLayer, layer, self.filters) self.input_channels = self.filters elif module_def['type'] == LayerType.Dropout: probability = float(module_def['probability']) layer = nn.Dropout(p=probability, inplace=False) self.addBlockList(LayerType.Dropout, layer, self.filters) self.input_channels = self.filters elif module_def['type'] == LayerType.NormalizeLayer: bn_name = module_def['batch_normalize'].strip() layer = NormalizeLayer(bn_name, self.filters) self.addBlockList(LayerType.NormalizeLayer, layer, self.filters) self.input_channels = self.filters elif module_def['type'] == LayerType.ActivationLayer: activation_name = module_def['activation'].strip() layer = ActivationLayer(activation_name, inplace=False) self.addBlockList(LayerType.ActivationLayer, layer, self.filters) self.input_channels = self.filters
def __init__(self, in_channels, out_channels, stride=1, dilation=1, start_with_relu=True, bn_name=NormalizationType.BatchNormalize2d, activation_name=ActivationType.ReLU): super().__init__(XceptionBlockName.BlockA) if out_channels != in_channels or stride != 1: self.skip = ConvBNActivationBlock(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=stride, bias=False, bnName=bn_name, activationName=ActivationType.Linear) else: self.skip = None self.relu = ActivationLayer(activation_name, inplace=False) rep = list() inter_channels = out_channels // 4 if start_with_relu: rep.append(self.relu) rep.append(SeparableConv2dBNActivation(in_channels, inter_channels, 3, 1, dilation, bn_name=bn_name, activation_name=activation_name)) rep.append(NormalizeLayer(bn_name, inter_channels)) rep.append(self.relu) rep.append(SeparableConv2dBNActivation(inter_channels, inter_channels, 3, 1, dilation, bn_name=bn_name, activation_name=activation_name)) rep.append(NormalizeLayer(bn_name, inter_channels)) if stride != 1: rep.append(self.relu) rep.append(SeparableConv2dBNActivation(inter_channels, out_channels, 3, stride, bn_name=bn_name, activation_name=activation_name)) rep.append(NormalizeLayer(bn_name, out_channels)) else: rep.append(self.relu) rep.append(SeparableConv2dBNActivation(inter_channels, out_channels, 3, 1, bn_name=bn_name, activation_name=activation_name)) rep.append(NormalizeLayer(bn_name, out_channels)) self.rep = nn.Sequential(*rep)
def __init__(self, in_channels, out_channels, stride, reduction=16, bn_name=NormalizationType.BatchNormalize2d, activation_name=ActivationType.ReLU): super().__init__(SeNetBlockName.BottleneckResidualSEBlock) self.residual = nn.Sequential( ConvBNActivationBlock(in_channels=in_channels, out_channels=out_channels, kernel_size=1, bnName=bn_name, activationName=activation_name), ConvBNActivationBlock(in_channels=out_channels, out_channels=out_channels, kernel_size=3, stride=stride, padding=1, bnName=bn_name, activationName=activation_name), ConvBNActivationBlock(in_channels=out_channels, out_channels=out_channels * self.expansion, kernel_size=1, bnName=bn_name, activationName=activation_name)) self.se_block = SEBlock(out_channels * self.expansion, reduction) self.shortcut = nn.Sequential() if stride != 1 or in_channels != out_channels * self.expansion: self.shortcut = ConvBNActivationBlock( in_channels=in_channels, out_channels=out_channels * self.expansion, kernel_size=1, stride=stride, bnName=bn_name, activationName=ActivationType.Linear) self.relu = ActivationLayer(activation_name=activation_name, inplace=False)
def __init__(self, highter_in_channels, lower_in_channels, out_channels, scale_factor=4, bn_name=NormalizationType.BatchNormalize2d, activation_name=ActivationType.ReLU): super().__init__(FastSCNNBlockName.FeatureFusionBlock) self.scale_factor = scale_factor self.dwconv = ConvBNActivationBlock(in_channels=lower_in_channels, out_channels=out_channels, kernel_size=1, bnName=bn_name, activationName=activation_name) self.conv_lower_res = ConvBNActivationBlock(in_channels=out_channels, out_channels=out_channels, kernel_size=1, bnName=bn_name, activationName=ActivationType.Linear) self.conv_higher_res = ConvBNActivationBlock(in_channels=highter_in_channels, out_channels=out_channels, kernel_size=1, bnName=bn_name, activationName=ActivationType.Linear) self.relu = ActivationLayer(activation_name, inplace=False)
def __init__(self, in_channels, middle_channels, out_channels, activation_name=ActivationType.ReLU, is_deconv=True): super().__init__(TernausNetBlockName.DecoderBlock) if is_deconv: self.block = nn.Sequential( ConvActivationBlock(in_channels=in_channels, out_channels=middle_channels, kernel_size=3, padding=1, activationName=activation_name), # nn.ConvTranspose2d(middle_channels, out_channels, kernel_size=4, stride=2, # padding=1), nn.ConvTranspose2d(middle_channels, out_channels, kernel_size=3, stride=2, padding=1, output_padding=1), ActivationLayer(activation_name), ) else: self.block = nn.Sequential( Upsample(scale_factor=2, mode='bilinear'), ConvActivationBlock(in_channels=in_channels, out_channels=middle_channels, kernel_size=3, padding=1, activationName=activation_name), ConvActivationBlock(in_channels=middle_channels, out_channels=out_channels, kernel_size=3, padding=1, activationName=activation_name), )
def __init__(self, inplanes, planes, stride=1, downsample=None, bn_name=NormalizationType.BatchNormalize2d, activation_name=ActivationType.ReLU): super().__init__(DFNetBlockName.BasicBlock) self.conv1 = ConvBNActivationBlock(in_channels=inplanes, out_channels=planes, kernel_size=3, stride=stride, padding=1, bias=False, bnName=bn_name, activationName=activation_name) self.conv2 = ConvBNActivationBlock(in_channels=planes, out_channels=planes, kernel_size=3, stride=1, padding=1, bias=False, bnName=bn_name, activationName=ActivationType.Linear) self.relu = ActivationLayer(activation_name=activation_name) self.downsample = downsample self.stride = stride
def __init__(self, input_channel, bn_name=NormalizationType.BatchNormalize2d, activation_name=ActivationType.ReLU): # Figure 19. The schema for 8×8 grid (Inception-ResNet-C) # module of the Inception-ResNet-v2 network.""" super().__init__(InceptionBlockName.InceptionResNetC) self.branch3x3 = nn.Sequential( ConvBNActivationBlock(input_channel, 192, kernel_size=1, bnName=bn_name, activationName=activation_name), ConvBNActivationBlock(192, 224, kernel_size=(1, 3), padding=(0, 1), bnName=bn_name, activationName=activation_name), ConvBNActivationBlock(224, 256, kernel_size=(3, 1), padding=(1, 0), bnName=bn_name, activationName=activation_name)) self.branch1x1 = ConvBNActivationBlock(input_channel, 192, kernel_size=1, bnName=bn_name, activationName=activation_name) self.reduction1x1 = nn.Conv2d(448, 2048, kernel_size=1) self.shorcut = nn.Conv2d(input_channel, 2048, kernel_size=1) self.bn = NormalizeLayer(bn_name=bn_name, out_channel=2048) self.relu = ActivationLayer(activation_name=activation_name, inplace=False)
def __init__(self, input_channel, bn_name=NormalizationType.BatchNormalize2d, activation_name=ActivationType.ReLU): super().__init__(InceptionBlockName.InceptionResNetB) self.branch7x7 = nn.Sequential( ConvBNActivationBlock(input_channel, 128, kernel_size=1, bnName=bn_name, activationName=activation_name), ConvBNActivationBlock(128, 160, kernel_size=(1, 7), padding=(0, 3), bnName=bn_name, activationName=activation_name), ConvBNActivationBlock(160, 192, kernel_size=(7, 1), padding=(3, 0), bnName=bn_name, activationName=activation_name)) self.branch1x1 = ConvBNActivationBlock(input_channel, 192, kernel_size=1, bnName=bn_name, activationName=activation_name) self.reduction1x1 = nn.Conv2d(384, 1154, kernel_size=1) self.shortcut = nn.Conv2d(input_channel, 1154, kernel_size=1) self.bn = NormalizeLayer(bn_name=bn_name, out_channel=1154) self.relu = ActivationLayer(activation_name=activation_name, inplace=False)
def __init__(self, in_channels, channels, stride=1, dilation=1, groups=1, dropout=None, dist_bn=False, bn_name=NormalizationType.BatchNormalize2d, activation_name=ActivationType.ReLU): super().__init__(WiderResNetBlockName.IdentityResidualBlock) # Check parameters for inconsistencies if len(channels) != 2 and len(channels) != 3: raise ValueError( "channels must contain either two or three values") if len(channels) == 2 and groups != 1: raise ValueError("groups > 1 are only valid if len(channels) == 3") self.dist_bn = dist_bn is_bottleneck = len(channels) == 3 need_proj_conv = stride != 1 or in_channels != channels[-1] self.normal = NormalizeLayer(bn_name, in_channels) self.activate = ActivationLayer(activation_name, inplace=False) if not is_bottleneck: layers = [("conv1", ConvBNActivationBlock(in_channels=in_channels, out_channels=channels[0], kernel_size=3, stride=stride, padding=dilation, dilation=dilation, bias=False, bnName=bn_name, activationName=activation_name)), ("conv2", nn.Conv2d(channels[0], channels[1], kernel_size=3, stride=1, padding=dilation, dilation=dilation, bias=False))] if dropout is not None: layers = [layers[0], ("dropout", dropout()), layers[1]] else: layers = [("conv1", ConvBNActivationBlock(in_channels=in_channels, out_channels=channels[0], kernel_size=1, stride=stride, padding=0, bias=False, bnName=bn_name, activationName=activation_name)), ("conv2", ConvBNActivationBlock(in_channels=channels[0], out_channels=channels[1], kernel_size=3, stride=1, padding=dilation, dilation=dilation, groups=groups, bias=False, bnName=bn_name, activationName=activation_name)), ("conv3", nn.Conv2d(channels[1], channels[2], kernel_size=1, stride=1, padding=0, bias=False))] if dropout is not None: layers = [ layers[0], layers[1], ("dropout", dropout()), layers[2] ] self.convs = nn.Sequential(OrderedDict(layers)) self.shortcut = nn.Sequential() if need_proj_conv: self.shortcut = nn.Conv2d(in_channels, channels[-1], kernel_size=1, stride=stride, padding=0, bias=False)
def __init__(self, inp, hidden_dim, oup, kernel_size, stride, use_se, bn_name=NormalizationType.BatchNormalize2d, activation_name=ActivationType.ReLU): super().__init__(MobileNetBlockName.InvertedResidual) assert stride in [1, 2] self.identity = stride == 1 and inp == oup if inp == hidden_dim: self.conv = nn.Sequential( # dw ConvBNActivationBlock(in_channels=hidden_dim, out_channels=hidden_dim, kernel_size=kernel_size, stride=stride, padding=(kernel_size - 1) // 2, groups=hidden_dim, bias=False, bnName=bn_name, activationName=activation_name), # Squeeze-and-Excite SEBlock(hidden_dim, reduction=4) if use_se else nn.Sequential(), # pw-linear ConvBNActivationBlock(in_channels=hidden_dim, out_channels=oup, kernel_size=1, stride=1, padding=0, bias=False, bnName=bn_name, activationName=ActivationType.Linear)) else: self.conv = nn.Sequential( # pw ConvBNActivationBlock(in_channels=inp, out_channels=hidden_dim, kernel_size=1, stride=1, padding=0, bias=False, bnName=bn_name, activationName=activation_name), # dw ConvBNActivationBlock(in_channels=hidden_dim, out_channels=hidden_dim, kernel_size=kernel_size, stride=stride, padding=(kernel_size - 1) // 2, groups=hidden_dim, bias=False, bnName=bn_name, activationName=ActivationType.Linear), # Squeeze-and-Excite SEBlock(hidden_dim, reduction=4) if use_se else nn.Sequential(), ActivationLayer(activation_name=activation_name, inplace=False), # pw-linear ConvBNActivationBlock(in_channels=hidden_dim, out_channels=oup, kernel_size=1, stride=1, padding=0, bias=False, bnName=bn_name, activationName=ActivationType.Linear))