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