def main(): opt = parse_option() set_seed(opt.seed) transform = get_color_mnist_transform() ds_train = get_predefined_dataset(dataset_name='color_mnist', root='./dataset/colour_mnist', weights=None, major_ratio=0.5, num_data=opt.num_data) dataloader = data.DataLoader(dataset=ds_train, batch_size=128, shuffle=False, num_workers=8, pin_memory=True) model = SimpleConvNet(num_labels=20).cuda() model.cuda() optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) scheduler = torch.optim.lr_scheduler.MultiStepLR( optimizer, [opt.epochs * 3 // 7, opt.epochs * 6 // 7], gamma=0.1) print(f'train_biased_model - opt: {optimizer}, sched: {scheduler}') ckpt_path = Path( f'./exp_results/color-mnist-convnet-{opt.num_data}-seed{opt.seed}') ckpt_path.mkdir(exist_ok=True, parents=True) for n in range(1, opt.epochs + 1): train_acc = train(model, dataloader, optimizer) print(f'[{n} / {opt.epochs}] train_acc: {train_acc}') if n % 10 == 0: torch.save(model.state_dict(), ckpt_path / f'ckpt_{n}.pt')
def main(): args = parse_option() set_seed(args.seed) print(args) output_dir = f'{args.work_dir}/{args.exp_name}' save_path = Path(output_dir) save_path.mkdir(parents=True, exist_ok=True) if torch.cuda.is_available(): device = "cuda" cudnn.benchmark = True else: device = "cpu" # load model assert args.netG_ckpt_step print(f'load model from {save_path} step: {args.netG_ckpt_step}') netG, _, netD_drs, _, _, _ = get_gan_model( dataset_name=args.dataset, model=args.model, loss_type=args.loss_type, drs=True, ) netG.to(device) if not args.netG_train_mode: netG.eval() netD_drs.eval() netG.to(device) netD_drs.to(device) if args.dataset == 'celeba': dataset = 'celeba_64' else: raise ValueError("Dataset should be CelebA") evaluate_drs_with_attr( metric='partial_recall', attr=args.attr, log_dir=save_path, netG=netG, netD_drs=netD_drs, dataset=dataset, num_real_samples=10000, num_fake_samples=10000, evaluate_step=args.netG_ckpt_step, num_runs=1, device=device, use_original_netD=args.use_original_netD, )
def main(): parser = argparse.ArgumentParser() parser.add_argument("--dataset", "-d", default="color_mnist", type=str) parser.add_argument("--root", "-r", default="./dataset/colour_mnist", type=str, help="dataset dir") parser.add_argument("--work_dir", default="./exp_results", type=str, help="output dir") parser.add_argument("--exp_name", default="colour_mnist", type=str, help="exp name") parser.add_argument("--baseline_exp_name", default="colour_mnist", type=str, help="exp name") parser.add_argument("--model", default="mnistgan", type=str, help="network model") parser.add_argument('--gpu', default='0', type=str, help='id(s) for CUDA_VISIBLE_DEVICES') parser.add_argument('--num_pack', default=1, type=int) parser.add_argument('--batch_size', default=64, type=int) parser.add_argument('--seed', default=1, type=int) parser.add_argument('--use_clipping', action='store_true') parser.add_argument('--num_steps', default=20000, type=int) parser.add_argument('--logit_save_steps', default=100, type=int) parser.add_argument('--decay', default='None', type=str) parser.add_argument('--n_dis', default=1, type=int) parser.add_argument('--p1_step', default=10000, type=int) parser.add_argument('--major_ratio', default=0.99, type=float) parser.add_argument('--num_data', default=10000, type=int) parser.add_argument('--resample_score', type=str) parser.add_argument("--loss_type", default="hinge", type=str, help="loss type") args = parser.parse_args() os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu output_dir = f'{args.work_dir}/{args.exp_name}' save_path = Path(output_dir) save_path.mkdir(parents=True, exist_ok=True) baseline_output_dir = f'{args.work_dir}/{args.baseline_exp_name}' baseline_save_path = Path(baseline_output_dir) prefix = args.exp_name.split('/')[-1] set_seed(args.seed) if torch.cuda.is_available(): device = "cuda" cudnn.benchmark = True else: device = "cpu" netG, netD, optG, optD = get_gan_model( dataset_name=args.dataset, model=args.model, loss_type=args.loss_type, gold=True ) netG_ckpt_path = baseline_save_path / f'checkpoints/netG/netG_{args.p1_step}_steps.pth' netD_ckpt_path = baseline_save_path / f'checkpoints/netD/netD_{args.p1_step}_steps.pth' print_num_params(netG, netD) ds_train = get_predefined_dataset( dataset_name=args.dataset, root=args.root, weights=None, major_ratio=args.major_ratio, num_data=args.num_data ) dl_train = get_dataloader( ds_train, batch_size=args.batch_size, weights=None) data_iter = iter(dl_train) imgs, _, _, _ = next(data_iter) plot_data(imgs, num_per_side=8, save_path=save_path, file_name=f'{prefix}_gold_train_data_p2', vis=None) print(args, netG_ckpt_path, netD_ckpt_path) # Start training trainer = LogTrainer( output_path=save_path, logit_save_steps=args.logit_save_steps, netD=netD, netG=netG, optD=optD, optG=optG, netG_ckpt_file=netG_ckpt_path, netD_ckpt_file=netD_ckpt_path, n_dis=args.n_dis, num_steps=args.num_steps, save_steps=1000, vis_steps=100, lr_decay=args.decay, dataloader=dl_train, log_dir=output_dir, print_steps=10, device=device, save_logits=False, gold=True, gold_step=args.p1_step ) trainer.train() plot_color_mnist_generator(netG, save_path=save_path, file_name=f'{prefix}-eval_p2') netG.restore_checkpoint(ckpt_file=netG_ckpt_path) netG.to(device) plot_color_mnist_generator(netG, save_path=save_path, file_name=f'{prefix}-eval_generated_p1')
def main(): parser = argparse.ArgumentParser() parser.add_argument("--dataset", "-d", default="cifar10", type=str) parser.add_argument("--root", "-r", default="./dataset/cifar10", type=str, help="dataset dir") parser.add_argument("--work_dir", default="./exp_results", type=str, help="output dir") parser.add_argument("--exp_name", type=str, help="exp name") parser.add_argument("--baseline_exp_name", type=str, help="exp name") parser.add_argument('--p1_step', default=40000, type=int) parser.add_argument("--model", default="sngan", type=str, help="network model") parser.add_argument("--loss_type", default="hinge", type=str, help="loss type") parser.add_argument('--gpu', default='0', type=str, help='id(s) for CUDA_VISIBLE_DEVICES') parser.add_argument('--num_steps', default=80000, type=int) parser.add_argument('--batch_size', default=64, type=int) parser.add_argument('--seed', default=1, type=int) parser.add_argument('--decay', default='linear', type=str) parser.add_argument('--n_dis', default=5, type=int) parser.add_argument('--resample_score', type=str) parser.add_argument('--gold', action='store_true') parser.add_argument('--topk', action='store_true') args = parser.parse_args() os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu output_dir = f'{args.work_dir}/{args.exp_name}' save_path = Path(output_dir) save_path.mkdir(parents=True, exist_ok=True) baseline_output_dir = f'{args.work_dir}/{args.baseline_exp_name}' baseline_save_path = Path(baseline_output_dir) set_seed(args.seed) if torch.cuda.is_available(): device = "cuda" cudnn.benchmark = True else: device = "cpu" prefix = args.exp_name.split('/')[-1] if args.dataset == 'celeba': window = 5000 elif args.dataset == 'cifar10': window = 5000 else: window = 5000 if not args.gold: logit_path = baseline_save_path / 'logits_netD_eval.pkl' print(f'Use logit from: {logit_path}') logits = pickle.load(open(logit_path, "rb")) score_start_step = (args.p1_step - window) score_end_step = args.p1_step score_dict = calculate_scores(logits, start_epoch=score_start_step, end_epoch=score_end_step) sample_weights = score_dict[args.resample_score] print( f'sample_weights mean: {sample_weights.mean()}, var: {sample_weights.var()}, max: {sample_weights.max()}, min: {sample_weights.min()}' ) else: sample_weights = None netG_ckpt_path = baseline_save_path / f'checkpoints/netG/netG_{args.p1_step}_steps.pth' netD_ckpt_path = baseline_save_path / f'checkpoints/netD/netD_{args.p1_step}_steps.pth' netD_drs_ckpt_path = baseline_save_path / f'checkpoints/netD/netD_{args.p1_step}_steps.pth' netG, netD, netD_drs, optG, optD, optD_drs = get_gan_model( dataset_name=args.dataset, model=args.model, loss_type=args.loss_type, drs=True, topk=args.topk, gold=args.gold, ) print(f'model: {args.model} - netD_drs_ckpt_path: {netD_drs_ckpt_path}') print_num_params(netG, netD) ds_train = get_predefined_dataset(dataset_name=args.dataset, root=args.root, weights=None) dl_train = get_dataloader(ds_train, batch_size=args.batch_size, weights=sample_weights) ds_drs = get_predefined_dataset(dataset_name=args.dataset, root=args.root, weights=None) dl_drs = get_dataloader(ds_drs, batch_size=args.batch_size, weights=None) if not args.gold: show_sorted_score_samples(ds_train, score=sample_weights, save_path=save_path, score_name=args.resample_score, plot_name=prefix) print(args) # Start training trainer = LogTrainer( output_path=save_path, netD=netD, netG=netG, optD=optD, optG=optG, netG_ckpt_file=str(netG_ckpt_path), netD_ckpt_file=str(netD_ckpt_path), netD_drs_ckpt_file=str(netD_drs_ckpt_path), netD_drs=netD_drs, optD_drs=optD_drs, dataloader_drs=dl_drs, n_dis=args.n_dis, num_steps=args.num_steps, save_steps=1000, lr_decay=args.decay, dataloader=dl_train, log_dir=output_dir, print_steps=10, device=device, topk=args.topk, gold=args.gold, gold_step=args.p1_step, save_logits=False, ) trainer.train()
def main(): parser = argparse.ArgumentParser() parser.add_argument("--model", default="vgg16", type=str, help="network model") parser.add_argument('--gpu', default='0', type=str, help='id(s) for CUDA_VISIBLE_DEVICES') parser.add_argument('--batch_size', default=128, type=int) parser.add_argument('--seed', default=1, type=int) parser.add_argument('--num_epochs', default=10, type=int) parser.add_argument('--attr', default='Bald', type=str) args = parser.parse_args() os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu set_seed(args.seed) if torch.cuda.is_available(): device = "cuda" cudnn.benchmark = True else: device = "cpu" # load dataset print('Load data') train_dataset = get_celeba_with_attr(attr=args.attr, split='train', size=64) valid_dataset = get_celeba_with_attr(attr=args.attr, split='valid', size=64) test_dataset = get_celeba_with_attr(attr=args.attr, split='test', size=64) train_loader = get_dataloader(train_dataset, batch_size=args.batch_size) valid_loader = get_dataloader(valid_dataset, batch_size=args.batch_size) test_loader = get_dataloader(test_dataset, batch_size=args.batch_size) # load model print('Load model') if args.model == 'vgg16': model = models.vgg16(pretrained=True) elif args.model == 'resnet18': model = models.resnet18(pretrained=True) elif args.model == 'inception': model = models.inception_v3(pretrained=True) else: raise ValueError('model should be vgg16 or resnet18 or inception') # change the number of classes in_features = model.classifier[6].in_features model.classifier[6] = nn.Linear(in_features, 2, bias=True) # freeze convolution weights for param in model.features.parameters(): param.requires_grad = False # optimizer optimizer = optim.SGD(model.classifier.parameters(), lr=0.001, momentum=0.9) # loss function criterion = nn.CrossEntropyLoss() model.to(device) save_path = f'./convnet_celeba' if not os.path.exists(save_path): os.makedirs(save_path) csv_file = os.path.join(save_path, 'loss_acc.csv') if os.path.exists(csv_file): f = open(csv_file, 'a', newline='') wr = csv.writer(f) else: f = open(csv_file, 'w', newline='') wr = csv.writer(f) wr.writerow([ '', 'Train Acc', 'Valid Acc', 'Test Acc', 'Train Loss', 'Valid Loss', 'Test Loss' ]) train_loss, train_accuracy = [], [] val_loss, val_accuracy = [], [] start = time.time() print('Start training') for epoch in range(args.num_epochs): print(f'Epoch: {epoch+1}') train_epoch_loss, train_epoch_accuracy = fit(model, optimizer, train_loader, criterion, device) print( f'Train Loss: {train_epoch_loss:.4f}, Train Acc: {train_epoch_accuracy:.2f}' ) val_epoch_loss, val_epoch_accuracy = validate(model, valid_loader, criterion, device) print( f'Valid Loss: {val_epoch_loss:.4f}, Valid Acc: {val_epoch_accuracy:.2f}' ) train_loss.append(train_epoch_loss) train_accuracy.append(train_epoch_accuracy) val_loss.append(val_epoch_loss) val_accuracy.append(val_epoch_accuracy) end = time.time() print((end - start) / 60, 'minutes') test_loss, test_accuracy = validate(model, test_loader, criterion, device) print(f'Test Loss: {test_loss:.4f}, Test Acc: {test_accuracy:.2f}') # save loss and accuracy wr.writerow([ args.attr, train_epoch_loss, val_epoch_loss, test_loss, train_epoch_accuracy, val_epoch_accuracy, test_accuracy ]) f.close() # save model print('Save model') torch.save(model.state_dict(), os.path.join(save_path, f'{args.attr}.pth'))
parser.add_argument('--resample_score', type=str) parser.add_argument('--p1_step', default=200000, type=int) parser.add_argument('--logit_save_steps', default=100, type=int) parser.add_argument('--save_logit_after', default=1000000, type=int) # parser.add_argument('--stop_save_logit_after', default=45000, type=int) args = parser.parse_args() print(args) if args.gpu: os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu output_dir = f'{args.work_dir}/{args.exp_name}' save_path = Path(output_dir) save_path.mkdir(parents=True, exist_ok=True) set_seed(args.seed) n_gpu = int(os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1 args.distributed = n_gpu > 1 if args.distributed: torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend="nccl", init_method="env://") synchronize() args.latent = 512 args.n_mlp = 8 args.start_iter = 0
def main(): parser = argparse.ArgumentParser() parser.add_argument("--dataset", "-d", default="cifar10", type=str) parser.add_argument("--work_dir", default="./exp_results", type=str, help="output dir") parser.add_argument("--exp_name", default="mimicry_pretrained-seed1", type=str, help="exp name") parser.add_argument("--baseline_exp_name", type=str, help="exp name") parser.add_argument('--p1_step', default=40000, type=int) parser.add_argument("--model", default="sngan", type=str, help="network model") parser.add_argument("--loss_type", default="hinge", type=str, help="loss type") parser.add_argument('--gpu', default='0', type=str, help='id(s) for CUDA_VISIBLE_DEVICES') parser.add_argument('--batch_size', default=128, type=int) parser.add_argument('--seed', default=1, type=int) parser.add_argument("--netG_ckpt_step", type=int) parser.add_argument("--netG_train_mode", action='store_true') parser.add_argument('--resample_score', type=str) parser.add_argument('--gold', action='store_true') parser.add_argument('--topk', action='store_true') parser.add_argument("--index_num", default=100, type=int, help="number of index to use for FID score") args = parser.parse_args() os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu output_dir = f'{args.work_dir}/{args.exp_name}' save_path = Path(output_dir) save_path.mkdir(parents=True, exist_ok=True) baseline_output_dir = f'{args.work_dir}/{args.baseline_exp_name}' baseline_save_path = Path(baseline_output_dir) set_seed(args.seed) if torch.cuda.is_available(): device = "cuda" cudnn.benchmark = True else: device = "cpu" # load model assert args.netG_ckpt_step print(f'load model from {save_path} step: {args.netG_ckpt_step}') netG, _, _, _ = get_gan_model( dataset_name=args.dataset, model=args.model, loss_type=args.loss_type, topk=args.topk, gold=args.gold, ) netG.to(device) if not args.netG_train_mode: netG.eval() if args.dataset == 'celeba': dataset = 'celeba_64' window = 5000 else: dataset = args.dataset window = 5000 logit_path = baseline_save_path / 'logits_netD_eval.pkl' print(f'Use logit from: {logit_path}') logits = pickle.load(open(logit_path, "rb")) score_start_step = (args.p1_step - window) score_end_step = args.p1_step score_dict = calculate_scores(logits, start_epoch=score_start_step, end_epoch=score_end_step) sample_weights = score_dict[args.resample_score] print( f'sample_weights mean: {sample_weights.mean()}, var: {sample_weights.var()}, max: {sample_weights.max()}, min: {sample_weights.min()}') print(args) sort_index = np.argsort(sample_weights) high_index = sort_index[-args.index_num:] low_index = sort_index[:args.index_num] # Evaluate fid with index of high weight evaluate_with_index( metric='fid', index=high_index, log_dir=save_path, netG=netG, dataset=dataset, num_fake_samples=50000, evaluate_step=args.netG_ckpt_step, num_runs=1, device=device, stats_file=None, name=f'high_{args.resample_score}', ) # Evaluate fid with index of low weight evaluate_with_index( metric='fid', index=low_index, log_dir=save_path, netG=netG, dataset=dataset, num_fake_samples=50000, evaluate_step=args.netG_ckpt_step, num_runs=1, device=device, stats_file=None, name=f'low_{args.resample_score}', )
def main(): parser = argparse.ArgumentParser() parser.add_argument("--dataset", "-d", default="cifar10", type=str) parser.add_argument("--root", "-r", default="./dataset/cifar10", type=str, help="dataset dir") parser.add_argument("--work_dir", default="./exp_results", type=str, help="output dir") parser.add_argument("--exp_name", default="cifar10", type=str, help="exp name") parser.add_argument("--model", default="sngan", type=str, help="network model") parser.add_argument("--loss_type", default="hinge", type=str, help="loss type") parser.add_argument('--gpu', default='0', type=str, help='id(s) for CUDA_VISIBLE_DEVICES') parser.add_argument('--num_pack', default=1, type=int) parser.add_argument('--batch_size', default=64, type=int) parser.add_argument('--seed', default=1, type=int) parser.add_argument('--download_dataset', action='store_true') parser.add_argument('--topk', action='store_true') parser.add_argument('--num_steps', default=100000, type=int) parser.add_argument('--logit_save_steps', default=100, type=int) parser.add_argument('--decay', default='linear', type=str) parser.add_argument('--n_dis', default=5, type=int) parser.add_argument('--imb_factor', default=0.1, type=float) parser.add_argument('--celeba_class_attr', default='glass', type=str) parser.add_argument('--ckpt_step', type=int) parser.add_argument('--no_save_logits', action='store_true') parser.add_argument('--save_logit_after', default=30000, type=int) parser.add_argument('--stop_save_logit_after', default=60000, type=int) args = parser.parse_args() os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu output_dir = f'{args.work_dir}/{args.exp_name}' save_path = Path(output_dir) save_path.mkdir(parents=True, exist_ok=True) set_seed(args.seed) if torch.cuda.is_available(): device = "cuda" cudnn.benchmark = True else: device = "cpu" netG, netD, optG, optD = get_gan_model( dataset_name=args.dataset, model=args.model, loss_type=args.loss_type, topk=args.topk, ) print_num_params(netG, netD) ds_train = get_predefined_dataset( dataset_name=args.dataset, root=args.root, ) dl_train = get_dataloader(ds_train, batch_size=args.batch_size) if args.dataset == 'celeba': args.num_steps = 75000 args.logit_save_steps = 100 args.save_logit_after = 55000 args.stop_save_logit_after = 60000 if args.dataset == 'cifar10': args.num_steps = 50000 args.logit_save_steps = 100 args.save_logit_after = 35000 args.stop_save_logit_after = 40000 print(args) if args.ckpt_step: netG_ckpt_file = save_path / f'checkpoints/netG/netG_{args.ckpt_step}_steps.pth' netD_ckpt_file = save_path / f'checkpoints/netD/netD_{args.ckpt_step}_steps.pth' else: netG_ckpt_file = None netD_ckpt_file = None # Start training trainer = LogTrainer( output_path=save_path, logit_save_steps=args.logit_save_steps, netG_ckpt_file=netG_ckpt_file, netD_ckpt_file=netD_ckpt_file, netD=netD, netG=netG, optD=optD, optG=optG, n_dis=args.n_dis, num_steps=args.num_steps, save_steps=1000, lr_decay=args.decay, dataloader=dl_train, log_dir=output_dir, print_steps=10, device=device, topk=args.topk, save_logits=not args.no_save_logits, save_logit_after=args.save_logit_after, stop_save_logit_after=args.stop_save_logit_after, ) trainer.train()
def main(): parser = argparse.ArgumentParser() parser.add_argument("--work_dir", default="./exp_results", type=str, help="output dir") parser.add_argument("--exp_name", default="mimicry_pretrained-seed1", type=str, help="exp name") parser.add_argument("--model", default="sngan", type=str, help="network model") parser.add_argument("--loss_type", default="hinge", type=str, help="loss type") parser.add_argument("--classifier", default="vgg16", type=str, help="calssifier network model") parser.add_argument('--gpu', default='0', type=str, help='id(s) for CUDA_VISIBLE_DEVICES') parser.add_argument('--batch_size', default=100, type=int) parser.add_argument('--seed', default=1, type=int) parser.add_argument("--netG_ckpt_step", type=int) parser.add_argument("--netG_train_mode", action='store_true') parser.add_argument("--use_original_netD", action='store_true') parser.add_argument('--attr', default='Bald', type=str) parser.add_argument('--drs', action='store_true') parser.add_argument('--num_samples', default=50000, type=int) args = parser.parse_args() os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu set_seed(args.seed) print(args) save_path = f'{args.work_dir}/{args.exp_name}' if torch.cuda.is_available(): device = "cuda" cudnn.benchmark = True else: device = "cpu" # load model assert args.netG_ckpt_step print(f'load model from {save_path} step: {args.netG_ckpt_step}') if args.drs: netG, _, netD_drs, _, _, _ = get_gan_model(dataset_name='celeba', model=args.model, loss_type=args.loss_type, drs=True) else: netG, _, _, _ = get_gan_model( dataset_name='celeba', model=args.model, loss_type=args.loss_type, ) netG.to(device) if not args.netG_train_mode: netG.eval() netG.to(device) if args.drs: netD_drs.eval() netD_drs.to(device) gan_ckpt = f'{args.work_dir}/{args.exp_name}/checkpoints/netG/netG_{args.netG_ckpt_step}_steps.pth' if args.use_original_netD: netD_drs_ckpt = f'{args.work_dir}/{args.exp_name}/checkpoints/netD/netD_{args.netG_ckpt_step}_steps.pth' else: netD_drs_ckpt = f'{args.work_dir}/{args.exp_name}/checkpoints/netD_drs/netD_drs_{args.netG_ckpt_step}_steps.pth' print(gan_ckpt) netG.restore_checkpoint(ckpt_file=gan_ckpt) if args.drs: netD_drs.restore_checkpoint(ckpt_file=netD_drs_ckpt) netG = DRS(netG=netG, netD=netD_drs, device=device) # load classifier print('Load classifier') if args.classifier == 'vgg16': model = models.vgg16(pretrained=True) elif args.classifier == 'resnet18': model = models.resnet18(pretrained=True) elif args.classifier == 'inception': model = models.inception_v3(pretrained=True) else: raise ValueError('model should be vgg16 or resnet18 or inception') # change the number of classes in_features = model.classifier[6].in_features model.classifier[6] = nn.Linear(in_features, 2, bias=True) classifier_path = './convnet_celeba' model.load_state_dict( torch.load(os.path.join(classifier_path, f'{args.attr}.pth'))) model.to(device) batch_size = min(args.batch_size, args.num_samples) num_batches = args.num_samples // batch_size attr_num = 0 not_attr_num = 0 for i in range(num_batches): with torch.no_grad(): img = netG.generate_images(batch_size, device=device) labels = model(img) answers = torch.argmax(labels, dim=1) attr = torch.count_nonzero(answers).item() not_attr = batch_size - attr attr_num += attr not_attr_num += not_attr print(f'attr: {attr_num}') print(f'not attr: {not_attr_num}') output_dir = os.path.join(save_path, 'evaluate', f'step-{args.netG_ckpt_step}') if not os.path.exists(output_dir): os.makedirs(output_dir) output_file = os.path.join(output_dir, f'count_attribute.csv') if os.path.exists(output_file): with open(output_file, 'a', newline='') as f: wr = csv.writer(f) wr.writerow([args.attr, attr_num, not_attr_num]) else: with open(output_file, 'w', newline='') as f: wr = csv.writer(f) wr.writerow(['', 'attr', 'not attr']) wr.writerow([args.attr, attr_num, not_attr_num])