def main(args): """ Main function for the script :param args: parsed command line arguments :return: None """ from config import cfg as opt opt.merge_from_file(args.config) opt.freeze() print("Creating generator object ...") # create the generator object gen = Generator(resolution=opt.dataset.resolution, num_channels=opt.dataset.channels, structure=opt.structure, **opt.model.gen) print("Loading the generator weights from:", args.generator_file) # load the weights into it # gen.load_state_dict(torch.load(args.generator_file)) gen.load(args.generator_file) src_seeds=[1,32, 44, 86] dst_seeds=[231,415,1515,16] draw_interp_figure(args.output, gen, out_depth=5, src_seeds=src_seeds, dst_seeds=dst_seeds, psis=[0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7,0.8, 0.9,1]) print('Done.')
def main(args): """ Main function for the script :param args: parsed command line arguments :return: None """ from config import cfg as opt opt.merge_from_file(args.config) opt.freeze() print("Creating generator object ...") # create the generator object gen = Generator(resolution=opt.dataset.resolution, num_channels=opt.dataset.channels, structure=opt.structure, **opt.model.gen) print("Loading the generator weights from:", args.generator_file) # load the weights into it # gen.load_state_dict(torch.load(args.generator_file)) gen.load(args.generator_file) draw_truncation_trick_figure('figure08-truncation-trick.png', gen, out_depth=5, seeds=[1, 32, 44, 86, 91, 388], psis=[1, 0.7, 0.5, 0, -0.5, -1]) print('Done.')
def main(args): """ Main function for the script :param args: parsed command line arguments :return: None """ # from config import cfg as opt # # opt.merge_from_file(args.config) # opt.freeze() print("Creating generator object ...") # create the generator object gen = Generator() print("Loading the generator weights from:", args.generator_file) # load the weights into it state_dict = torch.load(args.generator_file) gen.load_state_dict(state_dict['g_ema']) gen = gen.to(device) avg = state_dict['latent_avg'].numpy() draw_truncation_trick_figure('figure-truncation-trick.jpg', gen, avg, seeds=[91, 388], psis=[1, 0.7, 0.5, 0, -0.5, -1]) print('Done.')
def main(args): """ Main function for the script :param args: parsed command line arguments :return: None """ from config import cfg as opt opt.merge_from_file(args.config) opt.freeze() save_path = args.output_dir os.makedirs(save_path, exist_ok=True) print("Creating generator object ...") # create the generator object gen = Generator(resolution=opt.dataset.resolution, num_channels=opt.dataset.channels, structure=opt.structure, **opt.model.gen) print("Loading the generator weights from:", args.generator_file) # load the weights into it gen.load_state_dict(torch.load(args.generator_file)) build_truncation_trick_seq(save_path, gen, out_depth=5, num_samles=args.num_samples) print('Done.')
def main(args): train_set = DataLoader(dataset=FaceDataset('hw3_data/face', mode='train', normalize=True), batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers) valid_set = DataLoader(dataset=FaceDataset('hw3_data/face', mode='test'), batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers) G = Generator(args.latent_dim).to(args.device) D = Discriminator(args.weight_cliping_limit).to(args.device) # G.load_state_dict(torch.load( # '/home/en/SSD/DLCV/hw3-shuoenchang/weights/q2/G_{:02d}.pth'.format(150), map_location=args.device)) # D.load_state_dict(torch.load( # '/home/en/SSD/DLCV/hw3-shuoenchang/weights/q2/D_{:02d}.pth'.format(150), map_location=args.device)) optimzer_G = optim.RMSprop(G.parameters(), lr=args.learning_rate) optimzer_D = optim.RMSprop(D.parameters(), lr=args.learning_rate) latent = torch.randn((32, args.latent_dim, 1, 1)).to(args.device) for epoch in range(0, 1500): print('\nepoch: {}'.format(epoch)) train(train_set, G, D, optimzer_G, optimzer_D, args.device, args.latent_dim, args.n_critic) # noqa val(G, args.latent_dim, args.device, epoch, latent) torch.save(G.state_dict(), '{}/G_{:02d}.pth'.format(args.save_folder, epoch)) # noqa torch.save(D.state_dict(), '{}/D_{:02d}.pth'.format(args.save_folder, epoch)) # noqa
def main(args): """ Main function for the script :param args: parsed command line arguments :return: None """ # from config import cfg as opt # # opt.merge_from_file(args.config) # opt.freeze() print("Creating generator object ...") # create the generator object gen = Generator() print("Loading the generator weights from:", args.generator_file) # load the weights into it gen.load_state_dict(torch.load(args.generator_file)['g_ema']) gen = gen.to(device) # path for saving the files: # generate the images: # src_seeds = [639, 701, 687, 615, 1999], dst_seeds = [888, 888, 888], draw_style_mixing_figure(os.path.join('diagrams/figure-style-mixing.jpg'), gen, src_seeds=[639, 1995, 687, 615, 1999], dst_seeds=[888, 888, 888], style_ranges=[range(0, 4)] * 1 + [range(4, 12)] * 1 + [range(12, 18)] * 1) print('Done.')
def main(args): """ Main function for the script :param args: parsed command line arguments :return: None """ from config import cfg as opt opt.merge_from_file(args.config) opt.freeze() print("Creating generator object ...") # create the generator object gen = Generator(resolution=opt.dataset.resolution, num_channels=opt.dataset.channels, structure=opt.structure, **opt.model.gen) print("Loading the generator weights from:", args.generator_file) # load the weights into it # gen.load_state_dict(torch.load(args.generator_file)) gen = load(gen, args.generator_file) # path for saving the files: # generate the images: # src_seeds = [639, 701, 687, 615, 1999], dst_seeds = [888, 888, 888], draw_style_mixing_figure(os.path.join('figure03-style-mixing.png'), gen, out_depth=4, src_seeds=[639, 1995, 687, 615, 1999], dst_seeds=[888, 888, 888], style_ranges=[range(0, 2)] * 1 + [range(2, 8)] * 1 + [range(8, 14)] * 1) print('Done.')
def main(args): torch.manual_seed(args.seed) device = 'cuda' G = Generator(100).to(device) G.load_state_dict(torch.load('weights/q2.pth', map_location=device)) generate(G, device, output_path=args.save_folder, seed=args.seed)
def main(args): """ Main function for the script :param args: parsed command line arguments :return: None """ from config import cfg as opt opt.merge_from_file(args.config) opt.freeze() print("Creating generator object ...") # create the generator object gen = Generator(resolution=opt.dataset.resolution, num_channels=opt.dataset.channels, structure=opt.structure, **opt.model.gen) print("Loading the generator weights from:", args.generator_file) # load the weights into it # gen.load_state_dict(torch.load(args.generator_file)) gen.load(args.generator_file) # path for saving the files: save_path = args.output_dir os.makedirs(save_path, exist_ok=True) latent_size = opt.model.gen.latent_size out_depth = int(np.log2(opt.dataset.resolution)) - 2 print("Generating scale synchronized images ...") # generate the images: # with torch.no_grad(): with jt.no_grad(): # point = torch.randn(args.n_row * args.n_col, latent_size) np.random.seed(1000) point = np.random.randn(args.n_row * args.n_col, latent_size) # point = (point / point.norm()) * (latent_size ** 0.5) point = (point / np.linalg.norm(point)) * (latent_size**0.5) point = jt.array(point, dtype='float32') ss_image = gen(point, depth=out_depth, alpha=1) # color adjust the generated image: ss_image = adjust_dynamic_range(ss_image) print("gen done") # save the ss_image in the directory # ss_image = torch.from_numpy(ss_image.data) # save_image(ss_image, os.path.join(save_path, "grid.png"), nrow=args.n_row, # normalize=True, scale_each=True, pad_value=128, padding=1) jt.save_image_my(ss_image, os.path.join(save_path, "grid.png"), nrow=args.n_row, normalize=True, scale_each=True, pad_value=128, padding=1) print('Done.')
def main(args): """ Main function for the script :param args: parsed command line arguments :return: None """ from config import cfg as opt opt.merge_from_file(args.config) opt.freeze() print("Creating generator object ...") print(opt.model.gen) # create the generator object gen = Generator(resolution=opt.dataset.resolution, num_channels=opt.dataset.channels, structure=opt.structure, **opt.model.gen) print("Loading the generator weights from:", args.generator_file) # load the weights into it # gen.load_state_dict(torch.load(args.generator_file)) gen = load(gen, args.generator_file) # path for saving the files: save_path = args.output_dir os.makedirs(save_path, exist_ok=True) latent_size = opt.model.gen.latent_size out_depth = int(np.log2(opt.dataset.resolution)) - 2 if args.input is None: print("Generating scale synchronized images ...") for img_num in tqdm(range(1, args.num_samples + 1)): # generate the images: with torch.no_grad(): point = torch.randn(1, latent_size) point = (point / point.norm()) * (latent_size ** 0.5) ss_image = gen(point, depth=out_depth, alpha=1) # color adjust the generated image: ss_image = adjust_dynamic_range(ss_image) # save the ss_image in the directory save_image(ss_image, os.path.join(save_path, str(img_num) + ".png")) print("Generated %d images at %s" % (args.num_samples, save_path)) else: code = np.load(args.input) dlatent_in = torch.unsqueeze(torch.from_numpy(code), 0) ss_image = gen.g_synthesis(dlatent_in, depth=out_depth, alpha=1) # color adjust the generated image: ss_image = adjust_dynamic_range(ss_image) save_image(ss_image, args.output)
def main(args): """ Main function for the script :param args: parsed command line arguments :return: None """ from config import cfg as opt opt.merge_from_file(args.config) opt.model.gen.use_noise = False opt.freeze() print("Creating generator object ...") # create the generator object gen = Generator(resolution=opt.dataset.resolution, num_channels=opt.dataset.channels, structure=opt.structure, **opt.model.gen) print("Loading the generator weights from:", args.generator_file) # load the weights into it # gen.load_state_dict(torch.load(args.generator_file)) gen.load(args.generator_file) # path for saving the files: # generate the images: # src_seeds = [639, 701, 687, 615, 1999], dst_seeds = [888, 888, 888], # src_seeds = [i for i in range(200)] # src_seeds = [166, 1721, 1181, 21, 239] # dst_seeds = [284, 2310, 1140, 255, 626] src_seeds = [166, 1721, 1181, 255, 239, 284, 2310, 1140] dst_seeds = [21] * 6 draw_style_mixing_figure(args.output, gen, out_depth=5, src_seeds=src_seeds, dst_seeds=dst_seeds, style_ranges=[range(0, 2)] * 1 + [range(0, 4)] * 1 + [range(0, 6)] * 1 + [range(0, 8)] * 1 + [range(0, 10)] * 1 + [range(0, 12)] * 1) # draw_style_mixing_figure(os.path.join('figure03-style-mixing.png'), gen, # out_depth=4, src_seeds=[670, 1995, 687, 255, 1999], dst_seeds=[888, 888, 888], # style_ranges=[range(0, 1)] * 1 + [range(1, 6)] * 1 + [range(6, 10)] * 1) print('Done.')
def generate_model(pp, latent_dim, n_epochs, nb_patches): """ Loss function """ adversarial_loss = torch.nn.BCELoss().to(device) """ Initialize generator and discriminator """ generator = Generator().to(device) discriminator = Discriminator().to(device) """ Optimizers """ optimizer_G = torch.optim.Adam(generator.parameters(), lr=lr, betas=(b1, b2)) optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=lr, betas=(b1, b2)) gen_data = fitGAN(pp, generator, discriminator, optimizer_G, optimizer_D, adversarial_loss, latent_dim, n_epochs, nb_patches, Tensor) return gen_data
def main(args): from config import cfg as opt opt.merge_from_file(args.config) opt.freeze() print("Creating generator object ...") # create the generator object gen = Generator(resolution=opt.dataset.resolution, num_channels=opt.dataset.channels, structure=opt.structure, **opt.model.gen) state_G, state_D, state_Gs = load_weights(args.input_file) # we delete the useless to_rgb filters params = {} for k, v in state_Gs.items(): params[k] = v param_dict = { key_translate(k): weight_translate(k, v) for k, v in state_Gs.items() if 'torgb_lod' not in key_translate(k) } sd_shapes = {k: v.shape for k, v in gen.state_dict().items()} param_shapes = {k: v.shape for k, v in param_dict.items()} # check for mismatch for k in list(sd_shapes) + list(param_shapes): pds = param_shapes.get(k) sds = sd_shapes.get(k) if pds is None: print("sd only", k, sds) elif sds is None: print("pd only", k, pds) elif sds != pds: print("mismatch!", k, pds, sds) gen.load_state_dict(param_dict, strict=False) # needed for the blur kernels torch.save(gen.state_dict(), args.output_file) print('Done.')
def main(args): """ Main function for the script :param args: parsed command line arguments :return: None """ device = 'cuda' print("Creating generator object ...") # create the generator object gen = Generator() print("Loading the generator weights from:", args.generator_file) # load the weights into it gen.load_state_dict(torch.load(args.generator_file)['g_ema']) gen = gen.to(device) # path for saving the files: save_path = args.output_dir os.makedirs(save_path, exist_ok=True) print("Generating scale synchronized images ...") # generate the images: with torch.no_grad(): point = torch.randn(args.n_row * args.n_col, 512).to(device) # point = (point / point.norm()) * (latent_size ** 0.5) ss_image = gen(point) # color adjust the generated image: ss_image = adjust_dynamic_range(ss_image) # save the ss_image in the directory save_image(ss_image, os.path.join(save_path, "grid.jpg"), nrow=args.n_row, normalize=True, scale_each=True, pad_value=128, padding=1) print('Done.')
import numpy as np import torch from torchvision import utils from models.GAN import Generator if __name__ == '__main__': gen = Generator() gen.load_state_dict( torch.load('./weights/stylegan2-ffhq-config-f.pt')['g_ema']) device = 'cuda' batch_size = {256: 16, 512: 9, 1024: 9} n_sample = batch_size.get(1024, 25) g = gen.to(device) z = np.random.RandomState(1).randn(n_sample, 512).astype('float32') # x = torch.randn(n_sample, 512).to(device) with torch.no_grad(): img = g(torch.from_numpy(z).to(device)) utils.save_image(img, 'gen' + '.png', nrow=int(n_sample**0.5), normalize=True, range=(-1, 1))
return args if __name__ == '__main__': args = parse_arguments() from config import cfg as opt opt.merge_from_file(args.config) opt.freeze() print("Creating generator object ...") # create the generator object gen = Generator(resolution=opt.dataset.resolution, num_channels=opt.dataset.channels, structure=opt.structure, **opt.model.gen) out_depth = gen.g_synthesis.depth - 1 state_G, state_D, state_Gs, dlatent_avg = load_weights(args.input_file) # we delete the useless to_rgb filters params = {} for k, v in state_Gs.items(): params[k] = v param_dict = { key_translate(k): weight_translate(k, v) for k, v in state_Gs.items() if 'torgb_lod' not in key_translate(k) } for k, v in dlatent_avg.items():
type=int, default=1, help="number of image channels") parser.add_argument("--sample_interval", type=int, default=400, help="interval betwen image samples") opt = parser.parse_args() img_shape = (opt.channels, opt.img_size, opt.img_size) cuda = True if torch.cuda.is_available() else False adversarial_loss = torch.nn.BCELoss() # Initialize generator and discriminator generator = Generator(z_dim=opt.latent_dim, img_shape=img_shape) discriminator = Discriminator(img_shape=img_shape) if cuda: generator.cuda() discriminator.cuda() adversarial_loss.cuda() # Configure data loader if opt.dataset == 'mnist': dataloader = torch.utils.data.DataLoader( datasets.MNIST( "./data/mnist", train=True, transform=transforms.Compose([ transforms.Resize(opt.img_size),
from models.GAN import Generator from torchsummary import summary import torch g = Generator(1024) device = torch.device('cuda') g = g.to(device) # input = torch.rand((2, 512)).to(device) # noise_sample = torch.randn(2, 512, device=device) # output = g(noise_sample) # print('aa') summary(g, (512,)) # gen = Generator() # gen = gen.to(device) # test_latents_in = torch.randn(4, 512).to(device) # test_imgs_out = gen(test_latents_in) # print('Done.')
optimizer_D.step() if i % config.print_freq == 0: logging.info( f'Epoch [{epoch}][{i}/{len(dataloader)}] [D loss: {d_loss.item():.4f}] [G loss: {g_loss.item():.4f}]' ) if i % 100 == 0: save_image(gen_imgs.data[:25], epoch, i) if __name__ == "__main__": config = parser_args() logging.info(config) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') img_shape = (config.in_channel, config.img_size, config.img_size) generator = Generator(config, img_shape).to(device) discriminator = Discriminator(config, img_shape).to(device) logging.info(generator) logging.info(discriminator) dataset = Mnist(config, 'train') loader = Data.DataLoader(dataset, batch_size=config.batch_size, shuffle=True, num_workers=config.workers, pin_memory=True) main(generator, discriminator, loader, device, config)
transforms.CenterCrop(resize), transforms.ToTensor(), transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) ]) imgs = [] files = os.listdir('/home/dung/Data/anh') for imgfile in files: imgfile = '/home/dung/Data/anh/' + imgfile img = transform(Image.open(imgfile).convert('RGB')) imgs.append(img) imgs = torch.stack(imgs, 0).to(device) g_ema = Generator(args.size, 512, 8) g_ema.load_state_dict(torch.load(args.ckpt)['g_ema']) g_ema.eval() g_ema = g_ema.to(device) with torch.no_grad(): noise_sample = torch.randn(n_mean_latent, 512, device=device) latent_out = g_ema.style(noise_sample) latent_mean = latent_out.mean(0) latent_std = ((latent_out - latent_mean).pow(2).sum() / n_mean_latent)**0.5 # percept = lpips.PerceptualLoss( # model='net-lin', net='vgg', use_gpu=device.startswith('cuda'))