def __init__(self, args, num_classes=21): super(DeepLab, self).__init__() self.args = args output_stride = args.out_stride if args.backbone == 'drn': output_stride = 8 if args.backbone.split('-')[0] == 'efficientnet': output_stride = 32 if args.norm == 'gn': norm = gn elif args.norm == 'bn': norm = bn elif args.norm == 'syncbn': norm = syncbn else: print(args.norm, "normalization is not implemented") raise NotImplementedError self.backbone = build_backbone(args) self.aspp = build_aspp(args.backbone, args.out_stride, norm) self.decoder = build_decoder(num_classes, args.backbone, norm) self.classifier = nn.Linear(300, num_classes) if self.args.freeze_bn: self.freeze_bn()
def __init__(self, backbone='resnet', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False, use_iou=True): super(DeepLab, self).__init__() self.use_iou = use_iou if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.decoder = build_decoder(num_classes, backbone, BatchNorm) if self.use_iou: self.maskiou = build_maskiou(num_classes, BatchNorm) if freeze_bn: self.freeze_bn()
def __init__(self, backbone='resnet', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False): super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.decoder = build_decoder(num_classes, backbone, BatchNorm) self.sr_decoder = build_sr_decoder(num_classes, backbone, BatchNorm) self.pointwise = torch.nn.Sequential( torch.nn.Conv2d(num_classes, 3, 1), torch.nn.BatchNorm2d(3), #添加了BN层 torch.nn.ReLU(inplace=True)) self.up_sr_1 = nn.ConvTranspose2d(64, 64, 2, stride=2) self.up_edsr_1 = EDSRConv(64, 64) self.up_sr_2 = nn.ConvTranspose2d(64, 32, 2, stride=2) self.up_edsr_2 = EDSRConv(32, 32) self.up_sr_3 = nn.ConvTranspose2d(32, 16, 2, stride=2) self.up_edsr_3 = EDSRConv(16, 16) self.up_conv_last = nn.Conv2d(16, 3, 1) self.freeze_bn = freeze_bn
def __init__(self, backbone='resnet', output_stride=16, num_classes=19, sync_bn=True, freeze_bn=False, args=None, separate=False): super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm, args) self.aspp = build_aspp(backbone, output_stride, BatchNorm, args, separate) self.decoder = build_decoder(num_classes, backbone, BatchNorm, args, separate) if freeze_bn: self.freeze_bn()
def __init__(self, backbone='resnet_multiscale', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False): super(DeepLabCA, self).__init__() if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.decoder = build_decoder(num_classes, backbone, BatchNorm) self.avg_pool = nn.AdaptiveAvgPool2d(32) # self.se=RCAB(2048+1024+512+256+256,1,16) self.ca = CAM_Module() in_channels = 2048 + 1024 + 512 + 256 + 256 inter_channels = in_channels // 4 # self.conv5c = nn.Sequential(nn.Conv2d(in_channels, inter_channels, 3, padding=1, bias=False), # BatchNorm(inter_channels), # nn.ReLU()) # self.conv5 = nn.Sequential(nn.Conv2d(inter_channels, inter_channels, 3, padding=1, bias=False), # BatchNorm(inter_channels), # nn.ReLU()) # self.conv6 = nn.Sequential(nn.Dropout2d(0.1, False), nn.Conv2d(inter_channels, num_classes, 1)) if freeze_bn: self.freeze_bn()
def __init__( self, Norm, backbone="resnet", output_stride=16, num_classes=3, freeze_bn=False, abn=False, ): super(DeepLabv3, self).__init__() self.abn = abn if backbone == "drn": output_stride = 8 if Norm == "gn": norm = gn elif Norm == "bn": norm = bn elif Norm == "syncbn": norm = syncbn self.backbone = build_backbone(backbone, output_stride, Norm, dec=False, abn=abn) self.aspp = build_aspp(backbone, output_stride, norm, dec=False) if freeze_bn: self.freeze_bn()
def __init__(self, backbone='resnet', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False): super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm)#输出三个 x, feature_map,low_level_feat #self.aspp = build_aspp(backbone, output_stride, BatchNorm) #self.dspp=build_dspp(backbone,output_stride,BatchNorm,modulation=False,adaptive_d= False) self.decoder = build_decoder(num_classes, backbone, BatchNorm) #self.baseline=nn.Sequential(nn.Conv2d(in_channels=2048,out_channels=256,kernel_size=1,stride=1),BatchNorm(256)) #self.denseaspp = build_DenseASPP(BatchNorm) self.stack_resudial = build_stack_resudial_conv(backbone,output_stride,BatchNorm=BatchNorm,modulation=False,adaptive_d=False,deform=True) #self.stack = build_stack_conv(backbone,output_stride,modulation=True,adaptive_d=False,BatchNorm=BatchNorm,deform=True) #self.densedspp = build_densedspp() #self.densedspp_v3 =build_densedspp_v3(modulation=False,adaptive_d = False) #self.decoder_gau =build_decoder_gau(BatchNorm) #self.fpa = build_fpa(2048) #self.conv3x3_dspp_decoder = nn.Conv2d(2048,256,3) if freeze_bn: self.freeze_bn()
def __init__(self, args, backbone='resnet', output_stride=16, num_classes=4, sync_bn=False, freeze_bn=False, depth=50): super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.args = args if self.args.oly_s1 and not self.args.oly_s2: in_channel = 2 pretrn=False elif not self.args.oly_s1 and self.args.oly_s2 and not self.args.rgb: in_channel = 10 pretrn = False elif not self.args.oly_s1 and self.args.oly_s2 and self.args.rgb: in_channel = 3 pretrn = True elif not self.args.oly_s1 and not self.args.oly_s2 and not self.args.rgb: in_channel = 12 pretrn = False elif not self.args.oly_s1 and not self.args.oly_s2 and self.args.rgb: in_channel = 5 pretrn = False else: raise NotImplementedError self.backbone = build_backbone(backbone, in_channel, output_stride, BatchNorm, depth, pretrn) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.decoder = build_decoder(num_classes, backbone, BatchNorm) if freeze_bn: self.freeze_bn()
def __init__(self, backbone='resnet', output_stride=16, num_classes=21, sync_bn=False, freeze_bn=False): super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 if backbone == 'resnet': link_in = 1024 link_out = 1024 elif backbone == 'mobilenet': link_in = 64 link_out = 64 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.link_conv = nn.Sequential(nn.Conv2d(link_in, link_out, kernel_size=1, stride=1, padding=0, bias=False)) self.last_conv = nn.Sequential(nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1, bias=False), BatchNorm(64), nn.ReLU(), nn.Dropout(0.1), nn.Conv2d(64, num_classes, kernel_size=1, stride=1)) self._init_weight() if freeze_bn: self.freeze_bn()
def __init__(self, args, num_classes=21, freeze_bn=False, abn=False, deep_dec=True): super(DeepLab, self).__init__() self.args = args self.abn = abn self.deep_dec = deep_dec # if True, it deeplabv3+, otherwise, deeplabv3 output_stride = args.out_stride if args.backbone == "drn": output_stride = 8 if args.backbone.split("-")[0] == "efficientnet": output_stride = 32 if args.norm == "gn": norm = gn elif args.norm == "bn": norm = bn elif args.norm == "syncbn": norm = syncbn else: print(args.norm, "normalization is not implemented") raise NotImplementedError self.backbone = build_backbone(args) self.aspp = build_aspp(args.backbone, args.out_stride, norm) if self.deep_dec: self.decoder = build_decoder(num_classes, args.backbone, norm) if freeze_bn: self.freeze_bn()
def __init__(self, args, backbone='resnet', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False): super(DeepLab, self).__init__() self.args = args if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) if self.args.use_kinematic == False: self.decoder = build_decoder(num_classes, backbone, BatchNorm) else: self.decoder = build_decoder_kinematic(backbone, BatchNorm) self.kinematic_layer = build_kinematic_graph(BatchNorm) self.freeze_bn = freeze_bn
def __init__(self, backbone='resnet', output_stride=16, sync_bn=True, freeze_bn=False): super(DeepLabRegressor, self).__init__() if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d input_planes = { 'resnet': 2048, 'mobilenet': 320, } self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.classifier = nn.Sequential( nn.Linear(input_planes[backbone], 128), nn.ReLU(), nn.Linear(128, 4), nn.Sigmoid(), ) if freeze_bn: self.freeze_bn()
def __init__(self, backbone='resnet', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False, pretrain=True): super(DeepLabX, self).__init__() self.num_classes = num_classes if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) # self.aspp = build_psp() # self.aspp = build_naiveGCE() self.decoder = build_decoder(num_classes, backbone, BatchNorm) if freeze_bn: self.freeze_bn() if pretrain: self._load_pretrain() # change the last inference layer for binary segmentation mask last_conv = list(self.decoder.last_conv.children()) self.decoder.last_conv = nn.Sequential(*last_conv[:-1]) self.decoder.last_conv.add_module('8', nn.Conv2d(256, 2, 1, 1))
def __init__(self, backbone='resnet', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False): super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.decoder = build_decoder(num_classes, backbone, BatchNorm) # self.last_conv = nn.Sequential(nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1, bias=False), # BatchNorm(256), # nn.ReLU(), # nn.Dropout(0.5), # nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1, bias=False), # BatchNorm(256), # nn.ReLU(), # nn.Dropout(0.1), # nn.Conv2d(256, 2, kernel_size=1, stride=1)) self._init_weight() if freeze_bn: self.freeze_bn()
def __init__(self, backbone='resnet',output_stride=16, num_classes=1,nInputChannels=5,freeze_bn=False): super(IOG_loop, self).__init__() output_shape = 128 BatchNorm = nn.BatchNorm2d channel_settings = [512, 1024, 512, 256]#[2048, 1024, 512, 256] self.global_net = globalNet(channel_settings, output_shape, num_classes) self.refine_net = refineNet(channel_settings[-1], output_shape, num_classes) self.backbone = build_backbone(backbone, output_stride, BatchNorm,nInputChannels) self.psp4 = PSPModule(in_features=2048+64, out_features=512, sizes=(1, 2, 3, 6)) self.ex_points = nn.Sequential(nn.Conv2d(2, 64, kernel_size=3, stride=2, padding=1, bias=False), nn.BatchNorm2d(64), nn.ReLU(), nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1, bias=False), nn.BatchNorm2d(128), nn.ReLU(), nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1, bias=False), nn.BatchNorm2d(256), nn.ReLU(), nn.Conv2d(256, 256, kernel_size=3, stride=2, padding=1, bias=False), nn.BatchNorm2d(256), nn.ReLU(), nn.Conv2d(256, 64, kernel_size=1, stride=1, bias=False), nn.BatchNorm2d(64), nn.ReLU()) if freeze_bn: self.freeze_bn()
def __init__(self, backbone='resnet101', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False, enable_interpolation=True, pretrained_path=None, norm_layer=nn.BatchNorm2d, enable_aspp=True): super(DeepLab, self).__init__() self.enable_aspp = enable_aspp if backbone == 'drn': output_stride = 8 BatchNorm = norm_layer self.backbone = build_backbone(backbone, output_stride, BatchNorm, pretrained_path=pretrained_path) self.aspp = build_aspp(backbone, output_stride, BatchNorm, enable_aspp=self.enable_aspp) self.decoder = build_decoder(num_classes, backbone, BatchNorm) self.enable_interpolation = enable_interpolation
def __init__(self, backbone='resnet', output_stride=16, nclass=19, cuda=True, extension=None): super(SCNN, self).__init__() if backbone == 'drn': output_stride = 8 BatchNorm = nn.BatchNorm2d if cuda == True: device = "cuda" else: device = "cpu" self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.rnn = build_rnn(32, device) self.conv0 = nn.Sequential( nn.Conv2d(2048, 32, 3, padding=1, bias=False), BatchNorm(32), nn.ReLU()) self.conv1 = nn.Sequential( nn.Conv2d(32, nclass, 3, padding=1, bias=False), BatchNorm(nclass), nn.ReLU()) self.conv2 = nn.Sequential(nn.Conv2d(32, 2, 3, padding=1, bias=False), BatchNorm(2), nn.Softmax()) self.dropout = nn.Dropout2d() self.extension = build_extension(ext=extension, out_channels=nclass, kernel_size=3, padding=1, n_resblocks=3)
def __init__(self, backbone='resnet', output_stride=16, num_classes=19, use_ABN=True, freeze_bn=False, args=None, separate=False): super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 if use_ABN: BatchNorm = ABN else: BatchNorm = NaiveBN self.backbone = build_backbone(backbone, output_stride, BatchNorm, args) self.aspp = build_aspp(backbone, output_stride, BatchNorm, args, separate) self.decoder = build_decoder(num_classes, backbone, BatchNorm, args, separate) if freeze_bn: self.freeze_bn()
def __init__(self, backbone='seresnext101', output_stride=16, num_classes=5, sync_bn=True, freeze_bn=False): super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 if sync_bn: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) #print('bacbone') self.aspp = build_aspp(backbone, output_stride, BatchNorm) #print('aspp') self.decoder = build_decoder(num_classes, backbone, BatchNorm) #print('decoder') #self.up = DeconvBlock(304,256,BatchNorm=BatchNorm,n_iter=2) #self.last_conv = nn.Conv2d(256, num_classes, kernel_size=1, stride=1) if freeze_bn: self.freeze_bn()
def __init__(self, backbone='resnet', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False, cp_path=None): super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.decoder = build_decoder(21, backbone, BatchNorm) if (cp_path is not None): cp = torch.load(cp_path, map_location='cpu') self.load_state_dict(cp['state_dict']) if freeze_bn: self.freeze_bn() # predict two classes (background / foreground) self.decoder.last_conv[-1] = nn.Conv2d(256, 2, kernel_size=1, stride=1)
def test_vgg(self): vgg = build_backbone(cfg) model = build_fcn_model(cfg) print(model.backbone.conv1_1.weight[0, 0, 0, 0]) # x = torch.randn(5, 3, 224, 224) # y = model(x) from IPython import embed embed()
def __init__(self, cfg): super(DeformConvRCNN, self).__init__() self.backbone = build_backbone(cfg) self.rpn = build_rpn(cfg) self.roi_heads = build_roi_heads(cfg) self.mimicking_head = Mimicking_head(cfg, self.backbone, self.roi_heads)
def __init__(self, backbone='resnet',output_stride=16, num_classes=1,nInputChannels=5,freeze_bn=False): super(IOG, self).__init__() output_shape = 128 channel_settings = [512, 1024, 512, 256] BatchNorm = nn.BatchNorm2d self.global_net = globalNet(channel_settings, output_shape, num_classes) self.refine_net = refineNet(channel_settings[-1], output_shape, num_classes) self.backbone = build_backbone(backbone, output_stride, BatchNorm,nInputChannels) self.psp4 = PSPModule(in_features=2048, out_features=512, sizes=(1, 2, 3, 6), n_classes=256) if freeze_bn: self.freeze_bn()
def __init__(self, backbone:str,BatchNorm,in_channels=[512,512,512,512],pretrained=True,upsample_ratio=8,n_class=21): super(FCN, self).__init__() backbone_model=build_backbone(backbone=backbone,BatchNorm=BatchNorm,output_stride=16) if(backbone=='mobilenet'): in_channels=[320,32,24,16] if(upsample_ratio==8): self.model=FCN8(backbone=backbone_model,BatchNorm=BatchNorm,in_channels=in_channels,num_classes=n_class) else: raise NotImplementedError
def __init__(self, backbone='resnet', output_stride=16, num_classes=21, freeze_bn=False): super(DeepLab, self).__init__() BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.decoder = build_decoder(num_classes, backbone, BatchNorm) self.freeze_bn = freeze_bn
def __init__(self, backbone='resnet', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False): super(Deeplabv3, self).__init__() if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.decoder = build_decoder(num_classes, backbone, BatchNorm) self.freeze_bn = freeze_bn
def __init__(self, backbone='resnet', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False): super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.decoder = build_decoder(num_classes, backbone, BatchNorm) if freeze_bn: self.freeze_bn()
def __init__(self, backbone='resnet', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False): super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d #self.deconv1 = nn.ConvTranspose2d(21, 21, 1, 4, 0, 0, bias=True) self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.decoder = build_decoder(num_classes, backbone, BatchNorm) if freeze_bn: self.freeze_bn()
def build_skmtnet(backbone: str, auxiliary_head, trunk_head, num_classes, output_stride=32, sync_bn=False): """ :param backbone:the name of backbone :param auxiliary_head: :param trunk_head: :param num_classes: :param output_stride: :param sync_bn: :return: """ #选择BN方式 if sync_bn: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d #选择backbone if (backbone): backbone_model = build_backbone(backbone, output_stride, BatchNorm, num_classes) else: backbone_model = None #选择auxiliary_head if (auxiliary_head): auxiliary_head_model = build_auxiliary_head(auxiliary_head, backbone, BatchNorm, output_stride, num_classes) else: auxiliary_head_model = None #选择trunk head trunk_head_model = build_head(trunk_head, backbone, BatchNorm, output_stride=output_stride, num_classes=num_classes) #集成模型 return SkmtNet(backbone_model, auxiliary_head_model, trunk_head_model, num_classes)
def __init__(self, backbone='resnet', output_stride=16, num_classes=21): self.inplanes = 64 super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 inplanes = 512 elif backbone == 'mobilenet': inplanes = 320 else: inplanes = 2048 #if sync_bn == True: # BatchNorm = SynchronizedBatchNorm2d #else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.head = self._make_pred_layer(Classifier_Module, inplanes, [6, 12, 18, 24], [6, 12, 18, 24], num_classes)
def __init__(self, backbone='resnet', output_stride=16, sync_bn=True, freeze_bn=False): super().__init__() if backbone == 'drn': output_stride = 8 if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.decoder = build_decoder(5, backbone, BatchNorm) if freeze_bn: self.freeze_bn()