def __init__(self, num_classes, backbone="resnest101", use_groupnorm=True): super(CombineNet, self).__init__() self._backbone_name = backbone self.backbone = get_backbone(backbone) self.dec5 = nn.Sequential( *([nn.ConvTranspose2d(2048, 512, kernel_size=2, stride=2)] + [ nn.Conv2d(512, 512, kernel_size=3, padding=1), nn.BatchNorm2d(512), nn.ReLU(inplace=True) ])) self.dec4 = _DecoderBlock(int(1536), 128, 4) self.dec3 = _DecoderBlock(int(640), 128, 4) self.dec2 = _DecoderBlock(int(384), 64, 2) self.dec1 = _DecoderBlock(int(192), 64, 2) self.ppm1 = PyramidPoolingModule(128, 16, (1, 2, 3, 6)) self.ppm2 = PyramidPoolingModule(256, 16, (1, 2, 3, 6)) self.ppm3 = PyramidPoolingModule(512, 16, (1, 2, 3, 6)) self.ppm4 = PyramidPoolingModule(1024, 16, (1, 2, 3, 6)) self.ppm5 = PyramidPoolingModule(2048, 16, (1, 2, 3, 6)) self.merge = _MergeBlock(384, num_classes) if use_groupnorm: logging.getLogger(self.__class__.__name__).warning( "Transforming all BatchNorm layers into GroupNorm layers!") transform_batchnorm_to_groupnorm(self, self) initialize_weights(self.dec5, self.dec4, self.dec3, self.dec2, self.dec1, self.ppm1, self.ppm2, self.ppm3, self.ppm4, self.ppm5, self.merge)
def __init__(self, num_classes, pretrained=True, use_aux=True): super(PSPNet, self).__init__() self.use_aux = use_aux resnet = models.resnet101(pretrained=True) self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4 for n, m in self.layer3.named_modules(): if 'conv2' in n: m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1) elif 'downsample.0' in n: m.stride = (1, 1) for n, m in self.layer4.named_modules(): if 'conv2' in n: m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1) elif 'downsample.0' in n: m.stride = (1, 1) self.ppm = _PyramidPoolingModule(2048, 512, (1, 2, 3, 6)) self.final = nn.Sequential( nn.Conv2d(4096, 512, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(512, momentum=.95), nn.ReLU(inplace=True), nn.Dropout(0.1), nn.Conv2d(512, num_classes, kernel_size=1)) if use_aux: self.aux_logits = nn.Conv2d(1024, num_classes, kernel_size=1) initialize_weights(self.aux_logits) initialize_weights(self.ppm, self.final)
def __init__(self, layer_config: str, in_channels: int = 2): super(AlexNetBackbone, self).__init__(layer_config, in_channels) self.in_channels = in_channels self.norm_type = layer_config self.layers = self.make_layers(norm_type=self.norm_type, in_channels=in_channels) initialize_weights(self.layers, activation='relu')
def __init__(self, layer_config: dict, in_channels: int = 2): super(ResNetBackbone, self).__init__(layer_config, in_channels) self.in_channels = in_channels self.layer_config = layer_config self.layers = self.make_layers( layer_cfg=self.layer_config, in_channels=self.in_channels, widening_factor=self.layer_config.get('widening_factor', 1) ) initialize_weights(self.layers, activation='relu')
def __init__(self, layer_config: dict, in_channels: int = 2): super(ResNetBackbone, self).__init__(layer_config, in_channels) self.in_channels = in_channels self.layer_config = layer_config self.first_conv = layer_config.get('first_conv', 7) self.width = layer_config.get('width', 1) self.layers = self.make_layers( layer_cfg=self.layer_config, in_channels=self.in_channels, width=self.width, first_conv=self.first_conv, ) initialize_weights(self.layers, activation='relu')
def __init__(self, layer_config: dict, input_shape: tuple, output_shape: tuple): super(ResNetDecoder, self).__init__(layer_config, input_shape, output_shape) self.input_shape = input_shape self.output_shape = output_shape self.layer_config = layer_config self.layers = self.make_layers(layer_cfg=self.layer_config, input_shape=self.input_shape, output_shape=self.output_shape, widening_factor=self.layer_config.get( 'widening_factor', 1)) initialize_weights(self.layers, activation='relu')
def __init__(self, name: str = 'resnet50', data: str = 'imagenet', in_channels: int = 3): super(ResNetBackbone, self).__init__(in_channels) self.name = name # resnet18, resnet50, resnet101 self.data = data # cifar10, cifar100, svhn, stl10, tinyimagenet, imagenet self.layers = RESNET_FUNCTIONS[self.name](pretrained=False) self.layers = self._remove_gap_and_fc(self.layers) if self.in_channels != 3: self.layers = self._fix_first_conv_in_channels(self.layers, in_channels=self.in_channels) if not self.data.startswith('imagenet'): self.layers = self._fix_first_conv_kernel_size(self.layers) if self.data.startswith('cifar') or self.data.startswith('svhn'): self.layers = self._remove_maxpool(self.layers) initialize_weights(self)
def __init__(self, in_channels: int, num_features: int, dropout: float = 0.0): """ Arguments: in_channels: int, number of input feature maps. num_features: int, number of output features. """ super(LinearHead, self).__init__(num_features) self.in_channels = in_channels self.num_features = num_features self.dropout = dropout self.layers = self.make_layers( in_channels=self.in_channels, num_features=self.num_features, dropout=self.dropout, ) initialize_weights(self.layers)
def __init__(self, layer_config: list, in_channels: int = 2): """ Arguments: layer_config: list, following rules of VGG. in_channels: int, number of channels in the input. batch_norm: bool, default True. """ super(VggNetBackbone, self).__init__(layer_config, in_channels) self.layer_config = layer_config self.in_channels = in_channels self.layers = self.make_layers( layer_cfg=self.layer_config['channels'], in_channels=self.in_channels, batch_norm=self.layer_config['batch_norm']) initialize_weights(self.layers, activation='relu')
def __init__(self, input_shape: tuple, num_classes: int, dropout: float = 0.0): super(LinearClassifier, self).__init__(input_shape, num_classes) self.input_shape = input_shape # (C, H, W) self.num_classes = num_classes self.dropout = dropout self.layers = self.make_layers( num_features=functools.reduce(lambda a, b: a * b, self.input_shape), num_classes=self.num_classes, dropout=self.dropout, ) initialize_weights(self.layers, activation='relu')
def __init__(self, layer_config, input_shape, output_shape, batch_norm: bool = True): super(VGGDecoder, self).__init__(layer_config, input_shape, output_shape) self.layer_config = layer_config self.input_shape = input_shape self.output_shape = output_shape self.batch_norm = batch_norm self.layers = self.make_layers(cfg=self.layer_config, in_channels=self.input_shape[0], out_channels=self.output_shape[0], batch_norm=self.batch_norm) initialize_weights(self.layers, activation='relu')
def __init__(self, num_patches: int, in_channels: int, num_classes: int, dropout: float = 0.0): super(PatchGAPClassifier, self).__init__(in_channels, num_classes) self.num_patches = num_patches self.in_channels = in_channels self.num_classes = num_classes self.dropout = dropout self.layers = self.make_layers(num_patches=self.num_patches, in_channels=self.in_channels, num_classes=self.num_classes, dropout=self.dropout) initialize_weights(self.layers)
def __init__(self, num_classes, input_size, pretrained=True, use_aux=True): super(PSPNetDeform, self).__init__() self.input_size = input_size self.use_aux = use_aux resnet = models.resnet101() if pretrained: resnet.load_state_dict(torch.load(res101_path)) self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) self.layer1 = resnet.layer1 self.layer2 = resnet.layer2 self.layer3 = resnet.layer3 self.layer4 = resnet.layer4 for n, m in self.layer3.named_modules(): if 'conv2' in n: m.padding = (1, 1) m.stride = (1, 1) elif 'downsample.0' in n: m.stride = (1, 1) for n, m in self.layer4.named_modules(): if 'conv2' in n: m.padding = (1, 1) m.stride = (1, 1) elif 'downsample.0' in n: m.stride = (1, 1) for idx in range(len(self.layer3)): self.layer3[idx].conv2 = Conv2dDeformable(self.layer3[idx].conv2) for idx in range(len(self.layer4)): self.layer4[idx].conv2 = Conv2dDeformable(self.layer4[idx].conv2) self.ppm = _PyramidPoolingModule(2048, 512, (1, 2, 3, 6)) self.final = nn.Sequential( nn.Conv2d(4096, 512, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(512, momentum=.95), nn.ReLU(inplace=True), nn.Dropout(0.1), nn.Conv2d(512, num_classes, kernel_size=1)) if use_aux: self.aux_logits = nn.Conv2d(1024, num_classes, kernel_size=1) initialize_weights(self.aux_logits) initialize_weights(self.ppm, self.final)
def __init__(self, in_channels: int, num_classes: int, dropout: float = 0.0): """ Arguments: input_shape: list or tuple of length 3, (C, H, W). num_classes: int, number of target classes. """ super(GAPClassifier, self).__init__(in_channels, num_classes) self.in_channels = in_channels self.num_classes = num_classes self.dropout = dropout self.layers = self.make_layers( in_channels=self.in_channels, num_classes=self.num_classes, dropout=self.dropout, ) initialize_weights(self.layers)