def inceptionv3(num_classes=1000, pretrained='imagenet'):
r"""Inception v3 model architecture from
`"Rethinking the Inception Architecture for Computer Vision" <http://arxiv.org/abs/1512.00567>`_.
"""
model = models.inception_v3(pretrained=False)
if pretrained is not None:
settings = pretrained_settings['inceptionv3'][pretrained]
model = load_pretrained(model, num_classes, settings)
# Modify attributs
model.last_linear = model.fc
del model.fc
def features(self, input):
# 299 x 299 x 3
x = self.Conv2d_1a_3x3(input) # 149 x 149 x 32
x = self.Conv2d_2a_3x3(x) # 147 x 147 x 32
x = self.Conv2d_2b_3x3(x) # 147 x 147 x 64
x = F.max_pool2d(x, kernel_size=3, stride=2) # 73 x 73 x 64
x = self.Conv2d_3b_1x1(x) # 73 x 73 x 80
x = self.Conv2d_4a_3x3(x) # 71 x 71 x 192
x = F.max_pool2d(x, kernel_size=3, stride=2) # 35 x 35 x 192
x = self.Mixed_5b(x) # 35 x 35 x 256
x = self.Mixed_5c(x) # 35 x 35 x 288
x = self.Mixed_5d(x) # 35 x 35 x 288
x = self.Mixed_6a(x) # 17 x 17 x 768
x = self.Mixed_6b(x) # 17 x 17 x 768
x = self.Mixed_6c(x) # 17 x 17 x 768
x = self.Mixed_6d(x) # 17 x 17 x 768
x = self.Mixed_6e(x) # 17 x 17 x 768
if self.training and self.aux_logits:
self._out_aux = self.AuxLogits(x) # 17 x 17 x 768
x = self.Mixed_7a(x) # 8 x 8 x 1280
x = self.Mixed_7b(x) # 8 x 8 x 2048
x = self.Mixed_7c(x) # 8 x 8 x 2048
return x
def logits(self, features):
x = F.avg_pool2d(features, kernel_size=8) # 1 x 1 x 2048
x = F.dropout(x, training=self.training) # 1 x 1 x 2048
x = x.view(x.size(0), -1) # 2048
x = self.last_linear(x) # 1000 (num_classes)
if self.training and self.aux_logits:
aux = self._out_aux
self._out_aux = None
return x, aux
return x
def forward(self, input):
x = self.features(input)
x = self.logits(x)
return x
# Modify methods
setattr(model.__class__, 'features', features)
setattr(model.__class__, 'logits', logits)
setattr(model.__class__, 'forward', forward)
return model
def inceptionv3(num_classes=1000, pretrained='imagenet'):
r"""Inception v3 model architecture from
`"Rethinking the Inception Architecture for Computer Vision" <http://arxiv.org/abs/1512.00567>`_.
"""
model = models.inception_v3(pretrained=False)
if pretrained is not None:
settings = pretrained_settings['inceptionv3'][pretrained]
model = load_pretrained(model, num_classes, settings)
return model
def __init__(self):
super(INCEPTION_V3, self).__init__()
self.model = models.inception_v3()
url = 'https://download.pytorch.org/models/inception_v3_google-1a9a5a14.pth'
# print(next(model.parameters()).data)
state_dict = \
model_zoo.load_url(url, map_location=lambda storage, loc: storage)
self.model.load_state_dict(state_dict)
for param in self.model.parameters():
param.requires_grad = False
print('Load pretrained model from ', url)
def __init__(self, model):
super(feature_net, self).__init__()
if model == 'vgg':
vgg = models.vgg19(pretrained=True)
self.feature == nn.Sequential(*list(vgg.children())[:-1])
self.feature.add_module('global average', nn.AvgPool2d(9))
elif model == 'inceptionv3':
inception = models.inception_v3(pretrained=True)
self.feature = nn.Sequential(*list(inception.children())[:-1])
self.feature._modules.pop('13')
self.feature.add_modules('global average', nn.AvgPool2d(35))
elif model == 'resnet152':
resnet = models.resnet152(pretrained=True)
self.feature = nn.Sequential(*list(resnet.children())[:-1])
def get_FID_scores(self):
fake_features_list = []
real_features_list = []
#self.gen.eval()
#CHECK OP PÅ DEN HER ift. hvad vi har
#OBS OBS OBS
n_samples = self.numberOfSamples # The total number of samples
batch_size = self.batchsize # Samples per iteration
inception_model = inception_v3(pretrained=False)
#find pretrained downlaoded model
if self.config.run_polyaxon:
finalPath = self.config.data_path / 'models' / 'OutputModels' / 'inception_v3_google-1a9a5a14.pth'
else:
localdir = Path().absolute().parent
modelOutputPath = Path.joinpath(localdir, 'OutputModels')
finalPath = Path.joinpath(modelOutputPath,
'inception_v3_google-1a9a5a14.pth')
inception_model.load_state_dict(torch.load(finalPath))
inception_model.to(self.device)
inception_model = inception_model.eval() # Evaluation mode
inception_model.fc = torch.nn.Identity()
cur_samples = 0
Fake_dataloader_Iterations = iter(self.fakes)
with torch.no_grad(
): # You don't need to calculate gradients here, so you do this to save memory
try:
if self.TCI:
for real_example, target in tqdm(
self.reals,
total=n_samples // batch_size,
disable=self.config.run_polyaxon): # Go by batch
real_samples = real_example
real_features = inception_model(
real_samples.to(self.device)).detach().to(
'cpu') # Move features to CPU
real_features_list.append(real_features)
# Usikker på om det her dur
# https://stackoverflow.com/questions/53280967/pytorch-nextitertraining-loader-extremely-slow-simple-data-cant-num-worke
fake_samples = next(Fake_dataloader_Iterations)
# fake_samples = self.preprocess(self.gen(fake_samples))
fake_features = inception_model(fake_samples[0].to(
self.device)).detach().to('cpu')
fake_features_list.append(fake_features)
cur_samples += len(real_samples)
if cur_samples >= n_samples:
break
else:
for real_example in tqdm(
self.reals,
total=n_samples // batch_size,
disable=self.config.run_polyaxon): # Go by batch
real_samples = real_example
real_features = inception_model(
real_samples.to(self.device)).detach().to(
'cpu') # Move features to CPU
real_features_list.append(real_features)
# Usikker på om det her dur
# https://stackoverflow.com/questions/53280967/pytorch-nextitertraining-loader-extremely-slow-simple-data-cant-num-worke
fake_samples = next(Fake_dataloader_Iterations)
# fake_samples = self.preprocess(self.gen(fake_samples))
fake_features = inception_model(
fake_samples.to(self.device)).detach().to('cpu')
fake_features_list.append(fake_features)
cur_samples += len(real_samples)
if cur_samples >= n_samples:
break
except:
print("Error in FID loop")
#Combine all features of loop
fake_features_all = torch.cat(fake_features_list)
real_features_all = torch.cat(real_features_list)
#Get sigma, my
self.mu_fake = torch.mean(fake_features_all,
0) # ,True)#,dim=0,keepdim=True)
self.mu_real = torch.mean(real_features_all,
0) # ,True)#,dim=0,keepdim=True)
self.sigma_fake = self.get_covariance(fake_features_all)
self.sigma_real = self.get_covariance(real_features_all)
with torch.no_grad():
FID_Distance = self.frechet_distance(self.mu_real, self.mu_fake,
self.sigma_real,
self.sigma_fake).item()
#If you want to visualize uncomment this
#self.visualizeResults()
return FID_Distance
def __init__(self, device, model='resnet34', workers=4, batch_size=64):
'''
model: inception_v3, vgg13, vgg16, vgg19, resnet18, resnet34,
resnet50, resnet101, or resnet152
'''
self.model = model
self.batch_size = batch_size
self.workers = workers
if self.model.find('vgg') >= 0:
self.vgg = getattr(models, model)(pretrained=True).to(device).eval()
self.trans = transforms.Compose([
transforms.Resize(224),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406),
(0.229, 0.224, 0.225)),
])
elif self.model.find('resnet') >= 0:
resnet = getattr(models, model)(pretrained=True)
resnet.to(device).eval()
resnet_feature = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu,
resnet.maxpool, resnet.layer1,
resnet.layer2, resnet.layer3,
resnet.layer4).to(device).eval()
self.resnet = resnet
self.resnet_feature = resnet_feature
self.trans = transforms.Compose([
transforms.Resize(224),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406),
(0.229, 0.224, 0.225)),
])
elif self.model == 'inception' or self.model == 'inception_v3':
inception = models.inception_v3(
pretrained=True, transform_input=False).to(device).eval()
inception_feature = nn.Sequential(inception.Conv2d_1a_3x3,
inception.Conv2d_2a_3x3,
inception.Conv2d_2b_3x3,
nn.MaxPool2d(3, 2),
inception.Conv2d_3b_1x1,
inception.Conv2d_4a_3x3,
nn.MaxPool2d(3, 2),
inception.Mixed_5b,
inception.Mixed_5c,
inception.Mixed_5d,
inception.Mixed_6a,
inception.Mixed_6b,
inception.Mixed_6c,
inception.Mixed_6d,
inception.Mixed_7a,
inception.Mixed_7b,
inception.Mixed_7c,
).to(device).eval()
self.inception = inception
self.inception_feature = inception_feature
self.trans = transforms.Compose([
transforms.Resize(299),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
else:
raise NotImplementedError
import torch
from torch import nn
from torchvision import models
import numpy as np
import cv2
class AbandonDetector(nn.module):
def __init__():
super(AbandonDetector, self).__init__()
self.inception = models.inception_v3(pretrained=True)
inception = models.inception_v3(pretrained=True)
inception = inception.cuda()
frames = np.load('data/tensor0.npy')
batch = []
for i in range(10):
frame = cv2.resize(frames[i], (299, 299), cv2.INTER_AREA)
batch.append(frame)
batch = np.stack(batch)
batch = torch.FloatTensor(batch).transpose(1, 3).cuda()
out = inception(batch)
print(out)
def get_dcnn(arch, num_classes, pretrained):
if arch == 'resnet18':
model = models.resnet18(pretrained=pretrained)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)
if not pretrained:
model.apply(weights_init)
elif arch == 'myresnet18':
model = myresnet.myresnet18(pretrained=pretrained)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)
if not pretrained:
model.apply(weights_init)
elif arch == 'resnet34':
model = models.resnet34(pretrained=pretrained)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)
if not pretrained:
model.apply(weights_init)
elif arch == 'myresnet34':
model = myresnet.myresnet34(pretrained=pretrained)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)
if not pretrained:
model.apply(weights_init)
elif arch == 'resnet50':
model = models.resnet50(pretrained=pretrained)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)
if not pretrained:
print('initializing the resnet50 ...')
model.apply(weights_init)
elif arch == 'resnet101':
model = models.resnet101(pretrained=pretrained)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)
if not pretrained:
model.apply(weights_init)
elif arch == 'myresnet101':
model = myresnet.myresnet101(pretrained=pretrained)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)
if not pretrained:
model.apply(weights_init)
elif arch == 'resnet152':
model = models.resnet152(pretrained=pretrained)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)
if not pretrained:
model.apply(weights_init)
elif arch == 'myresnet152':
model = myresnet.myresnet152(pretrained=pretrained)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)
if not pretrained:
model.apply(weights_init)
elif arch == 'vgg16':
model = models.vgg16(pretrained=pretrained)
mod = list(model.classifier.children())[:-1] + [
torch.nn.Linear(4096, num_classes)
]
new_classifier = torch.nn.Sequential(*mod)
model.classifier = new_classifier
elif arch == 'vgg19':
model = models.vgg19(pretrained=pretrained)
mod = list(model.classifier.children())[:-1] + [
torch.nn.Linear(4096, num_classes)
]
new_classifier = torch.nn.Sequential(*mod)
model.classifier = new_classifier
# model = nets.Vgg19(num_classes, pretrained=bool(args.pretrained), bn_after_act=False)
elif arch == 'inception_v3':
model = models.inception_v3(pretrained=pretrained,
transform_input=True)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)
model.AuxLogits.fc = nn.Linear(model.AuxLogits.fc.in_features,
num_classes)
elif arch == 'inception_v3_dropout':
model = models.inception_v3(pretrained=pretrained,
transform_input=True)
num_ftrs = model.fc.in_features # 2048
model.fc = nn.Sequential(
nn.Linear(num_ftrs, num_ftrs),
nn.BatchNorm1d(num_ftrs),
nn.ReLU(inplace=True),
nn.Dropout(p=0.5, inplace=False),
# True will cause: "one of the variables needed for gradient computation
# has been modified by an inplace operation"
nn.Linear(num_ftrs, num_classes),
)
model.AuxLogits.fc = nn.Linear(model.AuxLogits.fc.in_features,
num_classes)
elif arch == 'inception_v3_alldrop':
model = my_inception.my_inception_v3(pretrained=pretrained,
transform_input=True)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, num_classes)
model.AuxLogits.fc = nn.Linear(model.AuxLogits.fc.in_features,
num_classes)
else:
print('No {}!'.format(arch))
return model
def __init__(self,
output_blocks=[3],
resize_input=True,
normalize_input=True,
requires_grad=False,
use_fid_inception=True):
"""Build pretrained InceptionV3
Parameters
----------
output_blocks : list of int
Indices of blocks to return features of. Possible values are:
- 0: corresponds to output of first max pooling
- 1: corresponds to output of second max pooling
- 2: corresponds to output which is fed to aux classifier
- 3: corresponds to output of final average pooling
resize_input : bool
If true, bilinearly resizes input to width and height 299 before
feeding input to model. As the network without fully connected
layers is fully convolutional, it should be able to handle inputs
of arbitrary size, so resizing might not be strictly needed
normalize_input : bool
If true, scales the input from range (0, 1) to the range the
pretrained Inception network expects, namely (-1, 1)
requires_grad : bool
If true, parameters of the model require gradients. Possibly useful
for finetuning the network
use_fid_inception : bool
If true, uses the pretrained Inception model used in Tensorflow's
FID implementation. If false, uses the pretrained Inception model
available in torchvision. The FID Inception model has different
weights and a slightly different structure from torchvision's
Inception model. If you want to compute FID scores, you are
strongly advised to set this parameter to true to get comparable
results.
"""
super(InceptionV3, self).__init__()
self.resize_input = resize_input
self.normalize_input = normalize_input
self.output_blocks = sorted(output_blocks)
self.last_needed_block = max(output_blocks)
assert self.last_needed_block <= 3, \
'Last possible output block index is 3'
self.blocks = nn.ModuleList()
if use_fid_inception:
inception = fid_inception_v3()
else:
inception = models.inception_v3(pretrained=True)
# Block 0: input to maxpool1
block0 = [
inception.Conv2d_1a_3x3, inception.Conv2d_2a_3x3,
inception.Conv2d_2b_3x3,
nn.MaxPool2d(kernel_size=3, stride=2)
]
self.blocks.append(nn.Sequential(*block0))
# Block 1: maxpool1 to maxpool2
if self.last_needed_block >= 1:
block1 = [
inception.Conv2d_3b_1x1, inception.Conv2d_4a_3x3,
nn.MaxPool2d(kernel_size=3, stride=2)
]
self.blocks.append(nn.Sequential(*block1))
# Block 2: maxpool2 to aux classifier
if self.last_needed_block >= 2:
block2 = [
inception.Mixed_5b,
inception.Mixed_5c,
inception.Mixed_5d,
inception.Mixed_6a,
inception.Mixed_6b,
inception.Mixed_6c,
inception.Mixed_6d,
inception.Mixed_6e,
]
self.blocks.append(nn.Sequential(*block2))
# Block 3: aux classifier to final avgpool
if self.last_needed_block >= 3:
block3 = [
inception.Mixed_7a, inception.Mixed_7b, inception.Mixed_7c,
nn.AdaptiveAvgPool2d(output_size=(1, 1))
]
self.blocks.append(nn.Sequential(*block3))
for param in self.parameters():
param.requires_grad = requires_grad
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":
""" 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 == "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
import math
import torch
import torch.nn.functional as F
from torch.autograd import Variable
from torchvision.models import inception_v3
net = inception_v3(pretrained=True).cuda()
def inception_score(images, batch_size=5):
scores = []
for i in range(int(math.ceil(float(len(images)) / float(batch_size)))):
batch = Variable(
torch.cat(images[i * batch_size:(i + 1) * batch_size], 0))
s, _ = net(batch) # skipping aux logits
scores.append(s)
p_yx = F.softmax(torch.cat(scores, 0), 1)
p_y = p_yx.mean(0).unsqueeze(0).expand(p_yx.size(0), -1)
KL_d = p_yx * (torch.log(p_yx) - torch.log(p_y))
final_score = KL_d.mean()
return final_score
if __name__ == '__main__':
if softmax is None:
_init_inception()
def get_images(filename):
return scipy.misc.imread(filename)
for iterations in range(100, 5000, 100):
def set_model(model_name, num_classes):
if model_name == 'resnext50_32x4d':
model = models.resnext50_32x4d(pretrained=True)
model.fc = torch.nn.Sequential(torch.nn.Linear(in_features=2048, out_features=num_classes))
elif model_name == 'resnet18':
model = models.resnet18(pretrained=True)
model.fc = torch.nn.Linear(in_features=512, out_features=num_classes)
elif model_name == 'resnet34':
model = models.resnet34(pretrained=True)
model.fc = torch.nn.Linear(in_features=512, out_features=num_classes)
elif model_name == 'resnet50':
model = models.resnet50(pretrained=True)
model.fc = torch.nn.Linear(in_features=2048, out_features=num_classes)
elif model_name == 'vgg16':
model = models.vgg16(pretrained=True)
model.classifier[6] = torch.nn.Linear(in_features=4096, out_features=num_classes)
elif model_name == 'densenet121':
model = models.densenet121(pretrained=True)
model.classifier = torch.nn.Linear(in_features=1024, out_features=num_classes)
elif model_name == 'densenet161':
model = models.densenet161(pretrained=True)
model.classifier = torch.nn.Linear(in_features=2208, out_features=num_classes)
elif model_name == 'inception':
model = models.inception_v3(pretrained=True)
model.fc = torch.nn.Linear(in_features=2048, out_features=num_classes)
elif model_name == 'googlenet':
model = models.googlenet(pretrained=True)
model.fc = torch.nn.Linear(in_features=1024, out_features=num_classes)
elif model_name == 'shufflenet_v2_x0_5':
model = models.shufflenet_v2_x0_5(pretrained=True)
model.fc = torch.nn.Linear(in_features=1024, out_features=num_classes)
elif model_name == 'shufflenet_v2_x1_0':
model = models.shufflenet_v2_x1_0(pretrained=True)
model.fc = torch.nn.Linear(in_features=1024, out_features=num_classes)
elif model_name == 'mobilenet_v2':
model = models.mobilenet_v2(pretrained=True)
model.classifier[1] = torch.nn.Linear(in_features=1280, out_features=num_classes)
elif model_name == 'mobilenet_v3_large':
model = models.mobilenet_v3_large(pretrained=True)
model.classifier[3] = torch.nn.Linear(in_features=1280, out_features=num_classes)
elif model_name == 'mobilenet_v3_small':
model = models.mobilenet_v3_small(pretrained=True)
model.classifier[3] = torch.nn.Linear(in_features=1280, out_features=num_classes)
elif model_name == 'wide_resnet50_2':
model = models.wide_resnet50_2(pretrained=True)
model.fc = torch.nn.Linear(in_features=2048, out_features=num_classes)
elif model_name == 'mnasnet0_5':
model = models.mnasnet0_5(pretrained=True)
model.classifier[1] = torch.nn.Linear(in_features=1280, out_features=num_classes)
elif model_name == 'mnasnet1_0':
model = models.mnasnet1_0(pretrained=True)
model.classifier[1] = torch.nn.Linear(in_features=1280, out_features=num_classes)
elif model_name == 'alexnet':
model = models.alexnet(pretrained=True)
model.classifier[6] = torch.nn.Linear(in_features=4096, out_features=num_classes)
elif model_name == 'vgg19_bn':
model = models.vgg19_bn(pretrained=True)
model.classifier[6] = torch.nn.Linear(in_features=4096, out_features=num_classes)
elif model_name == 'efficientnet-b0':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b1':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b2':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b3':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b4':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b5':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b6':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
elif model_name == 'efficientnet-b7':
model = EfficientNet.from_pretrained(model_name, num_classes=num_classes)
else:
raise NameError(f'!!!!! Model ERROR : {model_name} !!!!!')
return model
"path": "both"
},
"vgg16": {
"model": models.vgg16(pretrained=True),
"path": "both"
},
"squeezenet": {
"model": models.squeezenet1_0(pretrained=True),
"path": "both"
},
"densenet": {
"model": models.densenet161(pretrained=True),
"path": "both"
},
"inception_v3": {
"model": models.inception_v3(pretrained=True),
"path": "both"
},
#"googlenet": models.googlenet(pretrained=True),
"shufflenet": {
"model": models.shufflenet_v2_x1_0(pretrained=True),
"path": "both"
},
"mobilenet_v2": {
"model": models.mobilenet_v2(pretrained=True),
"path": "both"
},
"resnext50_32x4d": {
"model": models.resnext50_32x4d(pretrained=True),
"path": "both"
},
def main():
data_root = '/home/jsk/s/prcv/dataset'
data_dir = os.path.join(data_root, 'v2')
dataset_dir = '/home/jsk/s/prcv/dataset/v4/dataset'
gt_path = './txt/clean_dataset_v2_5010_50.txt'
pathlist = []
indexes = os.listdir(dataset_dir)
indexes.sort()
for index in indexes:
dire = os.path.join(dataset_dir, index)
pathlist.append(dire)
print('total image is %d' % (len(pathlist)))
#print(pathlist[394:405])
if model_str[:9] == 'inception':
size1 = 299
size2 = 299
else:
size1 = 256
size2 = 224
data_transforms = transforms.Compose([
transforms.Resize(size1),
transforms.CenterCrop(size2),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
image_datasets = customData(img_path=dataset_dir,
txt_path=(gt_path),
data_transforms=data_transforms)
testloader = torch.utils.data.DataLoader(image_datasets,
batch_size=1,
shuffle=False,
num_workers=32)
dataset_sizes = len(image_datasets)
#assert dataset_sizes==len(pathlist),'pytorch dataset is not equal to pathlist'
device = torch.device("cuda:2" if torch.cuda.is_available() else "cpu")
model = { #'resnet18':models.resnet18(pretrained=False),
'resnet50': models.resnet50(pretrained=False),
'resnet101': models.resnet101(pretrained=False),
#'resnet152':models.resnet152(pretrained=False),
#'densenet121':models.densenet121(pretrained=False),
'densenet161': models.densenet161(pretrained=False),
#'densenet169':models.densenet169(pretrained=False),
'densenet201': models.densenet201(pretrained=False),
'inception_v3': models.inception_v3(pretrained=False),
'vgg16_bn': models.vgg16_bn(pretrained=False),
'vgg19_bn': models.vgg19_bn(pretrained=False)
}
param = {
'v3_8': 'inception_v3_epoch30_all_batch8_SGD_0.001.pkl',
'16_bn': 'vgg16_bn_epoch30_all_batch8_SGD_0.001.pkl',
'101_8': 'resnet101_epoch26_ft_batch8.pkl',
'161_8': 'densenet161_epoch30_all_batch8_SGD_0.001.pkl',
'201_8': 'densenet201_epoch30_all_batch8_SGD_0.002.pkl',
'50_8_sgd': 'resnet50_epoch30_ft_batch8.pkl',
'50_8_adam': 'resnet50_epoch30_all_batch8_Adam_6e-05.pkl',
'101_4': 'resnet101_epoch30_all_batch4_SGD_0.0008.pkl',
'v3_4': 'inception_v3_epoch30_all_batch4_SGD_0.001.pkl',
'161_4': 'densenet161_epoch30_all_batch4_SGD_0.0008.pkl'
}
model_test = model[model_str]
if model_str[:6] == 'resnet':
num_ftrs = model_test.fc.in_features
model_test.fc = nn.Linear(num_ftrs, num_classes)
elif model_str[:8] == 'densenet':
num_ftrs = model_test.classifier.in_features
model_test.classifier = nn.Linear(num_ftrs, num_classes)
elif model_str[:9] == 'inception':
num_ftrs = model_test.fc.in_features
model_test.fc = nn.Linear(num_ftrs, num_classes)
elif model_str[:3] == 'vgg':
num_ftrs = model_test.classifier[6].in_features
model_test.classifier[6] = nn.Linear(num_ftrs, num_classes)
else:
raise ValueError('choose the available')
print(model_test)
print('current mode: %s' % (TEST_OR_COPY))
print('test param %s of model %s' % (param[param_str], model_str))
param_dir = os.path.join(root, param[param_str])
model_test.load_state_dict(torch.load(param_dir))
model_test = model_test.to(device)
model_test.eval()
correct = 0
correct_1 = 0
correct_5 = 0
top1 = 0
top5 = 0
total = 0
batch = 0
num1 = 0
num2 = 0
filename = param[param_str] + '.txt'
file_txt = open(filename, 'w')
with torch.no_grad():
index = 0
for inputs, labels in testloader:
inputs = inputs.to(device)
labels = labels.to(device)
outputs = model_test(inputs)
#_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
#correct += (predicted == labels).sum().item()
#print(type(inputs))
assert inputs.size()[0] == 1
img = pathlist[index]
index += 1
itop1, itop5 = stand_output(outputs, topk=(1, 5))
#top1_list.append(itop1)
#top5_list.append(itop5)
print(
img.split('/')[-1] + ' top1: ' + str(itop1) + ' top5: ' +
" ".join(str(x) for x in itop5))
str1 = img.split('/')[-1] + ' top1: ' + str(
itop1) + ' top5: ' + " ".join(str(x) for x in itop5) + '\n'
file_txt.writelines(str1)
dcorrect_1, dcorrect_5 = accuracy(outputs, labels, topk=(1, 5))
correct_1 += dcorrect_1
correct_5 += dcorrect_5
top1 = correct_1.float() / total
top5 = correct_5.float() / total
batch += 1
print('batch %d label %d correct %d' %
(batch, labels.item(), dcorrect_1.item()))
#print('batch %d accuracy: %.3f %%' % (batch,100.*correct/total))
#print('batch %d top1 accuracy: %.3f %% top5 accuracy: %.3f %%' % (batch,100*top1,100*top5))
print(
'Accuracy of the %s on the %d test images: top1 %.3f %% top5 %.3f %%'
% (param[param_str], total, 100 * top1, 100 * top5))
file_txt.close()
plt.subplot(num_samples,batch_size,j*batch_size+i+1)
img_clip = np.clip(img[i], 0, 1)
plt.imshow(img_clip.numpy().transpose((1, 2, 0)))
img, label = next(iter(train_dl))
#plt.show()
## Load pre-trained model
cache_dir = os.path.expanduser(os.path.join('~', '.torch'))
if not os.path.exists(cache_dir):
os.makedirs(cache_dir)
models_dir = os.path.join(cache_dir, 'models')
if not os.path.exists(models_dir):
os.makedirs(models_dir)
use_gpu = torch.cuda.is_available()
model_conv = models.inception_v3(pretrained=True)
print("Use GPU: ", use_gpu)
## freeze the first few layers. This is done in two stages:
freeze_layers = True
# Stage-1 Freezing all the layers
if freeze_layers:
for i, param in model_conv.named_parameters():
param.requires_grad = False
# Stage-2 , Freeze all the layers till "Conv2d_4a_3*3"
ct = []
for name, child in model_conv.named_children():
if "Conv2d_4a_3x3" in ct:
for params in child.parameters():
def Encode(use_cuda):
enc = inception_v3(True)
if use_cuda: enc = enc.cuda()
return enc
epoch)
torch.save(model, PATH)
print()
time_elapsed = time.time() - since
print('Training complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
print('Best val Acc: {:4f}'.format(best_acc))
# load best model weights
model.load_state_dict(best_model_wts)
return model
base_model = models.inception_v3(pretrained=True)
for param in base_model.parameters():
param.requires_grad = False
#num_ftrs = base_model.AuxLogits.fc.in_features
#base_model.AuxLogits.fc = nn.Linear(num_ftrs, len(class_names))
num_ftrs = base_model.fc.in_features
#base_model.fc = nn.Linear(num_ftrs,len(class_names))
base_model.fc = nn.Sequential(nn.Linear(num_ftrs, 1024, bias=True), nn.ReLU(),
nn.Linear(1024, len(class_names), bias=True))
epochs = 10
model = base_model.to(device)
criterion = nn.CrossEntropyLoss().to(device)
def __init__(self,
num_classes=100,
network='resnet18',
pretrained=True,
dropout_rate=0.2,
num_domain_classes=None):
super(BasicResNet, self).__init__()
if network == 'resnet152':
resnet_model = models.resnet152(pretrained=pretrained)
elif network == 'resnet101':
resnet_model = models.resnet101(pretrained=pretrained)
elif network == 'resnet50':
resnet_model = models.resnet50(pretrained=pretrained)
elif network == 'resnet34':
resnet_model = models.resnet34(pretrained=pretrained)
elif network == 'resnet18':
resnet_model = models.resnet18(pretrained=pretrained)
elif network == 'MobileNetV2':
resnet_model = models.mobilenet_v2(pretrained=pretrained)
elif network == 'inceptionV3':
resnet_model = models.inception_v3(pretrained=pretrained)
elif network == 'mnasnet':
resnet_model = models.mnasnet1_0(pretrained=pretrained)
elif network == 'VGG':
resnet_model = models.vgg11(pretrained=pretrained)
else:
raise Exception("{} model type not supported".format(network))
self.num_domain_classes = num_domain_classes
self.resnet_model = resnet_model
if 'resnet' in network:
if num_domain_classes is None:
self.resnet_model.fc = nn.Sequential(
nn.BatchNorm1d(resnet_model.fc.in_features),
nn.Dropout(dropout_rate),
nn.Linear(resnet_model.fc.in_features,
resnet_model.fc.in_features),
nn.ReLU(),
nn.BatchNorm1d(resnet_model.fc.in_features),
nn.Dropout(dropout_rate),
nn.Linear(resnet_model.fc.in_features,
resnet_model.fc.in_features),
nn.ReLU(),
nn.BatchNorm1d(resnet_model.fc.in_features),
nn.Dropout(dropout_rate),
nn.Linear(resnet_model.fc.in_features, num_classes),
)
else:
self.resnet_model.fc = nn.Sequential(
nn.BatchNorm1d(resnet_model.fc.in_features),
nn.Dropout(dropout_rate),
nn.Linear(resnet_model.fc.in_features,
resnet_model.fc.in_features), nn.ReLU(),
nn.BatchNorm1d(resnet_model.fc.in_features),
nn.Dropout(dropout_rate),
nn.Linear(resnet_model.fc.in_features,
resnet_model.fc.in_features), nn.ReLU(),
nn.BatchNorm1d(resnet_model.fc.in_features),
nn.Dropout(dropout_rate),
nn.Linear(resnet_model.fc.in_features,
num_classes + num_domain_classes), nn.ReLU(),
nn.BatchNorm1d(num_classes + num_domain_classes),
nn.Dropout(dropout_rate))
self.classes_output = nn.Linear(
num_classes + num_domain_classes, num_classes)
self.domain_output = nn.Linear(
num_classes + num_domain_classes, num_domain_classes)
elif 'VG' in network:
self.resnet_model.classifier = nn.Sequential(
nn.Linear(25088, 4096, bias=True), nn.ReLU(),
nn.Dropout(p=0.5, inplace=False),
nn.Linear(4096, 4096, bias=True), nn.ReLU(),
nn.Dropout(p=0.5, inplace=False), nn.Linear(4096, num_classes))
#----------------------------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
#----------------------------------------------------------------------------------------------
import argparse
import os
from six import text_type as _text_type
from mmdnn.conversion.examples.imagenet_test import TestKit
import torch
import torchvision.models as models
NETWORKS_MAP = {
'inception_v3' : lambda : models.inception_v3(pretrained=True),
'vgg16' : lambda : models.vgg16(pretrained=True),
'vgg19' : lambda : models.vgg19(pretrained=True),
'resnet152' : lambda : models.resnet152(pretrained=True),
'densenet' : lambda : models.densenet201(pretrained=True),
'squeezenet' : lambda : models.squeezenet1_1(pretrained=True)
}
def _main():
parser = argparse.ArgumentParser()
parser.add_argument('-n', '--network',
type=_text_type, help='Model Type', required=True,
choices=NETWORKS_MAP.keys())
parser.add_argument('-i', '--image', type=_text_type, help='Test Image Path')
def initialize_model(model_name,
num_classes,
feature_extract=False,
use_pretrained=True):
model_ft = None
input_size = 0
if model_name == 'resnet18':
""" 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 == 'resnet101':
""" Resnet101
"""
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 == 'resnext':
""" ResNext50_32x4d
"""
model_ft = models.resnext50_32x4d(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 == '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)
num_ftrs = model_ft.AuxLogits.fc.in_features
model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 299
else:
logger.warning("Invalid model name, exiting...")
exit()
return model_ft, input_size
def __init__(self,
output_blocks=[DEFAULT_BLOCK_INDEX],
resize_input=True,
normalize_input=True,
requires_grad=False):
"""Build pretrained InceptionV3
Parameters
----------
output_blocks : list of int
Indices of blocks to return features of. Possible values are:
- 0: corresponds to output of first max pooling
- 1: corresponds to output of second max pooling
- 2: corresponds to output which is fed to aux classifier
- 3: corresponds to output of final average pooling
resize_input : bool
If true, bilinearly resizes input to width and height 299 before
feeding input to model. As the network without fully connected
layers is fully convolutional, it should be able to handle inputs
of arbitrary size, so resizing might not be strictly needed
normalize_input : bool
If true, normalizes the input to the statistics the pretrained
Inception network expects
requires_grad : bool
If true, parameters of the model require gradient. Possibly useful
for finetuning the network
"""
super(InceptionV3, self).__init__()
self.resize_input = resize_input
self.normalize_input = normalize_input
self.output_blocks = sorted(output_blocks)
self.last_needed_block = max(output_blocks)
assert self.last_needed_block <= 3, \
'Last possible output block index is 3'
self.blocks = nn.ModuleList()
inception = models.inception_v3(pretrained=True)
# Block 0: input to maxpool1
block0 = [
inception.Conv2d_1a_3x3,
inception.Conv2d_2a_3x3,
inception.Conv2d_2b_3x3,
nn.MaxPool2d(kernel_size=3, stride=2)
]
self.blocks.append(nn.Sequential(*block0))
# Block 1: maxpool1 to maxpool2
if self.last_needed_block >= 1:
block1 = [
inception.Conv2d_3b_1x1,
inception.Conv2d_4a_3x3,
nn.MaxPool2d(kernel_size=3, stride=2)
]
self.blocks.append(nn.Sequential(*block1))
# Block 2: maxpool2 to aux classifier
if self.last_needed_block >= 2:
block2 = [
inception.Mixed_5b,
inception.Mixed_5c,
inception.Mixed_5d,
inception.Mixed_6a,
inception.Mixed_6b,
inception.Mixed_6c,
inception.Mixed_6d,
inception.Mixed_6e,
]
self.blocks.append(nn.Sequential(*block2))
# Block 3: aux classifier to final avgpool
if self.last_needed_block >= 3:
block3 = [
inception.Mixed_7a,
inception.Mixed_7b,
inception.Mixed_7c,
nn.AdaptiveAvgPool2d(output_size=(1, 1))
]
self.blocks.append(nn.Sequential(*block3))
for param in self.parameters():
param.requires_grad = requires_grad
def main():
start_time = time()
def get_input_args():
"""
Retrieves and parses the command line arguments provided by the user when
they run the program from a terminal window. This function uses Python's
argparse module to created and defined these command line arguments. If
the user fails to provide some or all of the arguments, then the default
values are used for the missing arguments.
"""
# Create Parse using ArgumentParser
parser = argparse.ArgumentParser()
# Create command line arguments as mentioned above using add_argument() from ArguementParser method
parser.add_argument('--image_path',type=str,default='flowers/test/10/image_07090.jpg',help='path for image to predict')
parser.add_argument('--save_dir',type=str,default='fc_checkpoint.pth',help='path for checkpoint')
parser.add_argument('--topk',type=int,default=5,help='input number of top classes for prediction')
parser.add_argument('--arch', type = str, default = 'vgg16', help = 'architecure of Model')
parser.add_argument('--gpu',default=True,help='use GPU to make predictions')
parser.add_argument('--cat_to_name', default = 'cat_to_name.json',help='enters a path to image.')
in_arg = parser.parse_args()
return in_arg
in_arg = get_input_args()
with open('cat_to_name.json', 'r') as f:
cat_to_name = json.load(f)
resnet18 = models.resnet18(pretrained=True)
alexnet = models.alexnet(pretrained=True)
squeezenet = models.squeezenet1_0(pretrained=True)
vgg16 = models.vgg16(pretrained=True)
densenet = models.densenet161(pretrained=True)
inception = models.inception_v3(pretrained=True)
models_dict = {'resnet':resnet18
,'alexnet':alexnet
,'squeezenet':squeezenet
,'vgg16':vgg16
,'densenet':densenet
,'inception':inception
}
def load_checkpoint(path):
checkpoint = torch.load(path)
if checkpoint['arch'] == in_arg.arch:
model = models_dict[in_arg.arch]
for param in model.parameters():
param.requires_grad = False
model.class_to_idx = checkpoint['class_to_idx']
model.classifier = checkpoint['classifier']
model.load_state_dict(checkpoint['model_state_dict'])
#optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epochs = checkpoint['epochs']
return model
trained_model = load_checkpoint(in_arg.save_dir)
print('Checkpoint loaded')
def predict(image_path, model, topk):
''' Predict the class of an image using a trained model.
'''
#Preprocess the image
im = process_image(image_path)
print('Image preprocessed')
im = im.unsqueeze_(0)
im = im.float()
print('image type is: {}'.format(type(im)))
print('Beginning Model Eval')
if torch.cuda.is_available() and in_arg.gpu == True:
model.cuda()
#Pass through the model
model.eval()
with torch.no_grad():
logps = model.forward(im.cuda())
ps = torch.exp(logps)
#Find top-k probabilities and indices
top_probability, indices = torch.topk(ps, dim=1, k=topk)
#Find the class using the indices
indices = np.array(indices)
index_to_class = {val: key for key, val in model.class_to_idx.items()}
top_classes = [index_to_class[i] for i in indices[0]]
#Map the class name with collected top-k classes
names = []
for classes in top_classes:
names.append(cat_to_name[str(classes)])
print('prediction complete')
return top_probability.cpu().numpy(), names
top_probability = predict(in_arg.image_path,trained_model,in_arg.topk)[0]
top_classes = predict(in_arg.image_path,trained_model,in_arg.topk)[1]
print(top_probability,top_classes)
end_time = time()
tot_time = end_time - start_time
print("\n** Total Elapsed Runtime:",
str(int((tot_time/3600)))+":"+str(int((tot_time%3600)/60))+":"
+str(int((tot_time%3600)%60)) )
def initialize_model(model_name,
num_classes,
feature_extract,
use_pretrained=True):
model_ft = None
input_size = 0
if model_name == "resnet":
model_ft = models.resnet18(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_fltrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_fltrs, num_classes)
input_size = 224
elif model_name == "alexnet":
model_ft = models.alexnet(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_fltrs = model_ft.classifier[6].in_features
model_ft.classifier[6] = nn.Linear(num_fltrs, num_classes)
input_size = 224
elif model_name == "vgg":
model_ft = models.vgg11_bn(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_fltrs = model_ft.classifier[6].in_features
model_ft.classifier[6] = nn.Linear(num_fltrs, num_classes)
input_size = 224
elif model_name == "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":
model_ft = models.densenet121(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_fltrs = model_ft.classifier.in_features
model_ft.classifier = nn.Linear(num_fltrs, num_classes)
input_size = 224
elif model_name == "inception":
model_ft = models.inception_v3(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
# Handle the auxilary net
num_fltrs = model_ft.AuxLogits.fc.in_features
model_ft.AuxLogits.fc = nn.Linear(num_fltrs, num_classes)
# Handle the primary net
num_fltrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_fltrs, num_classes)
input_size = 299
else:
print("Invalid model name, exiting...")
exit()
return model_ft, input_size
def initialize_model(model_name,
num_classes,
feature_extract,
use_pretrained=True):
"""
Source: https://pytorch.org/tutorials/beginner/finetuning_torchvision_models_tutorial.html
Initialize these variables which will be set in this if statement. Each of these
variables is model specific.
:param str model_name: model to be loaded
:param int num_classes: number of classes
:param bool feature_extract: deactivate gradients
:param bool use_pretrained: load pretrained weights
:return: pretrained model, input_size
"""
model_ft = None
input_size = 0
if model_name == "resnet":
""" 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 == "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 __init__(self,
output_blocks=[DEFAULT_BLOCK_INDEX],
resize_input=True,
normalize_input=True,
requires_grad=False):
# 学習ずみ InceptionV3の構築
super(InceptionV3, self).__init__()
self.resize_input = resize_input
self.normalize_input = normalize_input
self.output_blocks = sorted(output_blocks)
self.last_needed_block = max(output_blocks)
assert self.last_needed_block <= 3, \
'Last possible output block index is 3'
self.blocks = nn.ModuleList()
inception = models.inception_v3(pretrained=True)
# Block 0: input から max pooling 1 まで
block0 = [
inception.Conv2d_1a_3x3, inception.Conv2d_2a_3x3,
inception.Conv2d_2b_3x3,
nn.MaxPool2d(kernel_size=3, stride=2)
]
self.blocks.append(nn.Sequential(*block0))
# Block 1: maxpool1 から maxpool2 まで
if self.last_needed_block >= 1:
block1 = [
inception.Conv2d_3b_1x1, inception.Conv2d_4a_3x3,
nn.MaxPool2d(kernel_size=3, stride=2)
]
self.blocks.append(nn.Sequential(*block1))
# Block 2: maxpool2 から aux classifier まで
if self.last_needed_block >= 2:
block2 = [
inception.Mixed_5b,
inception.Mixed_5c,
inception.Mixed_5d,
inception.Mixed_6a,
inception.Mixed_6b,
inception.Mixed_6c,
inception.Mixed_6d,
inception.Mixed_6e,
]
self.blocks.append(nn.Sequential(*block2))
# Block 3: aux classifier から final avgpool まで
if self.last_needed_block >= 3:
block3 = [
inception.Mixed_7a, inception.Mixed_7b, inception.Mixed_7c,
nn.AdaptiveAvgPool2d(output_size=(1, 1))
]
self.blocks.append(nn.Sequential(*block3))
for param in self.parameters():
param.requires_grad = requires_grad
def __init__(self, in_size=(3, 256, 256)):
self.inception_network = inception_v3(pretrained=True)
self.in_size = in_size
# return model
# In[23]:
model_dict = {
"ResNet_152" : {"model" : models.resnet152(pretrained=True), "type" : "fc"},
"AlexNet" : {"model" : models.alexnet(pretrained=True), "type" : "cl"},
"VGG_19_bn" : {"model" : models.vgg19_bn(pretrained=True), "type" : "cl"},
# "ShuffleNet_v2_x1-0" : {"model" : models.shufflenet_v2_x1_0(pretrained=True), "type" : "fc"},
"MobileNet_v2" : {"model" : models.mobilenet_v2(pretrained=True), "type" : "cl"},
"MnasNet_1-0" : {"model" : models.mnasnet1_0(pretrained=True), "type" : "cl"},
"ResNeXt_101_32x8d" : {"model" : models.resnext101_32x8d(pretrained=True), "type" : "fc"},
"Wide_ResNet_101-2" : {"model" : models.wide_resnet101_2(pretrained=True), "type" : "fc"},
"Inception_v3" : {"model" : models.inception_v3(pretrained=True), "type" : "fc"}
}
# In[24]:
data_transforms, image_datasets, dataloaders = update_data(paths, resize_s, crop_s, batch_size)
# In[ ]:
for model_name in model_dict:
model = model_dict[model_name]["model"]
def initialize_model(model_name,
num_classes,
feature_extract,
use_pretrained=False) -> (nn.Module, int):
"""get models from https://pytorch.org/hub/.
Args:
model_name (string): model name.
num_classes (int): the output dimension of model classifier.
feature_extract (bool): if true, will freeze all the gradients.
use_pretrained (bool): if true, model will load pretrained weights.
Return:
model, input size.
"""
# 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":
""" 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 == "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
# Handle the primary net
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 299
elif model_name == "vision_transformer":
""" Vision Transformer base 16
"""
model_ft = models.vit_b_16(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
# Handle the primary net
num_ftrs = model_ft.hidden_dim
model_ft.heads = nn.Linear(num_ftrs, num_classes)
input_size = 224
else:
print("Invalid model name, exiting...")
exit()
return model_ft, input_size
def __init__(self,
output_blocks=[DEFAULT_BLOCK_INDEX],
resize_input=True,
normalize_input=True,
requires_grad=False):
"""Build pretrained InceptionV3
Parameters
----------
output_blocks : list of int
Indices of blocks to return features of. Possible values are:
- 0: corresponds to output of first max pooling
- 1: corresponds to output of second max pooling
- 2: corresponds to output which is fed to aux classifier
- 3: corresponds to output of final average pooling
resize_input : bool
If true, bilinearly resizes input to width and height 299 before
feeding input to model. As the network without fully connected
layers is fully convolutional, it should be able to handle inputs
of arbitrary size, so resizing might not be strictly needed
normalize_input : bool
If true, normalizes the input to the statistics the pretrained
Inception network expects
requires_grad : bool
If true, parameters of the model require gradient. Possibly useful
for finetuning the network
"""
super(InceptionV3, self).__init__()
self.resize_input = resize_input
self.normalize_input = normalize_input
self.output_blocks = sorted(output_blocks)
self.last_needed_block = max(output_blocks)
assert self.last_needed_block <= 3, \
'Last possible output block index is 3'
self.blocks = nn.ModuleList()
inception = models.inception_v3(pretrained=True)
# Block 0: input to maxpool1
block0 = [
inception.Conv2d_1a_3x3, inception.Conv2d_2a_3x3,
inception.Conv2d_2b_3x3,
nn.MaxPool2d(kernel_size=3, stride=2)
]
self.blocks.append(nn.Sequential(*block0))
# Block 1: maxpool1 to maxpool2
if self.last_needed_block >= 1:
block1 = [
inception.Conv2d_3b_1x1, inception.Conv2d_4a_3x3,
nn.MaxPool2d(kernel_size=3, stride=2)
]
self.blocks.append(nn.Sequential(*block1))
# Block 2: maxpool2 to aux classifier
if self.last_needed_block >= 2:
block2 = [
inception.Mixed_5b,
inception.Mixed_5c,
inception.Mixed_5d,
inception.Mixed_6a,
inception.Mixed_6b,
inception.Mixed_6c,
inception.Mixed_6d,
inception.Mixed_6e,
]
self.blocks.append(nn.Sequential(*block2))
# Block 3: aux classifier to final avgpool
if self.last_needed_block >= 3:
block3 = [
inception.Mixed_7a, inception.Mixed_7b, inception.Mixed_7c,
nn.AdaptiveAvgPool2d(output_size=(1, 1))
]
self.blocks.append(nn.Sequential(*block3))
for param in self.parameters():
param.requires_grad = requires_grad
def __init__(self):
super(Inception, self).__init__()
self.model = models.inception_v3(pretrained=True)
self.input_size = 299
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":
""" 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 == "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
#Model parameters: 40740314 # # #EfficientNet b7 has input image size: 600 #63792082 63792082 #Model parameters: 63792082 from torchvision import models net = models.MobileNetV2() count_parameters(net) net = models.densenet201() count_parameters(net) net = models.inception_v3() count_parameters(net) #[27161264, 27161264] net = models.googlenet() count_parameters(net) #[13004888, 13004888] net = models.vgg19_bn() count_parameters(net) # 143678248 net = models.vgg19() count_parameters(net) # 143667240
def __init__():
super(AbandonDetector, self).__init__()
self.inception = models.inception_v3(pretrained=True)
def saveFeature(imgFolder, opt, model='resnet34', workers=4, batch_size=64):
'''
model: inception_v3, vgg13, vgg16, vgg19, resnet18, resnet34,
resnet50, resnet101, or resnet152
'''
g = Globals()
mkdir(g.default_feature_dir + opt.data)
feature_dir = g.default_feature_dir + opt.data + "/" + lastFolder(imgFolder)
conv_path = '{}_{}_conv.pth'.format(feature_dir, model)
class_path = '{}_{}_class.pth'.format(feature_dir, model)
smax_path = '{}_{}_smax.pth'.format(feature_dir, model)
if (os.path.exists(conv_path) and os.path.exists(class_path) and os.path.exists(class_path)):
print("Feature already generated before. Now pass.")
return
if hasattr(opt, 'feat_model') and opt.feat_model is not None:
model = opt.feat_model
if model == 'vgg' or model == 'vgg16':
vgg = models.vgg16(pretrained=True).cuda().eval()
trans = transforms.Compose([
transforms.Scale(224),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
dataset = dset.ImageFolder(root=imgFolder, transform=trans)
dataloader = torch.utils.data.DataLoader(
dataset, batch_size=batch_size, num_workers=int(workers),
shuffle=False)
print('saving vgg features:')
feature_conv, feature_smax, feature_class = [], [], []
for img, _ in tqdm(dataloader):
input = Variable(img.cuda(), volatile=True)
fconv = vgg.features(input)
fconv_out = fconv.mean(3).mean(2).squeeze()
fconv = fconv.view(fconv.size(0), -1)
flogit = vgg.classifier(fconv)
fsmax = F.softmax(flogit)
feature_conv.append(fconv_out.data.cpu())
feature_class.append(flogit.data.cpu())
feature_smax.append(fsmax.data.cpu())
feature_conv = torch.cat(feature_conv, 0)
feature_class = torch.cat(feature_class, 0)
feature_smax = torch.cat(feature_smax, 0)
elif model.find('resnet') >= 0:
if model == 'resnet34_cifar':
# Please load your own model. Example here:
# c = torch.load(
# '/home/gh349/xqt/wide-resnet.pytorch/checkpoint/cifar10/gan-resnet-34.t7')
# resnet = c['net']
pass
print('Using resnet34 trained on cifar10.')
raise NotImplementedError()
elif model == 'resnet34_random':
# Please load your own model. Example here:
# resnet = torch.load(
# '/home/gh349/xqt/wide-resnet.pytorch/checkpoint/cifar10/random_resnet34.t7')
pass
print('Using resnet34 with random weights.')
raise NotImplementedError()
else:
resnet = getattr(models, 'resnet34')(pretrained=True)
print('Using resnet34 with pretrained weights.')
resnet.cuda().eval()
resnet_feature = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.maxpool, resnet.layer1,
resnet.layer2, resnet.layer3, resnet.layer4)
input = Variable(torch.FloatTensor().cuda())
trans = transforms.Compose([
transforms.Scale(224),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
# transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
dataset = dset.ImageFolder(root=imgFolder, transform=trans)
dataloader = torch.utils.data.DataLoader(
dataset, batch_size=batch_size, num_workers=int(workers),
shuffle=False)
print('saving resnet features:')
feature_conv, feature_smax, feature_class = [], [], []
for img, _ in tqdm(dataloader):
input = Variable(img.cuda(), volatile=True)
fconv = resnet_feature(input)
fconv = fconv.mean(3).mean(2).squeeze()
flogit = resnet.fc(fconv)
fsmax = F.softmax(flogit)
feature_conv.append(fconv.data.cpu())
feature_class.append(flogit.data.cpu())
feature_smax.append(fsmax.data.cpu())
feature_conv = torch.cat(feature_conv, 0)
feature_class = torch.cat(feature_class, 0)
feature_smax = torch.cat(feature_smax, 0)
mkdir(g.default_feature_dir)
feature_dir = g.default_feature_dir + \
opt.data + "/" + lastFolder(imgFolder)
mkdir(g.default_feature_dir + opt.data)
torch.save(feature_conv, feature_dir + '_' + model + '_conv.pth')
torch.save(feature_class, feature_dir + '_' + model + '_class.pth')
torch.save(feature_smax, feature_dir + '_' + model + '_smax.pth')
return feature_conv, feature_class, feature_smax
elif model == 'inception' or model == 'inception_v3':
inception = models.inception_v3(
pretrained=True, transform_input=False).cuda().eval()
inception_feature = nn.Sequential(inception.Conv2d_1a_3x3,
inception.Conv2d_2a_3x3,
inception.Conv2d_2b_3x3,
nn.MaxPool2d(3, 2),
inception.Conv2d_3b_1x1,
inception.Conv2d_4a_3x3,
nn.MaxPool2d(3, 2),
inception.Mixed_5b,
inception.Mixed_5c,
inception.Mixed_5d,
inception.Mixed_6a,
inception.Mixed_6b,
inception.Mixed_6c,
inception.Mixed_6d,
inception.Mixed_7a,
inception.Mixed_7b,
inception.Mixed_7c,
).cuda().eval()
trans = transforms.Compose([
transforms.Scale(224),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
dataset = dset.ImageFolder(root=imgFolder, transform=trans)
dataloader = torch.utils.data.DataLoader(
dataset, batch_size=batch_size, num_workers=int(workers),
shuffle=False)
print('saving resnet features:')
feature_conv, feature_smax, feature_class = [], [], []
for img, _ in tqdm(dataloader):
input = Variable(img.cuda(), volatile=True)
fconv = inception_feature(input)
fconv = fconv.mean(3).mean(2).squeeze()
flogit = inception.fc(fconv)
fsmax = F.softmax(flogit)
feature_conv.append(fconv.data.cpu())
feature_class.append(flogit.data.cpu())
feature_smax.append(fsmax.data.cpu())
feature_conv = torch.cat(feature_conv, 0)
feature_class = torch.cat(feature_class, 0)
feature_smax = torch.cat(feature_smax, 0)
else:
raise NotImplementedError
torch.save(feature_conv, '{}_{}_conv.pth'.format(feature_dir, model))
torch.save(feature_class, '{}_{}_class.pth'.format(feature_dir, model))
torch.save(feature_smax, '{}_{}_smax.pth'.format(feature_dir, model))
return feature_conv, feature_class, feature_smax
def __init__(self, model='resnet34', workers=4, batchSize=64):
'''
model: inception_v3, vgg13, vgg16, vgg19, resnet18, resnet34,
resnet50, resnet101, or resnet152
'''
self.model = model
self.batch_size = batchSize
self.workers = workers
if self.model.find('vgg') >= 0:
self.vgg = getattr(models, model)(pretrained=True).cuda().eval()
self.trans = transforms.Compose([
transforms.Resize(224),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406),
(0.229, 0.224, 0.225)),
])
elif self.model.find('resnet') >= 0:
resnet = getattr(models, model)(pretrained=True)
resnet.cuda().eval()
resnet_feature = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu,
resnet.maxpool, resnet.layer1,
resnet.layer2, resnet.layer3,
resnet.layer4).cuda().eval()
self.resnet = resnet
self.resnet_feature = resnet_feature
self.trans = transforms.Compose([
transforms.Resize(224),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406),
(0.229, 0.224, 0.225)),
])
elif self.model == 'inception' or self.model == 'inception_v3':
inception = models.inception_v3(
pretrained=True, transform_input=False).cuda().eval()
inception_feature = nn.Sequential(inception.Conv2d_1a_3x3,
inception.Conv2d_2a_3x3,
inception.Conv2d_2b_3x3,
nn.MaxPool2d(3, 2),
inception.Conv2d_3b_1x1,
inception.Conv2d_4a_3x3,
nn.MaxPool2d(3, 2),
inception.Mixed_5b,
inception.Mixed_5c,
inception.Mixed_5d,
inception.Mixed_6a,
inception.Mixed_6b,
inception.Mixed_6c,
inception.Mixed_6d,
inception.Mixed_7a,
inception.Mixed_7b,
inception.Mixed_7c,
).cuda().eval()
self.inception = inception
self.inception_feature = inception_feature
self.trans = transforms.Compose([
transforms.Resize(299),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
else:
raise NotImplementedError
resnet18 = models.resnet18(pretrained=pretrained)
resnet34 = models.resnet34(pretrained=pretrained)
resnet50 = models.resnet50(pretrained=pretrained)
resnet101 = models.resnet101(pretrained=pretrained)
resnet152 = models.resnet152(pretrained=pretrained)
squeezenet1_0 = models.squeezenet1_0(pretrained=pretrained)
squeezenet1_1 = models.squeezenet1_1(pretrained=pretrained)
densenet121 = models.densenet121(pretrained=pretrained)
densenet169 = models.densenet169(pretrained=pretrained)
densenet161 = models.densenet161(pretrained=pretrained)
densenet201 = models.densenet201(pretrained=pretrained)
inception_v3 = models.inception_v3(pretrained=pretrained)
googlenet = models.googlenet(pretrained=pretrained)
shufflenet_v2_x0_5 = models.shufflenet_v2_x0_5(pretrained=pretrained)
shufflenet_v2_x1_0 = models.shufflenet_v2_x1_0(pretrained=pretrained)
# shufflenet_v2_x1_5 = models.shufflenet_v2_x1_5(pretrained=pretrained)
# shufflenet_v2_x2_0 = models.shufflenet_v2_x2_0(pretrained=pretrained)
mobilenet_v2 = models.mobilenet_v2(pretrained=pretrained)
resnext50_32x4d = models.resnext50_32x4d(pretrained=pretrained)
resnext101_32x8d = models.resnext101_32x8d(pretrained=pretrained)
wide_resnet50_2 = models.wide_resnet50_2(pretrained=pretrained)
wide_resnet101_2 = models.wide_resnet101_2(pretrained=pretrained)
def __init__(self, num_classes: int):
super().__init__()
self.net = M.inception_v3(pretrained=True)
self.net.fc = nn.Linear(self.net.fc.in_features, num_classes)
def initialize_model(model_name, num_classes, feature_extract, verbose=False):
"""Initialize required model and set it up for feature extracting or finetuning.
Args:
model_name: Type of model to initialize.
num_classes: Total number of target classes.
feature_extract: Feature extracting or finetuning.
verbose: Print model info in the end or not.
Returns:
model_ft: Initialized model.
params_to_update: List of parameters to be updated during training.
"""
model_ft = None
if model_name == "resnet":
""" Resnet18
"""
model_ft = models.resnet18(pretrained=True)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
elif model_name == "alexnet":
""" Alexnet
"""
model_ft = models.alexnet(pretrained=True)
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)
elif model_name == "vgg":
""" VGG11_bn
"""
model_ft = models.vgg11_bn(pretrained=True)
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)
elif model_name == "squeezenet":
""" Squeezenet
"""
with warnings.catch_warnings(
): # temporarily suppress warnings about deprecated functions
warnings.simplefilter("ignore")
model_ft = models.squeezenet1_0(pretrained=True)
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
elif model_name == "densenet":
""" Densenet
"""
model_ft = models.densenet121(pretrained=True)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier.in_features
model_ft.classifier = nn.Linear(num_ftrs, num_classes)
elif model_name == "inception":
""" Inception v3
Be careful, expects (299,299) sized images and has auxiliary output
"""
model_ft = models.inception_v3(pretrained=True)
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)
else: # Unreachable
exit()
# Gather the parameters to be optimized
params_to_update = list(
filter(lambda p: p.requires_grad, model_ft.parameters()))
# Print model info
if verbose:
print()
print(model_ft)
print()
print("Params to learn:")
for name, param in model_ft.named_parameters():
if param.requires_grad:
print('\t', name)
return model_ft, params_to_update
def test_inception_v3(self):
self.image = read_image2()
process_model(models.inception_v3(self.pretrained), self.image,
_C_tests.forward_inceptionv3, 'Inceptionv3')
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
# Ignore ssl certification (prevent error for some users)
ssl._create_default_https_context = ssl._create_unverified_context
if model_name == "resnet":
""" 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 == "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
elif model_name == "xception":
""" Xception
Be careful, expects (299,299) sized images and has auxiliary output
"""
model_ft = xception.xception(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 = 299
elif model_name == "fleming_v1":
""" Fleming Model
Custom model created by team Fleming
"""
model_ft = fleming.FlemingModel_v1(num_classes=196)
input_size = 224
elif model_name == "fleming_v2":
""" Fleming Model
Custom model created by team Fleming
"""
model_ft = fleming.FlemingModel_v2(num_classes=196)
input_size = 224
elif model_name == "fleming_v3":
""" Fleming Model
Custom model created by team Fleming
"""
model_ft = fleming.FlemingModel_v3(num_classes=196)
input_size = 224
else:
print("Invalid model name, exiting...")
exit()
return model_ft, input_size