def main():
args = parser.parse_args()
if args.device is None:
device = torch.device('cuda' if (torch.cuda.is_available()) else 'cpu')
else:
device = torch.device(args.device)
# modified to lock the directory
outdir = args.outdir
if outdir is None:
outdir = os.path.join(args.path[-1], 'metrics/fidpth')
os.makedirs(outdir, exist_ok=True)
pidfile.exit_if_job_done(outdir, redo=False)
fid_value = calculate_fid_given_paths(args.path,
args.batch_size,
device,
args.dims)
print('FID: ', fid_value)
# modified: save it
np.savez(os.path.join(outdir, 'fid.npz'), fid=fid_value)
pidfile.mark_job_done(outdir)
parser.add_argument('--workers', type=int, default=4, help='workers')
parser.add_argument('--niter',
type=int,
default=200,
help='number of epochs to train for')
parser.add_argument('--lr',
type=float,
default=0.001,
help='learning rate, default=0.0002')
parser.add_argument('--beta1',
type=float,
default=0.9,
help='beta1 for adam. default=0.5')
parser.add_argument('--seed', default=0, type=int, help='manual seed')
parser.add_argument('--outf', type=str, help='output directory')
opt = parser.parse_args()
print(opt)
if opt.outf is None:
opt.outf = 'results/classifiers/celebahq/%s' % opt.attribute
os.makedirs(opt.outf, exist_ok=True)
# save options
pidfile.exit_if_job_done(opt.outf)
with open(os.path.join(opt.outf, 'optE.yml'), 'w') as f:
yaml.dump(vars(opt), f, default_flow_style=False)
train(opt)
print("finished training!")
pidfile.mark_job_done(opt.outf)
parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)
parser.add_argument("path", type=str, nargs=1,
help='Path to the generated images')
parser.add_argument('--outdir', type=str, default=None,
help='path to save computed prdc')
parser.add_argument('--batch_size', type=int, default=32,
help='batch size to compute vgg features')
parser.add_argument('--workers', type=int, default=4,
help='data loading workers')
parser.add_argument('--load_size', type=int, default=256,
help='size to load images at')
parser.add_argument('--crop_aspect_car', action='store_true',
help='crop out border padding for cars')
args = parser.parse_args()
outdir = args.outdir
if outdir is None:
outdir = os.path.join(args.path[-1], 'metrics/distances')
pidfile.exit_if_job_done(outdir, redo=False)
metrics = compute_distances(args)
for k,v in metrics.items():
if 'avg' in k:
print("{}: {}".format(k, v))
np.savez(os.path.join(outdir, 'distances.npz'), **metrics)
pidfile.mark_job_done(outdir)
loss = criterion(outputs, targets)
test_loss += loss.item()
_, predicted = outputs.max(1)
total += targets.size(0)
correct += predicted.eq(targets).sum().item()
progress_bar(
batch_idx, len(testloader),
'Loss: %.3f | Acc: %.3f%% (%d/%d)' %
(test_loss /
(batch_idx + 1), 100. * correct / total, correct, total))
# Save checkpoint.
acc = 100. * correct / total
if acc > best_acc:
print('Saving..')
state = {
'net': net.state_dict(),
'acc': acc,
'epoch': epoch,
}
torch.save(state, '%s/ckpt.pth' % save_dir)
best_acc = acc
for epoch in range(start_epoch, start_epoch + 200):
train(epoch)
test(epoch)
scheduler.step()
pidfile.mark_job_done(save_dir)
tags.append(tag)
amts.append(amt)
images = model.decode(feps)
# Save images as PNG.
for idx in range(images.shape[0]):
filename = os.path.join(opt.output_path, 'seed%03d_sample%06d.%s'
% (opt.seed, batch_start + idx,
opt.format))
im = PIL.Image.fromarray(images[idx], 'RGB')
if opt.resize:
im = im.resize((opt.resize, opt.resize), PIL.Image.LANCZOS)
im.save(filename)
if opt.manipulate:
outfile = os.path.join(opt.output_path, 'manipulations.npz')
np.savez(outfile, tags=np.concatenate(tags), amts=np.concatenate(amts))
if __name__ == '__main__':
opt = parse_args()
if os.environ.get('CUDA_VISIBLE_DEVICES') is None:
os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpu
expdir = opt.output_path
os.makedirs(expdir, exist_ok=True)
pidfile.exit_if_job_done(expdir)
sample(opt)
pidfile.mark_job_done(expdir)
pil_image.save(filename + '.png')
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Generate GAN samples')
parser.add_argument('--model', required=True, help='proggan, stylegan')
parser.add_argument('--domain', required=True, help='church, ffhq... etc')
parser.add_argument('--outdir', required=True, help='output directory')
parser.add_argument('--seed',
type=int,
default=0,
help='random seed for z samples')
parser.add_argument('--num_samples',
type=int,
default=500,
help='number of samples')
parser.add_argument('--batch_size',
type=int,
default=16,
help='batch_size')
parser.add_argument('--im_size', type=int, help='resize to this size')
args = parser.parse_args()
args.outdir = args.outdir.format(**vars(args))
os.makedirs(args.outdir, exist_ok=True)
pidfile.exit_if_job_done(args.outdir)
main(args)
cmd = f'cp utils/lightbox.html {args.outdir}/+lightbox.html'
print(cmd)
os.system(cmd)
pidfile.mark_job_done(args.outdir)
# additional options for top n patches
options.parser.add_argument(
'--unique',
action='store_true',
help='take only 1 patch per image when computing top n')
opt = options.parse()
print("Calculating patches from model: %s epoch %s" %
(opt.name, opt.which_epoch))
print("On dataset (real): %s" % (opt.real_im_path))
print("And dataset (fake): %s" % (opt.fake_im_path))
expdir = opt.name
dataset_name = opt.dataset_name
output_dir = os.path.join(opt.results_dir, expdir, opt.partition,
'epoch_%s' % opt.which_epoch, dataset_name,
'patches_top%d' % opt.topn)
print(output_dir)
os.makedirs(output_dir, exist_ok=True)
# check if checkpoint is out of date
redo = opt.force_redo
ckpt_path = os.path.join(opt.checkpoints_dir, opt.name,
'%s_net_D.pth' % opt.which_epoch)
timestamp_path = os.path.join(output_dir,
'timestamp_%s_net_D.txt' % opt.which_epoch)
if util.check_timestamp(ckpt_path, timestamp_path):
redo = True
util.update_timestamp(ckpt_path, timestamp_path)
pidfile.exit_if_job_done(output_dir, redo=True) # redo=redo)
run_patch_topn(opt, output_dir)
pidfile.mark_job_done(output_dir)
log_str = f"[TRAIN] Iter: {i} Loss: {loss.item()} PSNR: {psnr.item()} PSNR0: {psnr0} Var loss: {var_loss} Var loss coarse: {var_loss_coarse} Weight change loss: {weight_change_loss}"
with open(os.path.join(basedir, expname, 'log.txt'), 'a+') as f:
f.write(log_str + '\n')
print(log_str)
global_step += 1
if real_image_application and global_step - start == args.n_iters_real:
return
if real_image_application and global_step - start == args.n_iters_code_only:
optimize_mlp = True
dataset.optimizer_name = 'adam'
dataset.style_optimizer = torch.optim.Adam(dataset.params,
lr=dataset.lr)
print('Starting to jointly optimize weights with code')
if __name__ == '__main__':
parser = config_parser()
args = parser.parse_args()
if args.instance != -1:
# Allows for scripting over single instance experiments.
exit_if_job_done(os.path.join(args.basedir, args.expname))
torch.set_default_tensor_type('torch.cuda.FloatTensor')
train()
mark_job_done(os.path.join(args.basedir, args.expname))
else:
torch.set_default_tensor_type('torch.cuda.FloatTensor')
train()
# update val losses
for k, v in losses.items():
val_losses[k + '_val'].update(v, n=len(inputs['labels']))
# get average val losses
for k, v in val_losses.items():
val_losses[k] = v.avg
return val_losses
if __name__ == '__main__':
options = TrainOptions(print_opt=False)
opt = options.parse()
# lock active experiment directory and write out options
os.makedirs(os.path.join(opt.checkpoints_dir, opt.name), exist_ok=True)
pidfile.exit_if_job_done(os.path.join(opt.checkpoints_dir, opt.name))
options.print_options(opt)
# configure logging file
logging_file = os.path.join(opt.checkpoints_dir, opt.name, 'log.txt')
utils.logging.configure(logging_file, append=False)
# run train loop
train(opt)
# mark done and release lock
pidfile.mark_job_done(os.path.join(opt.checkpoints_dir, opt.name))
classifier = domain_classifier.define_classifier(args.domain,
args.classifier_name)
# output data structure
ensemble_data = {
'original': [], # predictions of the original image
'label': [], # GT label
args.aug_type: [], # ensembled predictions using specified image aug
'random_seed': args.seed,
}
# do evaluation
for i, imdata_from_loader in enumerate(tqdm(loader)):
# fix for too many open files error
# https://github.com/pytorch/pytorch/issues/11201
imdata = copy.deepcopy(imdata_from_loader)
del imdata_from_loader
im = imdata[0] # shape: 1xn_ensxCxHxW
label = imdata[1]
with torch.no_grad():
ensemble_data['label'].append(label.numpy())
im = im[0].cuda() # removes unused batch dim, keeps ensemble dim
predictions = domain_classifier.postprocess(classifier(im))
predictions_np = predictions.cpu().numpy()
ensemble_data['original'].append(predictions_np[[0]])
ensemble_data[args.aug_type].append(predictions_np[1:])
# save the result and unlock directory
np.savez(data_filename, **ensemble_data)
pidfile.mark_job_done(lockdir)
# histogram
f, ax = plt.subplots(1, 1, figsize=(6, 4))
ax.bar(range(1, len(labels) + 1), counts)
ax.set_xticks(range(1, len(labels) + 1))
ax.set_xticklabels(labels, rotation='vertical')
ax.set_ylabel('count')
f.savefig(os.path.join(cluster_dir, 'histogram.pdf'),
bbox_inches='tight')
# write counts to file
with open(os.path.join(cluster_dir, 'counts.txt'), 'w') as f:
[f.write('%s\n' % line) for line in infos]
# write random patch baseline to file
infos = []
for index, (k,v) in enumerate(sorted(clusters_baseline.items(), key=lambda item: item[1])[::-1]):
infos.append('%d: %s, %d patches' % (index, k, v))
with open(os.path.join(cluster_dir, 'baseline.txt'), 'w') as f:
[f.write('%s\n' % line) for line in infos]
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Cluster patches using face segmentation.')
parser.add_argument('path', type=str, help='path to precomputed top clusters')
args = parser.parse_args()
outpath = os.path.join(args.path, 'clusters')
os.makedirs(outpath, exist_ok =True)
pidfile.exit_if_job_done(outpath,redo=True)
cluster(args, outpath)
pidfile.mark_job_done(outpath)