def extractFlow(self, path, tube, h, w, bb):
flow_frame = torch.zeros((64, 2, 240, 320))
path = path + "/flows/"
os.mkdir(path)
print(tube.shape)
for index in range(1, 64):
data = skimage.transform.resize(
tube[0, :, index - 1, :, :].cpu().numpy(), (3, 240, 320))
x1 = torch.from_numpy(data).cuda()
data = skimage.transform.resize(
tube[0, :, index, :, :].cpu().numpy(), (3, 240, 320))
x2 = torch.from_numpy(data).cuda()
print(x2.type())
u1, u2, _ = of(x2.unsqueeze(0), x1.unsqueeze(0), need_result=True)
data = u1.detach()[0, 0, bb[index][1]:bb[index][3],
bb[index][0]:bb[index][2]]
data = skimage.transform.resize(data.cpu().numpy(),
(1, 1, 224, 224))
flow_frame[index, 0, :, :] = u1 # torch.from_numpy(data)
data = u2.detach()[0, 0, bb[index][1]:bb[index][3],
bb[index][0]:bb[index][2]]
data = skimage.transform.resize(data.cpu().numpy(),
(1, 1, 224, 224))
flow_frame[index, 1, :, :] = u2 # torch.from_numpy(data)
im = visualizeFlow(flow_frame[index, :, :, :])
print(im.shape)
imsave(path + str(index).zfill(7) + ".tiff", im)
np.save(path + "flows.npy", flow_frame.numpy())
return flow_frame
def attack(model, dataset, n_samples, method):
model.eval()
adversarial_attacks = []
for data, target in tqdm(dataset):
data = data.unsqueeze(0)
target = torch.tensor(target).unsqueeze(0)
if torch.cuda.is_available():
data, target = data.cuda(), target.cuda()
device = 'cuda'
else:
data, target = data.cpu(), target.cpu()
device = 'cpu'
samples_attacks = []
for idx in list(range(n_samples)):
random.seed(idx)
perturbed_image = run_attack(net=model,
image=data,
label=target,
method=method,
device=device,
hyperparams=None).squeeze()
perturbed_image = torch.clamp(perturbed_image, 0., 1.)
samples_attacks.append(perturbed_image)
adversarial_attacks.append(torch.stack(samples_attacks).mean(0))
return torch.stack(adversarial_attacks)
def get_seq_from_z(self, z):
parameters = pickle.load(open("Outputs/SH3.db", 'rb'))
q_n = parameters['q_n']
index = parameters['index']
v_traj_onehot = parameters['onehot']
N = np.size(v_traj_onehot, axis=0)
q = np.size(v_traj_onehot, axis=1)
n = np.size(q_n)
z_gen = [z]
data = torch.FloatTensor(z_gen).to(device)
data = model.decode(data)
v_gen = data.cpu().detach().numpy()
sample_list = []
for i in range(len(z_gen)): # number of sampling points
v_samp_nothot = toolkit.sample_seq(0, q, n, q_n, i, v_gen)
sample_list.append(v_samp_nothot)
sequences = toolkit.convert_alphabet(np.array(sample_list), index,
q_n)
sequence = sequences[0][:16] + "DD" + sequences[0][16:]
sequence = sequence[:44] + "A" + sequence[44:]
return (sequence)
def evaluate(args, model, val_loader):
model.eval()
correct = 0
output_list = []
labels_list = []
with torch.no_grad():
begin = time.time()
for data, target in val_loader:
if torch.cuda.is_available():
data, target = data.cuda(), target.cuda()
else:
data, target = data.cpu(), target.cpu()
output = model(data)
output = torch.nn.functional.softmax(output, dim=1)
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
output_list.append(output)
labels_list.append(target)
end = time.time()
print("inference throughput: ", 10000 / (end - begin), " images/s")
output = torch.cat(output_list)
target = torch.cat(labels_list)
print('\nTest Accuracy: {:.2f}%\n'.format(100. * correct /
len(val_loader.dataset)))
target_labels = target.cpu().data.numpy()
np.save('../experiments/bayesian_torch/probs_cifar_det.npy', output.data.cpu().numpy())
np.save('../experiments/bayesian_torch/cifar_test_labels.npy', target.data.cpu().numpy())
def visualize(data, title):
input_tensor = data.cpu()
in_grid = convert_image_np(torchvision.utils.make_grid(input_tensor))
# Plot the results side-by-side
plt.imshow(in_grid)
plt.title(title)
plt.show()
def test(epoch):
with experirment.test():
model.eval()
test_loss = 0
n = 0
for batch_idx, (data, ohe) in enumerate(test_loader):
data = data.cuda()
ohe = ohe.cuda()
recon_batch, mu, logvar = model(data)
loss = loss_function(recon_batch, ohe, mu, logvar)
test_loss += loss.item()
n += 1
experirment.log_metric('loss', loss.item())
num_right = 0
_, preds = torch.max(recon_batch, dim=2)
for i in range(recon_batch.shape[0]):
num_right += int(torch.equal(preds[i, ...], data[i, ...]))
experirment.log_metric(
'accuracy',
float(num_right) / float(recon_batch.shape[0]))
if batch_idx % log_interval == 0:
preds = preds.cpu().numpy()
targets_copy = data.cpu().numpy()
for i in range(4):
sample = preds[i, ...]
target = targets_copy[i, ...]
print("ORIG: {}\nNEW : {}".format(
"".join([charset[chars] for chars in target]),
"".join([charset[chars] for chars in sample])))
print('test', test_loss / len(test_loader))
return float(test_loss) / float(n)
def get_log_frequency(root="data/"):
WikiTextDataset._load_datasets(root=root)
data = WikiTextDataset.TEXT.numericalize(
[WikiTextDataset.DATASET_SETS["train"][0].text]).squeeze(dim=0)
word_bincount = np.bincount(data.cpu().numpy())
word_bincount += 1 # Smoothing
print("Maximum word count: %i" % (word_bincount.max()))
print("Minimum word count: %i" % (word_bincount.min()))
print(word_bincount[-10:])
word_probs = word_bincount * 1.0 / word_bincount.sum(keepdims=True)
word_bincount = np.log2(word_bincount.astype(np.float32)) - np.log2(
word_bincount.sum(keepdims=True).astype(np.float32))
printed_zero = False
for key in WikiTextDataset.DATASET_VOCAB.stoi.keys():
val = WikiTextDataset.DATASET_VOCAB.stoi[key]
if (val == 0 and not printed_zero) or \
(val == 1) or \
(val != 0 and word_probs[val] > 0.001) or \
(val > 10000 and val < 10010) or \
(val > 15000 and val < 15010) or \
(val > 19900):
printed_zero = printed_zero or (val == 0)
print("%s (%s): %4.2f%%, log %4.2f" %
(key, str(val), word_probs[val] * 100.0,
word_bincount[val]))
print("-" * 20)
print("Unigram Bpc: %4.2f" % (word_probs * (-word_bincount)).sum())
return word_bincount
def to_cpu(data):
if isinstance(data, dict):
for k, v in data.items():
data[k] = to_cpu(v)
return data
if isinstance(data, torch.Tensor):
return data.cpu()
return data
def MyPlotFuc(data):
import matplotlib.pyplot as plt
import numpy as np
data = data.cpu()
data = data.numpy()
data = np.where(data > 0)
plt.xlim(0, 128)
plt.ylim(0, 128)
plt.scatter(data[0], data[1], s=5)
plt.show()
def animate(i):
view = block_rot.get_view()
# Set skip index to anything > 15 to make sure nothing is skipped
x_mu = model.generate(x_real, v_real, view, 44, 99)
data = x_mu.squeeze(0)
data = data.repeat(3, 1, 1)
data = data.permute(1, 2, 0)
data = data.cpu().detach()
im.set_data(data)
return im
def de_normalization(data):
data=data.cpu()
mm=MinMaxScaler()
train=TrainData('./data/airport',label_dir='./data/label')
label_data=np.array(train.label_data).reshape(-1,1)
train_label=mm.fit_transform(label_data)
return mm.transform(data),train.label_data[910]
def generate(model, seed, q, q_n, n, d, device, n_gen, n_samp, thresh):
np.random.seed(seed)
z_gen = np.random.normal(0., 1., (n_gen, d)) #generate normal distribution of random numbers
data = torch.FloatTensor(z_gen).to(device)
data = model.decode(data) # Use the decoding layer to generate new sequences.
v_gen = data.cpu().detach().numpy()
sample_list = []
for i in range(n_gen):
for k in range(n_samp):
v_samp_nothot = sample_seq(seed+k, q, n, q_n, i, v_gen)
sample_list.append(v_samp_nothot)
return sample_list
def save_nii(data, save_folder, name, mask=None):
if not os.path.exists(save_folder):
os.mkdir(save_folder)
nifti_affine = np.array([[1,0,0,1], [0,1,0,1], [0,0,1,1], [0,0,0,1]], dtype=np.float)
data = data.cpu().detach().squeeze().numpy()
data = np.fliplr(data)
data = np.pad(data, ((2, 2), (6, 7), (6, 7)), mode='constant')
if mask is not None:
data = data * mask
nifti = nib.Nifti1Image(data, affine=nifti_affine)
nib.save(nifti, os.path.join(save_folder, name + '.nii'))
def visualize_stn():
with torch.no_grad():
# Get a batch of training data
data = next(iter(test_loader))[0].to(device)
input_tensor = data.cpu()
in_grid = convert_image_np(torchvision.utils.make_grid(input_tensor, nrow=4))
out_grid = convert_image_np(torchvision.utils.make_grid(input_tensor, nrow=4))
# Plot the results side-by-side
f, axarr = plt.subplots()
axarr.imshow(torchvision.utils.make_grid(input_tensor, nrow=4))
axarr.set_title('Dataset Images')
def test(frac_anom, beta_val):
model.eval()
test_loss_total = 0
test_loss_anom = 0
num_anom = 0
with torch.no_grad():
for i, (data, data_lab) in enumerate(test_loader):
# data = (data.gt(0.5).type(torch.FloatTensor)).to(device)
data = (data).to(device)
recon_batch, mu, logvar = model(data)
anom_lab = data_lab == 10
num_anom += np.sum(anom_lab.numpy()) # count number of anomalies
anom_lab = (anom_lab[:, None].float()).to(device)
test_loss_anom += MSE_loss(recon_batch * anom_lab,
data * anom_lab).item()
test_loss_total += MSE_loss(recon_batch, data).item()
if i == 0:
n = min(data.size(0), 100)
#samp = np.arange(200) # [
#1 - 1, 101 - 1, 5 - 1, 7 - 1, 15 - 1, 109 - 1, 120 - 1,
# 26 - 1, 30 - 1, 33 - 1
# ] #np.arange(200) #[4, 14, 50, 60, 25, 29, 32, 65]
samp = [4, 14, 50, 60, 25, 29, 32, 65]
comparison = torch.cat([
data.view(len(recon_batch), 1, 28, 28)[samp],
recon_batch.view(len(recon_batch), 1, 28, 28)[samp]
])
save_image(
comparison.cpu(),
'/big_disk/akrami/git_repos_new/fair_VAE/results/neg/fashion_mnist_recon_shallow_'
+ str(beta_val) + '_' + str(frac_anom) + '.png',
nrow=n)
np.savez(
'/big_disk/akrami/git_repos_new/fair_VAE/results/neg/fashion_mnist_'
+ str(beta_val) + '_' + str(frac_anom) + '.npz',
recon=recon_batch.cpu(),
data=data.cpu(),
anom_lab=anom_lab.cpu())
test_loss_normals = (test_loss_total - test_loss_anom) / (
len(test_loader.dataset) - num_anom)
test_loss_anom /= num_anom
test_loss_total /= len(test_loader.dataset)
print('====> Test set loss: {:.4f}'.format(test_loss_total))
return test_loss_total, test_loss_anom, test_loss_normals
def evaluate(model, val_loader, corrupt=None, level=None):
pred_probs_mc = []
test_loss = 0
correct = 0
with torch.no_grad():
pred_probs_mc = []
for batch_idx, (data, target) in enumerate(val_loader):
if torch.cuda.is_available():
data, target = data.cuda(), target.cuda()
else:
data, target = data.cpu(), target.cpu()
for mc_run in range(args.num_monte_carlo):
model.eval()
output, _ = model.forward(data)
pred_probs = torch.nn.functional.softmax(output, dim=1)
pred_probs_mc.append(pred_probs.cpu().data.numpy())
if corrupt == 'ood':
np.save(args.log_dir + '/preds/svi_avu_ood_probs.npy',
pred_probs_mc)
print('saved predictive probabilities')
return None
target_labels = target.cpu().data.numpy()
pred_mean = np.mean(pred_probs_mc, axis=0)
#print(pred_mean)
Y_pred = np.argmax(pred_mean, axis=1)
test_acc = (Y_pred == target_labels).mean()
#brier = np.mean(calib.brier_scores(target_labels, probs=pred_mean))
#ece = calib.expected_calibration_error_multiclass(pred_mean, target_labels)
print('Test accuracy:', test_acc * 100)
#print('Brier score: ', brier)
#print('ECE: ', ece)
if corrupt is not None:
np.save(
args.log_dir +
'/preds/svi_avu_corrupt-static-{}-{}_probs.npy'.format(
corrupt, level), pred_probs_mc)
np.save(
args.log_dir +
'/preds/svi_avu_corrupt-static-{}-{}_labels.npy'.format(
corrupt, level), target_labels)
print('saved predictive probabilities')
elif corrupt == 'test':
np.save(args.log_dir + '/preds/svi_avu_test_probs.npy',
pred_probs_mc)
np.save(args.log_dir + '/preds/svi_avu_test_labels.npy',
target_labels)
print('saved predictive probabilities')
return test_acc
def train(epoch):
global batches_loss_array
global epochs_loss_array
global least_error
model.train()
train_loss = 0
for batch_idx, data in enumerate(train_loader):
#print('next batch')
data = data.to(device)
optimizer.zero_grad()
recon_batch, mu, logvar = model(data)
if torch.isnan(recon_batch).any().item():
print("got a nan array")
print(recon_batch)
print(mu)
print(logvar)
raise Exception('nan value tensor')
np.save('fail_recon_x.npy', recon_batch.detach().cpu().numpy())
np.save('fail_x.npy', data.cpu().numpy())
loss = loss_function(recon_batch, data, mu, logvar)
train_loss += loss.item()
loss.backward()
#model_params = filter(lambda p: p.requires_grad, model.parameters())
#grad_vector = np.concatenate([p.grad.cpu().numpy().flatten() for p in model_params])
optimizer.step()
if batch_idx % args.log_interval == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.2f} '.format(
epoch, batch_idx * len(data), len(train_loader.dataset),
100. * batch_idx / len(train_loader), loss.item()))
batches_loss_array = np.append(batches_loss_array, loss.item())
avg_train_loss = train_loss / len(train_loader.dataset)
print('====> Epoch: {} Average Training loss: {:.2f}'.format(
epoch, avg_train_loss))
epochs_loss_array = np.append(epochs_loss_array, avg_train_loss)
if least_error == -1 or least_error > avg_train_loss:
PATH = os.path.join(output_dir, 'vae_model.pt')
torch.save(model.state_dict(), PATH)
least_error = avg_train_loss
def test(frac_anom, beta_val):
model.eval()
test_loss_total = 0
test_loss_anom = 0
num_anom = 0
with torch.no_grad():
for i, (data, data_lab) in enumerate(test_loader):
# data = (data.gt(0.5).type(torch.FloatTensor)).to(device)
data = (data).to(device)
recon_batch, mu = model(data)
#recon_batch = torch.tensor(recon_batch > 0.5).float()
anom_lab = data_lab == 10
num_anom += np.sum(anom_lab.numpy()) # count number of anomalies
anom_lab = (anom_lab[:, None].float()).to(device)
test_loss_anom += MSE_loss(recon_batch * anom_lab,
data * anom_lab).item()
test_loss_total += MSE_loss(recon_batch, data).item()
if i == 0:
n = min(data.size(0), 100)
samp = [96, 97, 99, 90, 14, 35, 53, 57]
comparison = torch.cat([
data.view(len(recon_batch), 1, 28, 28)[samp],
recon_batch.view(len(recon_batch), 1, 28, 28)[samp]
])
save_image(comparison.cpu(),
'results/letters_mnist_recon_' + str(beta_val) +
'_' + str(frac_anom) + '.png',
nrow=n)
np.savez('results/letters_mnist_' + str(beta_val) + '_' +
str(frac_anom) + '.npz',
recon=recon_batch.cpu(),
data=data.cpu(),
anom_lab=anom_lab.cpu())
test_loss_normals = (test_loss_total - test_loss_anom) / (
len(test_loader.dataset) - num_anom)
test_loss_anom /= num_anom
test_loss_total /= len(test_loader.dataset)
print('====> Test set loss: {:.4f}'.format(test_loss_total))
return test_loss_total, test_loss_anom, test_loss_normals
def plot_beat(data, recon_x=None):
# first, move everything to CPU
if data.is_cuda:
data = data.cpu()
if recon_x is not None and recon_x.is_cuda:
recon_x = recon_x.cpu()
# plot a bunch of data
ncol = int(data.shape[0] / 2)
nrow = 2
fig, axarr = plt.subplots(nrow, ncol, figsize=(4*ncol, 2*nrow))
for i, ax in enumerate(axarr.flatten()):
ax.plot(data[i, 0, :].data.numpy(), "-o", label="beat")
if recon_x is not None:
ax.plot(recon_x[i, 0, :].data.numpy(), label="recon")
ax.legend()
return fig, axarr
def evaluate(args, model, val_loader, n_samples):
pred_probs_mc = []
test_loss = 0
correct = 0
output_list = []
labels_list = []
model.eval()
with torch.no_grad():
begin = time.time()
for data, target in val_loader:
if torch.cuda.is_available():
data, target = data.cuda(), target.cuda()
else:
data, target = data.cpu(), target.cpu()
output_mc = []
for mc_run in range(n_samples):
output, _ = model.forward(data)
output_mc.append(output)
output_ = torch.stack(output_mc)
output_list.append(output_)
labels_list.append(target)
end = time.time()
print("inference throughput: ",
len(val_loader.dataset) / (end - begin), " images/s")
output = torch.stack(output_list)
output = output.permute(1, 0, 2, 3)
output = output.contiguous().view(n_samples, len(val_loader.dataset),
-1)
output = torch.nn.functional.softmax(output, dim=2)
labels = torch.cat(labels_list)
pred_mean = output.mean(dim=0)
Y_pred = torch.argmax(pred_mean, axis=1)
print('Test accuracy:',
(Y_pred.data.cpu().numpy() == labels.data.cpu().numpy()).mean() *
100)
np.save('../experiments/bayesian_torch/probs_cifar_mc.npy',
output.data.cpu().numpy())
np.save('../experiments/bayesian_torch/cifar_test_labels_mc.npy',
labels.data.cpu().numpy())
def test(epoch):
model.eval()
test_loss = 0
test_loss_mse = 0
total_diff = 0
with torch.no_grad():
for i, (data, _) in enumerate(test_loader):
data = data.to(device)
recon_batch, enc = model(data)
pred = (recon_batch.cpu().detach().numpy() > .5).astype(int)
total_diff += float(np.sum(data.cpu().detach().numpy() != pred))
test_loss += loss_function(recon_batch, data).item()
test_loss /= len(test_loader.dataset)
total_diff /= len(test_loader.dataset)
print('====> Test set loss: {:.4f}'.format(test_loss))
print('====> Test set diff: {:.4f}'.format(total_diff))
def evaluate(model, val_loader, args):
pred_probs_mc = []
test_loss = 0
correct = 0
with torch.no_grad():
pred_probs_mc = []
output_list = []
label_list = []
begin = time.time()
for batch_idx, (data, target) in enumerate(val_loader):
#print('Batch idx {}, data shape {}, target shape {}'.format(batch_idx, data.shape, target.shape))
if torch.cuda.is_available():
data, target = data.cuda(non_blocking=True), target.cuda(
non_blocking=True)
else:
data, target = data.cpu(non_blocking=True), target.cpu(
non_blocking=True)
output_mc = []
output_mc_np = []
for mc_run in range(args.num_monte_carlo):
model.eval()
output, _ = model.forward(data)
pred_probs = torch.nn.functional.softmax(output, dim=1)
output_mc_np.append(pred_probs.cpu().data.numpy())
output_mc = torch.from_numpy(
np.mean(np.asarray(output_mc_np), axis=0))
output_list.append(output_mc)
label_list.append(target)
end = time.time()
print('inference throughput: ', len_valset / (end - begin),
' images/s')
labels = torch.cat(label_list).cuda()
probs = torch.cat(output_list).cuda()
target_labels = labels.data.cpu().numpy()
pred_mean = probs.data.cpu().numpy()
Y_pred = np.argmax(pred_mean, axis=1)
test_acc = (Y_pred == target_labels).mean()
print('Test accuracy:', test_acc * 100)
np.save(args.log_dir + '/bayesian_imagenet_probs.npy', pred_mean)
np.save(args.log_dir + '/bayesian_imagenet_labels.npy', target_labels)
return test_acc
def visualize_gradients(viz, data, caption='', zoom=4):
batchSize = data.size(0)
rows = int(math.sqrt(batchSize))
toPIL = transforms.ToPILImage()
# normalize it
data = data.cpu()
dmin = data.min()
dmax = data.max()
width = dmax - dmin
if (width > 0.0):
data = data.add(-dmin).div(width)
data_imgs = utils.make_grid(data, nrow=rows)
pimg = toPIL(data_imgs)
pimg = pimg.resize((pimg.height * zoom, pimg.width * zoom), Image.NEAREST)
imgarray = np.array(pimg)
new_image = torch.from_numpy(imgarray)
assert (new_image.dim() == 3)
def test(model, dataloader, dataset_size, criterion, device):
running_corrects = 0
running_loss = 0
pred = []
true = []
pred_wrong = []
true_wrong = []
image = []
paths = []
prob = []
for batch_idx, (data, target, path) in enumerate(dataloader):
data, target = data.to(device), target.to(device)
data = data.type(torch.cuda.FloatTensor)
target = target.type(torch.cuda.LongTensor)
model.eval()
output = model(data)
loss = criterion(output, target)
output = nn.Softmax(dim=1)(output)
_, preds = torch.max(output, 1)
running_corrects += torch.sum(preds == target.data)
running_loss += loss.item() * data.size(0)
preds = preds.cpu().numpy()
target = target.cpu().numpy()
probs = output.detach().cpu().numpy()[:, 1]
preds = np.reshape(preds, (len(preds), 1))
target = np.reshape(target, (len(preds), 1))
data = data.cpu().numpy()
for i in range(len(preds)):
pred.append(preds[i])
true.append(target[i])
prob.append(probs[i])
paths.append(path[i])
if (preds[i] != target[i]):
pred_wrong.append(preds[i])
true_wrong.append(target[i])
image.append(data[i])
epoch_acc = running_corrects.double() / dataset_size
epoch_loss = running_loss / dataset_size
print(epoch_acc, epoch_loss)
return true, pred, prob, paths, image, true_wrong, pred_wrong
def evaluate(model, val_loader, args):
pred_probs_mc = []
test_loss = 0
correct = 0
with torch.no_grad():
pred_probs_mc = []
output_list = []
labels_list = []
model.eval()
begin = time.time()
for batch_idx, (data, target) in enumerate(val_loader):
#print('Batch idx {}, data shape {}, target shape {}'.format(batch_idx, data.shape, target.shape))
if torch.cuda.is_available():
data, target = data.cuda(non_blocking=True), target.cuda(
non_blocking=True)
else:
data, target = data.cpu(non_blocking=True), target.cpu(
non_blocking=True)
data = torch.cat([data for _ in range(args.num_monte_carlo)], 0)
output_mc = []
output, _ = model.forward(data)
output_mc.append(output)
output_ = torch.stack(output_mc)
output_ = output_.reshape(args.num_monte_carlo, -1, num_classes)
output_list.append(output_)
labels_list.append(target)
end = time.time()
print("inference throughput: ", len_valset / (end - begin),
" images/s")
output = torch.stack(output_list)
output = output.permute(1, 0, 2, 3)
output = output.contiguous().view(args.num_monte_carlo, len_valset, -1)
output = torch.nn.functional.softmax(output, dim=2)
labels = torch.cat(labels_list)
pred_mean = output.mean(dim=0)
Y_pred = torch.argmax(pred_mean, axis=1)
print('Test accuracy:',
(Y_pred.data.cpu().numpy() == labels.data.cpu().numpy()).mean() *
100)
def visualize_stn():
with torch.no_grad():
# Get a batch of training data
data = next(iter(test_loader))[0].to(device)
input_tensor = data.cpu()
transformed_input_tensor = model.stn(data).cpu()
in_grid = convert_image_np(torchvision.utils.make_grid(input_tensor))
out_grid = convert_image_np(
torchvision.utils.make_grid(transformed_input_tensor))
# Plot the results side-by-side
f, axarr = plt.subplots(1, 2)
axarr[0].imshow(in_grid)
axarr[0].set_title('Dataset Images')
axarr[1].imshow(out_grid)
axarr[1].set_title('Transformed Images')
def get_score_from_z(self, z):
z = [z]
parameters = pickle.load(open("Outputs/SH3.db", 'rb'))
q_n = parameters['q_n']
index = parameters['index']
v_traj_onehot = parameters['onehot']
N = np.size(v_traj_onehot, axis=0)
q = np.size(v_traj_onehot, axis=1)
n = np.size(q_n)
data = torch.FloatTensor(z).to(device)
data = model.decode(data)
v_gen = data.cpu().detach().numpy()
v_traj_onehot = v_gen
pred_ref, _, _ = model(torch.FloatTensor(v_traj_onehot))
p_weight = pred_ref.cpu().detach().numpy()
log_p_list = np.array(toolkit.make_logP(v_traj_onehot, p_weight, q_n))
return log_p_list
def _plot_image(self, data, gt_boxes, num_boxes):
import matplotlib.pyplot as plt
X=data.cpu().numpy().copy()
X += cfg.PIXEL_MEANS
X = X.astype(np.uint8)
X = X.squeeze(0)
boxes = gt_boxes[:num_boxes,:].cpu().numpy().copy()
fig, ax = plt.subplots(figsize=(8,8))
ax.imshow(X[:,:,::-1], aspect='equal')
for i in range(boxes.shape[0]):
bbox = boxes[i, :4]
ax.add_patch(
plt.Rectangle((bbox[0], bbox[1]),
bbox[2]-bbox[0],
bbox[3]-bbox[1], fill=False, linewidth=2.0)
)
#plt.imshow(X[:,:,::-1])
plt.tight_layout()
plt.show()
def evaluate(args, model, val_loader):
pred_probs_mc = []
test_loss = 0
correct = 0
output_list = []
labels_list = []
model.eval()
with torch.no_grad():
begin = time.time()
for data, target in val_loader:
if torch.cuda.is_available():
data, target = data.cuda(), target.cuda()
else:
data, target = data.cpu(), target.cpu()
data = torch.cat([data for _ in range(args.num_monte_carlo)], 0)
output_mc = []
output, _ = model.forward(data)
output_mc.append(output)
output_ = torch.stack(output_mc)
output_ = output_.reshape(args.num_monte_carlo, -1, num_classes)
output_list.append(output_)
labels_list.append(target)
end = time.time()
print("inference throughput: ", len_testset / (end - begin),
" images/s")
output = torch.stack(output_list)
output = output.permute(1, 0, 2, 3)
output = output.contiguous().view(args.num_monte_carlo, len_testset,
-1)
output = torch.nn.functional.softmax(output, dim=2)
labels = torch.cat(labels_list)
pred_mean = output.mean(dim=0)
Y_pred = torch.argmax(pred_mean, axis=1)
print('Test accuracy:',
(Y_pred.data.cpu().numpy() == labels.data.cpu().numpy()).mean() *
100)
np.save('./probs_cifar_mc_flipout.npy', output.data.cpu().numpy())
np.save('./cifar_test_labels_mc_flipout.npy',
labels.data.cpu().numpy())
def evaluate(model, val_loader):
model.eval()
correct = 0
with torch.no_grad():
for data, target in val_loader:
if torch.cuda.is_available():
data, target = data.cuda(), target.cuda()
else:
data, target = data.cpu(), target.cpu()
output = model(data)
output = torch.nn.functional.softmax(output, dim=1)
pred = output.argmax(
dim=1,
keepdim=True) # get the index of the max log-probability
correct += pred.eq(target.view_as(pred)).sum().item()
print('\nTest set: Accuracy: {:.2f}%\n'.format(100. * correct /
len(val_loader.dataset)))
target_labels = target.cpu().data.numpy()
np.save('./probs_cifar_det.npy', output.cpu().data.numpy())
np.save('./cifar_test_labels.npy', target_labels)
