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)
