def _create(self, name, **encoder_kwargs):
if name not in _basic_block_layers.keys():
fn_name = getattr(resnet, name)
model = fn_name(**encoder_kwargs)
else:
# special case due to prohibited dilation in the original BasicBlock
pretrained = encoder_kwargs.pop('pretrained', False)
progress = encoder_kwargs.pop('progress', True)
model = resnet.ResNet(BasicBlockWithDilation,
_basic_block_layers[name], **encoder_kwargs)
if pretrained:
state_dict = load_state_dict_from_url(model_urls[name])
model.load_state_dict(state_dict, strict=False)
# model = resnet._resnet(
# name, BasicBlockWithDilation, _basic_block_layers[name], pretrained, progress, **encoder_kwargs
# )
replace_stride_with_dilation = encoder_kwargs.get(
'replace_stride_with_dilation', (False, False, False))
assert len(replace_stride_with_dilation) == 3
if replace_stride_with_dilation[0]:
model.layer2[0].conv2.padding = (2, 2)
model.layer2[0].conv2.dilation = (2, 2)
if replace_stride_with_dilation[1]:
model.layer3[0].conv2.padding = (2, 2)
model.layer3[0].conv2.dilation = (2, 2)
if replace_stride_with_dilation[2]:
model.layer4[0].conv2.padding = (2, 2)
model.layer4[0].conv2.dilation = (2, 2)
return model
def __init__(self, layers=[3, 4, 6, 3]):
block = resnet.BasicBlock
num_classes = 7
self.model = resnet.ResNet(block, layers, num_classes)
if torch.cuda.is_available():
self.model.cuda()
self.bestaccur = 0.0
def __init__(self, scale, classes, epochs, split_size=0):
super(Scaled_ResNext, self).__init__()
# Based on the imagenet normalization params.
self.offset = 0.44900
self.multiplier = 4.42477
self.dev1 = torch.device('cuda:0')
self.dev2 = torch.device('cuda:0')
self.split_size = split_size
# Resnext50_32x4d.
layers = [2, 3, 5, 2]
if scale[0] > 1:
layers = [3, 4, 6, 3]
self.model = Resnet.ResNet(Resnet.Bottleneck,
layers,
num_classes=classes,
groups=4,
width_per_group=32)
self.model.avgpool = nn.AdaptiveAvgPool2d((1, 1))
# The first part also needs to be fixed.
self.model.conv1 = nn.Conv2d(
scale[0], 64, kernel_size=3, stride=1, padding=1,
bias=False) # Replace the harsh convolution.
del self.model.maxpool
self.model.maxpool = lambda x: x # Remove the early maxpool.
self.model = self.model.to(self.dev1)
self.epochs = epochs
def resnet101(pretrained=False, model_dir=None, **kwargs):
"""Constructs a ResNet-101 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = res.ResNet(res.Bottleneck, [3, 4, 23, 3], **kwargs)
if pretrained:
model.load_state_dict(model_zoo.load_url(res.model_urls['resnet101'], model_dir=model_dir))
return model
def ResNet18(low_dim=128):
net = resnet.ResNet(resnet.BasicBlock, [2, 2, 2, 2], low_dim)
net.conv1 = nn.Conv2d(3,
64,
kernel_size=3,
stride=1,
padding=1,
bias=False)
net.maxpool = nn.Identity()
return net
def __init__(self):
super(TinyImagenet_Resnet, self).__init__()
# Based on the imagenet normalization params.
self.offset = 0.44900
self.multiplier = 4.42477
# Resnet50.
self.model = Resnet.ResNet(Resnet.Bottleneck, [3, 4, 6, 3], num_classes=200)
# TinyImagenet would have a different sized feature map.
self.model.avgpool = nn.AdaptiveAvgPool2d((1,1))
# The first part also needs to be fixed.
self.model.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) # Replace the harsh convolution.
def __init__(self):
super(CIFAR10_LIGHTNING, self).__init__()
self.model = Resnet.ResNet(Resnet.Bottleneck, [3, 4, 6, 3],
num_classes=10)
self.model.inplanes = 64
self.model.conv1 = nn.Conv2d(3,
64,
kernel_size=3,
stride=1,
padding=1,
bias=False)
self.model.bn1 = nn.BatchNorm2d(64)
self.model.linear = nn.Linear(512 * Resnet.Bottleneck.expansion, 10)
del self.model.maxpool
self.model.maxpool = lambda x: x
def __init__(self):
super(MNIST_Resnet, self).__init__()
# Based on the imagenet normalization params.
self.offset = 0.44900
self.multiplier = 4.42477
# Resnet50.
self.model = Resnet.ResNet(Resnet.Bottleneck, [2, 3, 5, 2], num_classes=10)
# MNIST would have a different sized feature map.
self.model.avgpool = nn.AdaptiveAvgPool2d((1,1))
# The first part also needs to be fixed.
self.model.conv1 = nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1, bias=False) # Replace the harsh convolution.
del self.model.maxpool
self.model.maxpool = lambda x: x # Remove the early maxpool.
def __init__(self, arch, pool="avg"):
assert (arch == "resnet10" or arch == "resnet18" or arch == "resnet34"
or arch == "resnet50" or arch == "resnet101"
or arch == "resnet152")
if arch == "resnet10":
net = resnet_utils.ResNet(block=resnet_utils.BasicBlock,
layers=[1, 1, 1, 1],
num_classes=10)
else:
net = models.__dict__[arch](num_classes=10)
all_feat_names = []
feature_blocks = []
# 1st conv before any network block
conv1 = nn.Sequential()
conv1.add_module("Conv", net.conv1)
conv1.add_module("bn", net.bn1)
conv1.add_module("relu", net.relu)
conv1.add_module("maxpool", net.maxpool)
feature_blocks.append(conv1)
all_feat_names.append("conv1")
# 1st block.
feature_blocks.append(net.layer1)
all_feat_names.append("block1")
# 2nd block.
feature_blocks.append(net.layer2)
all_feat_names.append("block2")
# 3rd block.
feature_blocks.append(net.layer3)
all_feat_names.append("block3")
# 4th block.
feature_blocks.append(net.layer4)
all_feat_names.append("block4")
assert pool == "none" or pool == "avg" or pool == "max"
if pool == "max" or pool == "avg":
feature_blocks.append(tools.GlobalPooling(pool_type=pool))
all_feat_names.append("GlobalPooling")
super().__init__(all_feat_names, feature_blocks)
def resnet26(pretrained=False, remote=True):
"""Constructs a ResNet-26 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet_C5(Bottleneck, [2, 2, 2, 2])
if pretrained:
# Define ResNet26 ImageNet
model_IN = resnet.ResNet(block=Bottleneck,
layers=[2, 2, 2, 2],
num_classes=1000)
# Load checkpoint
if remote:
checkpoint = load_state_dict_from_url(model_urls['resnet26'],
map_location='cpu',
progress=True)
else:
checkpoint = torch.load(os.path.join(Path.models_dir(),
'resnet26.pth'),
map_location=lambda storage, loc: storage)
checkpoint = checkpoint['model_state']
# Handle DataParallel
if 'module.' in list(checkpoint.keys())[0]:
new_state_dict = OrderedDict()
for k, v in checkpoint.items():
name = k.replace('module.', '') # remove `module.`
new_state_dict[name] = v
else:
new_state_dict = checkpoint
# Load pre-trained IN model
model_IN.load_state_dict(new_state_dict)
# Load weights to dense-labelling network
model.load_pretrained(model_IN)
return model
def __init__(self):
super(SVHN_Resnet, self).__init__()
self.model = Resnet.ResNet(Resnet.Bottleneck, [3, 4, 6, 3],
num_classes=10)
self.model.inplanes = 64
self.model.conv1 = nn.Conv2d(3,
64,
kernel_size=3,
stride=1,
padding=1,
bias=False)
self.model.bn1 = nn.BatchNorm2d(64)
self.model.linear = nn.Linear(512 * Resnet.Bottleneck.expansion, 10)
del self.model.maxpool
self.model.maxpool = lambda x: x
self.model.avgpool = nn.AdaptiveAvgPool2d(output_size=(1, 1))
self.model.features = nn.Sequential(self.model.conv1, self.model.bn1,
self.model.relu, self.model.layer1,
self.model.layer2,
self.model.layer3,
self.model.layer4,
self.model.avgpool)
def __init__(self, hidden_size):
super().__init__(hidden_size)
self._models = resnet.ResNet(resnet.BasicBlock, [2, 2, 2, 2], num_classes=2)
self._models.train()
def __init__(self,
num_classes,
num_features=0,
dropout=0.6,
set_pooling='max'):
super(CelebNet, self).__init__()
self.dropout = dropout
self.num_class = num_classes
self.num_features = num_features
self.has_embedding = num_features > 0
self.set_pooling = set_pooling
img_base = resnet.resnet50(pretrained=True) # image branch
mask_base = resnet.ResNet(resnet.Bottleneck, [1, 1, 1, 1],
num_classes=1000,
zero_init_residual=True)
mask_base.load_state_dict(model_zoo.load_url(
'https://download.pytorch.org/models/resnet50-19c8e357.pth'),
strict=False)
# fixed_names = []
# for name, module in img_base._modules.items():
# if name == "layer3":
# print("break at layer3...")
# break
# fixed_names.append(name)
# for param in module.parameters():
# param.requires_grad = False
#
# fixed_names = []
# for name, module in mask_base._modules.items():
# if name == "layer3":
# print("break at layer3...")
# break
# fixed_names.append(name)
# for param in module.parameters():
# param.requires_grad = False
img_modules = list(img_base.children())[:-2]
self.img_base = nn.Sequential(*img_modules)
mask_modules = list(mask_base.children())[:-2]
self.mask_base = nn.Sequential(*mask_modules)
num_ftrs = img_base.fc.in_features
self.attenblock0 = CrossAttention(in_channels=num_ftrs,
out_channels=num_ftrs // 8)
# self.attenblock0 = CrossAttentionShort(in_channels=num_ftrs, out_channels=num_ftrs)
self.conv_layer1 = BasicResLayer(num_ftrs, num_ftrs // 2,
stride=2) # 1024
self.mask_layer1 = MaskConvBlock(num_ftrs, num_ftrs // 2,
padding=1) # 1024
self.glob_layer1 = BasicResLayer(num_ftrs, num_ftrs // 2, stride=2)
self.attenblock1 = CrossAttention(in_channels=num_ftrs // 2,
out_channels=num_ftrs // 8)
# self.attenblock1 = CrossAttentionShort(in_channels=num_ftrs // 2, out_channels=num_ftrs//2)
num_ftrs = num_ftrs // 2
self.conv_layer2 = BasicResLayer(num_ftrs, num_ftrs // 2,
stride=2) # 512
self.mask_layer2 = MaskConvBlock(num_ftrs, num_ftrs // 2,
padding=1) # 512
self.glob_layer2 = BasicResLayer(num_ftrs, num_ftrs // 2, stride=2)
self.attenblock2 = CrossAttention(in_channels=num_ftrs // 2,
out_channels=num_ftrs // 8)
# self.attenblock2 = CrossAttentionShort(in_channels=num_ftrs//2, out_channels=num_ftrs//2)
num_ftrs = num_ftrs // 2
if self.has_embedding:
self.fc_img = nn.Linear(num_ftrs, self.num_features)
self.img_feat_bn = nn.BatchNorm1d(self.num_features)
self.fc_mask = nn.Linear(num_ftrs, self.num_features)
self.mask_feat_bn = nn.BatchNorm1d(self.num_features)
self.fc_glob = nn.Linear(num_ftrs, self.num_features)
self.glob_feat_bn = nn.BatchNorm1d(self.num_features)
nn.init.kaiming_normal_(self.fc_img.weight, mode='fan_out')
nn.init.constant_(self.fc_img.bias, 0)
nn.init.constant_(self.img_feat_bn.weight, 1)
nn.init.constant_(self.img_feat_bn.bias, 0)
nn.init.kaiming_normal_(self.fc_mask.weight, mode='fan_out')
nn.init.constant_(self.fc_mask.bias, 0)
nn.init.constant_(self.mask_feat_bn.weight, 1)
nn.init.constant_(self.mask_feat_bn.bias, 0)
nn.init.kaiming_normal_(self.fc_glob.weight, mode='fan_out')
nn.init.constant_(self.fc_glob.bias, 0)
nn.init.constant_(self.glob_feat_bn.weight, 1)
nn.init.constant_(self.glob_feat_bn.bias, 0)
else:
self.num_features = num_ftrs
# if self.dropout:
# self.concat_drop = nn.Dropout(self.dropout)
# if self.num_class:
# self.concat_cls = nn.Linear(self.num_features*3, self.num_class)
# nn.init.normal_(self.concat_cls.weight, std=0.001)
# nn.init.constant_(self.concat_cls.bias, 0)
if self.dropout > 0:
self.conv_drop = nn.Dropout(self.dropout)
self.mask_drop = nn.Dropout(self.dropout)
self.glob_drop = nn.Dropout(self.dropout)
if self.num_class > 0:
self.conv_cls = nn.Linear(self.num_features, self.num_class)
self.mask_cls = nn.Linear(self.num_features, self.num_class)
self.glob_cls = nn.Linear(self.num_features, self.num_class)
nn.init.normal_(self.conv_cls.weight, std=0.001)
nn.init.constant_(self.conv_cls.bias, 0)
nn.init.normal_(self.mask_cls.weight, std=0.001)
nn.init.constant_(self.mask_cls.bias, 0)
nn.init.normal_(self.glob_cls.weight, std=0.001)
nn.init.constant_(self.glob_cls.bias, 0)
