def __init__(self, enet_type, out_dim, n_meta_features=0, n_meta_dim=[512, 128], pretrained=False): super(Seresnext_Melanoma, self).__init__() self.n_meta_features = n_meta_features if pretrained: self.enet = se_resnext101_32x4d(num_classes=1000, pretrained='imagenet') else: self.enet = se_resnext101_32x4d(num_classes=1000, pretrained=None) self.enet.avg_pool = nn.AdaptiveAvgPool2d((1, 1)) self.dropouts = nn.ModuleList([nn.Dropout(0.5) for _ in range(5)]) in_ch = self.enet.last_linear.in_features if n_meta_features > 0: self.meta = nn.Sequential( nn.Linear(n_meta_features, n_meta_dim[0]), nn.BatchNorm1d(n_meta_dim[0]), Swish_Module(), nn.Dropout(p=0.3), nn.Linear(n_meta_dim[0], n_meta_dim[1]), nn.BatchNorm1d(n_meta_dim[1]), Swish_Module(), ) in_ch += n_meta_dim[1] self.myfc = nn.Linear(in_ch, out_dim) self.enet.last_linear = nn.Identity()
def __init__(self, num_classes=1, num_filters=32, pretrained=True, is_deconv=False): super().__init__() self.num_classes = num_classes self.pool = nn.MaxPool2d(2, 2) if pretrained: self.encoder = se_resnext101_32x4d(num_classes=1000, pretrained='imagenet') else: self.encoder = se_resnext101_32x4d(num_classes=1000, pretrained=None) self.conv1 = self.encoder.layer0 self.conv2 = self.encoder.layer1 self.conv3 = self.encoder.layer2 self.conv4 = self.encoder.layer3 self.conv5 = self.encoder.layer4 self.center = DecoderBlock(2048, num_filters * 8, num_filters * 8, is_deconv=is_deconv) self.dec5 = DecoderBlock(2048 + num_filters * 8, num_filters * 8, num_filters * 8, is_deconv=is_deconv) self.dec4 = DecoderBlock(1024 + num_filters * 8, num_filters * 8, num_filters * 8, is_deconv=is_deconv) self.dec3 = DecoderBlock(512 + num_filters * 8, num_filters * 2, num_filters * 2, is_deconv=is_deconv) self.dec2 = DecoderBlock(256 + num_filters * 2, num_filters * 2, num_filters, is_deconv=is_deconv) self.dec1 = DecoderBlock(64 + num_filters, num_filters , num_filters, is_deconv=is_deconv) self.dec0 = ConvRelu(num_filters, num_filters) self.final = nn.Conv2d(num_filters, num_classes, kernel_size=1)
def __init__(self, out_channels=7, pretrained=True, nodes=(32, 32), dropout=0, enhance_diag=True, aux_pred=True): super(rx101_gcn_3head_4channel, self).__init__() # same with res_fdcs_v5 self.aux_pred = aux_pred self.node_size = nodes self.num_cluster = out_channels if pretrained: resnet = se_resnext101_32x4d() else: resnet = se_resnext101_32x4d(pretrained=None) print('NOTE: No pretraining') self.layer0, self.layer1, self.layer2, self.layer3, = \ resnet.layer0, resnet.layer1, resnet.layer2, resnet.layer3 self.conv0 = torch.nn.Conv2d(4, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False) for child in self.layer0.children(): for param in child.parameters(): par = param break break self.conv0.parameters = torch.cat([par[:, 0, :, :].unsqueeze(1), par], 1) self.layer0 = torch.nn.Sequential(self.conv0, *list(self.layer0)[1:4]) self.graph_layers1 = GCN_Layer(1024, 128, bnorm=True, activation=nn.ReLU(True), dropout=dropout) self.graph_layers2 = GCN_Layer(128, out_channels, bnorm=False, activation=None) self.scg = SCG_block(in_ch=1024, hidden_ch=out_channels, node_size=nodes, add_diag=enhance_diag, dropout=dropout) weight_xavier_init(self.graph_layers1, self.graph_layers2, self.scg)
def __init__(self): self.model = se_resnext101_32x4d(pretrained='imagenet') def base_arch(pretrained=True): return self.model self.base_arch = base_arch
def build_model(model_name): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # load pretrained model model_name = model_name # could be fbresnet152 or inceptionresnetv2 if (model_name == 'senet154'): model = pretrainedmodels.senet154(pretrained='imagenet') elif (model_name == 'se_resnet152'): model = pretrainedmodels.se_resnet152(pretrained='imagenet') elif (model_name == 'se_resnext101_32x4d'): model = pretrainedmodels.se_resnext101_32x4d(pretrained='imagenet') elif (model_name == 'resnet152'): model = pretrainedmodels.resnet152(pretrained='imagenet') elif (model_name == 'resnet101'): model = pretrainedmodels.resnet101(pretrained='imagenet') elif (model_name == 'densenet201'): model = pretrainedmodels.densenet201(pretrained='imagenet') model.to(device) for param in model.parameters(): param.requires_grad = False num_ftrs = model.last_linear.in_features class CustomModel(nn.Module): def __init__(self, model): super(CustomModel, self).__init__() self.features = nn.Sequential(*list(model.children())[:-1]) self.classifier = nn.Sequential( torch.nn.Linear(num_ftrs, 128), torch.nn.Dropout(0.3), # drop 50% of the neuron torch.nn.Linear(128, 7)) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x model = CustomModel(model) freeze_layer(model.features) num_ftrs = list(model.classifier.children())[-1].out_features model.to(device) model.name = model_name PATH = os.path.abspath(os.path.dirname(__file__)) PATH_par = os.path.abspath(os.path.join(PATH, os.pardir)) path_to_model = os.path.join(PATH_par, 'pretrained_model', '128_7') model.load_state_dict( torch.load(os.path.join(path_to_model, '%s.pth' % (model_name)))) model.to(device) for param in model.parameters(): param.requires_grad = False return model, num_ftrs
def create_net(name, pretrained=True): if name == 'se_resnext50_32x4d': return pm.se_resnext50_32x4d() elif name == 'se_resnext101_32x4d': return pm.se_resnext101_32x4d() elif name == 'resnext101_32x8d_wsl': return torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x8d_wsl') else: raise Exception('name ' + str(name) + ' is not supported')
def make_backend_se_resnext101_32x4d(pretrained=True): model = pretrainedmodels.se_resnext101_32x4d( pretrained='imagenet' if pretrained else None) weight = model.layer0[0].weight conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) conv1.weight = nn.Parameter(torch.mean(weight, dim=1, keepdim=True)) layer0 = nn.Sequential(conv1, model.layer0[1], model.layer0[2], model.layer0[3]) model.layer0 = layer0 return model
def get_resnet(self, name): resnets = { "resnet18": torchvision.models.resnet18(), "resnet50": torchvision.models.resnet50(), "se_resnet50" : pretrainedmodels.se_resnet50(num_classes=1000, pretrained="imagenet"), "se_resnext101_32x4d" : pretrainedmodels.se_resnext101_32x4d(num_classes=1000, pretrained="imagenet"), } if name not in resnets.keys(): raise KeyError(f"{name} is not a valid Model (ResNet) version") return resnets[name]
def _get_convnet(self, backbone, pretrained): if backbone == 'resnet34': convnet = nn.Sequential( *list(models.resnet34(pretrained=pretrained).children())[:-1]) shape = (512, 4 * 5) add_bn = True elif backbone == 'resnet50': convnet = nn.Sequential( *list(models.resnet50(pretrained=pretrained).children())[:-1]) shape = (2048, 4 * 5) add_bn = True elif backbone == 'resnet101': convnet = nn.Sequential( *list(models.resnet101(pretrained=pretrained).children())[:-1]) shape = (2048, 4 * 5) add_bn = True elif backbone == 'resnet152': convnet = nn.Sequential( *list(models.resnet152(pretrained=pretrained).children())[:-1]) shape = (2048, 4 * 5) add_bn = True elif backbone == 'densenet121': convnet = nn.Sequential( models.densenet121(pretrained=pretrained).features, nn.ReLU(inplace=True), nn.AvgPool2d(7, stride=1)) shape = (1024, 4 * 5) add_bn = False elif backbone == 'densenet201': convnet = nn.Sequential( models.densenet201(pretrained=pretrained).features, nn.ReLU(inplace=True), nn.AvgPool2d(7, stride=1)) shape = (1920, 4 * 5) add_bn = False elif backbone == 'se_resnext_50': pretrain = 'imagenet' if pretrained else None convnet = nn.Sequential(*list( se_resnext50_32x4d(num_classes=1000, pretrained=pretrain).children())[:-1]) shape = (2048, 4 * 5) add_bn = True elif backbone == 'se_resnext_101': pretrain = 'imagenet' if pretrained else None convnet = nn.Sequential(*list( se_resnext101_32x4d(num_classes=1000, pretrained=pretrain).children())[:-1]) shape = (2048, 4 * 5) add_bn = True elif backbone == 'sphere_net': convnet = PlainNet() shape = (512, 16 * 16) add_bn = False else: raise ValueError("Backbone [%s] not recognized." % backbone) return convnet, shape, add_bn
def __init__(self, num_classes, pretrained="imagenet", pool_type="concat"): super().__init__() self.net = se_resnext101_32x4d(pretrained=pretrained) if pool_type == "concat": self.net.avg_pool = AdaptiveConcatPool2d() last_channel = 2048 * 2 elif pool_type == "gem": self.net.avg_pool = GeM() last_channel = 2048 self.net.last_linear = nn.Sequential( Flatten(), SEBlock(last_channel), nn.Dropout(), nn.Linear(last_channel, num_classes))
def nets(model, num_class): if model == 'inceptionv4': model = ptm.inceptionv4(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'senet154': model = ptm.senet154(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'pnasnet': model = ptm.pnasnet5large(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'xception': model = ptm.xception(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'incepresv2': model = ptm.inceptionresnetv2(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'resnet152': model = models.resnet152(pretrained=True) model.fc = nn.Linear(2048, num_class) return model if model == 'se_resxt101': model = ptm.se_resnext101_32x4d(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'nasnet': model = ptm.nasnetalarge(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'dpn': # 224 input size model = ptm.dpn107(num_classes=1000, pretrained='imagenet+5k') model.last_linear = nn.Conv2d(model.last_linear.in_channels, num_class, kernel_size=1, bias=True) return model if model == 'resnext101':# 320 input size model = torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl') model.fc = nn.Linear(2048, num_class) return model
def __init__(self, senet_version='se_resnext50_32x4d', input_size=128, num_classes=340, pretrained='imagenet', dropout=0.): super().__init__() if senet_version == 'se_resnext50_32x4d': self.model = se_resnext50_32x4d(pretrained=pretrained) elif senet_version == 'se_resnext101_32x4d': self.model = se_resnext101_32x4d(pretrained=pretrained) self.features = self.model.features self.relu = nn.ReLU() self.avg_pool = nn.AvgPool2d(input_size // 32, stride=1, padding=0) self.dropout = nn.Dropout(p=dropout) self.last_linear = nn.Linear(2048, num_classes)
def __init__(self, train_fe=True, use_cuda=True, feature_extraction_cnn='vgg', last_layer=''): super(FeatureExtraction, self).__init__() if feature_extraction_cnn == 'vgg': model_urls['vgg16'] = model_urls['vgg16'].replace( 'https://', 'http://') self.model = models.vgg16(pretrained=True) # keep feature extraction network up to indicated layer vgg_feature_layers = [ 'conv1_1', 'relu1_1', 'conv1_2', 'relu1_2', 'pool1', 'conv2_1', 'relu2_1', 'conv2_2', 'relu2_2', 'pool2', 'conv3_1', 'relu3_1', 'conv3_2', 'relu3_2', 'conv3_3', 'relu3_3', 'pool3', 'conv4_1', 'relu4_1', 'conv4_2', 'relu4_2', 'conv4_3', 'relu4_3', 'pool4', 'conv5_1', 'relu5_1', 'conv5_2', 'relu5_2', 'conv5_3', 'relu5_3', 'pool5' ] if last_layer == '': last_layer = 'pool4' last_layer_idx = vgg_feature_layers.index(last_layer) self.model = nn.Sequential( *list(self.model.features.children())[:last_layer_idx + 1]) if feature_extraction_cnn == 'resnet101': resnet_urls['resnet101'] = resnet_urls['resnet101'].replace( 'https://', 'http://') self.model = models.resnet101(pretrained=True) resnet_feature_layers = [ 'conv1', 'bn1', 'relu', 'maxpool', 'layer1', 'layer2', 'layer3', 'layer4' ] if last_layer == '': last_layer = 'layer3' last_layer_idx = resnet_feature_layers.index(last_layer) resnet_module_list = [ self.model.conv1, self.model.bn1, self.model.relu, self.model.maxpool, self.model.layer1, self.model.layer2, self.model.layer3, self.model.layer4 ] self.model = nn.Sequential(*resnet_module_list[:last_layer_idx + 1]) if feature_extraction_cnn == 'resnext101': self.model = pretrainedmodels.resnext101_32x4d( pretrained='imagenet') self.model = nn.Sequential(*list(self.model.children())[0][:-1]) if feature_extraction_cnn == 'se_resnext101': self.model = pretrainedmodels.se_resnext101_32x4d( pretrained='imagenet') self.model = nn.Sequential(*list(self.model.children())[:-3]) if feature_extraction_cnn == 'densenet169': self.model = models.densenet169(pretrained=True) self.model = nn.Sequential( *list(self.model.features.children())[:-3]) if not train_fe: # freeze parameters for param in self.model.parameters(): param.requires_grad = False # print('FeatureExtraction Network is Freezed') # move to GPU if use_cuda: self.model.cuda()
import models import torchvision import pretrainedmodels MODEL_DISPATCHER = { 'se_resnext50': models.SEResNextModel(model=pretrainedmodels.se_resnext50_32x4d()), 'se_resnext101': models.SEResNextModel(model=pretrainedmodels.se_resnext101_32x4d()), 'densenet121': models.DensenetModel(model=torchvision.models.densenet121( pretrained=True)), 'densenet169': models.DensenetModel(model=torchvision.models.densenet169( pretrained=True)), 'densenet161': models.DensenetModel(model=torchvision.models.densenet161( pretrained=True)), 'efficientnet-b2': models.EfficientNetModel(model_name='efficientnet-b2'), 'efficientnet-b3': models.EfficientNetModel(model_name='efficientnet-b3'), 'efficientnet-b4': models.EfficientNetModel(model_name='efficientnet-b4'), 'efficientnet-b5': models.EfficientNetModel(model_name='efficientnet-b5'), }
def __init__(self, in_channels, out_channels, num_classes, model='seresnext50', pretrained=False, dropout=0, scale=64): super().__init__() assert model in ['seresnext50', 'seresnext101', 'senet154'] pretrained_dataset = 'imagenet' if pretrained else None if model == 'seresnext50': self.model = se_resnext50_32x4d(pretrained=pretrained_dataset) inplanes = 64 elif model == 'seresnext101': self.model = se_resnext101_32x4d(pretrained=pretrained_dataset) inplanes = 64 elif model == 'senet154': self.model = senet154(pretrained=pretrained_dataset) self.model.dropout = nn.Identity() inplanes = 128 else: assert False layer0_modules = [('conv1', nn.Conv2d(in_channels, 64, 3, stride=2, padding=1, bias=False)), ('bn1', nn.BatchNorm2d(64)), ('relu1', nn.ReLU(inplace=True)), ('conv2', nn.Conv2d(64, 64, 3, stride=1, padding=1, bias=False)), ('bn2', nn.BatchNorm2d(64)), ('relu2', nn.ReLU(inplace=True)), ('conv3', nn.Conv2d(64, inplanes, 3, stride=1, padding=1, bias=False)), ('bn3', nn.BatchNorm2d(inplanes)), ('relu3', nn.ReLU(inplace=True)), ('pool', nn.MaxPool2d(3, stride=2, ceil_mode=True))] self.model.layer0 = nn.Sequential(OrderedDict(layer0_modules)) self.model.avg_pool = nn.Sequential(CatPool2d(), GaussianNoise(), nn.Flatten()) #self.dist = DistanceLayer(self.model.last_linear.in_features, num_classes, middle_feature=None, scale=64, n_centers=5, dropout=0) #self.margin = ArcMarginProduct(self.model.last_linear.in_features, num_classes) self.mos = MoSLayer(2 * self.model.last_linear.in_features, num_classes, middle_feature=512, prior_feature=1024, scale=64, n_softmax=10, dropout=0) self.model.last_linear = nn.Identity() replace_relu(self.model) #self.out_proj = nn.Sequential(nn.Conv2d(self.model.layer4[-1].conv3.out_channels, out_channels, kernel_size=3, padding=1), # nn.Sigmoid()) self.scale = scale
def SK_se_resnext101_32x4d(num_classes=1000, pretrained='imagenet'): model = pretrainedmodels.se_resnext101_32x4d() model.last_linear = nn.Linear(2048, num_classes, bias=True) return model
def get_se_resnext101_pretrained_model(num_classes): pretrained_seresnext101 = se_resnext101_32x4d() pretrained_seresnext101.avg_pool = nn.AdaptiveAvgPool2d((1, 1)) pretrained_seresnext101.last_linear = nn.Linear(2048, num_classes) return pretrained_seresnext101
def build_model(model_name): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # load pretrained model model_name = model_name # could be fbresnet152 or inceptionresnetv2 if(model_name == 'senet154'): model = pretrainedmodels.senet154(pretrained='imagenet') elif(model_name == 'se_resnet152'): model = pretrainedmodels.se_resnet152(pretrained='imagenet') elif(model_name == 'se_resnext101_32x4d'): model = pretrainedmodels.se_resnext101_32x4d(pretrained='imagenet') elif(model_name == 'resnet152'): model = pretrainedmodels.resnet152(pretrained='imagenet') elif(model_name == 'resnet101'): model = pretrainedmodels.resnet101(pretrained='imagenet') elif(model_name == 'densenet201'): model = pretrainedmodels.densenet201(pretrained='imagenet') model.to(device) for param in model.parameters(): param.requires_grad = False num_ftrs = model.last_linear.in_features class CustomModel(nn.Module): def __init__(self, model): super(CustomModel, self).__init__() self.features = nn.Sequential(*list(model.children())[:-1] ) self.classifier = nn.Sequential( torch.nn.Linear(num_ftrs, 128), torch.nn.Dropout(0.3), # drop 50% of the neuron torch.nn.Linear(128, 7) ) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x model = CustomModel(model) freeze_layer(model.features) model.to(device) for param in model.parameters(): param.requires_grad = False class CustomModel1(nn.Module): def __init__(self, model): super(CustomModel1, self).__init__() self.features = nn.Sequential(*list(model.children())[:-1]) self.classifier = nn.Sequential( *[list(model.classifier.children())[i] for i in [0]] ) def forward(self, x): x = self.features(x) x = x.view(x.size(0), -1) x = self.classifier(x) return x CustomModel = CustomModel1(model) num_ftrs = list(CustomModel.classifier.children())[-1].out_features CustomModel.to(device) return CustomModel, num_ftrs
def initialize_model(model_name, num_classes, feature_extract, use_pretrained=True): # Initialize these variables which will be set in this if statement. Each of these # variables is model specific. model_ft = None input_size = 0 if model_name == "se_resnext50_32x4d": model_ft = pretrainedmodels.se_resnext50_32x4d(num_classes=1000, pretrained='imagenet') set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.last_linear.in_features # print('model_ft.last_linear.in_features: ', num_ftrs) model_ft.last_linear = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "se_resnext101_32x4d": model_ft = pretrainedmodels.se_resnext101_32x4d(num_classes=1000, pretrained='imagenet') set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.last_linear.in_features model_ft.last_linear = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "PolyNet": model_ft = pretrainedmodels.polynet(num_classes=1000, pretrained='imagenet') set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.last_linear.in_features model_ft.last_linear = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "SENet154": model_ft = pretrainedmodels.senet154(num_classes=1000, pretrained='imagenet') set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.last_linear.in_features model_ft.last_linear = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "resnet-18": """ Resnet18 """ model_ft = models.resnet18(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "resnet-50": """ Resnet50 """ model_ft = models.resnet50(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.fc.in_features # model_ft.fc = nn.Linear(num_ftrs, num_classes) model_ft.fc = nn.Sequential(nn.Dropout(p=0.4), nn.Linear(num_ftrs, num_classes)) input_size = 224 elif model_name == "resnet-152": """ Resnet152 """ model_ft = models.resnet152(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "alexnet": """ Alexnet """ model_ft = models.alexnet(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "vgg": """ VGG11_bn """ model_ft = models.vgg11_bn(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "squeezenet": """ Squeezenet """ model_ft = models.squeezenet1_0(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) model_ft.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1, 1), stride=(1, 1)) model_ft.num_classes = num_classes input_size = 224 elif model_name == "densenet": """ Densenet """ model_ft = models.densenet121(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "inception": """ Inception v3 Be careful, expects (299,299) sized images and has auxiliary output """ model_ft = models.inception_v3(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) # Handle the auxilary net num_ftrs = model_ft.AuxLogits.fc.in_features model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes) # Handle the primary net num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 299 else: print("Invalid model name, exiting...") exit() return model_ft, input_size
def build_backbone(self, base_model_name: str, pretrained: bool, finetune: bool, layer_freezed=3, num_classes: int = 4): base_model_accepted = [ "mobilenetv2", "vgg16", "resnet18", "resnet50", "resnext50", "seresnext50", "seresnext101", ] efficientnetns = ["efficientnetnsb" + str(i) for i in range(1, 8)] efficientnet = ["efficientnetb" + str(i) for i in range(1, 8)] base_model_accepted += efficientnetns + efficientnet # Mobilenet v2 if base_model_name == "mobilenetv2": backbone = torchvision.models.mobilenet_v2(pretrained).features if finetune: self.set_grad_for_finetunning(backbone, 7) num_ftrs = backbone.classifier[-1].in_features backbone.classifier[-1] = torch.nn.Linear(num_ftrs, num_classes) # VGG 16 elif base_model_name == "vgg16": backbone = torchvision.models.vgg16(pretrained).features if finetune: self.set_grad_for_finetunning(backbone, 10) num_ftrs = backbone.classifier[-1].in_features backbone.classifier[-1] = torch.nn.Linear(num_ftrs, num_classes) # ResNet 18 elif base_model_name == "resnet18": backbone = torchvision.models.resnet18(pretrained) if finetune: self.set_grad_for_finetunning(backbone, 7) num_ftrs = backbone.fc.in_features backbone.fc = torch.nn.Linear(num_ftrs, num_classes) # ResNet 50 elif base_model_name == "resnet50": backbone = torchvision.models.resnet50(pretrained) if finetune: self.set_grad_for_finetunning(backbone, 7) num_ftrs = backbone.fc.in_features backbone.fc = torch.nn.Linear(num_ftrs, num_classes) # ResNext 50 elif base_model_name == "resnext50": backbone = torchvision.models.resnext50_32x4d(pretrained) if finetune: self.set_grad_for_finetunning(backbone, 7) num_ftrs = backbone.fc.in_features backbone.fc = torch.nn.Linear(num_ftrs, num_classes) # EfficientNet elif base_model_name[:-1] == "efficientnetb": n = base_model_name[-1] backbone = CustomEfficientNet.from_pretrained("efficientnet-b" + str(n)) if finetune: self.set_grad_for_finetunning(backbone, 3) num_ftrs = backbone._fc.in_features backbone._fc = torch.nn.Linear(num_ftrs, num_classes) # EfficientNet Noisy Student elif base_model_name[:-1] == "efficientnetnsb": n = base_model_name[-1] backbone = timm.create_model(f"tf_efficientnet_b{n}_ns", num_classes=4, pretrained=True) if finetune: self.set_grad_for_finetunning(backbone, layer_freezed) num_ftrs = backbone.classifier.in_features backbone.classifier = torch.nn.Linear(num_ftrs, num_classes) # SE ResNeXt50 elif base_model_name == "seresnext50": backbone = pretrainedmodels.se_resnext50_32x4d() if finetune: self.set_grad_for_finetunning(backbone, 3) num_ftrs = backbone.last_linear.in_features backbone.last_linear = torch.nn.Linear(num_ftrs, num_classes) # SE ResNeXt101 elif base_model_name == "seresnext101": backbone = pretrainedmodels.se_resnext101_32x4d() if finetune: self.set_grad_for_finetunning(backbone, 3) num_ftrs = backbone.last_linear.in_features backbone.last_linear = torch.nn.Linear(num_ftrs, num_classes) else: print("Backbone model should be one of the following list: ") for name in base_model_accepted: print(" - {}".format(name)) raise NotImplementedError return backbone
def __init__(self, backbone, heads, head_conv=128, num_filters=[256, 256, 256], pretrained=True, dcn=False, gn=False, ws=False, freeze_bn=False, after_non_local='layer1', non_local_hidden_channels=None): super().__init__() self.heads = heads if backbone == 'resnet18': pretrained = 'imagenet' if pretrained else None self.backbone = pretrainedmodels.resnet18(pretrained=pretrained) num_bottleneck_filters = 512 elif backbone == 'resnet34': pretrained = 'imagenet' if pretrained else None self.backbone = pretrainedmodels.resnet34(pretrained=pretrained) num_bottleneck_filters = 512 elif backbone == 'resnet50': pretrained = 'imagenet' if pretrained else None self.backbone = pretrainedmodels.resnet50(pretrained=pretrained) num_bottleneck_filters = 2048 elif backbone == 'resnet101': pretrained = 'imagenet' if pretrained else None self.backbone = pretrainedmodels.resnet101(pretrained=pretrained) num_bottleneck_filters = 2048 elif backbone == 'resnet152': pretrained = 'imagenet' if pretrained else None self.backbone = pretrainedmodels.resnet152(pretrained=pretrained) num_bottleneck_filters = 2048 elif backbone == 'se_resnext50_32x4d': pretrained = 'imagenet' if pretrained else None self.backbone = pretrainedmodels.se_resnext50_32x4d( pretrained=pretrained) num_bottleneck_filters = 2048 elif backbone == 'se_resnext101_32x4d': pretrained = 'imagenet' if pretrained else None self.backbone = pretrainedmodels.se_resnext101_32x4d( pretrained=pretrained) num_bottleneck_filters = 2048 elif backbone == 'resnet34_v1b': self.backbone = timm.create_model('gluon_resnet34_v1b', pretrained=pretrained) convert_to_inplace_relu(self.backbone) num_bottleneck_filters = 512 elif backbone == 'resnet50_v1d': self.backbone = timm.create_model('gluon_resnet50_v1d', pretrained=pretrained) convert_to_inplace_relu(self.backbone) num_bottleneck_filters = 2048 elif backbone == 'resnet101_v1d': self.backbone = timm.create_model('gluon_resnet101_v1d', pretrained=pretrained) convert_to_inplace_relu(self.backbone) num_bottleneck_filters = 2048 elif backbone == 'resnext50_32x4d': self.backbone = timm.create_model('resnext50_32x4d', pretrained=pretrained) convert_to_inplace_relu(self.backbone) num_bottleneck_filters = 2048 elif backbone == 'resnext50d_32x4d': self.backbone = timm.create_model('resnext50d_32x4d', pretrained=pretrained) convert_to_inplace_relu(self.backbone) num_bottleneck_filters = 2048 elif backbone == 'seresnext26_32x4d': self.backbone = timm.create_model('seresnext26_32x4d', pretrained=pretrained) convert_to_inplace_relu(self.backbone) num_bottleneck_filters = 2048 elif backbone == 'resnet18_ctdet': self.backbone = models.resnet18() state_dict = torch.load( 'pretrained_weights/ctdet_coco_resdcn18.pth')['state_dict'] self.backbone.load_state_dict(state_dict, strict=False) num_bottleneck_filters = 512 elif backbone == 'resnet50_maskrcnn': self.backbone = models.detection.maskrcnn_resnet50_fpn( pretrained=pretrained).backbone.body print(self.backbone) num_bottleneck_filters = 2048 else: raise NotImplementedError if after_non_local is not None: self.after_non_local = after_non_local in_channels = getattr(self.backbone, after_non_local)[0].conv1.in_channels if non_local_hidden_channels is None: non_local_hidden_channels = in_channels // 2 self.non_local = NonLocal2d(in_channels, non_local_hidden_channels) if freeze_bn: for m in self.backbone.modules(): if isinstance(m, nn.BatchNorm2d): m.weight.requires_grad = False m.bias.requires_grad = False self.lateral4 = nn.Sequential( Conv2d(num_bottleneck_filters, num_filters[0], kernel_size=1, bias=False, ws=ws), nn.GroupNorm(32, num_filters) if gn else nn.BatchNorm2d(num_filters[0]), nn.ReLU(inplace=True)) self.lateral3 = nn.Sequential( Conv2d(num_bottleneck_filters // 2, num_filters[0], kernel_size=1, bias=False, ws=ws), nn.GroupNorm(32, num_filters[0]) if gn else nn.BatchNorm2d(num_filters[0]), nn.ReLU(inplace=True)) self.lateral2 = nn.Sequential( Conv2d(num_bottleneck_filters // 4, num_filters[1], kernel_size=1, bias=False, ws=ws), nn.GroupNorm(32, num_filters[1]) if gn else nn.BatchNorm2d(num_filters[1]), nn.ReLU(inplace=True)) self.lateral1 = nn.Sequential( Conv2d(num_bottleneck_filters // 8, num_filters[2], kernel_size=1, bias=False, ws=ws), nn.GroupNorm(32, num_filters) if gn else nn.BatchNorm2d(num_filters[2]), nn.ReLU(inplace=True)) self.decode3 = nn.Sequential( DCN(num_filters[0], num_filters[1], kernel_size=3, padding=1, stride=1) if dcn else \ Conv2d(num_filters[0], num_filters[1], kernel_size=3, padding=1, bias=False, ws=ws), nn.GroupNorm(32, num_filters[1]) if gn else nn.BatchNorm2d(num_filters[1]), nn.ReLU(inplace=True)) self.decode2 = nn.Sequential( Conv2d(num_filters[1], num_filters[2], kernel_size=3, padding=1, bias=False, ws=ws), nn.GroupNorm(32, num_filters[2]) if gn else nn.BatchNorm2d(num_filters[2]), nn.ReLU(inplace=True)) self.decode1 = nn.Sequential( Conv2d(num_filters[2], num_filters[2], kernel_size=3, padding=1, bias=False, ws=ws), nn.GroupNorm(32, num_filters[2]) if gn else nn.BatchNorm2d(num_filters[2]), nn.ReLU(inplace=True)) for head in sorted(self.heads): num_output = self.heads[head] fc = nn.Sequential( Conv2d(num_filters[2], head_conv, kernel_size=3, padding=1, bias=False, ws=ws), nn.GroupNorm(32, head_conv) if gn else nn.BatchNorm2d(head_conv), nn.ReLU(inplace=True), nn.Conv2d(head_conv, num_output, kernel_size=1)) if 'hm' in head: fc[-1].bias.data.fill_(-2.19) else: fill_fc_weights(fc) self.__setattr__(head, fc)
def __init__(self, class_names): super(SEResNeXT101, self).__init__() self.base = pretrainedmodels.se_resnext101_32x4d() self.backbone = nn.Sequential(*list(self.base.children())[:-1]) self.head = nn.Linear(self.base.last_linear.in_features, len(class_names))
def __init__(self, slug, num_filters=256, pretrained=True): """Creates an `FPN` instance for feature extraction. Args: slug: model slug e.g. 'r18', 'r101' for ResNet num_filters: the number of filters in each output pyramid level pretrained: use ImageNet pre-trained backbone feature extractor num_input_channels: number fo input channels """ self.slug = slug super().__init__() if not pretrained: print("Caution, not loading pretrained weights.") if slug == 'r18': self.resnet = models.resnet18(pretrained=pretrained) num_bottleneck_filters = 512 elif slug == 'r34': self.resnet = models.resnet34(pretrained=pretrained) num_bottleneck_filters = 512 elif slug == 'r50': self.resnet = models.resnet50(pretrained=pretrained) num_bottleneck_filters = 2048 elif slug == 'r101': self.resnet = models.resnet101(pretrained=pretrained) num_bottleneck_filters = 2048 elif slug == 'r152': self.resnet = models.resnet152(pretrained=pretrained) num_bottleneck_filters = 2048 elif slug == 'rx50': self.resnet = models.resnext50_32x4d(pretrained=pretrained) num_bottleneck_filters = 2048 elif slug == 'rx101': self.resnet = models.resnext101_32x8d(pretrained=pretrained) num_bottleneck_filters = 2048 elif slug == 'r50d': self.resnet = timm.create_model('gluon_resnet50_v1d', pretrained=pretrained) convert_to_inplace_relu(self.resnet) num_bottleneck_filters = 2048 elif slug == 'r101d': self.resnet = timm.create_model('gluon_resnet101_v1d', pretrained=pretrained) convert_to_inplace_relu(self.resnet) num_bottleneck_filters = 2048 elif slug == 'r152d': self.resnet = timm.create_model('gluon_resnet152_v1s', pretrained=pretrained) convert_to_inplace_relu(self.resnet) num_bottleneck_filters = 2048 elif slug == 'efnetb7': self.resnet = timm.create_model('tf_efficientnet_b7', pretrained=pretrained) num_bottleneck_filters = 2048 elif slug == 'serx50': self.resnet = pretrainedmodels.se_resnext50_32x4d( pretrained='imagenet') self.resnet.avg_pool = nn.AdaptiveAvgPool2d(1) num_bottleneck_filters = 2048 elif slug == 'serx101': self.resnet = pretrainedmodels.se_resnext101_32x4d( pretrained='imagenet') self.resnet.avg_pool = nn.AdaptiveAvgPool2d(1) num_bottleneck_filters = 2048 else: assert False, "Bad slug: %s" % slug # Access resnet directly in forward pass; do not store refs here due to # https://github.com/pytorch/pytorch/issues/8392 self.lateral4 = Conv1x1(num_bottleneck_filters, num_filters) self.lateral3 = Conv1x1(num_bottleneck_filters // 2, num_filters) self.lateral2 = Conv1x1(num_bottleneck_filters // 4, num_filters) self.lateral1 = Conv1x1(num_bottleneck_filters // 8, num_filters) self.smooth4 = Conv3x3(num_filters, num_filters) self.smooth3 = Conv3x3(num_filters, num_filters) self.smooth2 = Conv3x3(num_filters, num_filters) self.smooth1 = Conv3x3(num_filters, num_filters)
def __init__(self, num_classes): super(SEResNeXt, self).__init__() self.name = "SEResNeXt" self.model = model_zoo.se_resnext101_32x4d() #pretrained.features() self.fc = nn.Linear(2048, num_classes)
def __init__( self, backbone: str, n_output: int, input_channels: int = 3, pretrained: bool = True, activation=None, ): super(ClassificationModel, self).__init__() """ The aggregation model of different predefined archtecture Args: backbone : model architecture to use, one of (resnet18 | resnet34 | densenet121 | se_resnext50_32x4d | se_resnext101_32x4d) n_output : number of classes to predict input_channels : number of channels for the input image pretrained : bool value either to use weights pretrained on imagenet or to random initialization activation : a callable will be applied at the very end """ self.backbone = backbone if backbone == "resnet18": self.encoder = models.resnet18(pretrained=pretrained) elif backbone == "resnet34": self.encoder = models.resnet34(pretrained=pretrained) elif backbone == "densenet121": self.encoder = models.densenet121(pretrained=pretrained) elif backbone == "se_resnext50_32x4d": if pretrained: self.encoder = pretrainedmodels.se_resnext50_32x4d( pretrained="imagenet" ) else: self.encoder = pretrainedmodels.se_resnext50_32x4d(pretrained=None) elif backbone == "se_resnext101_32x4d": if pretrained: self.encoder = pretrainedmodels.se_resnext101_32x4d( pretrained="imagenet" ) else: self.encoder = pretrainedmodels.se_resnext101_32x4d(pretrained=None) avgpool = nn.AdaptiveAvgPool2d(1) if backbone == "resnet34" or backbone == "resnet18": if input_channels != 3: conv = nn.Conv2d( input_channels, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False, ) conv.weight.data = ( self.encoder.conv1.weight.data.sum(dim=1) .unsqueeze(1) .repeat_interleave(input_channels, dim=1) ) self.encoder.conv1 = conv self.encoder.avgpool = avgpool self.encoder.fc = nn.Linear(self.encoder.fc.in_features, n_output) elif backbone == "densenet121": if input_channels != 3: conv = nn.Conv2d( input_channels, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False, ) conv.weight.data = ( self.encoder.features.conv0.weight.data.sum(dim=1) .unsqueeze(1) .repeat_interleave(input_channels, dim=1) ) self.encoder.features.conv0 = conv self.encoder.classifier = nn.Linear( self.encoder.classifier.in_features, n_output ) self.encoder.avgpool = avgpool elif backbone == "se_resnext50_32x4d" or backbone == "se_resnext101_32x4d": if input_channels != 3: conv = nn.Conv2d( input_channels, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False, ) conv.weight.data = ( self.encoder.layer0.conv1.weight.data.sum(dim=1) .unsqueeze(1) .repeat_interleave(input_channels, dim=1) ) self.encoder.layer0.conv1 = conv self.encoder.avg_pool = avgpool in_features = self.encoder.last_linear.in_features self.fc0 = nn.Sequential( nn.Dropout(0.2), nn.Linear(in_features, 1024), nn.LeakyReLU(0.1), nn.BatchNorm1d(num_features=1024), nn.Linear(1024, n_output[0]), ) self.fc1 = nn.Sequential( nn.Dropout(0.2), nn.Linear(in_features, 1024), nn.LeakyReLU(0.1), nn.BatchNorm1d(num_features=1024), nn.Linear(1024, n_output[1]), ) self.fc2 = nn.Sequential( nn.Dropout(0.2), nn.Linear(in_features, 1024), nn.LeakyReLU(0.1), nn.BatchNorm1d(num_features=1024), nn.Linear(1024, n_output[2]), ) self.fc3 = nn.Sequential( nn.Dropout(0.2), nn.Linear(in_features, 1024), nn.LeakyReLU(0.1), nn.BatchNorm1d(num_features=1024), nn.Linear(1024, n_output[3]), ) self.encoder.last_linear = nn.Identity() self.activation = activation
def __init__(self, model_name, num_classes=200, pretrained=True, pool_type='cat', down=True): super().__init__() assert model_name in __arch__ self.model_name = model_name if model_name == 'resnet50' or model_name == 'resnet18' or model_name == 'resnet152' \ or model_name == 'resnext101_32x8d' or model_name == 'resnext50_32x4d' \ or model_name == 'resnest50' or model_name == 'resnest101' or model_name == 'dense121': if model_name == 'resnet50': backbone = nn.Sequential( *list(models.resnet50( pretrained=pretrained).children())[:-2]) plane = 2048 if model_name == 'resnet18': backbone = nn.Sequential( *list(models.resnet18( pretrained=pretrained).children())[:-2]) plane = 512 if model_name == 'resnext101_32x8d': backbone = nn.Sequential(*list( models.resnext101_32x8d( pretrained=pretrained).children())[:-2]) plane = 2048 if model_name == 'resnext50_32x4d': backbone = nn.Sequential(*list( models.resnext50_32x4d( pretrained=pretrained).children())[:-2]) plane = 2048 if model_name == 'dense121': backbone = nn.Sequential(*list( models.densenet121( pretrained=pretrained).features.children())) plane = 1024 if model_name == 'resnest50': backbone = nn.Sequential(*list( torch.hub.load('zhanghang1989/ResNeSt', 'resnest50', pretrained=True).children())[:-2]) plane = 2048 if model_name == 'resnest101': backbone = nn.Sequential(*list( torch.hub.load('zhanghang1989/ResNeSt', 'resnest101', pretrained=True).children())[:-2]) plane = 2048 elif model_name == 'se_resnext101_32x4d' or model_name == 'se_resnext50_32x4d': if model_name == 'se_resnext101_32x4d': backbone = nn.Sequential(*list( pretrainedmodels.se_resnext101_32x4d( pretrained='imagenet').children())[:-2]) plane = 2048 if model_name == 'se_resnext50_32x4d': backbone = nn.Sequential(*list( pretrainedmodels.se_resnext50_32x4d( pretrained='imagenet').children())[:-2]) plane = 2048 elif model_name == 'efficientnet-b7' or model_name == 'efficientnet-b6'\ or model_name == 'efficientnet-b5' or model_name == 'efficientnet-b4'\ or model_name == 'efficientnet-b3' or model_name == 'efficientnet-b2'\ or model_name == 'efficientnet-b1' or model_name == 'efficientnet-b0': if model_name == 'efficientnet-b0': backbone = EfficientNet.from_pretrained('efficientnet-b0') plane = 1280 if model_name == 'efficientnet-b1': backbone = EfficientNet.from_pretrained('efficientnet-b1') plane = 1280 if model_name == 'efficientnet-b3': backbone = EfficientNet.from_pretrained('efficientnet-b3') plane = 1536 if model_name == 'efficientnet-b4': backbone = EfficientNet.from_pretrained('efficientnet-b4') plane = 1792 if model_name == 'efficientnet-b5': backbone = EfficientNet.from_pretrained('efficientnet-b5') plane = 2048 if model_name == 'efficientnet-b6': backbone = EfficientNet.from_pretrained('efficientnet-b6') plane = 2304 if model_name == 'efficientnet-b7': backbone = EfficientNet.from_pretrained('efficientnet-b7') plane = 2560 # self.model = EfficientNet.from_pretrained(model_name) # self.model = get_efficientnet(model_name=model_name, num_classes=num_classes) # backbone = nn.Sequential(*list(EfficientNet.from_pretrained(model_name).children())[:-2]) # plane = 1536 #b0 plane = 1280,b3 plane = 1536,b4 plane = 1792 else: backbone = None plane = None self.backbone = backbone if pool_type == 'avg': self.pool = nn.AdaptiveAvgPool2d((1, 1)) elif pool_type == 'cat': self.pool = AdaptiveConcatPool2d() elif pool_type == 'max': self.pool = nn.AdaptiveMaxPool2d((1, 1)) elif pool_type == 'gem': self.pool = GeneralizedMeanPooling() else: self.pool = None if down: if pool_type == 'cat': self.down = nn.Sequential(nn.Linear(plane * 2, plane), nn.BatchNorm1d(plane), nn.Dropout(0.2), nn.ReLU(True)) else: self.down = nn.Sequential(nn.Linear(plane, plane), nn.BatchNorm1d(plane), nn.Dropout(0.2), nn.ReLU(True)) else: self.down = nn.Identity() self.se = SELayer(plane) self.hidden = nn.Linear(plane, plane) self.relu = nn.ReLU(True) self.metric = nn.Linear(plane, num_classes)
def se_resnext101_32x4d_(pretrained='imagenet', **kwargs): model = pretrainedmodels.se_resnext101_32x4d(pretrained=pretrained) model.avg_pool = nn.AvgPool2d((2, 5), stride=(2, 5)) model.last_linear = nn.Linear(512 * 4, 41) return model