def main(args,kwargs):
output_folder = args.output_folder
model_name = args.model_name
with open(os.path.join(output_folder,'hparams.json')) as json_file:
hparams = json.load(json_file)
image_shape, num_classes, _, test_mnist = get_MNIST(False, hparams['dataroot'], hparams['download'])
test_loader = data.DataLoader(test_mnist, batch_size=32,
shuffle=False, num_workers=6,
drop_last=False)
x, y = test_loader.__iter__().__next__()
x = x.to(device)
model = Glow(image_shape, hparams['hidden_channels'], hparams['K'], hparams['L'], hparams['actnorm_scale'],
hparams['flow_permutation'], hparams['flow_coupling'], hparams['LU_decomposed'], num_classes,
hparams['learn_top'], hparams['y_condition'], False if 'logittransform' not in hparams else hparams['logittransform'],False if 'sn' not in hparams else hparams['sn'])
model.load_state_dict(torch.load(os.path.join(output_folder, model_name)))
model.set_actnorm_init()
model = model.to(device)
model = model.eval()
with torch.no_grad():
# ipdb.set_trace()
images = model(y_onehot=None, temperature=1, batch_size=32, reverse=True).cpu()
better_dup_images = model(y_onehot=None, temperature=1, z=model._last_z, reverse=True, use_last_split=True).cpu()
dup_images = model(y_onehot=None, temperature=1, z=model._last_z, reverse=True).cpu()
worse_dup_images = model(y_onehot=None, temperature=1, z=model._last_z, reverse=True).cpu()
l2_err = torch.pow((images - dup_images).view(images.shape[0], -1), 2).sum(-1).mean()
better_l2_err = torch.pow((images - better_dup_images).view(images.shape[0], -1), 2).sum(-1).mean()
worse_l2_err = torch.pow((images - worse_dup_images).view(images.shape[0], -1), 2).sum(-1).mean()
print(l2_err, better_l2_err, worse_l2_err)
plot_imgs([images, dup_images, better_dup_images, worse_dup_images], '_recons')
#
with torch.no_grad():
# ipdb.set_trace()
z, nll, y_logits = model(x, None)
better_dup_images = model(y_onehot=None, temperature=1, z=z, reverse=True, use_last_split=True).cpu()
plot_imgs([x, better_dup_images], '_data_recons2')
fpath = os.path.join(output_folder, '_recon_evoluation.png')
pad = run_recon_evolution(model, x, fpath)
) #'/home/yellow/deep-learning-and-practice/hw7/dataset/task_2/'
test_loader = DataLoader(dataset_test,
batch_size=Batch_Size,
shuffle=False,
drop_last=True)
model = Glow(image_shape, hparams['hidden_channels'], hparams['K'],
hparams['L'], hparams['actnorm_scale'],
hparams['flow_permutation'], hparams['flow_coupling'],
hparams['LU_decomposed'], num_classes, hparams['learn_top'],
hparams['y_condition'])
model.load_state_dict(
torch.load(output_folder + model_name, map_location="cpu")['model'])
model.set_actnorm_init()
model = model.to(device)
model = model.eval()
# attribute_list = [8] # Black_Hair
attribute_list = [20, 31, 33] # Male, Smiling, Wavy_Hair, 24z No_Beard
# attribute_list = [11, 26, 31, 8, 6, 7] # Brown_Hair, Pale_Skin, Smiling, Black_Hair, Big_Lips, Big_Nose
# attribute_list = [i for i in range(40)]
N = 8
z_pos_list = [torch.Tensor([]).cuda() for i in range(len(attribute_list))]
z_neg_list = [torch.Tensor([]).cuda() for i in range(len(attribute_list))]
z_input_img = None
with torch.no_grad():
for i, (x, y) in enumerate(test_loader):
print('reading data: ', i, '/', 30000 / Batch_Size)
if i >= 3000: break # 3000
for j, attribute_num in enumerate(attribute_list):
def main(args):
# torch.manual_seed(args.seed)
# Test loading and sampling
output_folder = os.path.join('results', args.name)
with open(os.path.join(output_folder, 'hparams.json')) as json_file:
hparams = json.load(json_file)
device = "cpu" if not torch.cuda.is_available() else "cuda:0"
image_shape = (hparams['patch_size'], hparams['patch_size'],
args.n_modalities)
num_classes = 1
print('Loading model...')
model = Glow(image_shape, hparams['hidden_channels'], hparams['K'],
hparams['L'], hparams['actnorm_scale'],
hparams['flow_permutation'], hparams['flow_coupling'],
hparams['LU_decomposed'], num_classes, hparams['learn_top'],
hparams['y_condition'])
model_chkpt = torch.load(
os.path.join(output_folder, 'checkpoints', args.model))
model.load_state_dict(model_chkpt['model'])
model.set_actnorm_init()
model = model.to(device)
# Build images
model.eval()
temperature = args.temperature
if args.steps is None: # automatically calculate step size if no step size
fig_dir = os.path.join(output_folder, 'stepnum_results')
if not os.path.exists(fig_dir):
os.mkdir(fig_dir)
print('No step size entered')
# Create sample of images to estimate chord length
with torch.no_grad():
mean, logs = model.prior(None, None)
z = gaussian_sample(mean, logs, temperature)
images_raw = model(z=z, temperature=temperature, reverse=True)
images_raw[torch.isnan(images_raw)] = 0.5
images_raw[torch.isinf(images_raw)] = 0.5
images_raw = torch.clamp(images_raw, -0.5, 0.5)
images_out = np.transpose(
np.squeeze(images_raw[:, args.step_modality, :, :].cpu().numpy()),
(1, 0, 2))
# Threshold images and compute covariances
if args.binary_data:
thresh = 0
else:
thresh = threshold_otsu(images_out)
images_bin = np.greater(images_out, thresh)
x_cov = two_point_correlation(images_bin, 0)
y_cov = two_point_correlation(images_bin, 1)
# Compute chord length
cov_avg = np.mean(np.mean(np.concatenate((x_cov, y_cov), axis=2),
axis=0),
axis=0)
N = 5
S20, _ = curve_fit(straight_line_at_origin(cov_avg[0]), range(0, N),
cov_avg[0:N])
l_pore = np.abs(cov_avg[0] / S20)
steps = int(l_pore)
print('Calculated step size: {}'.format(steps))
else:
print('Using user-entered step size {}...'.format(args.steps))
steps = args.steps
# Build desired number of volumes
for iter_vol in range(args.iter):
if args.iter == 1:
stack_dir = os.path.join(output_folder, 'image_stacks',
args.save_name)
print('Sampling images, saving to {}...'.format(args.save_name))
else:
stack_dir = os.path.join(
output_folder, 'image_stacks',
args.save_name + '_' + str(iter_vol).zfill(3))
print('Sampling images, saving to {}_'.format(args.save_name) +
str(iter_vol).zfill(3) + '...')
if not os.path.exists(stack_dir):
os.makedirs(stack_dir)
with torch.no_grad():
mean, logs = model.prior(None, None)
alpha = 1 - torch.reshape(torch.linspace(0, 1, steps=steps),
(-1, 1, 1, 1))
alpha = alpha.to(device)
num_imgs = int(np.ceil(hparams['patch_size'] / steps) + 1)
z = gaussian_sample(mean, logs, temperature)[:num_imgs, ...]
z = torch.cat([
alpha * z[i, ...] + (1 - alpha) * z[i + 1, ...]
for i in range(num_imgs - 1)
])
z = z[:hparams['patch_size'], ...]
images_raw = model(z=z, temperature=temperature, reverse=True)
images_raw[torch.isnan(images_raw)] = 0.5
images_raw[torch.isinf(images_raw)] = 0.5
images_raw = torch.clamp(images_raw, -0.5, 0.5)
# apply median filter to output
if args.med_filt is not None or args.binary_data:
for m in range(args.n_modalities):
if args.binary_data:
SE = ball(1)
else:
SE = ball(args.med_filt)
images_np = np.squeeze(images_raw[:, m, :, :].cpu().numpy())
images_filt = median_filter(images_np, footprint=SE)
# Erode binary images
if args.binary_data:
images_filt = np.greater(images_filt, 0)
SE = ball(1)
images_filt = 1.0 * binary_erosion(images_filt,
selem=SE) - 0.5
images_raw[:, m, :, :] = torch.tensor(images_filt,
device=device)
images1 = postprocess(images_raw).cpu()
images2 = postprocess(torch.transpose(images_raw, 0, 2)).cpu()
images3 = postprocess(torch.transpose(images_raw, 0, 3)).cpu()
# apply Otsu thresholding to output
if args.save_binary and not args.binary_data:
thresh = threshold_otsu(images1.numpy())
images1[images1 < thresh] = 0
images1[images1 > thresh] = 255
images2[images2 < thresh] = 0
images2[images2 > thresh] = 255
images3[images3 < thresh] = 0
images3[images3 > thresh] = 255
# # erode binary images by 1 px to correct for training image transformation
# if args.binary_data:
# images1 = np.greater(images1.numpy(), 127)
# images2 = np.greater(images2.numpy(), 127)
# images3 = np.greater(images3.numpy(), 127)
# images1 = 255*torch.tensor(1.0*np.expand_dims(binary_erosion(np.squeeze(images1), selem=np.ones((1,2,2))), 1))
# images2 = 255*torch.tensor(1.0*np.expand_dims(binary_erosion(np.squeeze(images2), selem=np.ones((2,1,2))), 1))
# images3 = 255*torch.tensor(1.0*np.expand_dims(binary_erosion(np.squeeze(images3), selem=np.ones((2,2,1))), 1))
# save video for each modality
for m in range(args.n_modalities):
if args.n_modalities > 1:
save_dir = os.path.join(stack_dir, 'modality{}'.format(m))
else:
save_dir = stack_dir
if not os.path.exists(save_dir):
os.makedirs(save_dir)
write_video(images1[:, m, :, :], 'xy', hparams, save_dir)
write_video(images2[:, m, :, :], 'xz', hparams, save_dir)
write_video(images3[:, m, :, :], 'yz', hparams, save_dir)
print('Finished!')
def main(args):
seed_list = [int(item) for item in args.seed.split(',')]
for seed in seed_list:
device = torch.device("cuda")
experiment_folder = args.experiment_folder + '/' + str(seed) + '/'
print(experiment_folder)
#model_name = 'glow_checkpoint_'+ str(args.chk)+'.pth'
for thing in os.listdir(experiment_folder):
if 'best' in thing:
model_name = thing
print(model_name)
random.seed(seed)
torch.manual_seed(seed)
np.random.seed(seed)
torch.random.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
with open(experiment_folder + 'hparams.json') as json_file:
hparams = json.load(json_file)
image_shape = (32, 32, 3)
if hparams['y_condition']:
num_classes = 2
num_domains = 0
elif hparams['d_condition']:
num_classes = 10
num_domains = 0
elif hparams['yd_condition']:
num_classes = 2
num_domains = 10
else:
num_classes = 2
num_domains = 0
model = Glow(image_shape, hparams['hidden_channels'], hparams['K'],
hparams['L'], hparams['actnorm_scale'],
hparams['flow_permutation'], hparams['flow_coupling'],
hparams['LU_decomposed'], num_classes, num_domains,
hparams['learn_top'], hparams['y_condition'],
hparams['extra_condition'], hparams['sp_condition'],
hparams['d_condition'], hparams['yd_condition'])
print('loading model')
model.load_state_dict(torch.load(experiment_folder + model_name))
model.set_actnorm_init()
model = model.to(device)
model = model.eval()
if hparams['y_condition']:
print('y_condition')
def sample(model, temp=args.temperature):
with torch.no_grad():
if hparams['y_condition']:
print("extra", hparams['extra_condition'])
y = torch.eye(num_classes)
y = torch.cat(1000 * [y])
print(y.size())
y_0 = y[::2, :].to(
device) # number hardcoded in model for now
y_1 = y[1::2, :].to(device)
print(y_0.size())
print(y_0)
print(y_1)
print(y_1.size())
images0 = model(z=None,
y_onehot=y_0,
temperature=temp,
reverse=True,
batch_size=1000)
images1 = model(z=None,
y_onehot=y_1,
temperature=temp,
reverse=True,
batch_size=1000)
return images0, images1
images0, images1 = sample(model)
os.makedirs(experiment_folder + 'generations/Uninfected',
exist_ok=True)
os.makedirs(experiment_folder + 'generations/Parasitized',
exist_ok=True)
for i in range(images0.size(0)):
torchvision.utils.save_image(
images0[i, :, :, :], experiment_folder +
'generations/Uninfected/sample_{}.png'.format(i))
torchvision.utils.save_image(
images1[i, :, :, :], experiment_folder +
'generations/Parasitized/sample_{}.png'.format(i))
images_concat0 = torchvision.utils.make_grid(images0[:64, :, :, :],
nrow=int(64**0.5),
padding=2,
pad_value=255)
torchvision.utils.save_image(images_concat0,
experiment_folder + '/uninfected.png')
images_concat1 = torchvision.utils.make_grid(images1[:64, :, :, :],
nrow=int(64**0.5),
padding=2,
pad_value=255)
torchvision.utils.save_image(
images_concat1, experiment_folder + '/parasitized.png')
elif hparams['d_condition']:
print('d_cond')
def sample_d(model, idx, batch_size=1000, temp=args.temperature):
with torch.no_grad():
if hparams['d_condition']:
y_0 = torch.zeros([batch_size, 10], device='cuda:0')
y_0[:, idx] = torch.ones(batch_size)
y_0.to(device)
print(y_0)
# y_1 = torch.zeros([batch_size, 201], device='cuda:0')
# y_1[:, 157] = torch.ones(batch_size)
# y_1.to(device)
# y = torch.eye(num_classes)
# y = torch.cat(1000 * [y])
# print(y.size())
# y_0 = y[::2, :].to(device) # number hardcoded in model for now
# y_1 = y[1::2, :].to(device)
# print(y_0.size())
# print(y_0)
# print(y_1)
# print(y_1.size())
images0 = model(z=None,
y_onehot=y_0,
temperature=temp,
reverse=True,
batch_size=1000)
# images1 = model(z=None, y_onehot=y_1, temperature=1.0, reverse=True, batch_size=1000)
return images0
for idx, dom in enumerate(["C116P77ThinF", "C132P93ThinF", "C137P98ThinF", "C180P141NThinF", "C182P143NThinF", \
"C184P145ThinF", "C39P4thinF", 'C59P20thinF', "C68P29N", "C99P60ThinF"]):
images0 = sample_d(model, idx)
os.makedirs(experiment_folder + 'generations/' + dom +
'/Uninfected/',
exist_ok=True)
os.makedirs(experiment_folder + 'generations/' + dom +
'/Parasitized/',
exist_ok=True)
# os.makedirs(experiment_folder + 'generations/C59P20thinF/Uninfected/', exist_ok=True)
# os.makedirs(experiment_folder + 'generations/C59P20thinF/Parasitized/', exist_ok=True)
for i in range(images0.size(0)):
torchvision.utils.save_image(
images0[i, :, :, :],
experiment_folder + 'generations/' + dom +
'/Uninfected/sample_{}.png'.format(i))
#torchvision.utils.save_image(images1[i, :, :, :], experiment_folder + 'generations/C59P20thinF/Parasitized/sample_{}.png'.format(i))
images_concat0 = torchvision.utils.make_grid(
images0[:25, :, :, :],
nrow=int(25**0.5),
padding=2,
pad_value=255)
torchvision.utils.save_image(images_concat0,
experiment_folder + dom + '.png')
# images_concat1 = torchvision.utils.make_grid(images1[:64,:,:,:], nrow=int(64 ** 0.5), padding=2, pad_value=255)
# torchvision.utils.save_image(images_concat1, experiment_folder + 'C59P20thinF.png')
elif hparams['yd_condition']:
def sample_YD(model, idx, batch_size=1000, temp=args.temperature):
with torch.no_grad():
if hparams['yd_condition']:
y_0 = torch.zeros([batch_size, 12], device='cuda:0')
y_0[:, 0] = torch.ones(batch_size)
y_0[:, idx + 2] = torch.ones(batch_size)
y_0.to(device)
print(y_0)
y_1 = torch.zeros([batch_size, 12], device='cuda:0')
y_1[:, 1] = torch.ones(batch_size)
y_1[:, idx + 2] = torch.ones(batch_size)
y_1.to(device)
print(y_1)
images0 = model(z=None,
y_onehot=y_0,
temperature=temp,
reverse=True,
batch_size=1000)
images1 = model(z=None,
y_onehot=y_1,
temperature=temp,
reverse=True,
batch_size=1000)
return images0, images1
def sample_DD(model, idx, batch_size=1000, temp=args.temperature):
with torch.no_grad():
if hparams['yd_condition']:
y_1 = torch.zeros([batch_size, 20], device='cuda:0')
y_1[:, idx] = torch.ones(batch_size)
y_1.to(device)
print(y_1)
y_0 = torch.zeros([batch_size, 20], device='cuda:0')
y_0[:, idx + 10] = torch.ones(batch_size)
y_0.to(device)
print(y_0)
images0 = model(z=None,
y_onehot=y_0,
temperature=temp,
reverse=True,
batch_size=1000)
images1 = model(z=None,
y_onehot=y_1,
temperature=temp,
reverse=True,
batch_size=1000)
return images0, images1
for idx, dom in enumerate(
["C116P77ThinF", "C132P93ThinF", "C137P98ThinF", "C180P141NThinF", "C182P143NThinF", \
"C184P145ThinF", "C39P4thinF", 'C59P20thinF', "C68P29N", "C99P60ThinF"]):
images0, images1 = sample_YD(model, idx)
os.makedirs(experiment_folder + 'generations/' + dom +
'/Uninfected/',
exist_ok=True)
os.makedirs(experiment_folder + 'generations/' + dom +
'/Parasitized/',
exist_ok=True)
for i in range(images0.size(0)):
torchvision.utils.save_image(
images0[i, :, :, :],
experiment_folder + 'generations/' + dom +
'/Uninfected/sample_{}.png'.format(i))
torchvision.utils.save_image(
images1[i, :, :, :],
experiment_folder + 'generations/' + dom +
'/Parasitized/sample_{}.png'.format(i))
images_concat0 = torchvision.utils.make_grid(
images0[:64, :, :, :],
nrow=int(64**0.5),
padding=2,
pad_value=255)
torchvision.utils.save_image(
images_concat0, experiment_folder + dom +
str(args.temperature) + '_uninfected.png')
images_concat1 = torchvision.utils.make_grid(
images1[:64, :, :, :],
nrow=int(64**0.5),
padding=2,
pad_value=255)
torchvision.utils.save_image(
images_concat1, experiment_folder + dom +
str(args.temperature) + '_parasitized.png')
else:
def sample(model, temp=args.temperature):
with torch.no_grad():
images = model(z=None,
y_onehot=None,
temperature=temp,
reverse=True,
batch_size=1000)
return images
images = sample(model)
os.makedirs('unconditioned/' + str(seed) + '/generations/' +
experiment_folder[:-3],
exist_ok=True)
for i in range(images.size(0)):
torchvision.utils.save_image(
images[i, :, :, :],
'unconditioned/' + str(seed) + '/generations/' +
experiment_folder[:-2] + 'sample_{}.png'.format(i))
images_concat = torchvision.utils.make_grid(images[:64, :, :, :],
nrow=int(64**0.5),
padding=2,
pad_value=255)
torchvision.utils.save_image(
images_concat, 'unconditioned/' + str(seed) + '/' +
experiment_folder[:-3] + '.png')
def main(dataset, dataroot, download, augment, n_workers, eval_batch_size, output_dir,db, glow_path,ckpt_name):
(image_shape, num_classes, train_dataset, test_dataset) = check_dataset(dataset, dataroot, augment, download)
test_loader = data.DataLoader(test_dataset, batch_size=eval_batch_size,
shuffle=False, num_workers=n_workers,
drop_last=False)
x = test_loader.__iter__().__next__()[0].to(device)
# OOD data
ood_distributions = ['gaussian']
# ood_distributions = ['gaussian', 'rademacher', 'texture3', 'svhn','tinyimagenet','lsun']
tr = transforms.Compose([])
tr.transforms.append(transforms.ToPILImage())
tr.transforms.append(transforms.Resize((32,32)))
tr.transforms.append(transforms.ToTensor())
tr.transforms.append(one_to_three_channels)
tr.transforms.append(preprocess)
ood_tensors = [(out_name, torch.stack([tr(x) for x in load_ood_data({
'name': out_name,
'ood_scale': 1,
'n_anom': eval_batch_size,
})]).to(device)
) for out_name in ood_distributions]
if 'sd' in glow_path:
with open(os.path.join(os.path.dirname(glow_path), 'hparams.json'), 'r') as f:
model_kwargs = json.load(f)
model = Glow(
(32, 32, 3),
model_kwargs['hidden_channels'],
model_kwargs['K'],
model_kwargs['L'],
model_kwargs['actnorm_scale'],
model_kwargs['flow_permutation'],
model_kwargs['flow_coupling'],
model_kwargs['LU_decomposed'],
10,
model_kwargs['learn_top'],
model_kwargs['y_condition'],
model_kwargs['logittransform'],
model_kwargs['sn'],
model_kwargs['affine_eps'],
model_kwargs['no_actnorm'],
model_kwargs['affine_scale_eps'],
model_kwargs['actnorm_max_scale'],
model_kwargs['no_conv_actnorm'],
model_kwargs['affine_max_scale'],
model_kwargs['actnorm_eps'],
model_kwargs['no_split']
)
model.load_state_dict(torch.load(glow_path))
model.set_actnorm_init()
else:
model = torch.load(glow_path)
model = model.to(device)
model.eval()
with torch.no_grad():
samples = generate_from_noise(model, eval_batch_size,clamp=False, guard_nans=False)
stats = OrderedDict()
for name, x in [('data',x), ('samples',samples)] + ood_tensors:
p_pxs, p_ims, cn, dlogdet, bpd, pad = run_analysis(x, model, os.path.join(output_dir, f'recon_{ckpt_name}_{name}.jpeg'))
stats[f"{name}-percent-pixels-nans"] = p_pxs
stats[f"{name}-percent-imgs-nans"] = p_ims
stats[f"{name}-cn"] = cn
stats[f"{name}-dlogdet"] = dlogdet
stats[f"{name}-bpd"] = bpd
stats[f"{name}-recon-err"] = pad
with open(os.path.join(output_dir, f'results_{ckpt_name}.json'), 'w') as fp:
json.dump(stats, fp, indent=4)
