def __init__(self, resnet_layer, pretrained=None):
super(ResNetFPN, self).__init__()
self.lateral_conv1 = nn.Conv2d(2048, 256, kernel_size=1)
self.lateral_conv2 = nn.Conv2d(1024, 256, kernel_size=1)
self.lateral_conv3 = nn.Conv2d(512, 256, kernel_size=1)
self.lateral_conv4 = nn.Conv2d(256, 256, kernel_size=1)
self.anti_aliasing_conv1 = nn.Conv2d(256,
256,
kernel_size=3,
padding=1)
self.anti_aliasing_conv2 = nn.Conv2d(256,
256,
kernel_size=3,
padding=1)
self.anti_aliasing_conv3 = nn.Conv2d(256,
256,
kernel_size=3,
padding=1)
self._init_parameters()
assert resnet_layer in [18, 34, 50, 101, 152]
pretrained = True if pretrained is not None else False
if resnet_layer == 18:
self.resnet = resnet.resnet18(pretrained)
elif resnet_layer == 34:
self.resnet = resnet.resnet34(pretrained)
elif resnet_layer == 50:
self.resnet = resnet.resnet50(pretrained)
elif resnet_layer == 101:
self.resnet = resnet.resnet101(pretrained)
elif resnet_layer == 152:
self.resnet = resnet.resnet152(pretrained)
def __init__(self,
cf,
num_classes=21,
pretrained=False,
net_name='resnet152'):
super(ResNet152, self).__init__(cf)
self.pretrained = pretrained
self.net_name = net_name
if pretrained:
self.model = models.resnet152(pretrained=True)
self.model.fc = nn.Linear(2048, num_classes)
else:
self.model = models.resnet152(pretrained=False,
num_classes=num_classes)
def get_classification_model(classifier_name='resnet18',
num_classes=1000,
pretrained=True):
"""
Get the detection model
:param pretrained:
:param classifier_name:
:param num_classes:
:return:
"""
if classifier_name == 'resnet18':
model = resnet18(pretrained, num_classes=num_classes)
elif classifier_name == 'resnet34':
model = resnet34(pretrained, num_classes=num_classes)
elif classifier_name == 'resnet50':
model = resnet50(pretrained, num_classes=num_classes)
elif classifier_name == 'resnet101':
model = resnet101(pretrained, num_classes=num_classes)
elif classifier_name == 'resnet152':
model = resnet152(pretrained, num_classes=num_classes)
else:
raise ValueError('Unsupported resnet type.')
return model
def __init__(self, backbone='resnet50'):
super().__init__()
if backbone == 'resnet18':
backbone = resnet18(pretrained=True)
self.out_channels = [256, 512, 512, 256, 256, 128]
elif backbone == 'resnet34':
backbone = resnet34(pretrained=True)
self.out_channels = [256, 512, 512, 256, 256, 256]
elif backbone == 'resnet50':
backbone = resnet50(pretrained=True)
self.out_channels = [1024, 512, 512, 256, 256, 256]
elif backbone == 'resnet101':
backbone = resnet101(pretrained=True)
self.out_channels = [1024, 512, 512, 256, 256, 256]
else: # backbone == 'resnet152':
backbone = resnet152(pretrained=True)
self.out_channels = [1024, 512, 512, 256, 256, 256]
self.feature_extractor = nn.Sequential(*list(backbone.children())[:7])
conv4_block1 = self.feature_extractor[-1][0]
conv4_block1.conv1.stride = (1, 1)
conv4_block1.conv2.stride = (1, 1)
conv4_block1.downsample[0].stride = (1, 1)
def __init__(self, backbone="resnet50", backbone_path=None):
super().__init__()
if backbone == "resnet18":
backbone = resnet18(pretrained=not backbone_path)
self.out_channels = [256, 512, 512, 256, 256, 128]
elif backbone == "resnet34":
backbone = resnet34(pretrained=not backbone_path)
self.out_channels = [256, 512, 512, 256, 256, 256]
elif backbone == "resnet50":
backbone = resnet50(pretrained=not backbone_path)
self.out_channels = [1024, 512, 512, 256, 256, 256]
elif backbone == "resnet101":
backbone = resnet101(pretrained=not backbone_path)
self.out_channels = [1024, 512, 512, 256, 256, 256]
else:
backbone = resnet152(pretrained=not backbone_path)
self.out_channels = [1024, 512, 512, 256, 256, 256]
if backbone_path:
backbone.load_state_dict(torch.load(backbone_path))
self.feature_extractor = nn.Sequential(*list(backbone.children())[:7])
conv4_block1 = self.feature_extractor[-1][0]
conv4_block1.conv1.stride = (1, 1)
conv4_block1.conv2.stride = (1, 1)
conv4_block1.downsample[0].stride = (1, 1)
def __init__(self, backbone='resnet50', pretrained_path=None):
super().__init__()
if backbone == 'resnet18':
backbone = resnet18(pretrained=not pretrained_path)
self.final_out_channels = 256
self.low_level_inplanes = 64
elif backbone == 'resnet34':
backbone = resnet34(pretrained=not pretrained_path)
self.final_out_channels = 256
self.low_level_inplanes = 64
elif backbone == 'resnet50':
backbone = resnet50(pretrained=not pretrained_path)
self.final_out_channels = 1024
self.low_level_inplanes = 256
elif backbone == 'resnet101':
backbone = resnet101(pretrained=not pretrained_path)
self.final_out_channels = 1024
self.low_level_inplanes = 256
else: # backbone == 'resnet152':
backbone = resnet152(pretrained=not pretrained_path)
self.final_out_channels = 1024
self.low_level_inplanes = 256
if pretrained_path:
backbone.load_state_dict(torch.load(pretrained_path))
self.early_extractor = nn.Sequential(*list(backbone.children())[:5])
self.later_extractor = nn.Sequential(*list(backbone.children())[5:7])
conv4_block1 = self.later_extractor[-1][0]
conv4_block1.conv1.stride = (1, 1)
conv4_block1.conv2.stride = (1, 1)
conv4_block1.downsample[0].stride = (1, 1)
def __init__(self, backbone, num_classes=21):
super().__init__()
if backbone == 'resnet-18':
self.backbone = resnet18()
self.in_channel = [512, 128, 64, 64]
self.out_channel = [256, 64, 64, 64]
elif backbone == 'resnet-34':
self.backbone = resnet34()
self.in_channel = [512, 128, 64, 64]
self.out_channel = [256, 64, 64, 64]
elif backbone == 'resnet-50':
self.backbone = resnet50()
self.in_channel = [2048, 512, 256, 64]
self.out_channel = [1024, 256, 64, 64]
elif backbone == 'resnet-101':
self.backbone = resnet101()
self.in_channel = [2048, 512, 256, 64]
self.out_channel = [1024, 256, 64, 64]
elif backbone == 'resnet-152':
self.backbone = resnet152()
self.in_channel = [2048, 512, 256, 64]
self.out_channel = [1024, 256, 64, 64]
else:
raise NotImplementedError
self.encoder = Encoder(self.backbone)
self.decoder = Decoder(self.in_channel, self.out_channel)
self.out = nn.Conv2d(64, num_classes, 1)
self._init_weight()
def __init__(self, backbone='resnet50', backbone_path=None):
super().__init__()
if backbone == 'resnet18':
backbone = resnet18(pretrained=not backbone_path)
self.out_channels = [256, 512, 512, 256, 256, 128]
elif backbone == 'resnet34':
backbone = resnet34(pretrained=not backbone_path)
self.out_channels = [256, 512, 512, 256, 256, 256]
elif backbone == 'resnet50':
backbone = resnet50(pretrained=not backbone_path)
self.out_channels = [1024, 512, 512, 256, 256, 256]
elif backbone == 'resnet101':
backbone = resnet101(pretrained=not backbone_path)
self.out_channels = [1024, 512, 512, 256, 256, 256]
else: # backbone == 'resnet152':
backbone = resnet152(pretrained=not backbone_path)
self.out_channels = [1024, 512, 512, 256, 256, 256]
if backbone_path:
backbone.load_state_dict(torch.load(backbone_path))
for name, parameter in backbone.named_parameters():
if 'layer2' not in name and 'layer3' not in name and 'layer4' not in name:
parameter.requires_grad_(False)
self.feature_extractor = nn.Sequential(*list(backbone.children())[:7])
conv4_block1 = self.feature_extractor[-1][0]
conv4_block1.conv1.stride = (1, 1)
conv4_block1.conv2.stride = (1, 1)
conv4_block1.downsample[0].stride = (1, 1)
def __init__(self):
super().__init__()
layers = [3, 8, 36, 3]
self.inplanes = 64
self.conv1 = nn.Conv2d(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(resnet.Bottleneck, 64, layers[0])
self.layer2 = self._make_layer(resnet.Bottleneck,
128,
layers[1],
stride=2)
self.layer3 = self._make_layer(resnet.Bottleneck,
256,
layers[2],
stride=2)
self.layer4 = self._make_layer(resnet.Bottleneck,
512,
layers[3],
stride=2)
pre_model = resnet.resnet152(pretrained=True)
pre_dict = pre_model.state_dict()
self_dict = self.state_dict()
pre_dict = {k: v for k, v in pre_dict.items() if k in self_dict}
self_dict.update(pre_dict)
self.load_state_dict(self_dict)
def get_model(args):
if args.arch == 'resnet152':
def my_forward(self: ResNet, x):
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
x = self.maxpool(x)
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)
# x = self.avgpool(x)
# x = torch.flatten(x, 1)
# x = self.fc(x)
return x
model = resnet152(pretrained=True).cuda()
model.forward = my_forward.__get__(model, ResNet)
model.eval()
elif args.arch == 'vgg16':
full_model = vgg16_bn(pretrained=True).cuda()
full_model.eval()
model = full_model.features
else:
raise Exception
return model
def __init__(self, pretrained=None):
super(HeadCommon, self).__init__()
self.config = ConfigParser()
config_path = os.path.abspath(
os.path.join(__file__, "../../", "config.ini"))
assert os.path.exists(config_path), "config.ini not exists!"
self.config.read(config_path)
self.backbone_type = self.config['BACKBONE']['BACKBONE_TYPE']
_pretrained = True if pretrained is not None else False
assert self.backbone_type in ['resnet', 'vgg16']
if self.backbone_type == 'resnet':
resnet_layer = int(self.config['BACKBONE']['RESNET_LAYER'])
assert resnet_layer in [18, 34, 50, 101, 152]
if resnet_layer == 18:
_resnet = resnet.resnet18(_pretrained)
elif resnet_layer == 34:
_resnet = resnet.resnet34(_pretrained)
elif resnet_layer == 50:
_resnet = resnet.resnet50(_pretrained)
elif resnet_layer == 101:
_resnet = resnet.resnet101(_pretrained)
else:
_resnet = resnet.resnet152(_pretrained)
# using resnet_c5 the last bottle neck of resnet
_resnet.layer4[0].conv2.stride = (1, 1)
_resnet.layer4[0].downsample[0].stride = (1, 1)
self.resnet_c5 = _resnet.layer4
self.resnet_c5_avg = _resnet.avgpool
elif self.backbone_type == 'vgg16':
assert not bool(int(self.config['HEAD']['MASK_HEAD_ON'])), (
"When mask head on, not support vgg16 backbone.")
vgg = vgg16(pretrained=True)
self.vgg_fc = nn.Sequential(
*list(vgg.classifier._modules.values())[:-1])
def __init__(self, mode_name='wide_resnet50_2'):
super(Backbone, self).__init__()
assert mode_name in ('resnet18', 'resnet34', 'resnet50', 'resnet101',
'resnet152', 'resnext50_32x4d',
'resnext101_32x8d', 'wide_resnet50_2',
'wide_resnet101_2')
if mode_name == 'resnet18':
self.res_back_bone = resnet.resnet18()
elif mode_name == 'resnet34':
self.res_back_bone = resnet.resnet34()
elif mode_name == 'resnet50':
self.res_back_bone = resnet.resnet50()
elif mode_name == 'resnet101':
self.res_back_bone = resnet.resnet101()
elif mode_name == 'resnet152':
self.res_back_bone = resnet.resnet152()
elif mode_name == 'resnext50_32x4d':
self.res_back_bone = resnet.resnext50_32x4d()
elif mode_name == 'resnext101_32x8d':
self.res_back_bone = resnet.resnext101_32x8d()
elif mode_name == 'wide_resnet50_2':
self.res_back_bone = resnet.wide_resnet50_2()
else:
self.res_back_bone = resnet.wide_resnet101_2()
self.backbone = nn.Module()
layer0 = nn.Sequential(*list(self.res_back_bone.children())[:4])
self.backbone.add_module('layer0', layer0)
self.backbone.add_module('layer1', self.res_back_bone.layer1)
self.backbone.add_module('layer2', self.res_back_bone.layer2)
self.backbone.add_module('layer3', self.res_back_bone.layer3)
self.backbone.add_module('layer4', self.res_back_bone.layer4)
def __init__(self, resnet_layer, pretrained=None):
super(ResNet, self).__init__()
assert resnet_layer in [18, 34, 50, 101, 152]
pretrained = True if pretrained is not None else False
if resnet_layer == 18:
self.resnet = resnet.resnet18(pretrained)
elif resnet_layer == 34:
self.resnet = resnet.resnet34(pretrained)
elif resnet_layer == 50:
self.resnet = resnet.resnet50(pretrained)
elif resnet_layer == 101:
self.resnet = resnet.resnet101(pretrained)
else:
self.resnet = resnet.resnet152(pretrained)
# fix layer grad
for p in self.resnet.conv1.parameters():
p.requires_grad = False
for p in self.resnet.layer1.parameters():
p.requires_grad = False
for p in self.resnet.layer2.parameters():
p.requires_grad = True
for p in self.resnet.layer3.parameters():
p.requires_grad = True
# fix batch norm layer
for m in self.resnet.modules():
if isinstance(m, nn.BatchNorm2d):
for p in m.parameters():
p.requires_grad = False
def deploy_model(config):
model = resnet152()
model.fc = nn.Linear(model.fc.in_features, 10)
torch.cuda.set_device(config['gpu'])
model.cuda(config['gpu'])
model = torch.nn.parallel.DistributedDataParallel(
model, device_ids=[config['gpu']], find_unused_parameters=True)
return model
def __init__(self,
cf,
num_classes=21,
zero_init_residual=True,
pretrained=False,
net_name='ResNet101'):
super(ResNet101, self).__init__(cf)
self.url = None
self.pretrained = pretrained
self.net_name = net_name
if pretrained:
self.model = models.resnet152(pretrained=True)
self.model.fc = nn.Linear(2048, num_classes)
else:
self.model = models.resnet152(pretrained=False,
num_classes=num_classes)
def __init__(self,
cf,
num_classes=21,
pretrained=False,
net_name='resnet152'):
super(ResNet152, self).__init__(cf)
self.pretrained = pretrained
self.net_name = net_name
if self.pretrained:
self.model = models.resnet152(pretrained=True)
num_ftrs = self.model.fc.in_features
self.model.fc = nn.Linear(num_ftrs, num_classes)
self.model = models.resnet152(pretrained=False,
num_classes=num_classes)
'''if pretrained:
def pre_resnet152(in_channel=3, out_channel=1000):
model = resnet152(pretrained=True, progress=False)
model.conv1 = nn.Conv2d(in_channel,
64,
kernel_size=(7, 7),
stride=(2, 2),
padding=(3, 3),
bias=False)
model.fc = nn.Linear(model.fc.in_features, out_channel)
return model
def resnet152(pretrained=False, **kwargs):
"""Constructs a ResNet-152 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet_C5(Bottleneck, [3, 8, 36, 3], **kwargs)
model_full = resnet.resnet152(pretrained=True)
if pretrained:
model.load_pretrained(model_full)
return model
def get_base_model(name):
if name == "resnet18":
return resnet.resnet18()
if name == "resnet34":
return resnet.resnet34()
if name == "resnet50":
return resnet.resnet50()
if name == "resnet101":
return resnet.resnet101()
if name == "resnet152":
return resnet.resnet152()
def resnet152(pretrained=False, fixed_feature=True):
""" "ResNet-152 model from torchvision's resnet model.
:param pretrained: if true, return a model pretrained on ImageNet
:param fixed_feature: if true and pretrained is true, model features are fixed while training.
"""
from torchvision.models.resnet import resnet152
model = resnet152(pretrained)
ff = True if pretrained and fixed_feature else False
return _ResNet(model, ff)
def resnet_variant_builder(variant):
if str(variant) == '50':
return resnet50()
elif str(variant) == '101':
return resnet101()
elif str(variant) == '152':
return resnet152()
else:
raise ValueError(
'The variant Resnet{} is currently not supported'.format(
variant))
def get_backbone(self, name, pretrained):
if name == "resne34":
return resnet34(pretrained=pretrained)
elif name == "resnet50":
return resnet50(pretrained=pretrained)
elif name == "resnet101":
return resnet101(pretrained=pretrained)
elif name == "resnet152":
return resnet152(pretrained=pretrained)
else:
return resnet18(pretrained=pretrained) #default
def __init__(self, cf, num_classes=21, pretrained=False, net_name='resnet'):
super(ResNet, self).__init__(cf)
self.url = 'http://datasets.cvc.uab.es/models/pytorch/basic_vgg16.pth'
self.pretrained = pretrained
self.net_name = net_name
self.model = models.resnet152(pretrained=self.pretrained, num_classes=num_classes)
if pretrained:
self.model.fc = nn.Linear(512, num_classes)
def build_bottleneck_resnet(depth, nb_classes, mode='cifar'):
if mode == 'cifar':
nb = (depth - 2) // 9
return CifarResNet(Bottleneck, [nb, nb, nb], nb_classes)
elif mode == 'imagenet':
if depth == 50:
return resnet50(pretrained=False)
elif depth == 152:
return resnet152(pretrained=False)
else:
raise Exception(
"Only support resent50 and resnet 152 on Imagenet.")
def get_backbone(backbone_name):
if backbone_name == 'vgg16':
return vgg16(pretrained=True)
elif backbone_name == 'resnet50':
return resnet50(pretrained=True)
elif backbone_name == 'resnet101':
return resnet101(pretrained=True)
elif backbone_name == 'resnet152':
return resnet152(pretrained=True)
else:
raise ValueError(
'Only "vgg16", "resnet50", "resnet101" and "resnet152" are supported backbone names'
)
def __init__(self):
super(CNN, self).__init__()
cnn = resnet.resnet152(pretrained=True)
self.modifiedCNN = nn.Sequential(*list(cnn.children())[:-1])
# Using the imagenet mean and std
self.transform = transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(( 0.485, 0.456, 0.406 ),
( 0.229, 0.224, 0.225 ))])
def create_model(model_name, num_classes=1000, pretrained=False, **kwargs):
if 'test_time_pool' in kwargs:
test_time_pool = kwargs.pop('test_time_pool')
else:
test_time_pool = True
if 'extra' in kwargs:
extra = kwargs.pop('extra')
else:
extra = True
if model_name == 'dpn68':
model = dpn68(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn68b':
model = dpn68b(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn92':
model = dpn92(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool, extra=extra)
elif model_name == 'dpn98':
model = dpn98(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn131':
model = dpn131(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn107':
model = dpn107(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'resnet18':
model = resnet18(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet34':
model = resnet34(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet50':
model = resnet50(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet101':
model = resnet101(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet152':
model = resnet152(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet121':
model = densenet121(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet161':
model = densenet161(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet169':
model = densenet169(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet201':
model = densenet201(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'inception_v3':
model = inception_v3(
num_classes=num_classes, pretrained=pretrained, transform_input=False, **kwargs)
else:
assert False, "Unknown model architecture (%s)" % model_name
return model
def create_model(model_name, num_classes=1000, pretrained=False, **kwargs):
if 'test_time_pool' in kwargs:
test_time_pool = kwargs.pop('test_time_pool')
else:
test_time_pool = True
if 'extra' in kwargs:
extra = kwargs.pop('extra')
else:
extra = True
if model_name == 'dpn68':
model = dpn68(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn68b':
model = dpn68b(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn92':
model = dpn92(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool, extra=extra)
elif model_name == 'dpn98':
model = dpn98(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn131':
model = dpn131(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn107':
model = dpn107(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'resnet18':
model = resnet18(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet34':
model = resnet34(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet50':
model = resnet50(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet101':
model = resnet101(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet152':
model = resnet152(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet121':
model = densenet121(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet161':
model = densenet161(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet169':
model = densenet169(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet201':
model = densenet201(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'inception_v3':
model = inception_v3(
num_classes=num_classes, pretrained=pretrained, transform_input=False, **kwargs)
else:
assert False, "Unknown model architecture (%s)" % model_name
return model
def __init__(self, resnet_layer, pretrained=None):
super(ResNet, self).__init__()
assert resnet_layer in [18, 34, 50, 101, 152]
pretrained = True if pretrained is not None else False
if resnet_layer == 18:
self.resnet = resnet.resnet18(pretrained)
elif resnet_layer == 34:
self.resnet = resnet.resnet34(pretrained)
elif resnet_layer == 50:
self.resnet = resnet.resnet50(pretrained)
elif resnet_layer == 101:
self.resnet = resnet.resnet101(pretrained)
elif resnet_layer == 152:
self.resnet = resnet.resnet152(pretrained)
def build_model(stage=3):
cnn = resnet.resnet152(pretrained=True)
layers = [
cnn.conv1,
cnn.bn1,
cnn.relu,
cnn.maxpool,
]
for i in range(stage):
name = 'layer%d' % (i + 1)
layers.append(getattr(cnn, name))
model = torch.nn.Sequential(*layers)
model.cuda()
model.eval()
return model
def resnet152_planet(pretrained=False):
model = resnet152(False, num_classes=17)
if pretrained:
# load model dictionary
model_dict = model.state_dict()
# load pretrained model
pretrained_dict = model_zoo.load_url(model_urls['resnet152'])
# update model dictionary using pretrained model without classifier layer
model_dict.update({
key: pretrained_dict[key]
for key in pretrained_dict.keys() if 'fc' not in key
})
model.load_state_dict(model_dict)
return model
