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, 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, 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, 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 __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): 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=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=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, 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): 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, 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=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='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, 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, 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, num_classes, backbone='resnet', output_stride=16, sync_bn=True, freeze_bn=False): super(DeepLab, 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.decoder_seg = build_decoder(num_classes + 1, backbone, BatchNorm) self.decoder_box = build_decoder(6, backbone, BatchNorm) self.pos = None if freeze_bn: self.freeze_bn()
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, freeze_bn=False): super(DeepLab, self).__init__() if backbone == 'drn': output_stride = 8 BatchNorm = nn.BatchNorm2d self.backbone = ResNet101(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(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 __init__(self, backbone='resnet', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False, scales=[1.0, 0.5, 0.25]): super(DeepLab_Multiscale, self).__init__(backbone, output_stride, num_classes, sync_bn, freeze_bn) if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.scales = scales self.decoder = build_decoder(num_classes, backbone, BatchNorm, multiscale=True, scales=scales)
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()
def __init__(self, backbone='resnet', output_stride=16, num_classes=2, 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.cls1 = nn.Sequential( nn.Conv2d(512, 512, kernel_size=3, padding=1), # fc6 ) self.cls2 = nn.Sequential( nn.Conv2d(1024, 512, kernel_size=3, padding=1), # fc6 ) 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 self.multi_graph_conv = build_graph_conv(backbone, BatchNorm) # self.classifier_6 = nn.Sequential( # nn.Conv2d(128, 128, kernel_size=3, dilation=1, padding=1), # fc6 # nn.ReLU(inplace=True) # ) # self.exit_layer = nn.Conv2d(128, 2, kernel_size=1, padding=1) # self.cos_similarity_func = nn.CosineSimilarity() ############################################################ bins = [6, 13, 26, 52] self.features = [] for bin in bins: # [1,2,3,6] self.features.append( nn.Sequential( nn.AdaptiveAvgPool2d(bin), # 括号里面的大小是多少,输出来的大小就是多少 ))
def __init__(self, backbone='resnet', output_stride=16, num_classes=21, sync_bn=True, freeze_bn=False, model_path=os.getcwd()): super(DeepLab, self).__init__() self.model_path = model_path if sync_bn == True: BatchNorm = SynchronizedBatchNorm2d else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm, model_path) 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=15, 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 = xception.AlignedXception(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 = SyncBatchNorm else: BatchNorm = nn.BatchNorm2d self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm) self.encoding = build_encoding(backbone, num_classes, 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, pretrained=True): 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, pretrained) 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=2, 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) # for k in self.backbone.children(): # for param in k.parameters(): # param.requires_grad = False # for k in self.aspp.children(): # for param in k.parameters(): # param.requires_grad = False self.decoder = build_decoder(num_classes, backbone, BatchNorm) self._load_pretrained_model(backbone) 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.CSG = nn.Linear(CODE_SIZE, np.prod(SLICE_SHAPE), bias=False) self.backbone = build_backbone(backbone, output_stride, BatchNorm) self.aspp = build_aspp(backbone, output_stride, BatchNorm, self.CSG) 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, crop_size=513, crf_loss=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.crf_loss = crf_loss if self.crf_loss: _shape = int(crop_size/4) if crop_size/4 != int(crop_size/4): _shape += 1 config = convcrf.default_conf config['filter_size'] = 7 config['col_feats']['schan'] = 0.1 config['trainable'] = True self.convcrf = convcrf.GaussCRF(conf=config, shape=(_shape,_shape), nclasses=num_classes) ''' if freeze_bn: self.freeze_bn()