def main(): parser = argparse.ArgumentParser( description='Test Cartoon avatar Gan model') parser.add_argument('--model_root', default='pretrained_model/', help='Root directory for models') parser.add_argument('--model_name', default='', help='Model G name') parser.add_argument('--nz', default=100, type=int, help='Size of generator input') opt = parser.parse_args() model_root = opt.model_root model_name = opt.model_name nz = opt.nz netG = Generator() netG.load_state_dict(torch.load(model_root + model_name)) z = torch.randn(1, nz, 1, 1, device=device) fake = netG(z).detach().cpu() image_sample = vutils.make_grid(fake, padding=2, normalize=True) utils.save_image(image_sample, 'output/image_sample.png', padding=2)
def visualizeSingleBatch(fp_loader_test, opt, exp_folder, batches_done, batch_size=8): print('Loading saved model ... \n{}'.format( './checkpoints/{}_{}.pth'.format(exp_folder, batches_done))) generatorTest = Generator() generatorTest.load_state_dict( torch.load('./checkpoints/{}_{}.pth'.format(exp_folder, batches_done))) generatorTest = generatorTest.eval() generatorTest.cuda() with torch.no_grad(): # Unpack batch mks, nds, eds, nd_to_sample, ed_to_sample = next(iter(fp_loader_test)) real_mks = Variable(mks.type(Tensor)) given_nds = Variable(nds.type(Tensor)) given_eds = eds # Select random nodes ind_fixed_nodes, _ = selectNodesTypes(nd_to_sample, batch_size, nds) # build input state = {'masks': real_mks, 'fixed_nodes': ind_fixed_nodes} z, given_masks_in, given_nds, given_eds = _init_input(graph, state) z, given_masks_in, given_nds, given_eds = z.to(device), given_masks_in.to(device), \ given_nds.to(device), given_eds.to(device) gen_mks = generator(z, given_masks_in, given_nds, given_eds) # Generate a batch of images gen_mks = generatorTest(z, given_masks_in, given_nds, given_eds) # Generate image tensors real_imgs_tensor = combine_images(real_mks, given_nds, given_eds, \ nd_to_sample, ed_to_sample) fake_imgs_tensor = combine_images(gen_mks, given_nds, given_eds, \ nd_to_sample, ed_to_sample) # Save images save_image(real_imgs_tensor, "./exps/{}/{}_real.png".format(exp_folder, batches_done), \ nrow=12, normalize=False) save_image(fake_imgs_tensor, "./exps/{}/{}_fake.png".format(exp_folder, batches_done), \ nrow=12, normalize=False) return
foreign_dir = '/home/tlchen/GanTicket/' print(args) os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu torch.backends.cudnn.enabled = True torch.backends.cudnn.benchmark = True quant = True if 'GS8' in args.base_model_str else False subnet_model_path = os.path.join('subnet_structures_ticket', args.dataset, args.task, args.base_model_str, 'pth') ## Networks # G: dim_lst_path = os.path.join(subnet_model_path, 'epoch%d_netG.npy' % 199) netG = Generator(args.input_nc, args.output_nc, dim_lst=np.load(dim_lst_path), quant=quant).cuda() # D: netD = Discriminator(args.input_nc).cuda() ## results_dir: optimizer_str = 'adam_lr%s_wd%s' % (args.lr, args.wd) loss_str = '' results_dir = os.path.join('cp_finetune_results', args.dataset, args.task, args.base_model_str, '%s_%s' % (optimizer_str, loss_str)) img_dir = os.path.join(results_dir, 'img') pth_dir = os.path.join(results_dir, 'pth') create_dir(img_dir), create_dir(pth_dir) # Optimizers
syn_feature = netG(syn_noise, syn_att) return syn_feature, syn_label, syn_att """"pre-train a classifier on seen classes""" trc = utils.train_cla(data.train_feature, data.train_label, CLA, device=opts.device, ) trc.run(50, data.test_seen_feature, data.test_seen_label, save_path='./cla_model') # load best classifier pre_cla = torch.load("./cla_model/model.pt") for p in pre_cla.parameters(): # set requires_grad to False p.requires_grad = False if(opts.GD == 1): netG = Generator(opts).to(opts.device) netD = Discriminator(opts).to(opts.device) else: netG = Generator1(opts).to(opts.device) netD = Discriminator1(opts).to(opts.device) # seen reconstructor netRS = Reconstructor(opts).to(opts.device) # unseen reconstructor netRU = Reconstructor(opts).to(opts.device) if opts.optimizer == "ADAM": optimzerF = optim.Adam else: optimzerF = optim.RMSprop
parser = argparse.ArgumentParser() parser.add_argument('--dataset', type=str, default='horse2zebra', choices=['summer2winter_yosemite', 'horse2zebra', 'cityscapes']) parser.add_argument('--task', type=str, default='A2B', choices=['A2B', 'B2A']) parser.add_argument('--epoch', type=int, default=199) parser.add_argument('--gpu', default='7') parser.add_argument('--model_str') args = parser.parse_args() print(args) os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu quant = True if 'GS8' in args.model_str else False # load dense model: g_path = os.path.join('results', args.dataset, args.task, args.model_str, 'pth', 'epoch%d_netG.pth' % args.epoch) dense_model = Generator(input_nc, output_nc, quant=quant) dense_model.load_state_dict(torch.load(g_path)) dense_model = nn.DataParallel(dense_model) # measure_model(dense_model, 256, 256) # 54168.000000M # get channel numbers: dim_lst = [] for m in dense_model.modules(): if isinstance(m, nn.InstanceNorm2d) and m.weight is not None: gamma = m.weight.data.cpu().numpy() channel_num = np.sum(gamma!=0) dim_lst.append(channel_num) print(dim_lst) # construct subnet:
help="path to the dataset") parser.add_argument("--lambda_gp", type=int, default=10, help="lambda for gradient penalty") opt = parser.parse_args() exp_folder = "{}_{}".format(opt.exp_folder, opt.target_set) os.makedirs("./exps/" + exp_folder, exist_ok=True) # Loss function adversarial_loss = torch.nn.BCEWithLogitsLoss() distance_loss = torch.nn.L1Loss() # Initialize generator and discriminator generator = Generator() discriminator = Discriminator() if torch.cuda.is_available(): device = torch.device('cuda:0') generator.to(device) discriminator.to(device) adversarial_loss.to(device) # Visualize a single batch def visualizeSingleBatch(fp_loader_test, opt, exp_folder, batches_done, batch_size=8): print('Loading saved model ... \n{}'.format(
# Use third party images with 102 categories flowers. BATCH_SIZE = 128 EPOCH = 7 INPUT_SIZE = 8189 BUFFER_SIZE = 8000 NUM_CLASSES = 102 iter_number = (int)(INPUT_SIZE / BATCH_SIZE) + 1 image_root = utils.download_images() train_ds = utils.load_data(image_root) train_ds = utils.prepare_train_ds(train_ds, BATCH_SIZE, BUFFER_SIZE, image_size=128) # Guild generator and discriminator model. generator_net = Generator(dtype=flags.FLAGS.dtype) generator_optimizer = tf.train.AdamOptimizer( learning_rate=flags.FLAGS.learning_rate_generator, beta1=flags.FLAGS.beta1, beta2=flags.FLAGS.beta2) discriminator_net = Discriminator(alpha=flags.FLAGS.alpha, dtype=flags.FLAGS.dtype) discriminator_optimizer = tf.train.AdamOptimizer( learning_rate=flags.FLAGS.learning_rate_discriminator, beta1=flags.FLAGS.beta1, beta2=flags.FLAGS.beta2) # Print the network structure to show that the model is well built. generator_net.build(input_shape=(None, 128)) discriminator_net.build(input_shape=(None, 128, 128, 3))
def main(): parser = argparse.ArgumentParser( description='Train Cartoon avatar Gan models') parser.add_argument('--crop_size', default=64, type=int, help='Training images crop size') parser.add_argument('--num_epochs', default=50, type=int, help='Train epoch number') parser.add_argument('--data_root', default='data/cartoon', help='Root directory for dataset') parser.add_argument('--worker', default=2, type=int, help='Number of workers for dataloader') parser.add_argument('--batch_size', default=16, type=int, help='Batch size during training') parser.add_argument('--channels', default=3, type=int, help='Number of channels in the training images') parser.add_argument('--nz', default=100, type=int, help='Size of generator input') parser.add_argument('--ngf', default=64, type=int, help='Size of feature maps in generator') parser.add_argument('--ndf', default=64, type=int, help='Size of feature maps in descriminator') parser.add_argument('--lr', default=0.0002, type=float, help='Learning rate for optimizer') parser.add_argument('--beta1', default=0.5, type=float, help='Beta1 hyperparam for Adam optimizers') parser.add_argument('--beta2', default=0.999, type=float, help='Beta2 hyperparam for Adam optimizers') parser.add_argument('--ngpu', default=1, type=int, help='Number of GPUs , use 0 for CPU mode') parser.add_argument( '--latent_vector_num', default=8, type=int, help= 'latent vectors that we will use to visualize , 8 means that it will visualize 8 images during training' ) opt = parser.parse_args() dataroot = opt.data_root workers = opt.worker batch_size = opt.batch_size image_size = opt.crop_size nc = opt.channels nz = opt.nz ngf = opt.ngf ndf = opt.ndf num_epochs = opt.num_epochs lr = opt.lr beta1 = opt.beta1 beta2 = opt.beta2 ngpu = opt.ngpu latent_vector_num = opt.latent_vector_num # Create the dataset dataset = dset.ImageFolder(root=dataroot, transform=transforms.Compose([ transforms.Resize(image_size), transforms.CenterCrop(image_size), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])) # Create the dataloader dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=workers) # Decide which device we want to run on device = torch.device("cuda:0" if ( torch.cuda.is_available() and ngpu > 0) else "cpu") # Create the generator netG = Generator(ngpu, nz, ngf, nc).to(device) # Create the Discriminator netD = Discriminator(ngpu, nc, ndf).to(device) # Handle multi-gpu if desired if (device.type == 'cuda') and (ngpu > 1): netG = nn.DataParallel(netG, list(range(ngpu))) netD = nn.DataParallel(netD, list(range(ngpu))) # Apply the weights_init function to randomly initialize all weights # to mean=0, stdev=0.2. netG.apply(weights_init) netD.apply(weights_init) # Setup Adam optimizers for both G and D optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999)) optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999)) # Print models print(netG) print(netD) # Initialize BCELoss function criterion = nn.BCELoss() # Create batch of latent vectors that we will use to visualize fixed_noise = torch.randn(latent_vector_num, nz, 1, 1, device=device) #real and fake labels during training real_label = 1 fake_label = 0 # Lists to keep track of progress img_list = [] G_losses = [] D_losses = [] iters = 0 print("Starting Training ...") for epoch in range(num_epochs): for i, data in enumerate(dataloader, 0): ############################ # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z))) ########################### ## Train with all-real batch netD.zero_grad() # Format batch real_cpu = data[0].to(device) b_size = real_cpu.size(0) label = torch.full((b_size, ), real_label, device=device) # Forward pass real batch through D output = netD(real_cpu).view(-1) # Calculate loss on all-real batch errD_real = criterion(output, label) # Calculate gradients for D in backward pass errD_real.backward() D_x = output.mean().item() ## Train with all-fake batch # Generate batch of latent vectors noise = torch.randn(b_size, nz, 1, 1, device=device) # Generate fake image batch with G fake = netG(noise) label.fill_(fake_label) # Classify all fake batch with D output = netD(fake.detach()).view(-1) # Calculate D's loss on the all-fake batch errD_fake = criterion(output, label) # Calculate the gradients for this batch errD_fake.backward() D_G_z1 = output.mean().item() # Add the gradients from the all-real and all-fake batches errD = errD_real + errD_fake # Update D optimizerD.step() ############################ # (2) Update G network: maximize log(D(G(z))) ########################### netG.zero_grad() label.fill_(real_label) # fake labels are real for generator cost # Since we just updated D, perform another forward pass of all-fake batch through D output = netD(fake).view(-1) # Calculate G's loss based on this output errG = criterion(output, label) # Calculate gradients for G errG.backward() D_G_z2 = output.mean().item() # Update G optimizerG.step() # Output training stats if i % 50 == 0: # Save model data torch.save(netG.state_dict(), 'pretrained_model/netG_epoch_%d.pth' % (iters)) torch.save(netD.state_dict(), 'pretrained_model/netD_epoch_%d.pth' % (iters)) # Print training stats print( '[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f' % (epoch, num_epochs, i, len(dataloader), errD.item(), errG.item(), D_x, D_G_z1, D_G_z2)) # Save Losses for plotting later G_losses.append(errG.item()) D_losses.append(errD.item()) # Check how the generator is doing by saving G's output on fixed_noise if (iters % 650 == 0) or ((epoch == num_epochs - 1) and (i == len(dataloader) - 1)): with torch.no_grad(): fake = netG(fixed_noise).detach().cpu() img_list.append( vutils.make_grid(fake, padding=2, normalize=True)) iters += 1 # Display and Save samples GIF fig = plt.figure(figsize=(8, 8)) plt.axis("off") ims = [[plt.imshow(np.transpose(i, (1, 2, 0)), animated=True)] for i in img_list] ani = animation.ArtistAnimation(fig, ims, interval=1000, repeat_delay=1000, blit=True) ani.save('output/samples.gif', writer='imagemagick', fps=100)
opt = parser.parse_args() print(opt) # PARAMS target_set = 8 phase = 'eval' checkpoint = './checkpoints/exp_debug_E_165000.pth' PREFIX = "./" IM_SIZE = 64 output_dir = "./dump" # Create folder os.makedirs(opt.exp_folder, exist_ok=True) # Initialize generator and discriminator model = Generator() model.load_state_dict(torch.load(checkpoint), strict=False) model = model.eval() # Initialize variables cuda = True if torch.cuda.is_available() else False if cuda: model.cuda() rooms_path = '../' # initialize dataset iterator fp_dataset_test = FloorplanGraphDataset(rooms_path, transforms.Normalize(mean=[0.5], std=[0.5]), target_set=target_set, split=phase)
## results_dir: method_str = ('GS8' if args.quant else 'GS32') gamma_optimizer_str = 'sgd_mom%s_lrgamma%s' % (args.momentum, args.lrgamma) W_optimizer_str = 'adam_lrw%s_wd%s' % (args.lrw, args.wd) opt_str = 'e%d-b%d' % (args.epochs, args.batch_size) loss_str = 'rho%s_beta%s_%s' % (args.rho, args.beta, args.lc) results_dir = os.path.join( 'results', args.dataset, args.task, '%s_%s_%s_%s_%s' % (method_str, loss_str, opt_str, gamma_optimizer_str, W_optimizer_str)) img_dir = os.path.join(results_dir, 'img') pth_dir = os.path.join(results_dir, 'pth') create_dir(img_dir), create_dir(pth_dir) ## Networks # G: netG = Generator(args.input_nc, args.output_nc, quant=args.quant).cuda() # D: netD = Discriminator(args.input_nc).cuda() # param list: parameters_G, parameters_D, parameters_gamma = [], [], [] for name, para in netG.named_parameters(): if 'weight' in name and para.ndimension() == 1: parameters_gamma.append(para) else: parameters_G.append(para) for name, para in netD.named_parameters(): # print(name, para.size(), para.ndimension()) parameters_D.append(para) print('parameters_gamma:', len(parameters_gamma))
parser = argparse.ArgumentParser() parser.add_argument('--gpu', default='3') parser.add_argument('--cpus', default=4) parser.add_argument('--quant', action='store_true', help='enable quantization (for both activation and weight)') args = parser.parse_args() model_str = 'GS8v2_rho0.002_beta0.001_vgg_e200-b8_sgd_mom0.5_lrgamma0.1_adam_lrw1e-05_wd0.001' gen_photo_root_dir = os.path.join(model_str, 'gen') real_photo_root_dir = os.path.join('/home/haotao/PyTorch-CycleGAN/datasets/leftImg8bit/val') label_root_dir = os.path.join('/home/haotao/PyTorch-CycleGAN/datasets/gtFine/val') # network: netG = Generator(3, 3, quant=args.quant).cuda() g_path = os.path.join('results/cityscapes/B2A', model_str, 'pth/epoch199_netG.pth') netG.load_state_dict(torch.load(g_path)) # generate photo from labels: with torch.no_grad(): for city in os.listdir(real_photo_root_dir): real_photo_dir = os.path.join(real_photo_root_dir, city) print('real_photo_dir:', real_photo_dir) for real_photo_file_name in os.listdir(real_photo_dir): # print('realphoto_file_name:', real_photo_file_name) seg_color_file_name = '{}_{}'.format(real_photo_file_name.split('_leftImg8bit')[0], 'gtFine_color.png') # print('seg_color_file_name:', seg_color_file_name) gen_photo_file_name = real_photo_file_name # print('gen_photo_file_name:', gen_photo_file_name) seg_color = Image.open(os.path.join(label_root_dir, city, seg_color_file_name)).convert('RGB').resize((256, 256))
## results_dir: method_str = 'distill' W_optimizer_str = 'adam_lrw%s_wd%s' % (args.lrw, args.wd) opt_str = 'e%d-b%d' % (args.epochs, args.batch_size) loss_str = 'alpha%s_beta%s_%s' % (args.alpha, args.beta, args.lc) results_dir = os.path.join( 'distill_results', args.dataset, args.task, '%s_%s_%s_%s' % (method_str, loss_str, opt_str, W_optimizer_str)) img_dir = os.path.join(results_dir, 'img') pth_dir = os.path.join(results_dir, 'pth') create_dir(img_dir), create_dir(pth_dir) ## Networks # G: netG = Generator(args.input_nc, args.output_nc, quant=args.quant, alpha=args.alpha).cuda() # D: netD = Discriminator(args.input_nc).cuda() # FLOPs for G: netG.cpu() count_ops = measure_model(netG, 256, 256) print("#parameters: %s" % model_param_num(netG)) f = open(os.path.join(results_dir, 'model_size.txt'), 'a+') f.write('count_ops: {:.6f}M'.format(count_ops / 1024. / 1024.)) f.write("#parameters: %s" % model_param_num(netG)) f.close() netG.cuda() # Optimizers:
choices=['ori', 'transconv', 'nearest', 'bilinear'], help='which upsample method to use in generater') opt = parser.parse_args() print(opt) random.seed(opt.seed) torch.manual_seed(opt.seed) if torch.cuda.is_available(): torch.cuda.manual_seed(opt.seed) # Networks if opt.upsample == 'ori': netG_A2B = Generator_ori(opt.input_nc, opt.output_nc) netG_B2A = Generator_ori(opt.output_nc, opt.input_nc) else: netG_A2B = Generator(opt.input_nc, opt.output_nc) netG_B2A = Generator(opt.output_nc, opt.input_nc) netD_A = Discriminator(opt.input_nc) netD_B = Discriminator(opt.output_nc) netG_A2B.cuda() netG_B2A.cuda() netD_A.cuda() netD_B.cuda() netG_A2B.apply(weights_init_normal) netG_B2A.apply(weights_init_normal) netD_A.apply(weights_init_normal) netD_B.apply(weights_init_normal) torch.save(netG_A2B.state_dict(),