def validate(args, fixed_z, fid_stat, gen_net: nn.Module, writer_dict, clean_dir=True): writer = writer_dict["writer"] global_steps = writer_dict["valid_global_steps"] # eval mode gen_net = gen_net.eval() # generate images sample_imgs = gen_net(fixed_z) img_grid = make_grid(sample_imgs, nrow=5, normalize=True, scale_each=True) # get fid and inception score fid_buffer_dir = os.path.join(args.path_helper["sample_path"], "fid_buffer") os.makedirs(fid_buffer_dir, exist_ok=True) eval_iter = args.num_eval_imgs // args.eval_batch_size img_list = list() for iter_idx in tqdm(range(eval_iter), desc="sample images"): z = torch.cuda.FloatTensor( np.random.normal(0, 1, (args.eval_batch_size, args.latent_dim))) # Generate a batch of images gen_imgs = (gen_net(z).mul_(127.5).add_(127.5).clamp_( 0.0, 255.0).permute(0, 2, 3, 1).to("cpu", torch.uint8).numpy()) for img_idx, img in enumerate(gen_imgs): file_name = os.path.join(fid_buffer_dir, f"iter{iter_idx}_b{img_idx}.png") imsave(file_name, img) img_list.extend(list(gen_imgs)) # get inception score logger.info("=> calculate inception score") mean, std = get_inception_score(img_list) print(f"Inception score: {mean}") # get fid score logger.info("=> calculate fid score") fid_score = calculate_fid_given_paths([fid_buffer_dir, fid_stat], inception_path=None) print(f"FID score: {fid_score}") if clean_dir: os.system("rm -r {}".format(fid_buffer_dir)) else: logger.info(f"=> sampled images are saved to {fid_buffer_dir}") writer.add_image("sampled_images", img_grid, global_steps) writer.add_scalar("Inception_score/mean", mean, global_steps) writer.add_scalar("Inception_score/std", std, global_steps) writer.add_scalar("FID_score", fid_score, global_steps) writer_dict["valid_global_steps"] = global_steps + 1 return mean, fid_score
def get_score(opt, netG, netD, dataloader, loss, data_name): # eval mode netG.eval() img_list = list() ds = list() with torch.no_grad(): for data in dataloader: imgs = data[data_name] if len(opt.gpu_ids) != 0: imgs = imgs.cuda() conv_imgs = netG(imgs) d = [float(loss(netD(im.unsqueeze(0)), True)) for im in conv_imgs] conv_imgs = conv_imgs.mul_(127.5).add_(127.5).clamp_(0.0, 255.0).permute(0, 2, 3, 1).to('cpu', torch.uint8).numpy() img_list.extend(list(conv_imgs)) ds.extend(d) mean_is, std_is = get_inception_score(img_list, splits=1) mean_d = 1 / (np.mean(ds) + 0.00005) std_d = 1 / (np.std(ds) + 0.00005) return mean_is, mean_d * 3.0
def get_is(args, gen_net: nn.Module, num_img): """ Get inception score. :param args: :param gen_net: :param num_img: :return: Inception score """ # eval mode gen_net = gen_net.eval() eval_iter = num_img // args.eval_batch_size img_list = list() for _ in range(eval_iter): z = torch.cuda.FloatTensor( np.random.normal(0, 1, (args.eval_batch_size, args.latent_dim))) # Generate a batch of images gen_imgs = (gen_net(z).mul_(127.5).add_(127.5).clamp_( 0.0, 255.0).permute(0, 2, 3, 1).to("cpu", torch.uint8).numpy()) img_list.extend(list(gen_imgs)) # get inception score logger.info("calculate Inception score...") mean, std = get_inception_score(img_list) return mean
def calculate_inception_score(self): sample_list = [] for i in range(10): z = self.fixed_noise samples = self.netG(z) sample_list.append(samples.data.cpu().numpy()) new_sample_list = list(chain.from_iterable(sample_list)) print("Calculating Inception Score over 8k generated images") inception_score = get_inception_score( new_sample_list, cuda=True, batch_size=32, resize=True, splits=10, ) time = t.time() - self.t_begin print("Inception score: {}".format(inception_score)) print("Generator iter: {}".format(iters)) print("Time {}".format(time)) output = str(iters) + ", " + str(inception_score[0]) + "\n" return output
def validate(args, fixed_z, fid_stat, gen_net: nn.Module, writer_dict, epoch): np.random.seed(args.random_seed**2 + epoch) writer = writer_dict['writer'] global_steps = writer_dict['valid_global_steps'] # eval mode gen_net = gen_net.eval() # generate images sample_imgs = gen_net(fixed_z) img_grid = make_grid(sample_imgs, nrow=5, normalize=True, scale_each=True) # get fid and inception score fid_buffer_dir = os.path.join(args.path_helper['sample_path'], 'fid_buffer') os.makedirs(fid_buffer_dir) eval_iter = args.num_eval_imgs // args.eval_batch_size img_list = list() for iter_idx in range(eval_iter): z = torch.cuda.FloatTensor( np.random.normal(0, 1, (args.eval_batch_size, args.latent_dim))) # Generate a batch of images gen_imgs = gen_net(z).mul_(127.5).add_(127.5).clamp_( 0.0, 255.0).permute(0, 2, 3, 1).to('cpu', torch.uint8).numpy() for img_idx, img in enumerate(gen_imgs): file_name = os.path.join(fid_buffer_dir, 'iter%d_b%d.png' % (iter_idx, img_idx)) imsave(file_name, img) img_list.extend(list(gen_imgs)) # get inception score logger.info('=> calculate inception score') mean, std = get_inception_score(img_list) # get fid score logger.info('=> calculate fid score') fid_score = calculate_fid_given_paths([fid_buffer_dir, fid_stat], inception_path=None) os.system('rm -r {}'.format(fid_buffer_dir)) writer.add_image('sampled_images', img_grid, global_steps) writer.add_scalar('Inception_score/mean', mean, global_steps) writer.add_scalar('Inception_score/std', std, global_steps) writer.add_scalar('FID_score', fid_score, global_steps) writer_dict['valid_global_steps'] = global_steps + 1 return mean, fid_score
def validate(args, fixed_z, fid_stat, epoch, gen_net: nn.Module, writer_dict, clean_dir=True): writer = writer_dict['writer'] global_steps = writer_dict['valid_global_steps'] # eval mode gen_net = gen_net.eval() # generate images sample_imgs = gen_net(fixed_z, epoch) img_grid = make_grid(sample_imgs, nrow=5, normalize=True, scale_each=True) # get fid and inception score fid_buffer_dir = os.path.join(args.path_helper['sample_path'], 'fid_buffer') os.makedirs(fid_buffer_dir, exist_ok=True) eval_iter = args.num_eval_imgs // args.eval_batch_size img_list = list() for iter_idx in tqdm(range(eval_iter), desc='sample images'): z = torch.cuda.FloatTensor(np.random.normal(0, 1, (args.eval_batch_size, args.latent_dim))) # Generate a batch of images gen_imgs = gen_net(z, epoch).mul_(127.5).add_(127.5).clamp_(0.0, 255.0).permute(0, 2, 3, 1).to('cpu', torch.uint8).numpy() for img_idx, img in enumerate(gen_imgs): file_name = os.path.join(fid_buffer_dir, f'iter{iter_idx}_b{img_idx}.png') imsave(file_name, img) img_list.extend(list(gen_imgs)) # get inception score logger.info('=> calculate inception score') mean, std = get_inception_score(img_list) print(f"Inception score: {mean}") # get fid score logger.info('=> calculate fid score') fid_score = calculate_fid_given_paths([fid_buffer_dir, fid_stat], inception_path=None) print(f"FID score: {fid_score}") if clean_dir: os.system('rm -r {}'.format(fid_buffer_dir)) else: logger.info(f'=> sampled images are saved to {fid_buffer_dir}') # print('first') writer.add_image('sampled_images', img_grid, global_steps) writer.add_scalar('Inception_score/mean', mean, global_steps) writer.add_scalar('Inception_score/std', std, global_steps) writer.add_scalar('FID_score', fid_score, global_steps) # print('second') writer_dict['valid_global_steps'] = global_steps + 1 # print('third') return mean, fid_score
def fid_is_eval(): pathes = os.listdir("results_pure_noise/generated/") finished = [] tmp_path = [] for path in pathes: if path not in finished: tmp_path.append(path) pathes = tmp_path for path in pathes: fp = open("FID_IS_result.txt", 'a') info = path.split('_') dataset = info[0] model_name = path if dataset == "cifar10": data = np.load('results_pure_noise/generated/{}'.format(path)) mb_size, X_dim, width, height, channels, len_x_train, x_train, y_train, len_x_test, x_test, y_test = data_loader( dataset) real_set = x_train img_set = data['x'] print("Calculating Fréchet Inception Distance for {}".format( model_name)) print("Calculating Fréchet Inception Distance for {}".format( model_name), file=fp) fid_set_r = real_set * 255.0 fid_set_r = fid_set_r.astype(np.uint8) fid_set_r = np.transpose(fid_set_r, (0, 3, 1, 2)) fid_set_i = img_set * 255.0 fid_set_i = fid_set_i.astype(np.uint8) fid_set_i = np.transpose(fid_set_i, (0, 3, 1, 2)) #fid_set_i = fid_set_i[:256] #fid_set_r = fid_set_r[:256] fid_score = get_fid(fid_set_r, fid_set_i) print("FID: {}".format(fid_score)) print("FID: {}".format(fid_score), file=fp) tf.reset_default_graph() fp.close() fp = open("FID_IS_result.txt", 'a') print("Calculating inception score for {}".format(model_name)) print("Calculating inception score for {}".format(model_name), file=fp) is_set = img_set * 2.0 - 1.0 is_set = np.transpose(is_set, (0, 3, 1, 2)) #is_set = is_set[:256] mean, std = get_inception_score(is_set) print("mean: {} std: {}".format(mean, std)) print("mean: {} std: {}".format(mean, std), file=fp) tf.reset_default_graph() fp.close()
def get_is(args, gen_net: nn.Module, num_img, z_numpy=None, get_is_score=True): """ Get inception score. :param args: :param gen_net: :param num_img: :return: Inception score """ # eval mode gen_net = gen_net.eval() eval_iter = num_img // args.eval_batch_size img_list = list() state_list = list() for i in range(eval_iter): # We use a fixed set of random seeds for the reward and progressive states in the search stage to stabalize the training np.random.seed(i) z = torch.cuda.FloatTensor( np.random.normal(0, 1, (args.eval_batch_size, args.latent_dim))) # Generate a batch of images gen_imgs, gen_states = gen_net(z, eval=True) gen_imgs2 = gen_imgs.mul_(127.5).add_(127.5).clamp_(0.0, 255.0).permute( 0, 2, 3, 1) img_list.extend(list(gen_imgs2.to('cpu', torch.uint8).numpy())) state_list.extend(list(gen_states.to('cpu').numpy())) state = list(np.mean(state_list, axis=0).flatten()) if not get_is_score: return state # get inception score logger.info('calculate Inception score...') mean, std = get_inception_score(img_list) logger.info('=> calculate fid score') fid_buffer_dir = os.path.join(args.path_helper['sample_path'], 'fid_buffer') os.system('rm -rf {}'.format(fid_buffer_dir)) os.makedirs(fid_buffer_dir, exist_ok=True) for img_idx, img in enumerate(img_list): if img_idx < 5000: file_name = os.path.join(fid_buffer_dir, f'iter0_b{img_idx}.png') imsave(file_name, img) fid_stat = 'fid_stat/fid_stats_cifar10_train.npz' assert os.path.exists(fid_stat) fid_score = calculate_fid_given_paths([fid_buffer_dir, fid_stat], inception_path=None) return mean, fid_score, state
def get_inception_score(self, num_batches, splits=None): all_samples = [] config = self.config if not splits: splits = config.inps_splits batch_size = 100 dim_z = config.dim_z for i in range(num_batches): z = np.random.normal(size=[batch_size, dim_z]).astype(np.float32) feed_dict = {self.noise: z, self.is_training: False} samples = self.sess.run(self.fake_data, feed_dict=feed_dict) all_samples.append(samples) all_samples = np.concatenate(all_samples, axis=0) all_samples = ((all_samples + 1.) * 255. / 2.).astype(np.int32) all_samples = all_samples.reshape((-1, 32, 32, 3)) return inception_score.get_inception_score(list(all_samples), splits=splits)
def validate(args, fixed_z, gen_net: nn.Module, writer_dict): dataset = datasets.ImageDataset(args) train_loader = dataset.train gen_net = gen_net.eval() global_steps = writer_dict['valid_global_steps'] eval_iter = args.num_eval_imgs // args.eval_batch_size fid_buffer_dir = os.path.join(args.path_helper['sample_path'], 'fid_buffer') os.makedirs(fid_buffer_dir) img_list = list() for iter_idx in tqdm(range(eval_iter), desc='sample images'): z = torch.cuda.FloatTensor( np.random.normal(0, 1, (args.eval_batch_size, args.latent_dim))) # Generate a batch of images gen_imgs = gen_net(z).mul_(127.5).add_(127.5).clamp_( 0.0, 255.0).permute(0, 2, 3, 1).to('cpu', torch.uint8).numpy() for img_idx, img in enumerate(gen_imgs): file_name = os.path.join(fid_buffer_dir, f'iter{iter_idx}_b{img_idx}.png') imsave(file_name, img) img_list.extend(list(gen_imgs)) # compute IS inception_score, std = get_inception_score(img_list) print('------------------------ Inception Score ------------------------') print(inception_score) print('------------------------ FID pytorch ------------------------') print(fid_score) # Generate a batch of images sample_dir = os.path.join(args.path_helper['sample_path'], 'sample_dir') Path(sample_dir).mkdir(exist_ok=True) sample_imgs = gen_net(fixed_z).mul_(127.5).add_(127.5).clamp_(0.0, 255.0) img_grid = make_grid(sample_imgs, nrow=5).to('cpu', torch.uint8).numpy() file_name = os.path.join( sample_dir, f'final_fid_{fid}_inception_score{inception_score}.png') imsave(file_name, img_grid.swapaxes(0, 1).swapaxes(1, 2)) writer_dict['valid_global_steps'] = global_steps + 1 return inception_score, fid
def calculate_metrics(fid_buffer_dir, num_eval_imgs, eval_batch_size, latent_dim, fid_stat, G, do_IS=False, do_FID=True): # eval mode G = G.eval() # get fid and inception score if do_IS and do_FID: if not os.path.isdir(fid_buffer_dir): os.mkdir(fid_buffer_dir) eval_iter = num_eval_imgs // eval_batch_size img_list = list() for iter_idx in range(eval_iter): z = torch.cuda.FloatTensor(np.random.normal(0, 1, (eval_batch_size, latent_dim))) # Generate a batch of images gen_imgs = G(z).mul_(127.5).add_(127.5).clamp_(0.0, 255.0).permute(0, 2, 3, 1).to('cpu', torch.uint8).numpy() for img_idx, img in enumerate(gen_imgs): file_name = os.path.join(fid_buffer_dir, 'iter%d_b%d.png' % (iter_idx, img_idx)) imsave(file_name, img) img_list.extend(list(gen_imgs)) # get inception score if do_IS: print('=> calculate inception score') mean, std = get_inception_score(img_list) else: mean, std = 0, 0 # get fid score if do_FID: print('=> calculate fid score') fid_score = calculate_fid_given_paths([fid_buffer_dir, fid_stat], inception_path=None) else: fid_score = 0 if do_IS and do_FID: os.system('rm -r {}'.format(fid_buffer_dir)) return mean, fid_score
def evaluate(args, fixed_z, fid_stat, gen_net: nn.Module): # eval mode gen_net = gen_net.eval() # generate images sample_imgs = gen_net(fixed_z) img_grid = make_grid(sample_imgs, nrow=5, normalize=True, scale_each=True) # get fid and inception score fid_buffer_dir = 'fid_buffer_test' if not os.path.exists(fid_buffer_dir): os.makedirs(fid_buffer_dir) eval_iter = args.num_eval_imgs // args.eval_batch_size img_list = list() for iter_idx in tqdm(range(eval_iter), desc='sample images'): z = torch.cuda.FloatTensor( np.random.normal(0, 1, (args.eval_batch_size, args.latent_dim))) # Generate a batch of images gen_imgs = gen_net(z).mul_(127.5).add_(127.5).clamp_( 0.0, 255.0).permute(0, 2, 3, 1).to('cpu', torch.uint8).numpy() for img_idx, img in enumerate(gen_imgs): file_name = os.path.join(fid_buffer_dir, 'iter%d_b%d.png' % (iter_idx, img_idx)) imsave(file_name, img) img_list.extend(list(gen_imgs)) # get inception score print('=> calculate inception score') mean, std = get_inception_score(img_list) # get fid score print('=> calculate fid score') fid_score = calculate_fid_given_paths([fid_buffer_dir, fid_stat], inception_path=None) os.system('rm -r {}'.format(fid_buffer_dir)) return mean, fid_score
def validate(args, fixed_z, fid_stat, gen_net: nn.Module, writer_dict): dataset = datasets.ImageDataset(args) train_loader = dataset.train gen_net = gen_net.eval() global_steps = writer_dict['valid_global_steps'] eval_iter = args.num_eval_imgs // args.eval_batch_size # compute IS IS_buffer_dir = os.path.join(args.path_helper['sample_path'], 'fid_buffer') os.makedirs(IS_buffer_dir) img_list = list() for iter_idx in tqdm(range(eval_iter), desc='sample images'): z = torch.cuda.FloatTensor( np.random.normal(0, 1, (args.eval_batch_size, args.latent_dim))) # Generate a batch of images gen_imgs = gen_net(z).mul_(127.5).add_(127.5).clamp_( 0.0, 255.0).permute(0, 2, 3, 1).to('cpu', torch.uint8).numpy() for img_idx, img in enumerate(gen_imgs): file_name = os.path.join(IS_buffer_dir, f'iter{iter_idx}_b{img_idx}.png') imsave(file_name, img) img_list.extend(list(gen_imgs)) inception_score, std = get_inception_score(img_list) print('------------------------Inception Score------------------------') print(inception_score) # compute FID sample_list = [] for i in range(eval_iter): z = torch.cuda.FloatTensor( np.random.normal(0, 1, (args.eval_batch_size, args.latent_dim))) samples = gen_net(z) sample_list.append(samples.data.cpu().numpy()) new_sample_list = list(chain.from_iterable(sample_list)) fake_image_np = np.concatenate([img[None] for img in new_sample_list], 0) real_image_np = [] for i, (images, _) in enumerate(train_loader): real_image_np += [images.data.numpy()] batch_size = real_image_np[0].shape[0] if len(real_image_np) * batch_size >= fake_image_np.shape[0]: break real_image_np = np.concatenate(real_image_np, 0)[:fake_image_np.shape[0]] fid_score = calculate_fid(real_image_np, fake_image_np, batch_size=300) var_fid = fid_score[0][2] fid = round(fid_score[0][1], 3) print('------------------------fid_score------------------------') print(fid_score) # Generate a batch of images sample_dir = os.path.join(args.path_helper['sample_path'], 'sample_dir') Path(sample_dir).mkdir(exist_ok=True) sample_imgs = gen_net(fixed_z).mul_(127.5).add_(127.5).clamp_(0.0, 255.0) img_grid = make_grid(sample_imgs, nrow=5).to('cpu', torch.uint8).numpy() file_name = os.path.join( sample_dir, f'final_fid_{fid}_inception_score{inception_score}.png') imsave(file_name, img_grid.swapaxes(0, 1).swapaxes(1, 2)) writer_dict['valid_global_steps'] = global_steps + 1 return inception_score, fid
def train(self, train_loader): self.t_begin = t.time() generator_iter = 0 self.file = open("inception_score_graph.txt", "w") dis_params_flatten = parameters_to_vector(self.D.parameters()) gen_params_flatten = parameters_to_vector(self.G.parameters()) # just to fill the empty grad buffers if self.cuda: z = Variable(torch.randn(self.batch_size, 100, 1, 1)).cuda(self.cuda_index) else: z = Variable(torch.randn(self.batch_size, 100, 1, 1)) fake_images = self.G(z) outputs = self.D(fake_images) fake_labels = torch.zeros(self.batch_size) fake_labels = Variable(fake_labels).cuda(self.cuda_index) d_loss_fake = self.loss(outputs.squeeze(), fake_labels) (0.0 * d_loss_fake).backward(create_graph=True) d_loss_fake = 0.0 best_inception_score = 0.0 d_loss_list = [] g_loss_list = [] for epoch in range(self.epochs): self.epoch_start_time = t.time() for i, (images, _) in enumerate(train_loader): # Check if round number of batches if i == train_loader.dataset.__len__() // self.batch_size: break z = torch.rand((self.batch_size, 100, 1, 1)) real_labels = torch.ones(self.batch_size) fake_labels = torch.zeros(self.batch_size) if self.cuda: images, z = Variable(images).cuda( self.cuda_index), Variable(z).cuda(self.cuda_index) real_labels, fake_labels = Variable(real_labels).cuda( self.cuda_index), Variable(fake_labels).cuda( self.cuda_index) else: images, z = Variable(images), Variable(z) real_labels, fake_labels = Variable(real_labels), Variable( fake_labels) # Train discriminator # Compute BCE_Loss using real images outputs = self.D(images) d_loss_real = self.loss(outputs.squeeze(), real_labels) real_score = outputs # Compute BCE Loss using fake images if self.cuda: z = Variable(torch.randn(self.batch_size, 100, 1, 1)).cuda(self.cuda_index) else: z = Variable(torch.randn(self.batch_size, 100, 1, 1)) fake_images = self.G(z) outputs = self.D(fake_images) d_loss_fake = self.loss(outputs.squeeze(), fake_labels) fake_score = outputs # Optimize discriminator d_loss = d_loss_real + d_loss_fake if self.mode == 'adam': self.D.zero_grad() d_loss.backward() self.d_optimizer.step() elif self.mode == 'adam_vjp': gradsD = torch.autograd.grad(outputs=d_loss, inputs=(self.D.parameters()), create_graph=True) for p, g in zip(self.D.parameters(), gradsD): p.grad = g gen_params_flatten_prev = gen_params_flatten + 0.0 gen_params_flatten = parameters_to_vector( self.G.parameters()) + 0.0 grad_gen_params_flatten = optim.parameters_grad_to_vector( self.G.parameters()) delta_gen_params_flatten = gen_params_flatten - gen_params_flatten_prev vjp_dis = torch.autograd.grad( grad_gen_params_flatten, self.D.parameters(), grad_outputs=delta_gen_params_flatten) self.d_optimizer.step(vjps=vjp_dis) # Train generator # Compute loss with fake images if self.cuda: z = Variable(torch.randn(self.batch_size, 100, 1, 1)).cuda(self.cuda_index) else: z = Variable(torch.randn(self.batch_size, 100, 1, 1)) fake_images = self.G(z) outputs = self.D(fake_images) # non-zero_sum g_loss = self.loss(outputs.squeeze(), real_labels) # zer_sum: # g_loss = - self.loss(outputs.squeeze(), fake_labels) # Optimize generator if self.mode == 'adam': self.D.zero_grad() self.G.zero_grad() g_loss.backward() self.g_optimizer.step() elif self.mode == 'adam_vjp': gradsG = torch.autograd.grad(outputs=g_loss, inputs=(self.G.parameters()), create_graph=True) for p, g in zip(self.G.parameters(), gradsG): p.grad = g dis_params_flatten_prev = dis_params_flatten + 0.0 dis_params_flatten = parameters_to_vector( self.D.parameters()) + 0.0 grad_dis_params_flatten = optim.parameters_grad_to_vector( self.D.parameters()) delta_dis_params_flatten = dis_params_flatten - dis_params_flatten_prev vjp_gen = torch.autograd.grad( grad_dis_params_flatten, self.G.parameters(), grad_outputs=delta_dis_params_flatten) self.g_optimizer.step(vjps=vjp_gen) generator_iter += 1 if generator_iter % 1000 == 0: # Workaround because graphic card memory can't store more than 800+ examples in memory for generating image # Therefore doing loop and generating 800 examples and stacking into list of samples to get 8000 generated images # This way Inception score is more correct since there are different generated examples from every class of Inception model sample_list = [] for i in range(10): z = Variable(torch.randn(800, 100, 1, 1)).cuda(self.cuda_index) samples = self.G(z) sample_list.append(samples.data.cpu().numpy()) # Flattening list of lists into one list of numpy arrays new_sample_list = list(chain.from_iterable(sample_list)) print( "Calculating Inception Score over 8k generated images") # Feeding list of numpy arrays inception_score = get_inception_score(new_sample_list, cuda=True, batch_size=32, resize=True, splits=10) print('Epoch-{}'.format(epoch + 1)) print(inception_score) if inception_score >= best_inception_score: best_inception_score = inception_score self.save_model() # Denormalize images and save them in grid 8x8 z = Variable(torch.randn(800, 100, 1, 1)).cuda(self.cuda_index) samples = self.G(z) samples = samples.mul(0.5).add(0.5) samples = samples.data.cpu()[:64] grid = utils.make_grid(samples) utils.save_image( grid, self.name + '/iter_{}_inception_{}_.png'.format( str(generator_iter).zfill(3), str(inception_score))) time = t.time() - self.t_begin print("Inception score: {}".format(inception_score)) print("Generator iter: {}".format(generator_iter)) print("Time {}".format(time)) # Write to file inception_score, gen_iters, time output = str(generator_iter) + " " + str(time) + " " + str( inception_score[0]) + "\n" self.file.write(output) if ((i + 1) % 100) == 0: d_loss_list += [d_loss.item()] g_loss_list += [g_loss.item()] print("Epoch: [%2d] [%4d/%4d] D_loss: %.8f, G_loss: %.8f" % ((epoch + 1), (i + 1), train_loader.dataset.__len__() // self.batch_size, d_loss.item(), g_loss.item())) z = Variable( torch.randn(self.batch_size, 100, 1, 1).cuda(self.cuda_index)) # TensorBoard logging # Log the scalar values info = {'d_loss': d_loss.item(), 'g_loss': g_loss.item()} for tag, value in info.items(): self.logger.scalar_summary(tag, value, generator_iter) # Log values and gradients of the parameters for tag, value in self.D.named_parameters(): tag = tag.replace('.', '/') self.logger.histo_summary(tag, self.to_np(value), generator_iter) self.logger.histo_summary(tag + '/grad', self.to_np(value.grad), generator_iter) # Log the images while training info = { 'real_images': self.real_images(images, self.number_of_images), 'generated_images': self.generate_img(z, self.number_of_images) } for tag, images in info.items(): self.logger.image_summary(tag, images, generator_iter) self.t_end = t.time() print('Time of training-{}'.format((self.t_end - self.t_begin))) # Save the trained parameters self.save_final_model() np.save(self.name + '/d_loss', np.array(d_loss_list)) np.save(self.name + '/g_loss', np.array(g_loss_list)) self.evaluate(train_loader, self.name + '/discriminator.pkl', self.name + '/generator.pkl')