def densenet161(num_classes=1000, pretrained='imagenet'):
r"""Densenet-161 model from
`"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`
"""
model = models.densenet161(pretrained=False)
if pretrained is not None:
settings = pretrained_settings['densenet161'][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 get_model(num_classes, model_type='resnet50'):
if model_type == 'resnet50':
model = resnet50(pretrained=True).cuda()
model.fc = nn.Linear(model.fc.in_features, num_classes).cuda()
elif model_type == 'resnet101':
model = resnet101(pretrained=True).cuda()
model.fc = nn.Linear(model.fc.in_features, num_classes).cuda()
elif model_type == 'resnet152':
model = resnet152(pretrained=True).cuda()
model.fc = nn.Linear(model.fc.in_features, num_classes).cuda()
elif model_type == 'densenet121':
model = densenet121(pretrained=True).cuda()
model.classifier = nn.Linear(model.classifier.in_features, num_classes).cuda()
elif model_type == 'densenet161':
model = densenet161(pretrained=True).cuda()
model.classifier = nn.Linear(model.classifier.in_features, num_classes).cuda()
elif model_type == 'densenet201':
model = densenet201(pretrained=True).cuda()
model.classifier = nn.Linear(model.classifier.in_features, num_classes).cuda()
return model
def _initialize_model(self):
# Initialize these variables which will be set in this if statement. Each of these
# variables is model specific.
self.model = None
self.input_size = 0
if self.model_name == "resnet":
""" Resnet18
"""
self.model = models.resnet18(pretrained=self.use_pretrained)
self._set_parameter_requires_grad()
num_ftrs = self.model.fc.in_features
self.model.fc = nn.Linear(num_ftrs, self.num_classes)
self.input_size = 224
elif self.model_name == "alexnet":
""" Alexnet
"""
self.model = models.alexnet(pretrained=self.use_pretrained)
self._set_parameter_requires_grad()
num_ftrs = self.model.classifier[6].in_features
self.model.classifier[6] = nn.Linear(num_ftrs, self.num_classes)
self.input_size = 224
elif self.model_name == "vgg":
""" VGG16_bn
"""
self.model = models.vgg16(pretrained=self.use_pretrained)
self._set_parameter_requires_grad()
num_ftrs = self.model.classifier[6].in_features
self.model.classifier[6] = nn.Linear(num_ftrs, self.num_classes)
self.input_size = 224
elif self.model_name == "squeezenet":
""" Squeezenet
"""
self.model = models.squeezenet1_0(pretrained=self.use_pretrained)
self._set_parameter_requires_grad()
self.model.classifier[1] = nn.Conv2d(512,
self.num_classes,
kernel_size=(1, 1),
stride=(1, 1))
self.model.num_classes = self.num_classes
self.input_size = 224
elif self.model_name == "densenet":
""" Densenet
"""
self.model = models.densenet161(pretrained=self.use_pretrained)
self._set_parameter_requires_grad()
num_ftrs = self.model.classifier.in_features
self.model.classifier = nn.Linear(num_ftrs, self.num_classes)
self.input_size = 224
elif self.model_name == "inception":
""" Inception v3
Be careful, expects (299,299) sized images and has auxiliary output
"""
self.model = models.inception_v3(pretrained=self.use_pretrained)
self._set_parameter_requires_grad()
# Handle the auxilary net
num_ftrs = self.model.AuxLogits.fc.in_features
self.model.AuxLogits.fc = nn.Linear(num_ftrs, self.num_classes)
# Handle the primary net
num_ftrs = self.model.fc.in_features
self.model.fc = nn.Linear(num_ftrs, self.num_classes)
self.input_size = 299
else:
print("Invalid model name, exiting...")
exit()
def get_models(config):
model_name = config['model_name']
input_size = 224
if 'vgg' in model_name:
if model_name == 'vgg16':
model = models.vgg16(pretrained=True)
elif model_name == 'vgg19':
model = models.vgg19(pretrained=True)
elif model_name == 'vgg16_bn':
model = models.vgg16_bn(pretrained=True)
elif model_name == 'vgg19_bn':
model = models.vgg19_bn(pretrained=True)
for p in model.parameters():
p.requires_grad = False
#model.classifier[0] = nn.Linear(in_features=25088, out_features=4096)
#model.classifier[3] = nn.Linear(in_features=4096, out_features=4096)
model.classifier[6] = nn.Linear(in_features=4096, out_features=config['num_used_classes'])
elif 'res' in model_name:
if model_name == 'resnet50':
model = models.resnet50(pretrained=True)
elif model_name == 'resnet101':
model = models.resnet101(pretrained=True)
elif model_name == 'resnet152':
model = models.resnet152(pretrained=True)
elif model_name == 'resnext50_32x8d':
model = models.resnext50_32x4d(pretrained=True)
elif model_name == 'resnext101_32x8d':
model = models.resnext101_32x8d(pretrained=True)
elif model_name == 'wide_resnet50_2':
model = models.wide_resnet50_2(pretrained=True)
elif model_name == 'wide_resnet101_2':
model = models.wide_resnet101_2(pretrained=True)
for p in model.parameters():
p.requires_grad = False
model.fc = nn.Linear(in_features=2048, out_features=config['num_used_classes'])
elif 'inception' in model_name:
if model_name == 'inception_v3':
model = models.inception_v3(pretrained=True)
for p in model.parameters():
p.requires_grad = False
num_ftrs = model.AuxLogits.fc.in_features
model.AuxLogits.fc = nn.Linear(num_ftrs, config['num_used_classes'])
# Handle the primary net
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, config['num_used_classes'])
input_size = 299
elif 'densenet' in model_name:
if model_name == 'densenet121':
model = models.densenet121(pretrained=True)
if model_name == 'densenet161':
model = models.densenet161(pretrained=True)
if model_name == 'densenet169':
model = models.densenet169(pretrained=True)
if model_name == 'densenet201':
model = models.densenet201(pretrained=True)
for p in model.parameters():
p.requires_grad = False
num_ftrs = model.classifier.in_features
model.classifier = nn.Linear(num_ftrs, config['num_used_classes'])
return model, input_size
val_loader = torch.utils.data.DataLoader(val1, batch_size=500,shuffle=True, num_workers=0)
lr_values = np.array([0.00005])#, 0.0001, 0.0002]) #for the fc net
best_lr = []
best_acc = 0
k = 0
#TUNING
for lr in lr_values:
k += 1
print("##### ROUND "+str(k)+" #####")
model_ft = models.densenet161(pretrained=True)
for param in model_ft.features.parameters():
param.requires_grad = False
num_ftrs = model_ft.classifier.in_features
model_ft.classifier = nn.Linear(num_ftrs, 5)
#LOAD MODEL PARAMETERS IF NEEDED
#model_ft.load_state_dict(torch.load("models/test.pth.tar"))
if use_gpu:
model_ft = model_ft.cuda()
print("\nModel loaded in CUDA")
print("\nlr: "+str(lr))
def training(architecture, n_epoch, hidden_units, learning_rate):
t = time.time()
n_input = None
n_output = 102
if architecture == 'densenet':
densenet161 = models.densenet161(pretrained=True)
models_select = {'densenet': densenet161}
model = models_select[architecture]
for param in model.parameters():
param.requires_grad = False
n_input = 2208
classifier = nn.Sequential(
OrderedDict([('fc1', nn.Linear(n_input, hidden_units)),
('relu', nn.ReLU()), ('dropout', nn.Dropout(0.5)),
('fc2', nn.Linear(hidden_units, n_output)),
('output', nn.LogSoftmax(dim=1))]))
model.classifier = classifier
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.classifier.parameters(),
lr=learning_rate,
momentum=0.9)
elif architecture == 'vgg':
vgg16 = models.vgg16(pretrained=True)
models_select = {'vgg': vgg16}
model = models_select[architecture]
for param in model.parameters():
param.requires_grad = False
n_input = 4096
classifier = nn.Sequential(
OrderedDict([('fc1', nn.Linear(n_input, hidden_units)),
('relu', nn.ReLU()), ('dropout', nn.Dropout(0.5)),
('fc2', nn.Linear(hidden_units, n_output)),
('output', nn.LogSoftmax(dim=1))]))
model.classifier[6] = classifier
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.classifier[6].parameters(),
lr=learning_rate,
momentum=0.9)
epochs = n_epoch
steps = 0
running_loss = 0
accuracy_per_epoch = []
best_val_accuracy = None
train_len = 80
trainloader, validloader, testloader, train_dataset = data_load()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
t = time.time()
for epoch in range(epochs):
for inputs, labels in trainloader:
steps += 1
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
logits = model.forward(inputs)
loss = criterion(logits, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % train_len == 0:
test_loss = 0
accuracy = 0
model.eval()
with torch.no_grad():
for inputs, labels in validloader:
inputs, labels = inputs.to(device), labels.to(device)
logits = model.forward(inputs)
batch_loss = criterion(logits, labels)
test_loss += batch_loss.item()
ps = torch.exp(logits)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(equals.type(
torch.FloatTensor)).item()
running_loss = 0
model.train()
print(f'\nEpoch: {epoch+1}/{epochs}.. '
f'\nTraining Loss = {running_loss/train_len:.3f}.. '
f'\nValidation Loss = {test_loss/len(validloader):.3f}.. '
f'\nAccuracy = {accuracy/len(validloader)*100:.1f}..')
accuracy_per_epoch.append(accuracy / len(validloader) * 100)
time_elapsed = time.time() - t
print('\n')
print('\nTraining completed in {:.0f} min {:.0f} sec'.format(
time_elapsed // 60, time_elapsed % 60))
best_val_accuracy = max(float(val) for val in accuracy_per_epoch)
print("\nBest val accuracy = {:.1f}".format(best_val_accuracy))
print('\n\n** Saving checkpoint ...')
model.class_to_idx = train_dataset.class_to_idx
checkpoint = {
'arch': architecture,
'optimizer': optimizer.state_dict(),
'state_dict': model.state_dict(),
'epochs': epoch,
'learning_rate': learning_rate,
'class_to_idx': model.class_to_idx
}
checkpoint_saver(checkpoint)
def dn161(pre):
return children(densenet161(pre))[0]
def __init__(self,
num_classes=2,
feature='Alex',
feature_shape=(256,25,25),
pretrained=True,
requires_grad=False):
super(CNN, self).__init__()
# Feature Extraction
if(feature=='Alex'):
self.ft_ext = models.alexnet(pretrained=pretrained)
self.ft_ext_modules = list(self.ft_ext.children())[:-1]
elif(feature=='Res'):
self.ft_ext = models.resnet50(pretrained=pretrained)
self.ft_ext_modules=list(self.ft_ext.children())[:-2]
elif(feature=='Squeeze'):
self.ft_ext = models.squeezenet1_1(pretrained=pretrained)
self.ft_ext_modules=list(self.ft_ext.children())[:-1]
elif(feature=='Dense'):
self.ft_ext = models.densenet161(pretrained=pretrained)
self.ft_ext_modules=list(self.ft_ext.children())[:-1]
self.ft_ext=nn.Sequential(*self.ft_ext_modules)
for p in self.ft_ext.parameters():
p.requires_grad = requires_grad
# Classifier
if(feature=='Res'):
conv1_output_features = int(feature_shape[0]/4)
else:
conv1_output_features = int(feature_shape[0]/2)
fc_1_input_features = conv1_output_features*int(feature_shape[1]/2)*int(feature_shape[2]/2)
fc1_output_features = 256
fc2_output_features = 64
self.conv1 = nn.Sequential(
nn.Conv2d(
in_channels=feature_shape[0],
out_channels=conv1_output_features,
kernel_size=1,
),
nn.BatchNorm2d(conv1_output_features),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2)
)
self.fc1 = nn.Sequential(
nn.Linear(fc_1_input_features, fc1_output_features),
nn.BatchNorm1d(fc1_output_features),
nn.ReLU()
)
self.fc2 = nn.Sequential(
nn.Linear(fc1_output_features, fc2_output_features),
nn.BatchNorm1d(fc2_output_features),
nn.ReLU()
)
self.out = nn.Linear(fc2_output_features, num_classes)
def __init__(self, num_classes, input_size, k=7):
super(GCN_COMBINED, self).__init__()
self.K = k
self.input_size = input_size
dense161_path = os.path.join(pretrained_dir, 'densenet161.pth')
densenet = models.densenet161()
densenet.load_state_dict(torch.load(dense161_path))
self.layer0 = nn.Sequential(
densenet.features.conv0,
densenet.features.norm0,
densenet.features.relu0,
)
self.layer1 = nn.Sequential(
densenet.features.pool0,
densenet.features.denseblock1,
)
self.layer2 = nn.Sequential(
densenet.features.transition1,
densenet.features.denseblock2,
)
self.layer3 = nn.Sequential(
densenet.features.transition2,
densenet.features.denseblock3,
)
self.layer4 = nn.Sequential(
densenet.features.transition3,
densenet.features.denseblock4,
)
self.gcm1 = _GlobalConvModule(2208, num_classes, (self.K, self.K))
self.gcm2 = _GlobalConvModule(2112, num_classes, (self.K, self.K))
self.gcm3 = _GlobalConvModule(768, num_classes, (self.K, self.K))
self.gcm4 = _GlobalConvModule(384, num_classes, (self.K, self.K))
self.brm1 = _BoundaryRefineModule(num_classes)
self.brm2 = _BoundaryRefineModule(num_classes)
self.brm3 = _BoundaryRefineModule(num_classes)
self.brm4 = _BoundaryRefineModule(num_classes)
self.brm5 = _BoundaryRefineModule(num_classes)
self.brm6 = _BoundaryRefineModule(num_classes)
self.brm7 = _BoundaryRefineModule(num_classes)
self.brm8 = _BoundaryRefineModule(num_classes)
self.brm9 = _BoundaryRefineModule(num_classes)
self.deconv = _LearnedBilinearDeconvModule(num_classes)
self.psp = _PyramidPoolingModule(num_classes,
12,
input_size,
levels=(1, 2, 3, 6, 9))
self.final = nn.Sequential(
nn.Conv2d(num_classes + self.psp.out_channels,
num_classes,
kernel_size=3,
padding=1), nn.BatchNorm2d(num_classes),
nn.ReLU(inplace=True),
nn.Conv2d(num_classes, num_classes, kernel_size=1, padding=0))
initialize_weights(self.gcm1, self.gcm2, self.gcm3, self.gcm4,
self.brm1, self.brm2, self.brm3, self.brm4,
self.brm5, self.brm6, self.brm7, self.brm8,
self.brm9)
initialize_weights(self.psp, self.final)
model.classifier[6] = nn.Linear(num_ftrs,nnClassCount)
criterion = nn.BCELoss(size_average = True)
elif trNetName == "Vgg19":
model = models.vgg19_bn(pretrained=usePreTrain)
set_parameter_requires_grad(model, feature_extract)
num_ftrs = model.classifier[6].in_features
model.classifier[6] = nn.Linear(num_ftrs,nnClassCount)
criterion = nn.BCELoss(size_average = True)
elif trNetName == "DenseNet121":
model = models.densenet121(pretrained=usePreTrain)
set_parameter_requires_grad(model, feature_extract)
num_ftrs = model.classifier.in_features
model.classifier = nn.Linear(num_ftrs, nnClassCount)
criterion = nn.BCELoss(size_average = True)
elif trNetName == "DenseNet161":
model = models.densenet161(pretrained=usePreTrain)
set_parameter_requires_grad(model, feature_extract)
num_ftrs = model.classifier.in_features
model.classifier = nn.Linear(num_ftrs, nnClassCount)
criterion = nn.BCELoss(size_average = True)
elif trNetName == "DenseNet169":
model = models.densenet169(pretrained=usePreTrain)
set_parameter_requires_grad(model, feature_extract)
num_ftrs = model.classifier.in_features
model.classifier = nn.Linear(num_ftrs, nnClassCount)
criterion = nn.BCELoss(size_average = True)
elif trNetName == "DenseNet201":
model = models.densenet201(pretrained=usePreTrain)
set_parameter_requires_grad(model, feature_extract)
num_ftrs = model.classifier.in_features
model.classifier = nn.Linear(num_ftrs, nnClassCount)
imshow(inputs.cpu().data[j])
if images_so_far == num_images:
model.train(mode=was_training)
return
model.train(mode=was_training)
######################################################################
# Finetuning the convnet
# ----------------------
#
# Load a pretrained model and reset final fully connected layer.
#
model_ft = models.densenet161(pretrained=False)
#num_ftrs = model_ft.fc.in_features
#model_ft.fc = nn.Linear(num_ftrs, 2)
model_ft = model_ft.to(device)
criterion = nn.CrossEntropyLoss()
# Observe that all parameters are being optimized
optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)
# Decay LR by a factor of 0.1 every 7 epochs
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)
######################################################################
# Train and evaluate
def instantiate_model (dataset='cifar10',
num_classes=10,
input_quant='FP',
arch='resnet',
dorefa=False,
abit=32,
wbit=32,
qin=False,
qout=False,
suffix='',
load=False,
torch_weights=False,
device='cpu'):
"""Initializes/load network with random weight/saved and return auto generated model name 'dataset_arch_suffix.ckpt'
Args:
dataset : mnists/cifar10/cifar100/imagenet/tinyimagenet/simple dataset the netwoek is trained on. Used in model name
num_classes : number of classes in dataset.
arch : resnet/vgg/lenet5/basicnet/slpconv model architecture the network to be instantiated with
suffix : str appended to the model name
load : boolean variable to indicate load pretrained model from ./pretrained/dataset/
torch_weights : boolean variable to indicate load weight from torchvision for imagenet dataset
Returns:
model : models with desired weight (pretrained / random )
model_name : str 'dataset_arch_suffix.ckpt' used to save/load model in ./pretrained/dataset
"""
#Select the input transformation
if input_quant==None:
input_quant=''
Q=PreProcess()
elif input_quant.lower()=='q1':
Q = Quantise2d(n_bits=1).to(device)
elif input_quant.lower()=='q2':
Q = Quantise2d(n_bits=2).to(device)
elif input_quant.lower()=='q4':
Q = Quantise2d(n_bits=4).to(device)
elif input_quant.lower()=='q6':
Q = Quantise2d(n_bits=6).to(device)
elif input_quant.lower()=='q8':
Q = Quantise2d(n_bits=8).to(device)
elif input_quant.lower()=='fp':
Q = Quantise2d(n_bits=1,quantise=False).to(device)
else:
raise ValueError
# Instantiate model1
# RESNET IMAGENET
if(arch == 'torch_resnet18'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.resnet18(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_resnet34'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.resnet34(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_resnet50'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.resnet50(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_resnet101'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.resnet101(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_resnet152'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.resnet152(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_resnet34'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.resnet34(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_resnext50_32x4d'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.resnext50_32x4d(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_resnext101_32x8d'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.resnext101_32x8d(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_wide_resnet50_2'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.wide_resnet50_2(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_wide_resnet101_2'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.wide_resnet101_2(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
#VGG IMAGENET
elif(arch == 'torch_vgg11'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.vgg11(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_vgg11bn'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.vgg11_bn(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_vgg13'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.vgg13(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_vgg13bn'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.vgg13_bn(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_vgg16'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.vgg16(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_vgg16bn'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.vgg16_bn(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_vgg19'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.vgg19(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_vgg19bn'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.vgg19_bn(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
#MOBILENET IMAGENET
elif(arch == 'torch_mobnet'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.mobilenet_v2(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
#DENSENET IMAGENET
elif(arch == 'torch_densenet121'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.densenet121(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_densenet169'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.densenet169(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_densenet201'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.densenet201(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
elif(arch == 'torch_densenet161'):
if dorefa:
raise ValueError ("Dorefa net unsupported for {}".format(arch))
else:
model = models.densenet161(pretrained=torch_weights)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
#RESNET CIFAR
elif(arch[0:6] == 'resnet'):
cfg = arch[6:]
if dorefa:
model = ResNet_Dorefa_(cfg=cfg, num_classes=num_classes, a_bit=abit, w_bit=wbit)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch +"_a" + str(abit) + 'w'+ str(wbit) + suffix
else:
model = ResNet_(cfg=cfg, num_classes=num_classes)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
#VGG CIFAR
elif(arch[0:3] == 'vgg'):
len_arch = len(arch)
if arch[len_arch-2:len_arch]=='bn' and arch[len_arch-4:len_arch-2]=='bn':
batch_norm_conv=True
batch_norm_linear=True
cfg= arch[3:len_arch-4]
elif arch [len_arch-2: len_arch]=='bn':
batch_norm_conv=True
batch_norm_linear=False
cfg= arch[3:len_arch-2]
else:
batch_norm_conv=False
batch_norm_linear=False
cfg= arch[3:len_arch]
if dorefa:
model = vgg_Dorefa(cfg=cfg, batch_norm_conv=batch_norm_conv, batch_norm_linear=batch_norm_linear ,num_classes=num_classes, a_bit=abit, w_bit=wbit)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch +"_a" + str(abit) + 'w'+ str(wbit) + suffix
else:
model = vgg(cfg=cfg, batch_norm_conv=batch_norm_conv, batch_norm_linear=batch_norm_linear ,num_classes=num_classes)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
# LENET MNIST
elif (arch == 'lenet5'):
if dorefa:
model = LeNet5_Dorefa(num_classes=num_classes, abit=abit, wbit=wbit)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch +"_a" + str(abit) + 'w'+ str(wbit) + suffix
else:
model = LeNet5(num_classes=num_classes)
model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix
else:
# Right way to handle exception in python see https://stackoverflow.com/questions/2052390/manually-raising-throwing-an-exception-in-python
# Explains all the traps of using exception, does a good job!! I mean the link :)
raise ValueError("Unsupported neural net architecture")
model = model.to(device)
if load == True and torch_weights == False :
print(" Using Model: " + arch)
if model_name[-4:]=='_tfr':
model_path = os.path.join('./pretrained/', dataset.lower(), model_name + '.tfr')
else:
model_path = os.path.join('./pretrained/', dataset.lower(), model_name + '.ckpt')
model.load_state_dict(torch.load(model_path, map_location='cuda:0'))
print(' Loaded trained model from :' + model_path)
print(' {}'.format(Q))
else:
if model_name[-4:]=='_tfr':
model_path = os.path.join('./pretrained/', dataset.lower(), model_name + '.tfr')
else:
model_path = os.path.join('./pretrained/', dataset.lower(), model_name + '.ckpt')
print(' Training model save at:' + model_path)
print('')
return model, model_name, Q
def __init__(self, args):
super(DenseNet161, self).__init__()
self._model = models.densenet161(pretrained=args.trained_on_imagenet)
self._model.classifier = nn.Linear(args.rolled_size, args.num_classes)
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 train(trainloader, validloader, class_to_idx, epochs, lr, arch,
hidden_units):
# Build and train your network
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if arch == 'densenet121':
model = models.densenet121(pretrained=True)
input_size = 1024
elif arch == 'densenet161':
model = models.densenet161(pretrained=True)
input_size = 2208
elif arch == 'vgg16':
model = models.vgg16(pretrained=True)
input_size = 25088
else:
return Null
for param in model.parameters():
param.requires_grad = False
model.classifier = nn.Sequential(
nn.Linear(input_size, hidden_units), nn.ReLU(), nn.Dropout(p=0.3),
nn.Linear(hidden_units, len(class_to_idx)), nn.LogSoftmax(dim=1))
# Criterion
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(), lr=lr)
model.to(device)
epochs = epochs
steps = 0
running_loss = 0
print_every = 5
for epoch in range(epochs):
for inputs, labels in trainloader:
steps += 1
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
logps = model.forward(inputs)
loss = criterion(logps, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % print_every == 0:
valid_loss = 0
accuracy = 0
model.eval()
with torch.no_grad():
for inputs, labels in validloader:
inputs, labels = inputs.to(device), labels.to(device)
logps = model.forward(inputs)
batch_loss = criterion(logps, labels)
valid_loss += batch_loss.item()
ps = torch.exp(logps)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(equals.type(torch.FloatTensor))
print(f'Epoch {epoch+1}/{epochs}.. '
f'Validation loss: {running_loss/print_every:.3f}.. '
f'Validation loss: {valid_loss/len(validloader):.3f}.. '
f'Validation accuracy: {accuracy/len(validloader):.3f}')
running_loss = 0
model.train()
# TODO: Save the checkpoint
model.class_to_idx = class_to_idx
torch.save(model, 'checkpoint.pth')
#torch.save(model.state_dict(), filepath)
#torch.save(checkpoint, 'checkpoint.pth')
print("Model saved to 'checkpoint.pth'")
train_on_gpu = torch.cuda.is_available()
if not train_on_gpu:
print('CUDA is not available. Training on CPU ...')
else:
print('CUDA is available! Training on GPU ...')
ImageFile.LOAD_TRUNCATED_IMAGES = True
#!pip install --upgrade wandb
test_transforms = transforms.Compose([
transforms.Resize(255),
# transforms.CenterCrop(224),
transforms.ToTensor(),
])
model = models.densenet161()
model.classifier = nn.Sequential(nn.Linear(2208, 1000), nn.ReLU(),
nn.Dropout(0.2), nn.Linear(1000, 2),
nn.LogSoftmax(dim=1))
criterion = nn.NLLLoss()
# Only train the classifier parameters, feature parameters are frozen
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)
model = model.cuda()
model.load_state_dict(torch.load('tensorboardexp.pt'))
classes = ["accident", "noaccident"]
# model.load_state_dict(torch.load('tensorboardexp.pt'))
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.densenet161(True)
num_ftrs = model_ft.classifier.in_features
model_ft.classifier = nn.Linear(num_ftrs, 80)
if use_gpu:
model_ft = nn.DataParallel(model_ft, [0]).cuda()
criterion = nn.CrossEntropyLoss()
# Observe that all parameters are being optimized
optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)
# optimizer_ft = optim.Adam(model_ft.parameters(), lr=0.01)
# Decay LR by a factor of 0.1 every 7 epochs
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=2, gamma=0.1)
sort_by="cuda_time_total", row_limit=10))
print(
prof.key_averages(group_by_input_shape=True).table(
sort_by="cuda_memory_usage", row_limit=10))
prof.export_chrome_trace(filename + '.json')
# %%
model_zoo = {
'resnet18': models.resnet18(),
'resnet34': models.resnet34(),
'resnet50': models.resnet50(),
'resnet101': models.resnet101(),
'resnet152': models.resnet152(),
'mobilenetv2': models.mobilenet.mobilenet_v2(),
'mobilenetv3_small': models.mobilenet.mobilenet_v3_small(),
'mobilenetv3_large': models.mobilenet.mobilenet_v3_large(),
'densenet161': models.densenet161(),
'densenet201': models.densenet201()
}
profile_conv_runtimes(models.mobilenet.mobilenet_v3_small(), 'resnet18')
# %%
model = models.mobilenet.mobilenet_v2()
model = model.to(device)
print_mobilenet_shapes(model)
# shapes = print_resnet_conv_shapes(model)
# write_shapes(name, shapes)
# %%
def __init__(self, encoder_pretrained=True):
super(Encoder, self).__init__()
self.densenet = models.densenet161(pretrained=encoder_pretrained)
for param in self.densenet.parameters():
param.requires_grad = False
def main():
# To deal with num_workers>1 in DataLoader, which is needed only in Windows environment
# https://github.com/pytorch/pytorch/issues/11139
# https://stackoverflow.com/questions/33038209/python-multiprocessing-fails-for-example-code
import multiprocessing
multiprocessing.freeze_support()
data_transforms = {
'train':
T.Compose([
T.RandomResizedCrop(224),
T.ToTensor(),
T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'test':
T.Compose([
T.RandomResizedCrop(256),
T.CenterCrop(224),
T.ToTensor(),
T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
}
SVHN_path = os.path.join(path, 'mat')
SVHN = {
x: datasets.SVHN(SVHN_path, split=x, transform=data_transforms[x])
for x in ['train', 'test']
}
dataloaders = {
x: DataLoader(SVHN[x], batch_size=BS, shuffle=True, num_workers=4)
for x in ['train', 'test']
}
dataset_sizes = {x: len(SVHN[x]) for x in ['train', 'test']}
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
device = torch.device("cpu")
print('Device:', device)
# # Get a batch of training data
# inputs, classes = next(iter(dataloaders['train']))
# # Make a grid from batch
# out = torchvision.utils.make_grid(inputs)
# imshow(out, title=[x for x in classes])
########################
### Prepare DenseNet ###
########################
densenet = models.densenet161(pretrained=True)
num_ftrs = densenet.classifier.in_features
densenet.classifier = nn.Linear(num_ftrs, 10)
densenet = densenet.to(device)
criterion = nn.CrossEntropyLoss()
# Observe that all parameters are being optimized
optimizer_ft = optim.SGD(densenet.parameters(), lr=0.001, momentum=0.9)
# Decay LR by a factor of 0.1 every 7 epochs
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft,
step_size=7,
gamma=0.1)
densenet = train_model(dataloaders,
dataset_sizes,
device,
densenet,
criterion,
optimizer_ft,
exp_lr_scheduler,
num_epochs=1,
test=True)
torch.save(densenet.state_dict(),
os.path.join(path, 'densenet_weights_final.pth'))
def __init__(self, num_hidden):
densenet = models.densenet161(pretrained=True)
modules = list(densenet.features.children())
annotation_dim = modules[-1].num_features
feature_extractor = nn.Sequential(*modules[:-1]) # intermediate feature map: (-1, 2208, 7, 7)
super().__init__(feature_extractor, annotation_dim, num_hidden)
def main(train_root, train_csv, val_root, val_csv, test_root, test_csv, epochs,
aug, model_name, batch_size, num_workers, val_samples, test_samples,
early_stopping_patience, limit_data, images_per_epoch, _run):
assert (model_name
in ('inceptionv4', 'resnet152', 'densenet161', 'senet154'))
AUGMENTED_IMAGES_DIR = os.path.join(fs_observer.dir, 'images')
CHECKPOINTS_DIR = os.path.join(fs_observer.dir, 'checkpoints')
BEST_MODEL_PATH = os.path.join(CHECKPOINTS_DIR, 'model_best.pth')
LAST_MODEL_PATH = os.path.join(CHECKPOINTS_DIR, 'model_last.pth')
RESULTS_CSV_PATH = os.path.join('results', 'results.csv')
EXP_NAME = _run.meta_info['options']['--name']
EXP_ID = _run._id
for directory in (AUGMENTED_IMAGES_DIR, CHECKPOINTS_DIR):
os.makedirs(directory)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if model_name == 'inceptionv4':
model = ptm.inceptionv4(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, 2)
aug['size'] = 299
aug['mean'] = model.mean
aug['std'] = model.std
elif model_name == 'resnet152':
model = models.resnet152(pretrained=True)
model.fc = nn.Linear(model.fc.in_features, 2)
aug['size'] = 224
aug['mean'] = [0.485, 0.456, 0.406]
aug['std'] = [0.229, 0.224, 0.225]
elif model_name == 'densenet161':
model = models.densenet161(pretrained=True)
model.classifier = nn.Linear(model.classifier.in_features, 2)
aug['size'] = 224
aug['mean'] = [0.485, 0.456, 0.406]
aug['std'] = [0.229, 0.224, 0.225]
elif model_name == 'senet154':
model = ptm.senet154(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, 2)
aug['size'] = model.input_size[1]
aug['mean'] = model.mean
aug['std'] = model.std
model.to(device)
augs = Augmentations(**aug)
model.aug_params = aug
datasets = {
'samples':
CSVDataset(train_root,
train_csv,
'image_id',
'melanoma',
transform=augs.tf_augment,
add_extension='.jpg',
limit=(400, 433)),
'train':
CSVDataset(train_root,
train_csv,
'image_id',
'melanoma',
transform=augs.tf_transform,
add_extension='.jpg',
random_subset_size=limit_data),
'val':
CSVDatasetWithName(val_root,
val_csv,
'image_id',
'melanoma',
transform=augs.tf_transform,
add_extension='.jpg'),
'test':
CSVDatasetWithName(test_root,
test_csv,
'image_id',
'melanoma',
transform=augs.tf_transform,
add_extension='.jpg'),
'test_no_aug':
CSVDatasetWithName(test_root,
test_csv,
'image_id',
'melanoma',
transform=augs.no_augmentation,
add_extension='.jpg'),
'test_144':
CSVDatasetWithName(test_root,
test_csv,
'image_id',
'melanoma',
transform=augs.inception_crop,
add_extension='.jpg'),
}
dataloaders = {
'train':
DataLoader(datasets['train'],
batch_size=batch_size,
shuffle=True,
num_workers=num_workers,
worker_init_fn=set_seeds),
'samples':
DataLoader(datasets['samples'],
batch_size=batch_size,
shuffle=False,
num_workers=num_workers,
worker_init_fn=set_seeds),
}
save_images(datasets['samples'], to=AUGMENTED_IMAGES_DIR, n=32)
sample_batch, _ = next(iter(dataloaders['samples']))
save_image(make_grid(sample_batch, padding=0),
os.path.join(AUGMENTED_IMAGES_DIR, 'grid.jpg'))
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),
lr=0.001,
momentum=0.9,
weight_decay=0.001)
scheduler = optim.lr_scheduler.MultiStepLR(optimizer,
milestones=[10],
gamma=0.1)
metrics = {
'train': pd.DataFrame(columns=['epoch', 'loss', 'acc', 'auc']),
'val': pd.DataFrame(columns=['epoch', 'loss', 'acc', 'auc'])
}
best_val_auc = 0.0
best_epoch = 0
epochs_without_improvement = 0
if images_per_epoch:
batches_per_epoch = images_per_epoch // batch_size
else:
batches_per_epoch = None
for epoch in range(epochs):
print('train epoch {}/{}'.format(epoch + 1, epochs))
epoch_train_result = train_epoch(device, model, dataloaders, criterion,
optimizer, batches_per_epoch)
metrics['train'] = metrics['train'].append(
{
**epoch_train_result, 'epoch': epoch
}, ignore_index=True)
print('train', epoch_train_result)
epoch_val_result, _ = test_with_augmentation(model, datasets['val'],
device, num_workers,
val_samples)
metrics['val'] = metrics['val'].append(
{
**epoch_val_result, 'epoch': epoch
}, ignore_index=True)
print('val', epoch_val_result)
print('-' * 40)
scheduler.step()
if epoch_val_result['auc'] > best_val_auc:
best_val_auc = epoch_val_result['auc']
best_epoch = epoch
epochs_without_improvement = 0
torch.save(model, BEST_MODEL_PATH)
else:
epochs_without_improvement += 1
if epochs_without_improvement > early_stopping_patience:
torch.save(model, LAST_MODEL_PATH)
break
if epoch == (epochs - 1):
torch.save(model, LAST_MODEL_PATH)
for phase in ['train', 'val']:
metrics[phase].epoch = metrics[phase].epoch.astype(int)
metrics[phase].to_csv(os.path.join(fs_observer.dir, phase + '.csv'),
index=False)
# Run testing
test_result, _ = test_with_augmentation(torch.load(BEST_MODEL_PATH),
datasets['test'], device,
num_workers, test_samples)
print('test', test_result)
test_noaug_result, _ = test_with_augmentation(torch.load(BEST_MODEL_PATH),
datasets['test_no_aug'],
device, num_workers, 1)
print('test (no augmentation)', test_noaug_result)
test_144crop_result, _ = test_with_augmentation(
torch.load(BEST_MODEL_PATH), datasets['test_144'], device, num_workers,
1)
print('test (144-crop)', test_144crop_result)
with open(RESULTS_CSV_PATH, 'a') as file:
file.write(','.join((EXP_NAME, str(EXP_ID), str(best_epoch),
str(best_val_auc), str(test_noaug_result['auc']),
str(test_result['auc']),
str(test_144crop_result['auc']))) + '\n')
return (test_noaug_result['auc'], test_result['auc'],
test_144crop_result['auc'])
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
correct = pred.eq(target.view(1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
res.append(correct_k.mul_(100.0 / batch_size))
return res
NAME_TO_MODEL = {
'resnet50': resnet50(num_classes=100),
'ayangnet': AyangNet(),
'densenet': models.densenet161(num_classes=100),
'inceptionv3': inception_v3(num_classes=100),
'inceptionv4': inception_v4(num_classes=100),
'wideresnet': WideResNet(28, 100, widen_factor=10),
'widedensenet': DenseNet(60, (6, 6, 6, 6), 64, num_classes=100)
}
if __name__ == '__main__':
default_path = './preprocess'
noise_decay = 0.55
loss_fn = CrossEntropyLoss()
# set up argument parser
parser = argparse.ArgumentParser()
# experiment
def get_model(model_id, use_pretrained):
model_ft = None
if model_id == PyTorchModelsEnum.ALEXNET:
model_ft = models.alexnet(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.DENSENET121:
model_ft = models.densenet121(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.DENSENET161:
model_ft = models.densenet161(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.DENSENET169:
model_ft = models.densenet169(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.DENSENET201:
model_ft = models.densenet201(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.GOOGLENET:
model_ft = models.googlenet(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.INCEPTION_V3:
model_ft = models.inception_v3(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.MOBILENET_V2:
model_ft = models.mobilenet_v2(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.MNASNET_0_5:
model_ft = models.mnasnet0_5(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.MNASNET_0_75: # no pretrained
model_ft = models.mnasnet0_75(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.MNASNET_1_0:
model_ft = models.mnasnet1_0(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.MNASNET_1_3:
model_ft = models.mnasnet1_3(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.RESNET18:
model_ft = models.resnet18(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.RESNET34:
model_ft = models.resnet34(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.RESNET50:
model_ft = models.resnet50(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.RESNET101:
model_ft = models.resnet101(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.RESNET152:
model_ft = models.resnet152(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.RESNEXT50:
model_ft = models.resnext50_32x4d(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.RESNEXT101:
model_ft = models.resnext101_32x8d(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.SHUFFLENET_V2_0_5:
model_ft = models.shufflenet_v2_x0_5(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.SHUFFLENET_V2_1_0:
model_ft = models.shufflenet_v2_x1_0(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.SHUFFLENET_V2_1_5:
model_ft = models.shufflenet_v2_x1_5(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.SHUFFLENET_V2_2_0:
model_ft = models.shufflenet_v2_x2_0(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.SQUEEZENET1_0:
model_ft = models.squeezenet1_0(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.SQUEEZENET1_1:
model_ft = models.squeezenet1_1(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.VGG11:
model_ft = models.vgg11(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.VGG11_BN:
model_ft = models.vgg11_bn(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.VGG13:
model_ft = models.vgg13(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.VGG13_BN:
model_ft = models.vgg13_bn(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.VGG16:
model_ft = models.vgg16(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.VGG16_BN:
model_ft = models.vgg16_bn(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.VGG19:
model_ft = models.vgg19(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.VGG19_BN:
model_ft = models.vgg19_bn(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.WIDE_RESNET50:
model_ft = models.wide_resnet50_2(pretrained=use_pretrained)
elif model_id == PyTorchModelsEnum.WIDE_RESNET101:
model_ft = models.wide_resnet101_2(pretrained=use_pretrained)
return model_ft
print('LR is set to {}'.format(lr))
optimizer.param_groups[0]['lr'] = lr
optimizer.param_groups[1]['lr'] = lr * 10
return optimizer
######################################################################
# Finetuning the convnet
# ----------------------
#
# Load a pretrained model and reset final fully connected layer.
#
model_ft = models.densenet161(pretrained=True, drop_rate=0.5)
num_ftrs = model_ft.classifier.in_features
model_ft.classifier = nn.Linear(num_ftrs, n_classes)
model_ft.max_num = 2
if use_gpu:
model_ft = model_ft.cuda()
criterion = nn.CrossEntropyLoss()
# Observe that all parameters are being optimized
# Observe that all parameters are being optimized
ignored_params = list(map(id, model_ft.classifier.parameters()))
base_params = filter(lambda p: id(p) not in ignored_params,
model_ft.parameters())
return optimizer
### SECTION 3 : DEFINING MODEL ARCHITECTURE.
# Set the pre-trained model in the ocnfig file by MODEL_FT.
if MODEL_FT == 'inception_v3':
model_ft = models.inception_v3(pretrained=IS_PRETRAINED)
elif MODEL_FT == 'resnet18':
model_ft = models.resnet18(pretrained=IS_PRETRAINED)
elif MODEL_FT == 'resnet152':
model_ft = models.resnet152(pretrained=IS_PRETRAINED)
elif MODEL_FT == 'vgg16':
model_ft = models.vgg16(pretrained=IS_PRETRAINED)
elif MODEL_FT == 'densenet':
model_ft = models.densenet161(pretrained=IS_PRETRAINED)
elif MODEL_FT == 'alexnet':
model_ft = models.alexnet(pretrained=IS_PRETRAINED)
else:
model_ft = None
print("Error from FT Config Setting! Invalid Pretrained Model Name Value!")
# Set model parameters
if 'vgg' in MODEL_FT or 'alexnet' in MODEL_FT:
num_ftrs = model_ft.classifier[6].in_features
features = list(model_ft.classifier.children())[:-1]
features.apppend([nn.Linear(num_ftrs, NUM_CLASSES)])
model_ft.classifier = nn.Sequential(*features)
elif 'densenet' in MODEL_FT:
num_ftrs = model_ft.classifier.in_features
def __init__(self,
num_classes,
num_channels=3,
is_deconv=False,
decoder_kernel_size=4,
pretrained=True):
super().__init__()
filters = [384, 768, 2112, 2208]
densenet = models.densenet161(pretrained=pretrained)
self.mean = (0.485, 0.456, 0.406)
self.std = (0.229, 0.224, 0.225)
if num_channels == 3:
self.firstconv = densenet.features.conv0
else:
self.firstconv = nn.Conv2d(num_channels,
64,
kernel_size=(7, 7),
stride=(2, 2),
padding=(3, 3))
self.stem = nn.Sequential(
self.firstconv,
densenet.features.norm0,
densenet.features.relu0,
densenet.features.pool0,
)
self.encoder1 = nn.Sequential(densenet.features.denseblock1)
self.encoder2 = nn.Sequential(densenet.features.transition1,
densenet.features.denseblock2)
self.encoder3 = nn.Sequential(densenet.features.transition2,
densenet.features.denseblock3)
self.encoder4 = nn.Sequential(densenet.features.transition3,
densenet.features.denseblock4)
# Decoder
self.decoder4 = DecoderBlock(in_channels=filters[3],
n_filters=filters[2],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder3 = DecoderBlock(in_channels=filters[2],
n_filters=filters[1],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder2 = DecoderBlock(in_channels=filters[1],
n_filters=filters[0],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
self.decoder1 = DecoderBlock(in_channels=filters[0],
n_filters=filters[0],
kernel_size=decoder_kernel_size,
is_deconv=is_deconv)
# Final Classifier
self.finaldeconv1 = nn.ConvTranspose2d(filters[0], 32, 3, stride=2)
self.finalrelu1 = nonlinearity(inplace=True)
self.finalconv2 = nn.Conv2d(32, 32, 3)
self.finalrelu2 = nonlinearity(inplace=True)
self.finalconv3 = nn.Conv2d(32, num_classes, 2, padding=1)
def main():
parser = argparse.ArgumentParser(description='train DSH')
parser.add_argument('--cifar',
default='../dataset/cifar',
help='path to cifar')
parser.add_argument('--weights',
default='',
help="path to weight (to continue training)")
parser.add_argument('--outf',
default='checkpoints',
help='folder to output model checkpoints')
parser.add_argument('--checkpoint',
type=int,
default=2,
help='checkpointing after batches')
parser.add_argument('--batchSize',
type=int,
default=4,
help='input batch size')
parser.add_argument('--ngpu', type=int, default=0, help='which GPU to use')
parser.add_argument('--binary_bits',
type=int,
default=12,
help='length of hashing binary')
parser.add_argument('--alpha',
type=float,
default=0.01,
help='weighting of regularizer')
parser.add_argument('--niter',
type=int,
default=2,
help='number of epochs to train for')
parser.add_argument('--lr',
type=float,
default=0.001,
help='learning rate')
opt = parser.parse_args()
print(opt)
os.makedirs(opt.outf, exist_ok=True)
choose_gpu(opt.ngpu)
feed_random_seed()
train_loader, test_loader = init_cifar_dataloader(opt.cifar, opt.batchSize)
logger = SummaryWriter()
densenet161 = models.densenet161(pretrained=True)
#vgg19_bn_model = models.vgg19_bn(pretrained=True)
#print(model)
for param in densenet161.parameters():
param.requires_grad = False
num_ftrs = densenet161.classifier.in_features
# five classes
Output_features = opt.binary_bits
densenet161.classifier.out_features = Output_features
for param in densenet161.classifier.parameters():
param.requires_grad = True
net = torch.nn.DataParallel(densenet161).cuda()
# setup net
# net = DSH(opt.binary_bits)
resume_epoch = 0
print(net)
if opt.weights:
print(f'loading weight form {opt.weights}')
resume_epoch = int(os.path.basename(opt.weights)[:-4])
net.load_state_dict(
torch.load(opt.weights,
map_location=lambda storage, location: storage))
# setup optimizer
# optimizer = optim.Adam(net.parameters(), lr=opt.lr, weight_decay=0.004)
optimizer = optim.SGD(net.module.classifier.parameters(),
lr=1e-3,
weight_decay=1e-4,
momentum=0.9)
for epoch in range(resume_epoch, opt.niter):
train_loss = train(epoch, train_loader, net, optimizer,
2 * opt.binary_bits, opt.alpha)
logger.add_scalar('train_loss', train_loss, epoch)
test_loss = test(epoch, test_loader, net, 2 * opt.binary_bits,
opt.alpha)
logger.add_scalar('test_loss', test_loss, epoch)
if epoch % opt.checkpoint == 0:
# compute mAP by searching testset images from trainset
trn_binary, trn_label = compute_result(train_loader, net)
tst_binary, tst_label = compute_result(test_loader, net)
#mAP = compute_mAP(trn_binary, tst_binary, trn_label, tst_label)
#print(f'[{epoch}] retrieval mAP: {mAP:.4f}')
#logger.add_scalar('retrieval_mAP', mAP, epoch)
# change the learning rate
optimizer = optim.SGD(net.module.classifier.parameters(),
lr=((1e-3) - epoch * (1e-4)),
weight_decay=1e-4,
momentum=0.9)
print((1e-3) - epoch * (1e-4))
# save checkpoints
torch.save(net.state_dict(),
os.path.join(opt.outf, f'{epoch:03d}.pth'))
def __init__(self, num_classes):
super(DenseNet161, self).__init__()
self.name = "DenseNet_{}".format(161)
densenet = torch_model.densenet161()
self.features = densenet.features
self.fc = nn.Linear(densenet.classifier.in_features, num_classes)
def load_checkpoint(filepath,input_device):
checkpoint = torch.load(filepath)
print('')
print('===============')
print('checkpoint:')
print(checkpoint['model_name'])
print(checkpoint['model_classifier'])
print('')
if (checkpoint['model_name']=='resnet152'):
model = models.resnet152(pretrained=True)
for param in model.parameters():
param.requires_grad = False
#model=checkpoint['model_base']
model.class_to_idx=checkpoint['class_to_label']
model.fc = checkpoint['model_classifier']
model.load_state_dict(checkpoint['model_state_dict'])
elif (checkpoint['model_name']=='alexnet'):
model = models.alexnet(pretrained=True)
for param in model.parameters():
param.requires_grad = False
model.class_to_idx=checkpoint['class_to_label']
model.classifier = checkpoint['model_classifier']
model.load_state_dict(checkpoint['model_state_dict'])
elif (checkpoint['model_name']=='densenet161'):
model = models.densenet161(pretrained=True)
for param in model.parameters():
param.requires_grad = False
model.class_to_idx=checkpoint['class_to_label']
model.classifier = checkpoint['model_classifier']
model.load_state_dict(checkpoint['model_state_dict'])
else:
print('!!!!Prediction module supports only resnet152, densenet161, and alexnet checkpoint!!!!')
print('')
print('')
if(input_device=='cuda'):
model=model.cuda()
if(input_device=='cpu'):
model=model.cpu()
# model=model.cuda()
model=model.eval()
return model,checkpoint,input_device
checkpoint = torch.load(pretrained_path)
self.encoder.load_state_dict(checkpoint)
def forward(self, x):
self.features = []
out = self.encoder.features.conv0(x)
out = self.encoder.features.norm0(out)
out = self.encoder.features.relu0(out)
self.features.append(out) # 1/2
out = self.encoder.features.pool0(out)
self.features.append(out) # 1/4
out = self.encoder.features.transition1(self.encoder.features.denseblock1(out))
self.features.append(out) # 1/8
out = self.encoder.features.transition2(self.encoder.features.denseblock2(out))
self.features.append(out) # 1/16
out = self.encoder.features.transition3(self.encoder.features.denseblock3(out))
out = self.encoder.features.norm5(self.encoder.features.denseblock4(out))
out = F.relu(out)
return out, self.features
if __name__ == "__main__":
import torchvision.models as models
model = models.densenet161(True)
models = {
"alexnet": {
"model": models.alexnet(pretrained=True),
"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"
},
import pdb
# input image
LABELS_URL = 'https://s3.amazonaws.com/outcome-blog/imagenet/labels.json'
IMG_URL = 'http://media.mlive.com/news_impact/photo/9933031-large.jpg'
# networks such as googlenet, resnet, densenet already use global average pooling at the end, so CAM could be used directly.
model_id = 1
if model_id == 1:
net = models.squeezenet1_1(pretrained=True)
finalconv_name = 'features' # this is the last conv layer of the network
elif model_id == 2:
net = models.resnet18(pretrained=True)
finalconv_name = 'layer4'
elif model_id == 3:
net = models.densenet161(pretrained=True)
finalconv_name = 'features'
net.eval()
# hook the feature extractor
features_blobs = []
def hook_feature(module, input, output):
features_blobs.append(output.data.cpu().numpy())
net._modules.get(finalconv_name).register_forward_hook(hook_feature)
# get the softmax weight
params = list(net.parameters())
weight_softmax = np.squeeze(params[-2].data.numpy())
def CAM(self):
# simple implementation of CAM in PyTorch for the networks such as ResNet, DenseNet, SqueezeNet, Inception
import io
import requests
from PIL import Image
from torchvision import models, transforms
from torch.autograd import Variable
from torch.nn import functional as F
import numpy as np
import cv2
import pdb
# input image
LABELS_URL = 'https://s3.amazonaws.com/outcome-blog/imagenet/labels.json'
IMG_URL = 'http://media.mlive.com/news_impact/photo/9933031-large.jpg'
# networks such as googlenet, resnet, densenet already use global average pooling at the end, so CAM could be used directly.
model_id = 1
if model_id == 1:
net = models.squeezenet1_1(pretrained=True)
finalconv_name = 'features' # this is the last conv layer of the network
elif model_id == 2:
net = models.resnet18(pretrained=True)
finalconv_name = 'layer4'
elif model_id == 3:
net = models.densenet161(pretrained=True)
finalconv_name = 'features'
net.eval()
# hook the feature extractor
features_blobs = []
def hook_feature(module, input, output):
features_blobs.append(output.data.cpu().numpy())
net._modules.get(finalconv_name).register_forward_hook(hook_feature)
# get the softmax weight
params = list(net.parameters())
weight_softmax = np.squeeze(params[-2].data.numpy())
def returnCAM(feature_conv, weight_softmax, class_idx):
# generate the class activation maps upsample to 256x256
size_upsample = (256, 256)
bz, nc, h, w = feature_conv.shape
output_cam = []
for idx in class_idx:
cam = weight_softmax[idx].dot(feature_conv.reshape((nc, h * w)))
cam = cam.reshape(h, w)
cam = cam - np.min(cam)
cam_img = cam / np.max(cam)
cam_img = np.uint8(255 * cam_img)
output_cam.append(cv2.resize(cam_img, size_upsample))
return output_cam
normalize = transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]
)
preprocess = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
normalize
])
response = requests.get(IMG_URL)
img_pil = Image.open(io.BytesIO(response.content))
img_pil.save('test.jpg')
img_tensor = preprocess(img_pil)
img_variable = Variable(img_tensor.unsqueeze(0))
logit = net(img_variable)
# download the imagenet category list
classes = {int(key): value for (key, value)
in requests.get(LABELS_URL).json().items()}
h_x = F.softmax(logit, dim=1).data.squeeze()
probs, idx = h_x.sort(0, True)
probs = probs.numpy()
idx = idx.numpy()
# output the prediction
for i in range(0, 5):
print('{:.3f} -> {}'.format(probs[i], classes[idx[i]]))
# generate class activation mapping for the top1 prediction
CAMs = returnCAM(features_blobs[0], weight_softmax, [idx[0]])
# render the CAM and output
print('output CAM.jpg for the top1 prediction: %s' % classes[idx[0]])
img = cv2.imread('test.jpg')
height, width, _ = img.shape
heatmap = cv2.applyColorMap(cv2.resize(CAMs[0], (width, height)), cv2.COLORMAP_JET)
result = heatmap * 0.3 + img * 0.5
cv2.imwrite('CAM.jpg', result)
def dn161(pre): return children(densenet161(pre))[0]
@_fastai_model('Densenet-161', 'Densely Connected Convolutional Networks',
def dn161(pre): return children(densenet161(pre))[0] def dn169(pre): return children(densenet169(pre))[0]
