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)
parser.add_argument('--resume', '-r', action='store_true', help='resume from checkpoint') parser.add_argument('--stylemix_layer', type=str, help='which layer to perform stylemixing (e.g. fine)') args = parser.parse_args() # setup output directory if args.stylemix_layer is None: save_dir = 'results/classifiers/cifar10/latentclassifier' else: save_dir = 'results/classifiers/cifar10/latentclassifier_stylemix_%s' % args.stylemix_layer os.makedirs(save_dir, exist_ok=True) pidfile.exit_if_job_done(save_dir) torch.manual_seed(0) device = 'cuda' if torch.cuda.is_available() else 'cpu' best_acc = 0 # best test accuracy start_epoch = 0 # start from epoch 0 or last checkpoint epoch # Data print('==> Preparing data..') transform_train = data.get_transform('cifar10', 'imtrain') transform_test = data.get_transform('cifar10', 'imval') trainset = data.get_dataset('cifar10', 'train', load_w=True, transform=transform_train) trainloader = torch.utils.data.DataLoader(trainset,
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))
help='which image transform to use for ensembling') parser.add_argument('--partition', type=str, default='val') parser.add_argument('--n_ens', type=int, default=32) parser.add_argument('--seed', type=int, default=2) args = parser.parse_args() print(args) # set random seeds torch.manual_seed(args.seed) np.random.seed(args.seed) random.seed(args.seed) # lock the experiment directory lockdir = f'results/evaluations/{args.domain}/lockfiles/{args.classifier_name}_{args.partition}/image_ensemble_{args.aug_type}' os.makedirs(lockdir, exist_ok=True) pidfile.exit_if_job_done(lockdir, redo=False) # data output filename data_filename = lockdir.replace('lockfiles', 'output') + '.npz' os.makedirs(os.path.dirname(data_filename), exist_ok=True) print("saving result in: %s" % data_filename) # load dataset and classifier val_transform = data.get_transform(args.domain, 'imval') ensemble_transform = data.get_transform(args.domain, args.aug_type) transform = ImageEnsemble(val_transform, ensemble_transform, args.n_ens) print("Ensemble transform:") print(ensemble_transform) if 'celebahq' in args.domain: # for celebahq, load the attribute-specific dataset attribute = args.classifier_name.split('__')[0]
# 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)