def __init__( self, encoder_weights: str = None, encoder_freeze: bool = True, decoder_use_batchnorm: bool = True, decoder_channels: List[int] = (256, 128, 64, 32, 16), classes: int = 1, activation: Optional[Union[str, callable]] = "sigmoid", device=torch.device("cpu"), ): super().__init__() self.encoder = moco_r50(encoder_weights, encoder_freeze=encoder_freeze, map_location=device) self.decoder = UnetDecoder( encoder_channels=(12, 64, 256, 512, 1024, 2048), decoder_channels=decoder_channels, n_blocks=5, use_batchnorm=decoder_use_batchnorm, center=False, attention_type=None, ) self.segmentation_head = torch.nn.Sequential( torch.nn.AdaptiveAvgPool2d((1, 1)), torch.nn.Flatten(), torch.nn.Linear(16, classes), Activation(activation), ) self.classification_head = None self.initialize()
def __init__(self, **kwargs): super(Multibranch_resnet50_noclassification, self).__init__() self.model = smp.Unet('resnet50', in_channels=in_channels, classes=classes, activation=activation, **kwargs) self.distancemap_branch = UnetDecoder( encoder_channels=self.model.encoder.out_channels, decoder_channels=(256, 128, 64, 32, 16), # List[int] = (256, 128, 64, 32, 16), n_blocks=5, # int = 5, use_batchnorm=True, # bool = True, center=False, #True if encoder_name.startswith("vgg") else False, attention_type=None, # Optional[str] = None, ) self.distancemap_head = DistanceMapHead( in_channels= 16, # 原来此处为decoder_channels[-1],而该参数默认值为decoder_channels: List[int] = (256, 128, 64, 32, 16) out_channels=classes, activation=activation, kernel_size=3, ) initialize_decoder(self.distancemap_branch) initialize_head(self.distancemap_head)
def __init__( self, encoder_name: str = "resnet34", encoder_depth: int = 5, encoder_weights: str = "imagenet", decoder_use_batchnorm: bool = True, decoder_channels: List[int] = (256, 128, 64, 32, 16), decoder_attention_type: Optional[str] = None, in_channels: int = 3, classes: int = 1, activation: Optional[Union[str, callable]] = None, pretext_classes=-1, domain_classes=2, ): super().__init__() self.encoder = get_encoder( encoder_name, in_channels=in_channels, depth=encoder_depth, weights=encoder_weights, ) self.decoder = UnetDecoder( encoder_channels=self.encoder.out_channels, decoder_channels=decoder_channels, n_blocks=encoder_depth, use_batchnorm=decoder_use_batchnorm, center=True if encoder_name.startswith("vgg") else False, attention_type=decoder_attention_type, ) self.segmentation_head = SegmentationHead( in_channels=decoder_channels[-1], out_channels=classes, activation=activation, kernel_size=3, ) self.domain_layer = -2 self.domain_classification_head = DomainClassifier( in_channels=self.encoder.out_channels[self.domain_layer], domain_classes=domain_classes) if pretext_classes == -1: raise ValueError(f'initialize pretext_classes') self.pretext_classification_head = PretextClassifier( in_channels=self.encoder.out_channels[-1], pretext_classes=pretext_classes) self.name = "u-{}".format(encoder_name) self.initialize() return
def __init__(self): super(EfficientNet_3_unet, self).__init__() self.model_encoder = EfficientNet_3_Encoder() self.model_decoder = UnetDecoder(encoder_channels=(1536, 136, 48, 32, 24), decoder_channels=(256, 128, 64, 32, 16), final_channels=1, use_batchnorm=True, center=False, ) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.cls_head = nn.Sequential(nn.Linear(2048, 2048, bias=True), nn.Linear(2048, 1, bias=True)) self.fea_bn = nn.BatchNorm1d(512) self.fea_bn.bias.requires_grad_(False)
def __init__( self, encoder_name: str = "resnet34", encoder_depth: int = 5, encoder_weights: str = "imagenet", decoder_use_batchnorm: bool = True, decoder_channels: List[int] = (256, 128, 64, 32, 16), in_channels: int = 3, ): super().__init__() self.encoder = get_encoder( encoder_name, in_channels=in_channels, depth=encoder_depth, weights=encoder_weights, ) self.decoder = UnetDecoder( encoder_channels=self.encoder.out_channels, decoder_channels=decoder_channels, n_blocks=encoder_depth, use_batchnorm=decoder_use_batchnorm, center=True if encoder_name.startswith("vgg") else False, attention_type=None, ) self.xydir_head = EncoderRegressionHead( in_channels=self.encoder.out_channels[-1], out_channels=2, ) self.height_head = RegressionHead( in_channels=decoder_channels[-1], out_channels=1, kernel_size=3, ) self.mag_head = RegressionHead( in_channels=decoder_channels[-1], out_channels=1, kernel_size=3, ) self.scale_head = ScaleHead() self.name = "u-{}".format(encoder_name) self.initialize()
def get_basenet_decoder(basenet, encoder_channels, decoder_channels): if basenet == 'fpn': return FPNDecoder(encoder_channels) elif basenet == 'psp': return PSPDecoder(encoder_channels) elif basenet == 'deeplabv3': return DeepLabV3Decoder(encoder_channels[-1], decoder_channels[-1]) return UnetDecoder( encoder_channels=encoder_channels, decoder_channels=decoder_channels, n_blocks=len(decoder_channels), use_batchnorm=True, center=False, attention_type=None, )
def __init__( self, encoder_name: str = "resnet34", encoder_depth: int = 5, encoder_weights: str = "imagenet", decoder_use_batchnorm: bool = True, decoder_channels: List[int] = (256, 128, 64, 32, 16), decoder_attention_type: Optional[str] = None, in_channels: int = 3, classes: int = 1, activation: Optional[Union[str, callable]] = None, aux_params: Optional[dict] = None, ): super().__init__() self.encoder = get_encoder( encoder_name, in_channels=in_channels, depth=encoder_depth, weights=encoder_weights, ) self.decoder = UnetDecoder( encoder_channels=self.encoder.out_channels, decoder_channels=decoder_channels, n_blocks=encoder_depth, use_batchnorm=decoder_use_batchnorm, center=True if encoder_name.startswith("vgg") else False, attention_type=decoder_attention_type, ) self.segmentation_head = SegmentationHead( in_channels=decoder_channels[-1], out_channels=classes, activation=activation, kernel_size=3, ) if aux_params is not None: self.classification_head = ClassificationHead( in_channels=self.encoder.out_channels[-1], **aux_params) else: self.classification_head = None self.name = "u-{}".format(encoder_name) self.initialize()
def __init__(self, b, num_channels): super().__init__() self.model_encoder = EfficientNet_Encoder(b) self.model_decoder = nn.Sequential( UnetDecoder( encoder_channels=self.model_encoder.encoder_channels, decoder_channels=(256, 128, 64, 32, 16), final_channels=num_channels, use_batchnorm=True, center=False, ), nn.LogSoftmax(dim=1), ) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.cls_head = nn.Sequential(nn.Linear(2048, 2048, bias=True), nn.Linear(2048, 1, bias=True)) self.fea_bn = nn.BatchNorm1d(512) self.fea_bn.bias.requires_grad_(False)
def __init__( self, encoder_name='resnet34', encoder_weights='imagenet', decoder_use_batchnorm=True, decoder_channels=(256, 128, 64, 32, 16), classes=1, activation='sigmoid', center=False, # usefull for VGG models attention_type=None): encoder = get_encoder(encoder_name, encoder_weights=encoder_weights) decoder = UnetDecoder(encoder_channels=encoder.out_shapes, decoder_channels=decoder_channels, final_channels=classes, use_batchnorm=decoder_use_batchnorm, center=center, attention_type=attention_type) super().__init__(encoder, decoder, activation) self.name = 'u-{}'.format(encoder_name)
def __init__( self, encoder_name: str = "resnet34", encoder_depth: int = 5, encoder_weights: str = "imagenet", decoder_use_batchnorm: bool = True, decoder_channels: List[int] = (256, 128, 64, 32, 16), decoder_attention_type: Optional[str] = None, in_channels: int = 3, classes: int = 1, activation: Optional[Union[str, callable]] = None, pretext_classes=-1, domain_classes=2, domain_layer=-2, domain_classifier='DomainClassifierFlatten', separate=False, input_shape=80, ): super().__init__() self.encoder = get_encoder( encoder_name, in_channels=in_channels, depth=encoder_depth, weights=encoder_weights, ) if separate is False else \ get_separate_encoder( encoder_name, in_channels=in_channels, depth=encoder_depth, weights=encoder_weights, ) self.separate = separate self.decoder = UnetDecoder( encoder_channels=self.encoder.out_channels, decoder_channels=decoder_channels, n_blocks=encoder_depth, use_batchnorm=decoder_use_batchnorm, center=True if encoder_name.startswith("vgg") else False, attention_type=decoder_attention_type, ) self.segmentation_head = SegmentationHead( in_channels=decoder_channels[-1], out_channels=classes, activation=activation, kernel_size=3, ) if domain_classifier == 'DomainClassifier': domain_classifier = DomainClassifier elif domain_classifier == 'DomainClassifierFlatten': domain_classifier = DomainClassifierFlatten elif domain_classifier == 'DomainClassifierFlattenSimple': domain_classifier = DomainClassifierFlattenSimple elif domain_classifier == 'DomainClassifierFlattenCat': domain_classifier = DomainClassifierFlattenCat elif domain_classifier == 'DomainClassifierReduceFlatten': domain_classifier = DomainClassifierReduceFlatten self.domain_layer = domain_layer if type(self.domain_layer) == list: self.domain_classification_head = domain_classifier( in_channels=sum([ self.encoder.out_channels[idx_dl] for idx_dl in self.domain_layer ]), domain_classes=domain_classes) if separate: self.encoder.set_domain_layer(self.domain_layer) else: self.domain_classification_head = domain_classifier( in_channels=self.encoder.out_channels[self.domain_layer], domain_classes=domain_classes, input_shape=input_shape, ) if pretext_classes == -1: raise ValueError(f'initialize pretext_classes') self.pretext_classification_head = PretextClassifier( in_channels=self.encoder.out_channels[-1], pretext_classes=pretext_classes) self.name = "u-{}".format(encoder_name) self.initialize() return