def get_cnn(num_classes, args):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("args.pretrained: " + str(args.pretrained))
if (args.arch.startswith("resnet") or args.arch.startswith("inception")):
if (args.arch == "resnet18"):
model_ft = models.resnet18(
pretrained=args.pretrained
) # Load the pretrained model from pytorch
elif (args.arch == "resnet50"):
model_ft = models.resnet50(pretrained=args.pretrained)
elif (args.arch == "resnetusm"):
model_ft = resnet18_usm(pretrained=args.pretrained, cuda=args.cuda)
elif (args.arch == "inception_v3"):
print("Using Inception v3")
model_ft = models.inception_v3(pretrained=args.pretrained)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
elif (args.arch == "vgg19_bn"):
model_ft = models.vgg19_bn(pretrained=args.pretrained
) # Load the pretrained model from pytorch
num_features = model_ft.classifier[
6].in_features # Newly created modules have require_grad=True by default
features = list(
model_ft.classifier.children())[:-1] # Remove last layer
features.extend([nn.Linear(num_features, num_classes)
]) # Add our layer with 4 outputs
model_ft.classifier = nn.Sequential(
*features) # Replace the model classifier
model_ft = model_ft.to(device)
return model_ft
def choose_vgg(name):
f = None
if name == 'vgg11':
f = models.vgg11(pretrained=True)
elif name == 'vgg11_bn':
f = models.vgg11_bn(pretrained=True)
elif name == 'vgg13':
f = models.vgg13(pretrained=True)
elif name == 'vgg13_bn':
f = models.vgg13_bn(pretrained=True)
elif name == 'vgg16':
f = models.vgg16(pretrained=True)
elif name == 'vgg16_bn':
f = models.vgg16_bn(pretrained=True)
elif name == 'vgg19':
f = models.vgg19(pretrained=True)
elif name == 'vgg19_bn':
f = models.vgg19_bn(pretrained=True)
for params in f.parameters():
params.requires_grad = False
return f
def __init__(self, network='resnet-101'):
# in original paper, authors used vgg.
# however, there exist much better convolutional networks than vgg, and we may experiment with them
# possible models may be vgg, resnet, etc
super().__init__()
assert network in ['vgg', 'resnet-101']
if network == 'vgg':
vgg = tvmodels.vgg19_bn(pretrained=True)
self.feature_extractor = vgg.features[:37]
# vgg.features[36] is conv4_4, which is what authors used
# when input has shape [3, 512, 512], output of feature extractor is [512, 64, 64]
elif network == 'resnet-101':
# TODO
resnet = tvmodels.resnet101(pretrained=True)
layers = [
resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool,
resnet.layer1, resnet.layer2
]
self.feature_extractor = nn.Sequential(*layers)
# when input has shape [3, 512, 512], output of feature extractor is [512, 64, 64]
# same output shape as vgg version.
# FeatureExtractor should not be trained
for child in self.feature_extractor.children():
for param in child.parameters():
param.requires_grad = False
def vgg19_bn(pretrained: bool,
progress: bool = True,
requires_grad: bool = True):
model = models.vgg19_bn(pretrained=pretrained, progress=progress)
for params in model.parameters():
params.requires_grad = requires_grad
return model
def __init__(self, num_classes=1, num_input_channels=4, pretrained=False):
super(SegNet, self).__init__()
#######change to work with 4 channels
vgg = models.vgg19_bn(pretrained=pretrained)
features = list(vgg.features.children())
self.enc1 = nn.Sequential(
*([nn.Conv2d(num_input_channels, 64, 3, padding=1)]) +
features[1:7])
#######change to work with 4 channels
self.enc2 = nn.Sequential(*features[7:14])
self.enc3 = nn.Sequential(*features[14:27])
self.enc4 = nn.Sequential(*features[27:40])
self.enc5 = nn.Sequential(*features[40:])
self.dec5 = nn.Sequential(
*([nn.ConvTranspose2d(512, 512, kernel_size=2, stride=2)] + [
nn.Conv2d(512, 512, kernel_size=3, padding=1),
nn.BatchNorm2d(512),
nn.ReLU(inplace=True)
] * 4))
self.dec4 = _DecoderBlock2(1024, 256, 4)
self.dec3 = _DecoderBlock2(512, 128, 4)
self.dec2 = _DecoderBlock2(256, 64, 2)
self.dec1 = _DecoderBlock2(128, num_classes, 2)
def vgg19_bn_kw(config):
model = models.vgg19_bn()
# remove all fc layers, replace for a single fc layer, from 143mi to 20mi parameters
model.classifier = nn.Linear(7 * 7 * 512, config["num_classes"])
new_features = []
for layer in model.features:
# remove max pooling
if isinstance(layer, nn.MaxPool2d):
nn.AvgPool2d(kernel_size=2, stride=2)
# store the number of out channels from conv layers
elif isinstance(layer, nn.Conv2d):
new_features.append(layer)
last_conv_out_channels = layer.out_channels
# switch ReLU to kWinners2d
elif isinstance(layer, nn.ReLU):
new_features.append(
KWinners2d(
channels=last_conv_out_channels,
percent_on=config["percent_on"],
boost_strength=config["boost_strength"],
boost_strength_factor=config["boost_strength_factor"],
))
# otherwise add it as normal
else:
new_features.append(layer)
model.features = nn.Sequential(*new_features)
return model
def grad_cam(image):
model = models.vgg19_bn(pretrained=True)
model.to(device)
model.eval()
image = cv2.resize(image, (224, 224))
image = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
)
])(image).unsqueeze(0)
image = image.to(device)
gcam = GradCAM(model=model)
probs, idx = gcam.forward(image)
output = None
for i in range(0, 5):
gcam.backward(idx=idx[i])
temp = gcam.generate(target_layer='features.52')
if not output is None:
output += temp
else:
output = temp
output /= 5
return output
def __init__(self):
super(VGG, self).__init__()
self.model = vgg19_bn(True).features
self.mean = torch.Tensor([123.68, 116.779,
103.939]).cuda().view(1, 3, 1, 1)
for param in self.model.parameters():
param.requires_grad = False
def vggcam(pretrained, vggconfig='vggcam16', method='cam', **kwargs):
use_bn = ('bn' in vggconfig)
if pretrained:
model = VGGCAM(make_layers(cfg[vggconfig[:8]], batch_norm=use_bn),
method=method,
**kwargs)
model_dict = model.state_dict()
if vggconfig == 'vggcam16':
vgg = vmodels.vgg16(pretrained=True)
elif vggconfig == 'vggcam19':
vgg = vmodels.vgg19(pretrained=True)
elif vggconfig == 'vggcam16bn':
vgg = vmodels.vgg16_bn(pretrained=True)
elif vggconfig == 'vggcam19bn':
vgg = vmodels.vgg19_bn(pretrained=True)
else:
print("NOT IMPLEMENTED FOR ", vggconfig)
exit(-3)
pretrained_dict = vgg.state_dict()
pretrained_dict = {
k: v
for k, v in pretrained_dict.items()
if k in model_dict and 'features' in k
}
model_dict.update(pretrained_dict)
model.load_state_dict(model_dict)
else:
model = VGGCAM(make_layers(cfg[vggconfig[:8]], use_bn), **kwargs)
return model
def __init__(self, requires_grad=False, layers=['conv1_1'], BN=False):
super(myVGG, self).__init__()
if BN:
self.original_model = models.vgg19_bn(pretrained=False)
self.original_model.load_state_dict(torch.load('../weights/vgg19_bn-c79401a0.pth'))
self.checkpoints = [3, 7, 10, 14, 17, 20, 23, 27, 30, 33, 36, 40, 43, 46, 49, 53]
else:
self.original_model = models.vgg19(pretrained=False)
self.original_model.load_state_dict(torch.load('../weights/vgg19-dcbb9e9d.pth'))
self.checkpoints = [2, 5, 7, 10, 12, 14, 16, 19, 21, 23, 25, 28, 30, 32, 34, 37]
#if vgg_bn: 17, 17-30; vgg: 12, 12-21
self.layers = layers
self.convs = [
'conv1_1','conv1_2',
'conv2_1','conv2_2',
'conv3_1','conv3_2','conv3_3','conv3_4',
'conv4_1','conv4_2','conv4_3','conv4_4',
'conv5_1','conv5_2','conv5_3','conv5_4',
]
self.features = []
self.CreateCheckPoint()
if requires_grad == False:
for param in self.parameters():
param.requires_grad = False
def __init__(self, embed_size, ver=19, attention_mechanism=False):
'''
Load the pretrained VGG and replace fc layer.
Args:
embed_size (int): dimension of word embedding vectors
ver (int): version of the pretrained network
attention_mechanism (bool): use attention layers in decoder network or not
'''
super(VGG, self).__init__()
if ver == 19:
vgg = models.vgg19_bn(pretrained=True)
else:
raise ModuleNotFoundError()
self.features = vgg.features
self.classifier = vgg.classifier
# change the number of output features (4096 -> 2048)
self.classifier[3] = nn.Linear(vgg.classifier[3].in_features, 2048)
self.classifier[6] = nn.Linear(2048, embed_size)
self.linear = self.classifier[6]
self.bn = nn.BatchNorm1d(embed_size, momentum=0.01)
if attention_mechanism:
# Initialize the weights
self.classifier[3].weight.data.normal_(0.0, 0.02)
self.classifier[3].bias.data.fill_(0)
self.classifier[6].weight.data.normal_(0.0, 0.02)
self.classifier[6].bias.data.fill_(0)
self.attention_mechanism = attention_mechanism
def __init__(self):
super(VGG19custom, self).__init__() #基底クラスのコンストラクタを実行する
#学習済みモデルの取得
from torchvision.models import vgg19_bn
net = vgg19_bn(False) #Trueならば学習済みの重みをダウンロードする
#既にあるモデルファイルから重みをロードする
import modelio
#modelio.SaveModelWeights(net, "vgg19_bn.pt")
modelio.LoadModelWeights("vgg19_bn.pt", net, False)
#畳み込み部は流用
self.features = net.features #モデルを定義（たたみ込み部)
#パラメータ固定
for p in self.features.parameters():
p.requires_grad = False
#畳み込み部の出力サイズを調べる
size = (3, 224, 224) #入力画像のテンソル形状
test_input = torch.ones(1,size[0],size[1],size[2]) #ダミーの入力データ
temp = self.features(test_input) #畳み込みする
temp = temp.view(temp.size()[0], -1) #Flattenをかける
conv_output_size = temp.size()[-1] #出力テンソルサイズを取得
#クラス分類を定義
self.classifier = torch.nn.Sequential(
torch.nn.Linear(conv_output_size,512),
torch.nn.ReLU(),
#torch.nn.BatchNorm1d(512),
torch.nn.Dropout(0.25),
torch.nn.Linear(512,101)
)
def __init__(self, num_classes, pretrained=True, phase='train'):
super(FCN8VGG, self).__init__()
vgg = models.vgg19_bn()
if pretrained:
vgg.load_state_dict(torch.load(vgg19_bn_path))
features = list(vgg.features.children())
self.features3_4 = nn.Sequential(
*features[0:26]) # for FCN 256,128,128
# self.features3 = nn.Sequential(*features[26:27]) # for FCN 256,64,64
self.features4_4 = nn.Sequential(*features[26:39]) # for FCN 256,64,64
self.features4 = nn.Sequential(*features[39:40]) # for FCN 512, 32, 32
self.features5_4 = nn.Sequential(
*features[40:52]) # for FCN 512, 32, 32
self.features5 = nn.Sequential(*features[52:]) # for FCN 512, 16, 16
self.fconv3 = nn.Conv2d(256, num_classes, kernel_size=1)
self.fconv4 = nn.Conv2d(512, num_classes, kernel_size=1)
self.fconv5 = nn.Sequential(
nn.Conv2d(1536, 2048, kernel_size=7), nn.ReLU(inplace=True),
nn.Dropout(), nn.Conv2d(2048, 2048, kernel_size=1),
nn.ReLU(inplace=True), nn.Dropout(),
nn.Conv2d(2048, num_classes, kernel_size=1))
initialize_weights(self.fconv3, self.fconv4, self.fconv5)
self.ssd_conv5_1 = nn.Conv2d(512,
512,
kernel_size=3,
padding=1,
dilation=1)
def Classifier(arch = 'vgg16', dropout = 0.5, hidden_layer = 1024):
if arch == 'vgg16':
model = models.vgg16(pretrained = True)
input_layer = 25088
elif arch == 'vgg19_bn':
model = models.vgg19_bn(pretrained = True)
input_layer = 25088
elif arch == 'densenet121':
model = models.densenet121(pretrained = True)
input_layer = 1024
# Freeze parameters
for param in model.parameters():
param.requires_grad = False
My_Classifier = nn.Sequential(nn.Linear(input_layer, hidden_layer),
nn.ReLU(),
nn.Dropout(dropout),
nn.Linear(hidden_layer, 512),
nn.ReLU(),
nn.Dropout(dropout),
nn.Linear(512, 102),
nn.LogSoftmax(dim = 1)
)
model.classifier = My_Classifier
return model
def vgg19():
"""Constructs a VGG-19 model for ILSVRC12 dataset"""
model = models.vgg19_bn()
model.classifier[2] = nn.BatchNorm1d(4096)
model.classifier[5] = nn.BatchNorm1d(4096)
model.apply(weights_init)
return model
def load_checkpoint(filepath):
'''
Rebuilds a trained torchvision model
filepath: string, contains filepath where the trained model parameters are saved in a dictionary
returns: a pytorch model, the optimizer, and the number of epochs
'''
# Create a dictionary of torchvision models to choose from
print('Downloading models...')
arch_dict = {
'vgg19_bn': models.vgg19_bn(pretrained=True),
'alexnet': models.alexnet(pretrained=True)
}
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model_dict = torch.load(filepath, map_location=device)
model = arch_dict[model_dict['arch']]
for param in model.parameters():
param.requires_grad = False
# Build the model layers
model.classifier = DeepNetworkClassifier(model_dict['input_size'],
model_dict['output_size'],
model_dict['hidden_layers'])
model.load_state_dict(model_dict['state_dict'])
model.class_to_idx = model_dict['class_to_idx']
optimizer = optim.Adam(model.classifier.parameters())
optimizer.load_state_dict(model_dict['optimizer_state_dict'])
epochs = model_dict['epochs']
return model, optimizer, epochs
def getVGG19(self, batch_norm=False):
if batch_norm == True:
model = models.vgg19_bn()
else:
model = models.vgg19()
model.train()
return model
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 == "resnet":
""" Resnet50
"""
model_ft = models.resnet101(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 == "vgg":
""" vgg19bn
"""
model_ft = models.vgg19_bn(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier[-1].in_features
model_ft.classifier[-1] = nn.Linear(num_ftrs, num_classes)
input_size = 224
else:
print("Invalid model name, exiting...")
exit()
return model_ft, input_size
def __init__(self):
"""Select conv1_1 ~ conv5_1 activation maps."""
super(VGGNet, self).__init__()
self.vgg = models.vgg19_bn(pretrained=True)
self.vgg_features = self.vgg.features
self.fc_features = nn.Sequential(
*list(self.vgg.classifier.children())[:-2])
def __init__(self, device):
super(Vgg, self).__init__()
self.model_vgg = vgg19_bn(True).features
self.mean = torch.Tensor([123.68, 116.779,
103.939]).to(device).view(1, 3, 1, 1)
for param in self.model_vgg.parameters():
param.requires_grad = False
def __init__(self, num_classes=1000, *models):
"""
models: string names of models (lookup for the global namespace)
"""
super(Model, self).__init__()
imgDim = 3
if len(models) == 0:
print('switching to the default combination')
models = [
# 'IceResNet'
# , 'LeNet'
'densenet161'
]
self.models_str = models
for model in models:
if model == 'IceResNet':
setattr(self, model,
IceResNet(IceSEBasicBlock, 1, num_classes, 3, 32))
elif model == 'LeNet':
setattr(self, model, LeNet(num_classes, imgDim))
# elif model == 'MiniDenseNet':
# setattr(self, model,
# MiniDenseNet(growthRate=48, depth=20, reduction=0.5, bottleneck=True, nClasses=num_classes,
# n_dim=imgDim))
elif model == 'densenet161':
setattr(self, model, built_in_models.densenet161())
elif model == 'vgg19':
setattr(self, model, built_in_models.vgg19_bn())
else:
raise ValueError('unrecognized model: %s' % str(model))
self.fc = nn.Linear(len(models) * num_classes, num_classes)
self.softmax = nn.Softmax()
self.load_weights('weights.pth')
def select_model(model_param, in_arg):
"""
Selects the NN model based on command line argument "arch"
Parameters:
model_param - dictionary of our model parameters
in_arg - command line arguments
Returns:
Selected NN model (object)
model_param - dictionary of our model parameters
"""
# We will manage 3 choices: alexnet, resnet18, vgg19_bn
alexnet = models.alexnet(pretrained=True)
resnet18 = models.resnet18(pretrained=True)
vgg19_bn = models.vgg19_bn(pretrained=True)
models_dict = {
'alexnet': alexnet,
'resnet18': resnet18,
'vgg19_bn': vgg19_bn
}
if in_arg.arch not in models_dict.keys():
print(
"CNN model '{}' is not managed. It can only be chosen among alexnet, resnet18 and vgg19_bn. Try again!"
.format(in_arg.arch))
sys.exit(0)
model_param['arch'] = in_arg.arch
return models_dict[in_arg.arch], model_param
def load_pretrained_model(arch):
'''
Load pretrained model
'''
if arch == 'densenet121':
model = models.densenet121(pretrained = True)
inputsize = model.classifier.in_features
elif arch == 'densenet161':
model = models.densenet161(pretrained = True)
inputsize = model.classifier.in_features
elif arch == 'densenet201':
model = models.densenet201(pretrained = True)
inputsize = model.classifier.in_features
elif arch == 'resnet18':
model = models.resnet18(pretrained = True)
inputsize = model.fc.in_features
elif arch == 'resnet34':
model = models.resnet34(pretrained = True)
inputsize = model.fc.in_features
elif arch == 'resnet50':
model = models.resnet50(pretrained = True)
inputsize = model.fc.in_features
elif arch == 'vgg13_bn':
model = models.vgg13_bn(pretrained = True)
inputsize = model.classifier[0].in_features
elif arch == 'vgg16_bn':
model = models.vgg16_bn(pretrained = True)
inputsize = model.classifier[0].in_features
elif arch == 'vgg19_bn':
model = models.vgg19_bn(pretrained = True)
inputsize = model.classifier[0].in_features
return model, inputsize
def PoseModel(num_point, num_stages=6, batch_norm=False, pretrained=False):
net_dict = make_net_dict()
model = CPM(net_dict, batch_norm)
if pretrained:
parameter_num = 10
if batch_norm:
vgg19 = models.vgg19_bn(pretrained=True)
parameter_num *= 6
else:
vgg19 = models.vgg19(pretrained=True)
parameter_num *= 2
vgg19_state_dict = vgg19.state_dict()
vgg19_keys = vgg19_state_dict.keys()
model_dict = model.state_dict()
from collections import OrderedDict
weights_load = OrderedDict()
for i in range(parameter_num):
weights_load[model.state_dict().keys()[i]] = vgg19_state_dict[
vgg19_keys[i]]
model_dict.update(weights_load)
model.load_state_dict(model_dict)
return model
def initialize_model(model_name,
num_classes,
feature_extract,
use_pretrained=True):
if model_name == "resnet":
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 == "alexnet":
model_ft = models.alexnet(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
s = len(model_ft.classifier) - 1
num_ftrs = model_ft.classifier[s].in_features
model_ft.classifier[s] = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "vgg":
model_ft = models.vgg19_bn()
set_parameter_requires_grad(model_ft, feature_extract)
s = len(model_ft.classifier) - 1
num_ftrs = model_ft.classifier[s].in_features
model_ft.classifier[s] = nn.Linear(num_ftrs, num_classes)
input_size = 224
else:
print("model not implemented")
return None, None
return model_ft, input_size
def __init__(self, dir, arch, file):
"""Init the variable
Parameters:
-----------
dir: string
Image path
arch: string
CNN model archtecture
file: json file
Text file with spacies name
"""
# set the default models
pretrain_model = {
"vgg19_bn": models.vgg19_bn(pretrained=True),
"vgg19": models.vgg19(pretrained=True),
"resnet50": models.resnet50(pretrained=True)
}
self.dir = dir
self.train = os.path.join(dir, "train")
self.test = os.path.join(dir, "test")
self. validate = os.path.join(dir, "valid")
self.file = file
try:
self.model = pretrain_model[arch]
except KeyError:
arch = input("Invalidate model, choose vgg19_nb, vgg19, resnet50: ")
self.model = pretrain_model[arch]
# freeze the model grad
for param in self.model.parameters():
param.requires_grad = False
def get_model(self):
if self.args.architecture in ['resnet34' , 'resnet50' , 'resnet101']:
if self.args.architecture == 'resnet34':
model = torchmodels.resnet34(pretrained=True)
if self.args.architecture == 'resnet50':
model = torchmodels.resnet50(pretrained=True)
if self.args.architecture == 'resnet101':
model = torchmodels.resnet101(pretrained=True)
num_classes = self.args.num_classes
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)
if self.args.architecture in ['densenet121', 'densenet169', 'densenet201', 'densenet161']:
if self.args.architecture == 'densenet121':
model = torchmodels.densenet121(pretrained=True)
if self.args.architecture == 'densenet169':
model = torchmodels.densenet169(pretrained=True)
if self.args.architecture == 'densenet201':
model = torchmodels.densenet201(pretrained=True)
if self.args.architecture == 'densenet161':
model = torchmodels.densenet161(pretrained=True)
num_classes = self.args.num_classes
num_ftrs = model.classifier.in_features
model.classifier = nn.Linear(num_ftrs, num_classes)
if self.args.architecture in [ 'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn',
'vgg19_bn', 'vgg19']:
if self.args.architecture == 'vgg11':
model = torchmodels.vgg11(pretrained=True)
if self.args.architecture == 'vgg11_bn':
model = torchmodels.vgg11_bn(pretrained=True)
if self.args.architecture == 'vgg13':
model = torchmodels.vgg13(pretrained=True)
if self.args.architecture == 'vgg13_bn':
model = torchmodels.vgg13_bn(pretrained=True)
if self.args.architecture == 'vgg16':
model = torchmodels.vgg16(pretrained=True)
if self.args.architecture == 'vgg16_bn':
model = torchmodels.vgg16_bn(pretrained=True)
if self.args.architecture == 'vgg19_bn':
model = torchmodels.vgg19_bn(pretrained=True)
if self.args.architecture == 'vgg19':
model = torchmodels.vgg19(pretrained=True)
num_classes = self.args.num_classes
in_features = model.classifier[6].in_features
n_module = nn.Linear(in_features, num_classes)
n_classifier = list(model.classifier.children())[:-1]
n_classifier.append(n_module)
model.classifier = nn.Sequential(*n_classifier)
if self.args.cuda:
model.cuda()
return model
def set_model (model_name, num_class, neurons_reducer_block=0, comb_method=None, comb_config=None, pretrained=True,
freeze_conv=False, p_dropout=0.5):
if pretrained:
pre_ptm = 'imagenet'
pre_torch = True
else:
pre_torch = False
pre_ptm = None
if model_name not in _MODELS:
raise Exception("The model {} is not available!".format(model_name))
model = None
if model_name == 'resnet-50':
model = MyResnet(models.resnet50(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'resnet-101':
model = MyResnet(models.resnet101(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'densenet-121':
model = MyDensenet(models.densenet121(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'vgg-13':
model = MyVGGNet(models.vgg13_bn(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'vgg-16':
model = MyVGGNet(models.vgg16_bn(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'vgg-19':
model = MyVGGNet(models.vgg19_bn(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'mobilenet':
model = MyMobilenet(models.mobilenet_v2(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'efficientnet-b4':
if pretrained:
model = MyEffnet(EfficientNet.from_pretrained(model_name), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
else:
model = MyEffnet(EfficientNet.from_name(model_name), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'inceptionv4':
model = MyInceptionV4(ptm.inceptionv4(num_classes=1000, pretrained=pre_ptm), num_class, neurons_reducer_block,
freeze_conv, comb_method=comb_method, comb_config=comb_config)
elif model_name == 'senet':
model = MySenet(ptm.senet154(num_classes=1000, pretrained=pre_ptm), num_class, neurons_reducer_block,
freeze_conv, comb_method=comb_method, comb_config=comb_config)
return model
def __init__(self, base_model='vgg'):
"""
Construct the EncoderCNN class.
Args:
base_model: Base CNN model to use
Returns;
A PyTorch network model
"""
super(EncoderCNN, self).__init__()
try:
assert base_model in self.base_model_options
except AssertionError:
print('Invalid base model: %s'.format(base_model))
print(' -- Valid types: ', self.base_model_options)
return
# Load selected base model with pre-trained weights
if base_model == 'resnet18':
self.bm = models.resnet18(pretrained=True)
elif base_model == 'resnet50':
self.bm = models.resnet50(pretrained=True)
elif base_model == 'resnet152':
self.bm = models.resnet152(pretrained=True)
elif base_model == 'vgg11':
self.bm = models.vgg11(pretrained=True)
elif base_model == 'vgg11_bn':
self.bm = models.vgg11_bn(pretrained=True)
elif base_model == 'vgg16':
self.bm = models.vgg16(pretrained=True)
elif base_model == 'vgg16_bn':
self.bm = models.vgg16_bn(pretrained=True)
elif base_model == 'vgg19':
self.bm = models.vgg19(pretrained=True)
elif base_model == 'vgg19_bn':
self.bm = models.vgg19_bn(pretrained=True)
elif base_model == 'squeezenet0':
self.bm = models.squeezenet1_0(pretrained=True)
elif base_model == 'squeezenet1':
self.bm = models.squeezenet1_1(pretrained=True)
elif base_model == 'densenet121':
self.bm = models.densenet121(pretrained=True)
elif base_model == 'densenet201':
self.bm = models.densenet201(pretrained=True)
elif base_model == 'inception':
self.bm = models.inception_v3(pretrained=True)
# Freeze layers
for param in self.bm.parameters():
param.requires_grad = False
modules = list(self.bm.children())[:-1]
# num_features = self.bm.fc.in_features
self.bm = nn.Sequential(*modules)
return
def __init__(self):
super().__init__()
self.enc1_1 = VGGBlock(3, 64, 64, True)
self.enc1_2 = VGGBlock(64, 128, 128, True)
self.enc1_3 = VGGBlock(128, 256, 256, True)
self.enc1_4 = VGGBlock(256, 512, 512, True)
self.enc1_5 = VGGBlock(512, 512, 512, True)
# apply pretrained vgg19 weights on 1st unet
vgg19 = models.vgg19_bn()
vgg19.load_state_dict(
torch.load("E:\dataset\pretrain/vgg19_bn-c79401a0.pth"))
self.enc1_1.conv1.weights = vgg19.features[0].weight
self.enc1_1.bn1.weights = vgg19.features[1].weight
self.enc1_1.conv2.weights = vgg19.features[3].weight
self.enc1_1.bn2.weights = vgg19.features[4].weight
self.enc1_2.conv1.weights = vgg19.features[7].weight
self.enc1_2.bn1.weights = vgg19.features[8].weight
self.enc1_2.conv2.weights = vgg19.features[10].weight
self.enc1_2.bn2.weights = vgg19.features[11].weight
self.enc1_3.conv1.weights = vgg19.features[14].weight
self.enc1_3.bn1.weights = vgg19.features[15].weight
self.enc1_3.conv2.weights = vgg19.features[17].weight
self.enc1_3.bn2.weights = vgg19.features[18].weight
self.enc1_4.conv1.weights = vgg19.features[27].weight
self.enc1_4.bn1.weights = vgg19.features[28].weight
self.enc1_4.conv2.weights = vgg19.features[30].weight
self.enc1_4.bn2.weights = vgg19.features[31].weight
self.enc1_5.conv1.weights = vgg19.features[33].weight
self.enc1_5.bn1.weights = vgg19.features[34].weight
self.enc1_5.conv2.weights = vgg19.features[36].weight
self.enc1_5.bn2.weights = vgg19.features[37].weight
del vgg19
self.aspp1 = ASPP(512, 512)
self.up = nn.Upsample(scale_factor=2, mode='bilinear')
self.dec1_4 = VGGBlock(1024, 256, 256, False)
self.dec1_3 = VGGBlock(512, 128, 128, False)
self.dec1_2 = VGGBlock(256, 64, 64, False)
self.dec1_1 = VGGBlock(128, 32, 32, False)
self.output1 = output_block()
self.enc2_1 = VGGBlock(3, 64, 64, True, True)
self.enc2_2 = VGGBlock(64, 128, 128, True, True)
self.enc2_3 = VGGBlock(128, 256, 256, True, True)
self.enc2_4 = VGGBlock(256, 512, 512, True, True)
self.enc2_5 = VGGBlock(512, 512, 512, True, True)
self.aspp2 = ASPP(512, 512)
self.dec2_4 = VGGBlock(1536, 256, 256, False, True)
self.dec2_3 = VGGBlock(768, 128, 128, False, True)
self.dec2_2 = VGGBlock(384, 64, 64, False, True)
self.dec2_1 = VGGBlock(192, 32, 32, False, True)
self.output2 = output_block()
def vgg19_bn(num_classes=1000, pretrained='imagenet'):
"""VGG 19-layer model (configuration 'E') with batch normalization
"""
model = models.vgg19_bn(pretrained=False)
if pretrained is not None:
settings = pretrained_settings['vgg19_bn'][pretrained]
model = load_pretrained(model, num_classes, settings)
return model
def select_model(name='vgg19'):
if name == 'vgg19':
model, feature_count = models.vgg19_bn(pretrained=True), 25088
elif name == 'densenet161':
model, feature_count = models.densenet161(pretrained=True), 2208
elif name == 'densenet121':
model, feature_count = models.densenet121(pretrained=True), 1024
else:
model, feature_count = models.alexnet(pretrained=True), 9216
return model, feature_count
def __init__(self, num_classes, pretrained=True):
super(SegNet, self).__init__()
vgg = models.vgg19_bn()
if pretrained:
vgg.load_state_dict(torch.load(vgg19_bn_path))
features = list(vgg.features.children())
self.enc1 = nn.Sequential(*features[0:7])
self.enc2 = nn.Sequential(*features[7:14])
self.enc3 = nn.Sequential(*features[14:27])
self.enc4 = nn.Sequential(*features[27:40])
self.enc5 = nn.Sequential(*features[40:])
self.dec5 = nn.Sequential(
*([nn.ConvTranspose2d(512, 512, kernel_size=2, stride=2)] +
[nn.Conv2d(512, 512, kernel_size=3, padding=1),
nn.BatchNorm2d(512),
nn.ReLU(inplace=True)] * 4)
)
self.dec4 = _DecoderBlock(1024, 256, 4)
self.dec3 = _DecoderBlock(512, 128, 4)
self.dec2 = _DecoderBlock(256, 64, 2)
self.dec1 = _DecoderBlock(128, num_classes, 2)
initialize_weights(self.dec5, self.dec4, self.dec3, self.dec2, self.dec1)
outputs = model(inputs)
_, preds = torch.max(outputs.data, 1)
for j in range(inputs.size()[0]):
images_so_far += 1
ax = plt.subplot(num_images // 2, 2, images_so_far)
ax.axis('off')
ax.set_title('predicted: {}'.format(class_names[preds[j]]))
imshow(inputs.cpu().data[j])
if images_so_far == num_images:
return
model_ft = models.vgg19_bn(True)
mod = list(model_ft.classifier.children())
mod.pop()
mod.append(torch.nn.Linear(4096, 80))
new_classifier = torch.nn.Sequential(*mod)
model_ft.classifier = new_classifier
if use_gpu:
model_ft = nn.DataParallel(model_ft, [0]).cuda()
model_ft = torch.load('model_pretrained_vgg19.pkl')
criterion = nn.CrossEntropyLoss()
# Observe that all parameters are being optimized
