def __init__(self, class_num, bn_momentum=0.01): super(DeepLabV3, self).__init__() self.Resnet101 = resnet101.get_resnet101(dilation=[1, 1, 1, 2], bn_momentum=bn_momentum, is_fpn=False) self.ASPP = ASPP(2048, 256, [6, 12, 18], norm_act=nn.BatchNorm2d) self.classify = nn.Conv2d(256, class_num, 1, bias=True)
def __init__(self, class_num, bn_momentum=0.01): super(FastFCN, self).__init__() self.Resnet101 = resnet101.get_resnet101(dilation=[1, 1, 1, 2], bn_momentum=bn_momentum, is_fpn=True) self.jpu = JPU([512, 1024, 2048], width=512, norm_layer=nn.BatchNorm2d) self.head = Head(class_num, norm_layer=nn.BatchNorm2d)
def __init__(self, class_num, bn_momentum=0.01): super(DenseASPP, self).__init__() self.Resnet101 = resnet101.get_resnet101(dilation=[1, 1, 1, 2], bn_momentum=bn_momentum, is_fpn=False) self.head = _DenseASPPHead(2048, class_num=class_num, norm_layer=nn.BatchNorm2d)
def __init__(self, output_stride, class_num, pretrained, bn_momentum=0.1, freeze_bn=False, drop_out=True, model_path=''): super(DeepLabV3plus, self).__init__() self.Resnet101 = resnet101.get_resnet101(dilation=[1, 1, 1, 2], bn_momentum=bn_momentum, is_fpn=False) self.encoder = Encoder(bn_momentum, output_stride, drop_out) self.decoder = Decoder(class_num, bn_momentum, drop_out) if freeze_bn: self.freeze_bn() print("freeze bacth normalization successfully!")
def __init__(self, output_stride, class_num, pretrained, bn_momentum=0.01, freeze_bn=False, model_path=''): super(DeepLabV3, self).__init__() self.Resnet101 = resnet101.get_resnet101(num_classes=0, dilation=[1, 1, 1, 2], bn_momentum=bn_momentum, is_fpn=False) self.ASPP = AsppModule(out_channels=256, bn_momentum=bn_momentum, output_stride=output_stride) self.classify = nn.Conv2d(256, class_num, 1, bias=True) if freeze_bn: self.freeze_bn() print("freeze bacth normalization successfully!")
def __init__(self, class_num, bn_momentum=0.01): super(PSPNet, self).__init__() self.Resnet101 = resnet101.get_resnet101(dilation=[1, 1, 1, 2], bn_momentum=bn_momentum, is_fpn=False) self.psp_layer = PyramidPooling('psp', class_num, 2048, norm_layer=nn.BatchNorm2d)
def __init__(self, class_num, bn_momentum=0.01): super(DeepLabV3plus, self).__init__() self.Resnet101 = resnet101.get_resnet101(dilation=[1, 1, 1, 2], bn_momentum=bn_momentum, is_fpn=True) self.head = Head(class_num, norm_layer=nn.BatchNorm2d)
def __init__(self, input_size, num_classes, bn_momentum=0.0003, features=256, pretained=False, model_path=''): super(RDF, self).__init__() self.Resnet101rgb = get_resnet101(bn_momentum=bn_momentum) self.Resnet101hha = get_resnet101(bn_momentum=bn_momentum) # This is the four stages of each resnet. self.rgblayer1 = nn.Sequential( self.Resnet101rgb.conv1, self.Resnet101rgb.bn1, self.Resnet101rgb.relu1, self.Resnet101rgb.conv2, self.Resnet101rgb.bn2, self.Resnet101rgb.relu2, self.Resnet101rgb.conv3, self.Resnet101rgb.bn3, self.Resnet101rgb.relu3, self.Resnet101rgb.maxpool, self.Resnet101rgb.layer1) self.rgblayer2 = self.Resnet101rgb.layer2 self.rgblayer3 = self.Resnet101rgb.layer3 self.rgblayer4 = self.Resnet101rgb.layer4 self.hhalayer1 = nn.Sequential( self.Resnet101hha.conv1, self.Resnet101hha.bn1, self.Resnet101hha.relu1, self.Resnet101hha.conv2, self.Resnet101hha.bn2, self.Resnet101hha.relu2, self.Resnet101hha.conv3, self.Resnet101hha.bn3, self.Resnet101hha.relu3, self.Resnet101hha.maxpool, self.Resnet101hha.layer1) self.hhalayer2 = self.Resnet101hha.layer2 self.hhalayer3 = self.Resnet101hha.layer3 self.hhalayer4 = self.Resnet101hha.layer4 # MMF Block self.mmf1 = MMFBlock(256) self.mmf2 = MMFBlock(512) self.mmf3 = MMFBlock(1024) self.mmf4 = MMFBlock(2048) # modify the feature maps from each stage of RenNet, modify their channels self.layer1_rn = nn.Conv2d(256, features, kernel_size=3, stride=1, padding=1, bias=False) self.layer2_rn = nn.Conv2d(512, features, kernel_size=3, stride=1, padding=1, bias=False) self.layer3_rn = nn.Conv2d(1024, features, kernel_size=3, stride=1, padding=1, bias=False) self.layer4_rn = nn.Conv2d( 2048, 2 * features, kernel_size=3, stride=1, padding=1, bias=False ) # here, 2*fetures means we use two same stage-4 features as input self.refinenet4 = RefineNetBlock( 2 * features, (2 * features, math.ceil(input_size // 32))) self.refinenet3 = RefineNetBlock(features, (2 * features, input_size // 32), (features, input_size // 16)) self.refinenet2 = RefineNetBlock(features, (features, input_size // 16), (features, input_size // 8)) self.refinenet1 = RefineNetBlock(features, (features, input_size // 8), (features, input_size // 4)) self.output_conv = nn.Sequential( ResidualConvUnit(features), ResidualConvUnit(features), nn.Conv2d(features, num_classes, kernel_size=1, stride=1, padding=0, bias=True))
def get_refinenet(input_size, num_classes, features=256, bn_momentum=0.01, pretrained=True): resnet101 = get_resnet101(num_classes=num_classes, bn_momentum=bn_momentum) # new ResNet proposed in PSPNet return RefineNet4Cascade(input_size, num_classes=num_classes, resnet_factory=resnet101, features=features, bn_momentum=bn_momentum, pretrained=pretrained)
def __init__(self, input_channel, input_size, refinenet_block, num_classes=1, features=256, resnet_factory=models.resnet101, bn_momentum = 0.01, pretrained=True, freeze_resnet=False): """Multi-path 4-Cascaded RefineNet for image segmentation Args: input_shape ((int, int)): (channel, size) assumes input has equal height and width refinenet_block (block): RefineNet Block num_classes (int, optional): number of classes features (int, optional): number of features in refinenet resnet_factory (func, optional): A Resnet model from torchvision. Default: models.resnet101 pretrained (bool, optional): Use pretrained version of resnet Default: True freeze_resnet (bool, optional): Freeze resnet model Default: True Raises: ValueError: size of input_shape not divisible by 32 """ super().__init__() input_channel = input_channel input_size = input_size self.Resnet101 = get_resnet101(num_classes=0, bn_momentum=bn_momentum) self.layer1 = nn.Sequential(self.Resnet101.conv1, self.Resnet101.bn1, self.Resnet101.relu1, self.Resnet101.conv2, self.Resnet101.bn2, self.Resnet101.relu2, self.Resnet101.conv3, self.Resnet101.bn3, self.Resnet101.relu3, self.Resnet101.maxpool, self.Resnet101.layer1) self.layer2 = self.Resnet101.layer2 self.layer3 = self.Resnet101.layer3 self.layer4 = self.Resnet101.layer4 # freeze the resnet parameters, default is false if freeze_resnet: layers = [self.layer1, self.layer2, self.layer3, self.layer4] for layer in layers: for param in layer.parameters(): param.requires_grad = False # modify the feature maps from each stage of RenNet, modify their channels self.layer1_rn = nn.Conv2d( 256, features, kernel_size=3, stride=1, padding=1, bias=False) self.layer2_rn = nn.Conv2d( 512, features, kernel_size=3, stride=1, padding=1, bias=False) self.layer3_rn = nn.Conv2d( 1024, features, kernel_size=3, stride=1, padding=1, bias=False) self.layer4_rn = nn.Conv2d( 2048, 2 * features, kernel_size=3, stride=1, padding=1, bias=False) # here, 2*fetures means we use two same stage-4 features as input self.refinenet4 = RefineNetBlock(2 * features, (2 * features, math.ceil(input_size // 32))) self.refinenet3 = RefineNetBlock(features, (2 * features, input_size // 32), (features, input_size // 16)) self.refinenet2 = RefineNetBlock(features, (features, input_size // 16), (features, input_size // 8)) self.refinenet1 = RefineNetBlock(features, (features, input_size // 8), (features, input_size // 4)) self.output_conv = nn.Sequential( ResidualConvUnit(features), ResidualConvUnit(features), nn.Conv2d( features, num_classes, kernel_size=1, stride=1, padding=0, bias=True))