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)