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
