def genimg(model): # parameters -------------------------------- ext = 'jpg' num_image_tiles = 5 num_rows = num_image_tiles latent_dim = model.G.latent_dim image_size = model.G.image_size num_layers = model.G.num_layers batch_size = 3 av = None num = 'gen' # noise------------------------------------------- noise_ = custom_image_nosie(num_rows**2, 100) n = latent_to_nosie(model.N, noise_) # mixing regularities-------------------------------------------- nn = noise(num_rows, latent_dim) tmp1 = tile(nn, 0, num_rows) tmp2 = nn.repeat(num_rows, 1) tt = int(num_layers / 2) mixed_latents = [(tmp1, tt), (tmp2, num_layers - tt)] # generated_images-------------------------------------------- generated_images = generate_truncated(model.SE, model.GE, mixed_latents, n, av, batch_size) torchvision.utils.save_image(generated_images, str(Path(save_dir_path) / f'{str(num)}-mr.{ext}'), nrow=5) # moving averages------------------------------------------- latents = noise_list(num_rows**2, num_layers, latent_dim) generated_images = generate_truncated(model.S, model.G, latents, n, av, batch_size) torchvision.utils.save_image(generated_images[10:15], str(Path(save_dir_path) / f'{str(num)}-dcgan.{ext}'), nrow=num_rows) # diff noise============================================================================================ # mixing regularities-------------------------------------------- nn = nn[0].repeat(num_rows, 1) tmp1 = tile(nn, 0, num_rows) tmp2 = nn.repeat(num_rows, 1) tt = int(num_layers / 2) mixed_latents_d = [(tmp1, tt), (tmp2, num_layers - tt)] # generated_images-------------------------------------------- generated_images = generate_truncated(model.SE, model.GE, mixed_latents_d, n, av, batch_size) torchvision.utils.save_image(generated_images[0:5], str(Path(save_dir_path) / f'{str(num)}-dn.{ext}'), nrow=5) # diff w============================================================================================ # noise------------------------------------------- noise_ = custom_image_nosie(1, 100) noise_ = noise_.repeat(num_rows**2, 1) ndn = latent_to_nosie(model.N, noise_) # mixing regularities-------------------------------------------- for _ in range(3): nn = torch.randn(num_rows, latent_dim).to(device) tmp1 = tile(nn, 0, num_rows) tmp2 = nn.repeat(num_rows, 1) tt = 0 mixed_latents = [(tmp1, tt), (tmp2, num_layers - tt)] # generated_images-------------------------------------------- generated_images = generate_truncated(model.SE, model.GE, mixed_latents, ndn, av, batch_size) torchvision.utils.save_image(generated_images[0:5], str(Path(save_dir_path) / f'{str(num)}-dw.{ext}'), nrow=5)
def genimg(model, save_dir_path): # parameters -------------------------------- ext = 'jpg' num_image_tiles = 5 num_rows = num_image_tiles latent_dim = model.G.latent_dim image_size = model.G.image_size num_layers = model.G.num_layers batch_size = 3 av = None num = 'gen' # Logger instance-------------------------------------------- fo = open(f"{save_dir_path}/foo.txt", "w") # noise------------------------------------------- noise_ = custom_image_nosie(num_rows**2, 100) n = latent_to_nosie(model.N, noise_) # mixing regularities-------------------------------------------- nn = noise(num_rows, latent_dim) tmp1 = tile(nn, 0, num_rows) tmp2 = nn.repeat(num_rows, 1) tt = int(num_layers / 2) mixed_latents = [(tmp1, tt), (tmp2, num_layers - tt)] # generated_images-------------------------------------------- generated_images = generate_truncated(model.SE, model.GE, mixed_latents, n, av, batch_size) fo.write(str(noise_.numpy()[0])) torchvision.utils.save_image( generated_images, str(Path(save_dir_path) / f'{str(num)}-mr.{ext}'), nrow=5)
def evaluate(self, num=0, num_image_tiles=8): self.GAN.eval() ext = "jpg" if not self.transparent else "png" num_rows = num_image_tiles latent_dim = self.GAN.G.latent_dim image_size = self.GAN.G.image_size num_layers = self.GAN.G.num_layers # latents and noise latents = noise_list(num_rows**2, num_layers, latent_dim) n = image_noise(num_rows**2, image_size) # regular generated_images = self.generate_truncated(self.GAN.S, self.GAN.G, latents, n, trunc_psi=self.trunc_psi) grid = torchvision.utils.make_grid(generated_images, nrow=num_rows) wandb.log( {"Generated Images": [wandb.Image(grid, caption=f"Step {num}")]}) # moving averages generated_images = self.generate_truncated(self.GAN.SE, self.GAN.GE, latents, n, trunc_psi=self.trunc_psi) grid = torchvision.utils.make_grid(generated_images, nrow=num_rows) wandb.log({ "Generated Images EMA": [wandb.Image(grid, caption=f"Step {num}")] }) # mixing regularities def tile(a, dim, n_tile): init_dim = a.size(dim) repeat_idx = [1] * a.dim() repeat_idx[dim] = n_tile a = a.repeat(*(repeat_idx)) order_index = torch.LongTensor( np.concatenate([ init_dim * np.arange(n_tile) + i for i in range(init_dim) ])).cuda() return torch.index_select(a, dim, order_index) nn = noise(num_rows, latent_dim) tmp1 = tile(nn, 0, num_rows) tmp2 = nn.repeat(num_rows, 1) tt = int(num_layers / 2) mixed_latents = [(tmp1, tt), (tmp2, num_layers - tt)] generated_images = self.generate_truncated(self.GAN.SE, self.GAN.GE, mixed_latents, n, trunc_psi=self.trunc_psi) grid = torchvision.utils.make_grid(generated_images, nrow=num_rows) wandb.log({"Style Mixing": [wandb.Image(grid, caption=f"Step {num}")]})
def evaluate(self, num = 0, num_image_tiles = 8, trunc = 1.0): self.GAN.eval() ext = 'jpg' if not self.transparent else 'png' num_rows = num_image_tiles def generate_images(stylizer, generator, latents, noise): w = latent_to_w(stylizer, latents) w_styles = styles_def_to_tensor(w) generated_images = evaluate_in_chunks(self.batch_size, generator, w_styles, noise) generated_images.clamp_(0., 1.) return generated_images latent_dim = self.GAN.G.latent_dim image_size = self.GAN.G.image_size num_layers = self.GAN.G.num_layers # latents and noise latents = noise_list(num_rows ** 2, num_layers, latent_dim) n = image_noise(num_rows ** 2, image_size) # regular generated_images = self.generate_truncated(self.GAN.S, self.GAN.G, latents, n, trunc_psi = self.trunc_psi) torchvision.utils.save_image(generated_images, str(self.results_dir / self.name / f'{str(num)}.{ext}'), nrow=num_rows) # moving averages generated_images = self.generate_truncated(self.GAN.SE, self.GAN.GE, latents, n, trunc_psi = self.trunc_psi) torchvision.utils.save_image(generated_images, str(self.results_dir / self.name / f'{str(num)}-ema.{ext}'), nrow=num_rows) # mixing regularities def tile(a, dim, n_tile): init_dim = a.size(dim) repeat_idx = [1] * a.dim() repeat_idx[dim] = n_tile a = a.repeat(*(repeat_idx)) order_index = torch.LongTensor(np.concatenate([init_dim * np.arange(n_tile) + i for i in range(init_dim)])).cuda() return torch.index_select(a, dim, order_index) nn = noise(num_rows, latent_dim) tmp1 = tile(nn, 0, num_rows) tmp2 = nn.repeat(num_rows, 1) tt = int(num_layers / 2) mixed_latents = [(tmp1, tt), (tmp2, num_layers - tt)] generated_images = self.generate_truncated(self.GAN.SE, self.GAN.GE, mixed_latents, n, trunc_psi = self.trunc_psi) torchvision.utils.save_image(generated_images, str(self.results_dir / self.name / f'{str(num)}-mr.{ext}'), nrow=num_rows)
def evaluate(self, num = 0, trunc = 1.0): self.GAN.eval() ext = self.image_extension num_rows = self.num_image_tiles latent_dim = self.GAN.G.latent_dim image_size = self.GAN.G.image_size num_layers = self.GAN.G.num_layers # latents and noise latents = noise_list(num_rows ** 2, num_layers, latent_dim, device=self.rank) n = image_noise(num_rows ** 2, image_size, device=self.rank) # regular generated_images = self.generate_truncated(self.GAN.S, self.GAN.G, latents, n, trunc_psi = self.trunc_psi) torchvision.utils.save_image(generated_images, str(self.results_dir / self.name / f'{str(num)}.{ext}'), nrow=num_rows) if self.plotting: self.image_plotter.plot(vutils.make_grid(generated_images, padding=2, normalize=True),name="generator-S-output") # moving averages generated_images = self.generate_truncated(self.GAN.SE, self.GAN.GE, latents, n, trunc_psi = self.trunc_psi) torchvision.utils.save_image(generated_images, str(self.results_dir / self.name / f'{str(num)}-ema.{ext}'), nrow=num_rows) if self.plotting: self.image_plotter.plot(vutils.make_grid(generated_images, padding=2, normalize=True),name="generator-SE-output") # mixing regularities def tile(a, dim, n_tile): init_dim = a.size(dim) repeat_idx = [1] * a.dim() repeat_idx[dim] = n_tile a = a.repeat(*(repeat_idx)) order_index = torch.LongTensor(np.concatenate([init_dim * np.arange(n_tile) + i for i in range(init_dim)])).cuda(self.rank) return torch.index_select(a, dim, order_index) nn = noise(num_rows, latent_dim, device=self.rank) tmp1 = tile(nn, 0, num_rows) tmp2 = nn.repeat(num_rows, 1) tt = int(num_layers / 2) mixed_latents = [(tmp1, tt), (tmp2, num_layers - tt)] generated_images = self.generate_truncated(self.GAN.SE, self.GAN.GE, mixed_latents, n, trunc_psi = self.trunc_psi) torchvision.utils.save_image(generated_images, str(self.results_dir / self.name / f'{str(num)}-mr.{ext}'), nrow=num_rows)
def test(model, save_dir_path, args, num=0, num_image_tiles=8): model.eval() # parameters -------------------------------- ext = 'jpg' num_rows = num_image_tiles latent_dim = model.G.latent_dim image_size = model.G.image_size num_layers = model.G.num_layers av = None # w---------------------------------------------- latents = noise_list(num_rows**2, num_layers, latent_dim) # noise------------------------------------------- noise_ = custom_image_nosie(num_rows**2, 100) n = latent_to_nosie(model.N, noise_) # regular------------------------------------------- generated_images = generate_images(model.S, model.G, latents, n, args) torchvision.utils.save_image( generated_images, str(Path(save_dir_path) / f'{str(num)}.{ext}'), nrow=num_rows) # moving averages------------------------------------------- generated_images = generate_truncated(model.SE, model.GE, latents, n, av, args) torchvision.utils.save_image( generated_images, str(Path(save_dir_path) / f'{str(num)}-ema.{ext}'), nrow=num_rows) # mixing regularities-------------------------------------------- nn = noise(num_rows, latent_dim) tmp1 = tile(nn, 0, num_rows) tmp2 = nn.repeat(num_rows, 1) tt = int(num_layers / 2) mixed_latents = [(tmp1, tt), (tmp2, num_layers - tt)] generated_images = generate_truncated(model.SE, model.GE, mixed_latents, n, av, args) torchvision.utils.save_image( generated_images, str(Path(save_dir_path) / f'{str(num)}-mr.{ext}'), nrow=num_rows)
def genimg(model): # parameters -------------------------------- ext = 'jpg' num_image_tiles = 5 num_rows = num_image_tiles latent_dim = model.G.latent_dim image_size = model.G.image_size num_layers = model.G.num_layers batch_size = 3 av = None num = 'gen' # noise------------------------------------------- noise_ = custom_image_nosie(num_rows**2, 100) n = latent_to_nosie(model.N, noise_) # diff noise============================================================================================ # mixing regularities-------------------------------------------- nn = noise(num_rows, latent_dim) nn = nn[0].repeat(num_rows, 1) tmp1 = tile(nn, 0, num_rows) tmp2 = nn.repeat(num_rows, 1) tt = int(num_layers / 2) mixed_latents_d = [(tmp1, tt), (tmp2, num_layers - tt)] # generated_images-------------------------------------------- generated_images = generate_truncated(model.SE, model.GE, mixed_latents_d, n, av, batch_size) torchvision.utils.save_image( generated_images[0:5], str(Path(save_dir_path) / f'{str(num)}-check.{ext}'), nrow=5) for i in range(5): diff = (generated_images[i] - generated_images[0]) * 50 torchvision.utils.save_image( diff, str(Path(save_dir_path) / f'{str(num)}-check{i}.{ext}'), nrow=5)