def visualise_layer_with_hooks(self,plots_path):
# Hook the selected layer
self.hook_layer()
# Generate a random image
random_image = np.uint8(np.random.uniform(150, 180, (227, 227, 3)))
# Process image and return variable
processed_image = preprocess_image(random_image, False)
# Define optimizer for the image
vi = GaussianVariationalInference(torch.nn.CrossEntropyLoss())
optimizer = Adam([processed_image], lr=0.1, weight_decay=1e-6)
for i in range(1, 101):
optimizer.zero_grad()
# Assign create image to a variable to move forward in the model
x = processed_image
kl = 0
for index, layer in enumerate(self.model):
# Forward pass layer by layer
# x is not used after this point because it is only needed to trigger
# the forward hook function
if hasattr(layer, 'convprobforward') and callable(layer.convprobforward):
x, _kl, = layer.convprobforward(x)
kl += _kl
# Only need to forward until the selected layer is reached
if index == self.selected_layer:
# (forward hook function triggered)
break
# Loss function is the mean of the output of the selected layer/filter
# We try to minimize the mean of the output of that specific filter
# loss = -torch.mean(self.conv_output)
loss = vi(outputs, y, kl, beta)
print('Iteration:', str(i), 'Loss:', "{0:.2f}".format(loss.data.numpy()))
# Backward
loss.backward()
# Update image
optimizer.step()
# Recreate image
self.created_image = recreate_image(processed_image)
# Save image
if i % 5 == 0:
im_path = plots_path + 'layer_vis_l' + str(self.selected_layer) + \
'_f' + str(self.selected_filter) + '_iter' + str(i) + '.jpg'
print('saving image at:' + im_path)
save_image(self.created_image, im_path)
assert os.path.isdir('checkpoint'), 'Error: No checkpoint directory found!'
_, file_name = getNetwork(args)
checkpoint = torch.load('./checkpoint/'+args.dataset+os.sep+file_name+str(cf.num_samples)+'.t7')
net = checkpoint['net']
best_acc = checkpoint['acc']
cf.start_epoch = checkpoint['epoch']
else:
print('| Building net type [' + args.net_type + '3FC]...')
utils.writeLogs('| Building net type [' + args.net_type + ' ]...')
print("test0.1")
net, file_name = getNetwork(args)
print("test0")
if use_cuda:
net.cuda()
print("test1")
vi = GaussianVariationalInference(torch.nn.CrossEntropyLoss())
print("test2")
logfile = os.path.join('diagnostics_Bayes{}_{}_{}.txt'.format(args.net_type, args.dataset, cf.num_samples))
# Training
def train(epoch):
net.train()
train_loss = 0
correct = 0
total = 0
optimizer = optim.Adam(net.parameters(), lr=cf.dynamic_lr(cf.lr, epoch), weight_decay=cf.weight_decay)
print('\n=> Training Epoch #%d, LR=%.4f' %(epoch, cf.dynamic_lr(cf.lr, epoch)))
utils.writeLogs('\n=> Training Epoch #%d, LR=%.4f' %(epoch, cf.dynamic_lr(cf.lr, epoch)))
m = math.ceil(len(testset) / cf.batch_size)
def cross_validation_for_clustered_data(num_labels, num_cluster, args):
print("cross validation for clustered data")
best_acc = 0
resize = cf.resize
start_epoch, num_epochs, batch_size, optim_type = cf.start_epoch, cf.num_epochs, cf.batch_size, cf.optim_type
results = {}
for i in range(num_cluster):
cv_idx = i
test_list = [i]
train_eval_list = list(range(num_cluster))
train_eval_list = [x for x in train_eval_list if x != i]
print(test_list, train_eval_list)
trainset, evalset, testset, inputs, outputs = prepare_data(
args, train_eval_list, test_list, resize)
# Hyper Parameter settings
use_cuda = torch.cuda.is_available()
use_cuda = cf.use_cuda()
if use_cuda is True:
torch.cuda.set_device(0)
best_acc = 0
resize = cf.resize
start_epoch, num_epochs, batch_size, optim_type = cf.start_epoch, cf.num_epochs, cf.batch_size, cf.optim_type
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=batch_size,
shuffle=True,
num_workers=4)
evalloader = torch.utils.data.DataLoader(evalset,
batch_size=batch_size,
shuffle=False,
num_workers=4)
testloader = torch.utils.data.DataLoader(testset,
batch_size=batch_size,
shuffle=False,
num_workers=4)
# num_workers: how many subprocesses to use for data loading. 0 means that the data will be loaded in the main process. (default: 0)# Return network & file name
# Model
print('\n[Phase 2] : Model setup')
if args.resume:
# Load checkpoint
print('| Resuming from checkpoint...')
assert os.path.isdir(
'checkpoint'), 'Error: No checkpoint directory found!'
_, file_name = getNetwork(args, inputs, outputs)
checkpoint = torch.load('./checkpoint/' + args.dataset + os.sep +
file_name + args.cv_type + str(cv_idx) +
'.t7')
# checkpoint = torch.load('./checkpoint/' + args.dataset + os.sep + file_name + '.t7')
net = checkpoint['net']
best_acc = checkpoint['acc']
start_epoch = checkpoint['epoch']
else:
print('| Building net type [' + args.net_type + ']...')
net, file_name = getNetwork(args, inputs, outputs)
if use_cuda:
net.cuda()
vi = GaussianVariationalInference(torch.nn.CrossEntropyLoss())
logfile_train = os.path.join(
'diagnostics_Bayes{}_{}_cv{}_train_vgmm.txt'.format(
args.net_type, args.dataset, i))
logfile_test = os.path.join(
'diagnostics_Bayes{}_{}_cv{}_test_vgmm.txt'.format(
args.net_type, args.dataset, i))
logfile_eval = os.path.join(
'diagnostics_Bayes{}_{}_cv{}_val_vgmm.txt'.format(
args.net_type, args.dataset, i))
print('\n[Phase 3] : Training model with validation')
print('| Training Epochs = ' + str(num_epochs))
print('| Initial Learning Rate = ' + str(args.lr))
print('| Optimizer = ' + str(optim_type))
elapsed_time = 0
train_return = []
eval_return = []
test_return = []
for epoch in range(start_epoch, start_epoch + num_epochs):
start_time = time.time()
temp_train_return = train(epoch, trainset, inputs, net, batch_size,
trainloader, resize, num_epochs,
use_cuda, vi, logfile_train)
temp_eval_return = test(epoch, evalset, inputs, batch_size,
evalloader, net, use_cuda, num_epochs,
resize, vi, logfile_eval, file_name)
temp_test_return = test(epoch, testset, inputs, batch_size,
testloader, net, use_cuda, num_epochs,
resize, vi, logfile_test, "test")
train_return = np.append(train_return, temp_train_return)
eval_return = np.append(eval_return, temp_eval_return)
test_return = np.append(test_return, temp_test_return)
print(temp_train_return)
print(temp_eval_return)
print(temp_test_return)
epoch_time = time.time() - start_time
elapsed_time += epoch_time
print('| Elapsed time : %d:%02d:%02d' % (cf.get_hms(elapsed_time)))
print('\n[Phase 4] : Testing model')
print('* Test results : Acc@1 = %.2f%%' % (best_acc))
results[str(i)] = {
"train": train_return,
"test": test_return,
"val": eval_return
}
print(results)
return results
def cross_validation(num_labels,num_cluster,args):
method = args.cv_type
print("cross validation for random resampling")
best_acc = 0
resize = cf.resize
start_epoch, num_epochs, batch_size, optim_type = cf.start_epoch, cf.num_epochs, cf.batch_size, cf.optim_type
results = {}
ds = mdataset_class.InputDataset("fashion-mnist", -1, 10)
#X, y = utils_parent.load_mnist('fashion-mnist')
X, y = ds.data_X, ds.data_y
kf = KFold(n_splits=num_cluster, shuffle = True)
mlist = list(kf.split(X,y))
#i = 0
#for train_eval_idx, test_idx in kf.split(X, y): #iterator
for i in range(num_cluster): #iterator
#breakpoint() iter = kf.split(X,y); for xx in iter: print(xx); it seems that KFold.split works
cv_idx = i
if method == "rand":
#i = i +1
train_eval_idx = list(mlist[i][0])
test_idx = list(mlist[i][1])
trainset, evalset, testset, inputs, outputs = prepare_data_for_normal_cv(args, train_eval_idx, test_idx, resize)
elif method == "vgmm":
test_list = [i]
train_eval_list = list(range(num_cluster))
train_eval_list = [x for x in train_eval_list if x != i]
print(test_list,train_eval_list)
trainset, evalset, testset,inputs,outputs = prepare_data(args,train_eval_list,test_list,resize, method = "vgmm")
else:
raise NotImplementedError
# Hyper Parameter settings
use_cuda = torch.cuda.is_available()
use_cuda = cf.use_cuda()
if use_cuda is True:
torch.cuda.set_device(GPUIndex)
best_acc = 0
resize = cf.resize
start_epoch, num_epochs, batch_size, optim_type = cf.start_epoch, cf.num_epochs, cf.batch_size, cf.optim_type
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=4)
evalloader = torch.utils.data.DataLoader(evalset, batch_size=batch_size, shuffle=False, num_workers=4)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=4)
# num_workers: how many subprocesses to use for data loading. 0 means that the data will be loaded in the main process. (default: 0)# Return network & file name
# Model
print('\n[Phase 2] : Model setup')
if args.resume:
# Load checkpoint
print('| Resuming from checkpoint...')
assert os.path.isdir('checkpoint'), 'Error: No checkpoint directory found!'
_, file_name = getNetwork(args, inputs, outputs)
checkpoint = torch.load('./checkpoint/' + args.dataset + os.sep + file_name+ args.cv_type + str(cv_idx) + '.t7')
net = checkpoint['net']
best_acc = checkpoint['acc']
start_epoch = checkpoint['epoch']
else:
print('| Building net type [' + args.net_type + ']...')
net, file_name = getNetwork(args, inputs, outputs)
if use_cuda:
net.cuda()
vi = GaussianVariationalInference(torch.nn.CrossEntropyLoss())
#logfile = os.path.join('diagnostics_Bayes{}_{}.txt'.format(args.net_type, args.dataset))
logfile_train = os.path.join(rstfolder, 'diagnostics_Bayes{}_{}_cv{}_train_rand.txt'.format(args.net_type, args.dataset, i))
logfile_test = os.path.join(rstfolder, 'diagnostics_Bayes{}_{}_cv{}_test_rand.txt'.format(args.net_type, args.dataset, i))
logfile_eval = os.path.join(rstfolder, 'diagnostics_Bayes{}_{}_cv{}_val_rand.txt'.format(args.net_type, args.dataset, i))
print('\n[Phase 3] : Training model')
print('| Training Epochs = ' + str(num_epochs))
print('| Initial Learning Rate = ' + str(args.lr))
print('| Optimizer = ' + str(optim_type))
elapsed_time = 0
train_return = []
test_return = []
eval_return = []
for epoch in range(start_epoch, start_epoch + num_epochs):
start_time = time.time()
temp_train_return = train(epoch, trainset, inputs, net, batch_size, trainloader, resize, num_epochs, use_cuda, vi, logfile_train)
temp_eval_return = test(epoch, evalset, inputs, batch_size, evalloader, net, use_cuda, num_epochs, resize, vi, logfile_eval,file_name)
temp_test_return = test(epoch, testset, inputs, batch_size, testloader, net, use_cuda, num_epochs, resize, vi, logfile_test, "test")
train_return = np.append(train_return,temp_train_return)
eval_return = np.append(eval_return,temp_eval_return)
test_return = np.append(test_return, temp_test_return)
print(temp_train_return)
print(temp_eval_return)
print(temp_test_return)
epoch_time = time.time() - start_time
elapsed_time += epoch_time
print('| Elapsed time : %d:%02d:%02d' % (cf.get_hms(elapsed_time)))
print('\n[Phase 4] : Testing model')
print('* Test results : Acc@1 = %.2f%%' % (best_acc))
results[str(i)] = {"train": train_return, "test": test_return, "eval": eval_return}
print(results)
return results
raise Exception("No GPU found, please run without --cuda")
torch.manual_seed(opt.seed)
device = torch.device("cuda" if opt.cuda else "cpu")
print('===> Loading datasets')
train_set = get_training_set(opt.upscale_factor)
test_set = get_test_set(opt.upscale_factor)
training_data_loader = DataLoader(dataset=train_set, num_workers=opt.threads, batch_size=opt.batch_size, shuffle=True)
testing_data_loader = DataLoader(dataset=test_set, num_workers=opt.threads, batch_size=opt.testBatchSize, shuffle=False)
print('===> Building model')
model = BBBNet(upscale_factor=opt.upscale_factor).to(device)
vi = GaussianVariationalInference(torch.nn.MSELoss())
optimizer = optim.Adam(model.parameters(), lr=opt.lr)
#load a model from checkpoint
if opt.resume:
if os.path.isfile(opt.resume):
print("=> loading checkpoint '{}'".format(opt.resume))
checkpoint = torch.load(opt.resume)
opt.start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(opt.resume, checkpoint['epoch']))
else:
print('| Resuming from checkpoint...')
assert os.path.isdir('checkpoint'), 'Error: No checkpoint directory found!'
_, file_name = getNetwork(args)
checkpoint = torch.load('./checkpoint/'+args.dataset+os.sep+file_name+'.t7')
net = checkpoint['net']
best_acc = checkpoint['acc']
start_epoch = checkpoint['epoch']
else:
print('| Building net type [' + args.net_type + ']...')
net, file_name = getNetwork(args)
#print(net)
if use_cuda:
net.cuda()
vi = GaussianVariationalInference(torch.nn.CrossEntropyLoss()) ## GaussianVariationalInference is a subclass of nn.Module
# vi(...) is equivalent to vi.forward(...)
logfile = os.path.join('diagnostics_Bayes{}_{}.txt'.format(args.net_type, args.dataset))
# Training
def train(epoch):
net.train() # torch.nn.Module.train:torch.nn.Module.train: Sets the module in training mode.
train_loss = 0
correct = 0
total = 0
m = math.ceil(len(trainset) / batch_size)
optimizer = optim.Adam(net.parameters(), lr=cf.learning_rate(args.lr, epoch), weight_decay=args.weight_decay)
print('\n=> Training Epoch #%d, LR=%.4f' %(epoch, cf.learning_rate(args.lr, epoch)))
for batch_idx, (inputs_value, targets) in enumerate(trainloader):
def tr_val_te(ds, num_labels, num_cluster, args, cv_idx, config_parent):
print("cross validation for random resampling")
best_acc = 0
resize = cf.resize
start_epoch, num_epochs, batch_size, optim_type = cf.start_epoch, cf.num_epochs, cf.batch_size, cf.optim_type
transform_train = transforms.Compose([
transforms.Resize((resize, resize)),
transforms.ToTensor(),
transforms.Normalize(cf.mean[args.dataset], cf.std[args.dataset]),
]) # meanstd transformation
transform_test = transforms.Compose([
transforms.Resize((resize, resize)),
transforms.ToTensor(),
transforms.Normalize(cf.mean[args.dataset], cf.std[args.dataset]),
])
print('\n[Phase 1] : Data Preparation')
trainset, evalset, testset, inputs, outputs = ds.prepare_data(config_parent, args, transform_train, transform_test, cv_idx, num_cluster)
# Hyper Parameter settings
use_cuda = torch.cuda.is_available()
use_cuda = cf.use_cuda()
if use_cuda is True:
torch.cuda.set_device(args.g)
print("*** using gpu ind", args.g)
best_acc = 0
resize = cf.resize
start_epoch, num_epochs, batch_size, optim_type = cf.start_epoch, cf.num_epochs, cf.batch_size, cf.optim_type
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=4)
evalloader = torch.utils.data.DataLoader(evalset, batch_size=batch_size, shuffle=False, num_workers=4)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=4)
# num_workers: how many subprocesses to use for data loading. 0 means that the data will be loaded in the main process. (default: 0)# Return network & file name
# Model
print('\n[Phase 2] : Model setup')
if args.resume:
# Load checkpoint
print('| Resuming from checkpoint...')
assert os.path.isdir('checkpoint'), 'Error: No checkpoint directory found!'
_, file_name = getNetwork(args, inputs, outputs)
checkpoint = torch.load('./checkpoint/' + args.dataset + os.sep + file_name+ args.cv_type + str(cv_idx) + '.t7')
net = checkpoint['net']
best_acc = checkpoint['acc']
start_epoch = checkpoint['epoch']
else:
print('| Building net type [' + args.net_type + ']...')
net, file_name = getNetwork(args, inputs, outputs)
if use_cuda:
net.cuda()
vi = GaussianVariationalInference(torch.nn.CrossEntropyLoss())
rstfolder = args.rst_dir
logfile_train = os.path.join(rstfolder, 'diagnostics_Bayes{}_{}_cv{}_train_{}.txt'.format(args.net_type, args.dataset, cv_idx, args.cv_type))
logfile_test = os.path.join(rstfolder, 'diagnostics_Bayes{}_{}_cv{}_test_{}.txt'.format(args.net_type, args.dataset, cv_idx, args.cv_type))
logfile_eval = os.path.join(rstfolder, 'diagnostics_Bayes{}_{}_cv{}_val_{}.txt'.format(args.net_type, args.dataset, cv_idx, args.cv_type))
print('\n[Phase 3] : Training model')
print('| Training Epochs = ' + str(num_epochs))
print('| Initial Learning Rate = ' + str(args.lr))
print('| Optimizer = ' + str(optim_type))
elapsed_time = 0
train_return = []
test_return = []
eval_return = []
for epoch in range(start_epoch, start_epoch + num_epochs):
start_time = time.time()
temp_train_return = train(epoch, trainset, inputs, net, batch_size, trainloader, resize, num_epochs, use_cuda, vi, logfile_train)
temp_eval_return = test(epoch, evalset, inputs, batch_size, evalloader, net, use_cuda, num_epochs, resize, vi, logfile_eval, file_name)
temp_test_return = test(epoch, testset, inputs, batch_size, testloader, net, use_cuda, num_epochs, resize, vi, logfile_test, "test")
train_return = np.append(train_return,temp_train_return)
eval_return = np.append(eval_return,temp_eval_return)
test_return = np.append(test_return, temp_test_return)
print(temp_train_return)
print(temp_eval_return)
print(temp_test_return)
epoch_time = time.time() - start_time
elapsed_time += epoch_time
print('| Elapsed time : %d:%02d:%02d' % (cf.get_hms(elapsed_time)))
print('\n[Phase 4] : Testing model')
print('* Test results : Acc@1 = %.2f%%' % (best_acc))
rst = {"train": train_return, "test": test_return, "eval": eval_return}
return rst