def setup_latents(self, dim_noise): self.origin = np.random.randn(1, dim_noise).astype('float32') self.noise_vars = [ var for name, var in self.Gs.components.synthesis.vars.items() if name.startswith('noise') ] self.noise_values = [ np.random.randn(*var.shape.as_list()).astype('float32') for var in self.noise_vars ] self.noise_values2 = [ np.random.randn(*var.shape.as_list()).astype('float32') for var in self.noise_vars ] tflib.set_vars({ var: self.noise_values[idx] for idx, var in enumerate(self.noise_vars) }) self.latents = np.random.randn(1, dim_noise).astype('float32') self.dlatents = self.Gs.components.mapping.run(self.latents, None) self.chroma = random_orthonormal(12, dim_noise) self.rotation = random_rotation() self.rotation = fractional_rotation(self.rotation, 1 / 4) self.mfcc_buffer = np.zeros((64, 64), dtype='float32')
def generate_images(network_pkl, seeds, truncation_psi): print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) noise_vars = [var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise')] Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False if truncation_psi is not None: Gs_kwargs.truncation_psi = truncation_psi L = [] for seed_idx, seed in enumerate(seeds): rnd = np.random.RandomState(seed) z = rnd.randn(1, *Gs.input_shape[1:]) # [minibatch, component] vars = {var: rnd.randn(*var.shape.as_list()) for var in noise_vars} L.append((seed, z, vars)) L0 = L[0] L = L[1:] for i in range (200): random.shuffle(L) #L0, L1 = L[0], L[1] L1 = L[0] r = random.random() z = r*L0[1] + (1-r)*L1[1] vars = { var : r*L0[2][var] + (1-r)*L1[2][var] for var in noise_vars } tflib.set_vars(vars) # [height, width] images = Gs.run(z, None, **Gs_kwargs) # [minibatch, height, width, channel] path = 'seed{:010d}-{:010d}-{:03d}.png'.format(L0[0], L1[0], int(r*1000)) print(path) PIL.Image.fromarray(images[0], 'RGB').save(dnnlib.make_run_dir_path(path))
def generate_images(network_pkl, num, truncation_psi=0.5): print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) noise_vars = [ var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise') ] Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False if truncation_psi is not None: Gs_kwargs.truncation_psi = truncation_psi for i in range(num): print('Generating image %d/%d ...' % (i, num)) # Generate random latent z = np.random.randn(1, *Gs.input_shape[1:]) # [minibatch, component] # Save latent txt_filename = 'results/generate_codes/' + str(i).zfill(4) + '.txt' with open(txt_filename, 'w') as f: text_save(f, z) # Generate image tflib.set_vars( {var: np.random.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] images = Gs.run(z, None, **Gs_kwargs) # [minibatch, height, width, channel] # Save image PIL.Image.fromarray(images[0], 'RGB').save( dnnlib.make_run_dir_path('results/' + str(i) + '.png'))
def draw_noise_components_figure(png, Gs, w, h, seeds, noise_ranges, flips): print(png) Gsc = Gs.clone() noise_vars = [ var for name, var in Gsc.components.synthesis.vars.items() if name.startswith('noise') ] noise_pairs = list(zip(noise_vars, tflib.run(noise_vars))) # [(var, val), ...] latents = np.stack( np.random.RandomState(seed).randn(Gs.input_shape[1]) for seed in seeds) all_images = [] for noise_range in noise_ranges: tflib.set_vars({ var: val * (1 if i in noise_range else 0) for i, (var, val) in enumerate(noise_pairs) }) range_images = Gsc.run(latents, None, truncation_psi=1, randomize_noise=False, **synthesis_kwargs) range_images[flips, :, :] = range_images[flips, :, ::-1] all_images.append(list(range_images)) canvas = PIL.Image.new('RGB', (w * 2, h * len(seeds)), 'white') for col, col_images in enumerate(zip(*all_images)): canvas.paste(PIL.Image.fromarray(col_images[0], 'RGB'), (0, col * h)) canvas.paste(PIL.Image.fromarray(col_images[1], 'RGB'), (w, col * h)) # canvas.paste(PIL.Image.fromarray(col_images[1], 'RGB'), (col * w + w//2, 0)) #canvas.paste(PIL.Image.fromarray(col_images[2], 'RGB').crop((0, 0, w//2, h)), (col * w, h)) #canvas.paste(PIL.Image.fromarray(col_images[3], 'RGB').crop((w//2, 0, w, h)), (col * w + w//2, h)) canvas.save(png)
def vary_seeds(network_pkl, seeds, psi0, psi1, save_noise, q, count): print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) #noise_vars = [var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise')] noise_vars_dict = {name:var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise')} Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False #if truncation_psi is not None: # Gs_kwargs.truncation_psi = truncation_psi for seed_idx, seed in enumerate(seeds): print('Generating image for seed %d (%d/%d) ...' % (seed, seed_idx, len(seeds))) rnd = np.random.RandomState(seed) z = rnd.randn(1, *Gs.input_shape[1:]) # [minibatch, component] z2 = z noise_seed = rnd.randint(0,1000000) rnd_noise = np.random.RandomState(noise_seed) vars = {var: rnd_noise.randn(*var.shape.as_list()) for name, var in noise_vars_dict.items()} truncation_psi = psi0 + (psi1-psi0)*np.random.random() Gs_kwargs.truncation_psi = truncation_psi for i in range (count): tflib.set_vars(vars) # [height, width] images = Gs.run(z2, None, **Gs_kwargs) # [minibatch, height, width, channel] im = PIL.Image.fromarray(images[0], 'RGB') #.save(dnnlib.make_run_dir_path('varysingle_%04d.png' % i)) fn = 'vary_seed_%08d.jpg'%seed metadata = {'z':z2, 'truncation_psi':truncation_psi} if save_noise: metadata_noise_vars = { name : vars[var] for name, var in noise_vars_dict.items()} metadata['noise_vars'] = metadata_noise_vars else: metadata['noise_seed'] = noise_seed save_with_metadata(im, fn, metadata, True) z2 = (z + np.random.randn(*z.shape)/q) / (1 + 1/(q*q))
def configure(self, minibatch_size, lod=0): lod = int(np.floor(lod)) assert minibatch_size >= 1 and 0 <= lod <= self.resolution_log2 tflib.set_vars({ self._tf_minibatch_var: minibatch_size, self._tf_lod_var: lod })
def read_face_latent(): tflib.init_tf() with open('networks/stylegan2-ffhq-config-f.pkl', "rb") as f: generator_network, discriminator_network, Gs_network = pickle.load(f) w_avg = Gs_network.get_var('dlatent_avg') noise_vars = [ var for name, var in Gs_network.components.synthesis.vars.items() if name.startswith('noise') ] Gs_syn_kwargs = dnnlib.EasyDict() Gs_syn_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_syn_kwargs.randomize_noise = False Gs_syn_kwargs.minibatch_size = 1 truncation_psi = 0.5 face_latent = read_feature('results/generate_codes/0000.txt') z = np.stack(face_latent for _ in range(1)) tflib.set_vars( {var: np.random.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] w = Gs_network.components.mapping.run(z, None) w = w_avg + (w - w_avg) * truncation_psi return w, Gs_network, Gs_syn_kwargs
def project_generated_images(network_pkl, seeds, num_snapshots, num_steps, truncation_psi, save_target_dlatent, save_every_dlatent, save_final_dlatent): assert num_snapshots <= num_steps, "Can't have more snapshots than number of steps taken!" print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) proj = projector.Projector(num_steps=num_steps) proj.set_network(Gs) noise_vars = [ var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise') ] Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.randomize_noise = False Gs_kwargs.truncation_psi = truncation_psi for seed_idx, seed in enumerate(seeds): print('Projecting seed %d (%d/%d) ...' % (seed, seed_idx, len(seeds))) rnd = np.random.RandomState(seed) z = rnd.randn(1, *Gs.input_shape[1:]) tflib.set_vars( {var: rnd.randn(*var.shape.as_list()) for var in noise_vars}) w = Gs.components.mapping.run(z, None) if save_target_dlatent: np.save(dnnlib.make_run_dir_path('seed%04d.npy' % seed), w) images = Gs.components.synthesis.run(w, **Gs_kwargs) project_image(proj, targets=images, png_prefix=dnnlib.make_run_dir_path('seed%04d-' % seed), num_snapshots=num_snapshots, save_every_dlatent=save_every_dlatent, save_final_dlatent=save_final_dlatent)
def get_images_from_seeds(self, truncation_psi, seeds): Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False if truncation_psi is not None: Gs_kwargs.truncation_psi = truncation_psi images_list = [] zs = [] for seed_idx, seed in enumerate(seeds): print('Generating image for seed %d (%d/%d) ...' % (seed, seed_idx, len(range(len(seeds))))) rnd = np.random.RandomState(seed) z = rnd.randn(1, *self.Gs.input_shape[1:]) # [minibatch, component] tflib.set_vars({ var: rnd.randn(*var.shape.as_list()) for var in self.noise_vars }) # [height, width] images = self.Gs.run( z, None, **Gs_kwargs) # [minibatch, height, width, channel] images_list.append(Image.fromarray(images[0], 'RGB')) zs.append(z) return images_list, zs
def gen_image_mix(Gs, latents_high, latents_band, latents_low, noise_vectors, noise_vars, fmt, lpf, hpf, bpf, save_path="example.png"): for i in range(len(noise_vars)): tflib.set_vars({noise_vars[i]: noise_vectors[i]}) high_latents = np.stack(latents_high) band_latents = np.stack(latents_band) low_latents = np.stack(latents_low) high_dlatents = Gs.components.mapping.run(high_latents, None) band_dlatents = Gs.components.mapping.run(band_latents, None) low_dlatents = Gs.components.mapping.run(low_latents, None) combined_dlatents = low_dlatents for style in lpf: combined_dlatents[:, style] = low_dlatents[:, style] for style in hpf: combined_dlatents[:, style] = high_dlatents[:, style] for style in bpf: combined_dlatents[:, style] = band_dlatents[:, style] # combined_dlatents = low_dlatents # combined_dlatents[:, 3:6] = high_dlatents[:, 3:6] # combined_dlatents[:, 6:] = band_dlatents[:, 6:] synthesis_kwargs = dict(output_transform=dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True), minibatch_size=8) images = Gs.components.synthesis.run(combined_dlatents, randomize_noise=False, **synthesis_kwargs) PIL.Image.fromarray(images[0], 'RGB').save(save_path)
def generate_images_in_w_space(ws, truncation_psi, outdir, save_npy, prefix, vidname, framerate): Gs_kwargs = { 'output_transform': dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True), 'randomize_noise': False, 'truncation_psi': truncation_psi } for w_idx, w in enumerate(ws): print('Generating image for step %d/%d ...' % (w_idx, len(ws))) noise_rnd = np.random.RandomState(1) # fix noise tflib.set_vars( {var: noise_rnd.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] images = Gs.components.synthesis.run( w, **Gs_kwargs) # [minibatch, height, width, channel] PIL.Image.fromarray(images[0], 'RGB').save(f'{outdir}/{prefix}{w_idx:05d}.png') if save_npy: np.save(dnnlib.make_run_dir_path('%s%05d.npy' % (prefix, w_idx)), w) cmd = "ffmpeg -y -r {} -i {}/{}%05d.png -vcodec libx264 -pix_fmt yuv420p {}/walk-{}-{}fps.mp4".format( framerate, outdir, prefix, outdir, vidname, framerate) subprocess.call(cmd, shell=True)
def random_generate_demo(): tflib.init_tf() with open(model_dir, "rb") as f: generator_network, discriminator_network, Gs_network = pickle.load(f) w_avg = Gs_network.get_var('dlatent_avg') noise_vars = [ var for name, var in Gs_network.components.synthesis.vars.items() if name.startswith('noise') ] Gs_syn_kwargs = dnnlib.EasyDict() Gs_syn_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_syn_kwargs.randomize_noise = False Gs_syn_kwargs.minibatch_size = 1 truncation_psi = 0.5 z = np.random.randn(1, *Gs_network.input_shape[1:]) tflib.set_vars( {var: np.random.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] w = Gs_network.components.mapping.run(z, None) w = w_avg + (w - w_avg) * truncation_psi image = move_latent(w, Gs_network, Gs_syn_kwargs) if save: np.save('./latent_representations/{}'.format(time.ctime()), w[0]) return image
def start(self, target_images): assert self._Gs is not None # Prepare target images. # 准备目标图像(组),即:优化迭代的目标对象 self._info('Preparing target images...') target_images = np.asarray(target_images, dtype='float32') target_images = (target_images + 1) * (255 / 2) sh = target_images.shape assert sh[0] == self._minibatch_size # 如果目标图像尺寸太大,就按照_target_images_var的尺寸缩小到256x256 if sh[2] > self._target_images_var.shape[2]: factor = sh[2] // self._target_images_var.shape[2] target_images = np.reshape( target_images, [-1, sh[1], sh[2] // factor, factor, sh[3] // factor, factor ]).mean((3, 5)) # Initialize optimization state. self._info('Initializing optimization state...') # 设置_target_images_var变量、_dlatents_var变量 # 把_dlatent_avg作为_dlatents_var优化迭代的起点,_target_images_var为优化迭代的目标图像(组) tflib.set_vars({ self._target_images_var: target_images, self._dlatents_var: np.tile(self._dlatent_avg, [self._minibatch_size, 1, 1]) }) # 初始化噪声 tflib.run(self._noise_init_op) # 复位优化器状态 self._opt.reset_optimizer_state() # 迭代计数从0开始 self._cur_step = 0
def get_sample(color=None): # import os # os.environ['CUDA_VISIBLE_DEVICES'] = "3" Gs, Gs_kwargs, noise_vars = load_model() # Gs = current_app.config['GS'] # Gs_kwargs = current_app.config['GS_KWARGS'] # noise_vars = current_app.config['NOISE_VARS'] img_data_list = [] seed_list = [random.randint(1, 100000) for i in range(500)] for i in seed_list: if len(img_data_list) >= 6: break rnd = np.random.RandomState(i) z = rnd.randn(1, *Gs.input_shape[1:]) # [minibatch, component] tflib.set_vars( {var: rnd.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] images = Gs.run(z, None, **Gs_kwargs) # [minibatch, height, width, channel] img = Image.fromarray(images[0], 'RGB') base64_str_data = img_to_base64(img) if color: np_array = np.asarray(img) image_cv2 = cv2.cvtColor(np_array, cv2.COLOR_RGB2BGR) color_tags = majoColor_inrange(image_cv2) if color_tags == color: img_data_list.append(base64_str_data) del np_array, image_cv2 else: img_data_list.append(base64_str_data) del images, img, return img_data_list
def generate_images(network_pkl, seeds, truncation_psi, outdir, class_idx, dlatents_npz, prefix): tflib.init_tf() print('Loading networks from "%s"...' % network_pkl) with dnnlib.util.open_url(network_pkl) as fp: _G, _D, Gs = pickle.load(fp) os.makedirs(outdir, exist_ok=True) # Render images for a given dlatent vector. if dlatents_npz is not None: print(f'Generating images from dlatents file "{dlatents_npz}"') dlatents = np.load(dlatents_npz)['dlatents'] assert dlatents.shape[1:] == (18, 512) # [N, 18, 512] imgs = Gs.components.synthesis.run( dlatents, output_transform=dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True)) for i, img in enumerate(imgs): fname = f'{outdir}/dlatent{i:02d}.png' print(f'Saved {fname}') PIL.Image.fromarray(img, 'RGB').save(fname) return # Render images for dlatents initialized from random seeds. Gs_kwargs = { 'output_transform': dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True), 'randomize_noise': False } if truncation_psi is not None: Gs_kwargs['truncation_psi'] = truncation_psi print("using tpsi: ", truncation_psi) noise_vars = [ var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise') ] label = np.zeros([1] + Gs.input_shapes[1][1:]) if class_idx is not None: label[:, class_idx] = 1 for seed_idx, seed in enumerate(seeds): print('Generating image for seed %d (%d/%d) ...' % (seed, seed_idx, len(seeds))) rnd = np.random.RandomState(seed) z = rnd.randn(1, *Gs.input_shape[1:]) # [minibatch, component] tflib.set_vars( {var: rnd.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] images = Gs.run(z, label, **Gs_kwargs) # [minibatch, height, width, channel] if prefix is None: fname = f'{outdir}/seed{seed:04d}.png' else: fname = f'{outdir}/{prefix}seed{seed:04d}.png' PIL.Image.fromarray(images[0], 'RGB').save(fname)
def generate_ws(network_pkl, seeds, truncation_psi): print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) noise_vars = [var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise')] w_avg = Gs.get_var('dlatent_avg') # [component] Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False if truncation_psi is not None: Gs_kwargs.truncation_psi = truncation_psi Ws = np.zeros((len(seeds), 18, 512)) for seed_idx, seed in enumerate(seeds): print('Generating W for seed %d (%d/%d) ...' % (seed, seed_idx+1, len(seeds))) rnd = np.random.RandomState(seed) z = rnd.randn(1, *Gs.input_shape[1:]) # [1, component] tflib.set_vars({var: rnd.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] start = time.time() w = Gs.components.mapping.run(z, None) # [1, layer, component] w = w_avg + (w - w_avg) * truncation_psi # [1, layer, component] print('Time: {}s'.format(time.time() - start)) Ws[seed_idx, :, :] = w np.save('W_{}.npy'.format(len(seeds)), Ws)
def generate_images(self, zs, truncation_psi): # Get tf noise variables, for the stochastic variation noise_vars = [ var for name, var in self.__Gs.components.synthesis.vars.items() if name.startswith('noise')] Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict( func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False if not isinstance(truncation_psi, list): truncation_psi = [truncation_psi] * len(zs) imgs = [] for z_idx, z in tqdm(enumerate(zs)): Gs_kwargs.truncation_psi = truncation_psi[z_idx] noise_rnd = np.random.RandomState(1) # fix noise tflib.set_vars({var: noise_rnd.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] # [minibatch, height, width, channel] images = self.__Gs.run(z, None, **Gs_kwargs) imgs.append(PIL.Image.fromarray(images[0], 'RGB')) # Return array of PIL.Image return imgs
def generate_latent_images(zs, truncation_psi, outdir, save_npy,prefix,vidname,framerate): Gs_kwargs = { 'output_transform': dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True), 'randomize_noise': False } if not isinstance(truncation_psi, list): truncation_psi = [truncation_psi] * len(zs) os.makedirs(f'{outdir}/frames', exist_ok=True) for z_idx, z in enumerate(zs): if isinstance(z,list): z = np.array(z).reshape(1,512) elif isinstance(z,np.ndarray): z.reshape(1,512) print('Generating image for step %d/%d ...' % (z_idx, len(zs))) Gs_kwargs['truncation_psi'] = truncation_psi[z_idx] noise_rnd = np.random.RandomState(1) # fix noise tflib.set_vars({var: noise_rnd.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] images = Gs.run(z, None, **Gs_kwargs) # [minibatch, height, width, channel] PIL.Image.fromarray(images[0], 'RGB').save(f'{outdir}/frames/{prefix}{z_idx:05d}.png') if save_npy: np.save(dnnlib.make_run_dir_path('%s%05d.npy' % (prefix,z_idx)), z) cmd="ffmpeg -y -r {} -i {}/frames/{}%05d.png -vcodec libx264 -pix_fmt yuv420p {}/walk-{}-{}fps.mp4".format(framerate,outdir,prefix,outdir,vidname,framerate) subprocess.call(cmd, shell=True)
def generate_latent_images(zs, truncation_psi): Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False if not isinstance(truncation_psi, list): truncation_psi = [truncation_psi] * len(zs) # temp_dir = 'frames%06d'%int(1000000*random.random()) # os.system('mkdir %s'%temp_dir) for z_idx, z in enumerate(zs): if isinstance(z, list): z = np.array(z).reshape(1, 512) elif isinstance(z, np.ndarray): z.reshape(1, 512) print('Generating image for step %d/%d ...' % (z_idx, len(zs))) Gs_kwargs.truncation_psi = truncation_psi[z_idx] noise_rnd = np.random.RandomState(1) # fix noise tflib.set_vars( {var: noise_rnd.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] images = Gs.run(z, None, **Gs_kwargs) # [minibatch, height, width, channel] PIL.Image.fromarray(images[0], 'RGB').save( dnnlib.make_run_dir_path('frame%05d.png' % z_idx))
def generate_images(network_pkl, seeds, truncation_psi, label=None, output_dir=None): print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) noise_vars = [var for name, var in Gs.components.synthesis.vars.items( ) if name.startswith('noise')] Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict( func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False if truncation_psi is not None: Gs_kwargs.truncation_psi = truncation_psi if label is not None: label = label.reshape([1, -1]) if output_dir is None: output_dir = dnnlib.make_run_dir_path() os.makedirs(output_dir, exist_ok=True) for seed_idx, seed in enumerate(seeds): print('[%d/%d] Generating image for seed %d, labels = [%s]...' % (seed_idx, len(seeds), seed, _label2str(label, ','))) rnd = np.random.RandomState(seed) z = rnd.randn(1, *Gs.input_shape[1:]) # [minibatch, component] tflib.set_vars({var: rnd.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] # [minibatch, height, width, channel] images = Gs.run(z, label, **Gs_kwargs) PIL.Image.fromarray(images[0], 'RGB').save( os.path.join(output_dir, '%s_seed%04d.png' % (_label2str(label), seed)))
def generate_images(network_pkl, seeds, truncation_psi): print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) noise_vars = [ var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise') ] Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False if truncation_psi is not None: Gs_kwargs.truncation_psi = truncation_psi for seed_idx, seed in enumerate(seeds): print('Generating image for seed %d (%d/%d) ...' % (seed, seed_idx, len(seeds))) rnd = np.random.RandomState(seed) z = rnd.randn(1, *Gs.input_shape[1:]) # [minibatch, component] tflib.set_vars( {var: rnd.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] images = Gs.run(z, None, **Gs_kwargs) # [minibatch, height, width, channel] PIL.Image.fromarray(images[0], 'RGB').save( dnnlib.make_run_dir_path('seed%04d.png' % seed))
def truncation_traversal(network_pkl, npys, seed=[0], start=-1.0, stop=1.0, increment=0.1): print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) noise_vars = [var for name, var in Gs.components.synthesis.vars.items( ) if name.startswith('noise')] Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict( func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False count = 1 trunc = start while trunc <= stop: Gs_kwargs.truncation_psi = trunc print('Generating truncation %0.2f' % trunc) rnd = np.random.RandomState(seed) z = rnd.randn(1, *Gs.input_shape[1:]) # [minibatch, component] tflib.set_vars({var: rnd.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] # [minibatch, height, width, channel] images = Gs.run(z, None, **Gs_kwargs) PIL.Image.fromarray(images[0], 'RGB').save( dnnlib.make_run_dir_path('frame%05d.png' % count)) trunc += increment count += 1
def project_generated_images(network_pkl, seeds, num_snapshots, truncation_psi): print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) proj = projector.Projector() proj.set_network(Gs) noise_vars = [ var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise') ] Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.randomize_noise = False Gs_kwargs.truncation_psi = truncation_psi for seed_idx, seed in enumerate(seeds): print('Projecting seed %d (%d/%d) ...' % (seed, seed_idx, len(seeds))) rnd = np.random.RandomState(seed) z = rnd.randn(1, *Gs.input_shape[1:]) tflib.set_vars( {var: rnd.randn(*var.shape.as_list()) for var in noise_vars}) images = Gs.run(z, None, **Gs_kwargs) project_image(proj, targets=images, labels=None, png_prefix=dnnlib.make_run_dir_path('seed%04d-' % seed), num_snapshots=num_snapshots, save_npy=False, npy_file_prefix='NONAME')
def images_beetwen_weights(self, weights, iteration, copy_layers=[]): rnd = np.random.RandomState(0) tflib.set_vars({ var: rnd.randn(*var.shape.as_list()) for var in self.__noise_vars }) # [height, width] weights = np.array(weights) weights = self.__Gs.components.mapping.run(weights, None) images = [] if copy_layers: for w in range(weights.shape[0] - 1): if len(copy_layers) + 1 == len(weights): weights[w + 1][copy_layers[w]] = weights[w][ copy_layers[w]].copy() else: weights[w + 1][copy_layers] = weights[w][copy_layers].copy() for w in range(weights.shape[0] - 1): images_weights = [] w1 = weights[w].copy() w2 = weights[w + 1].copy() step = (w2 - w1) / iteration _weights = w1.copy() for _ in range(iteration + 1): images_weights.append(_weights.copy()) _weights += step images.append( self.__Gs.components.synthesis.run(np.array(images_weights), **self.__Gs_kwargs)) return images
def interpolate_folder(network_pkl, input_dir, input_dir2, count): files = glob.glob(input_dir + "/*.png") + glob.glob(input_dir + "/*.jpg") L = [] for f in files: metadata = read_metadata(f) z = metadata['z'] truncation_psi = metadata['truncation_psi'] L.append((z, truncation_psi)) if input_dir2: files2 = glob.glob(input_dir2 + "/*.png") + glob.glob(input_dir2 + "/*.jpg") L2 = [] for f in files2: metadata = read_metadata(f) z = metadata['z'] truncation_psi = metadata['truncation_psi'] L2.append((z, truncation_psi)) else: L2 = [] print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) noise_vars = [var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise')] Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) noise_vars = [var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise')] Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False random.shuffle(L) if L2: random.shuffle(L2) it = itertools.product(L, L2) else: it = itertools.combinations(L, 2) for x, y in it: psi0, psi1 = x[1], y[1] truncation_psi = psi0 + (psi1-psi0)*np.random.random() Gs_kwargs.truncation_psi = truncation_psi noise_seed = np.random.randint(0,1000000) rnd_noise = np.random.RandomState(noise_seed) vars = {var: rnd_noise.randn(*var.shape.as_list()) for var in noise_vars} tflib.set_vars(vars) # [height, width] for i in range(count): r = (i+1)/(count+1) #r = random.random() z = (1-r)*x[0] + r*y[0] images = Gs.run(z, None, **Gs_kwargs) # [minibatch, height, width, channel] im = PIL.Image.fromarray(images[0], 'RGB') #.save(dnnlib.make_run_dir_path('varysingle_%04d.png' % i)) fn = 'if_{:03d}.jpg'.format(int(r*1000)) metadata = {'z':z, 'truncation_psi':truncation_psi, 'noise_seed':noise_seed} save_with_metadata(im, fn, metadata, True)
def main(): tflib.init_tf() with open('networks/stylegan2-ffhq-config-f.pkl', "rb") as f: generator_network, discriminator_network, Gs_network = pickle.load(f) w_avg = Gs_network.get_var('dlatent_avg') noise_vars = [ var for name, var in Gs_network.components.synthesis.vars.items() if name.startswith('noise') ] Gs_syn_kwargs = dnnlib.EasyDict() Gs_syn_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_syn_kwargs.randomize_noise = False Gs_syn_kwargs.minibatch_size = 1 truncation_psi = 0.5 face_latent = read_feature('results/generate_codes/0000.txt') z = np.stack(face_latent for _ in range(1)) tflib.set_vars( {var: np.random.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] w = Gs_network.components.mapping.run(z, None) w = w_avg + (w - w_avg) * truncation_psi direction_file = [ 'age.npy', 'angle_horizontal.npy', 'emotion_happy.npy', 'emotion_sad.npy', 'angle_pitch.npy', 'gender.npy' ] coeffs = [-12., -9., -6., -3., 0., 3., 6., 9., 12.] for i_file in direction_file: move_latent_and_save(w, i_file, coeffs, Gs_network, Gs_syn_kwargs)
def regenerate_folder(network_pkl, input_dir): files = glob.glob(input_dir + "/*.png") + glob.glob(input_dir + "/*.jpg") print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) noise_vars = [var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise')] Gs_kwargs = dnnlib.EasyDict() Gs_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_kwargs.randomize_noise = False for f in files: metadata = read_metadata(f) print(metadata.keys()) z = metadata['z'] truncation_psi = metadata['truncation_psi'] if 'noise_vars' in metadata: noise_vars = metadata['noise_vars'] vars = {var:noise_vars[name] for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise')} else: rnd = np.random.RandomState(metadata['noise_seed']) vars = {var: rnd.randn(*var.shape.as_list()) for var in noise_vars} Gs_kwargs.truncation_psi = truncation_psi tflib.set_vars(vars) # [height, width] images = Gs.run(z, None, **Gs_kwargs) # [minibatch, height, width, channel] im = PIL.Image.fromarray(images[0], 'RGB') #.save(dnnlib.make_run_dir_path('varysingle_%04d.png' % i)) fn = os.path.splitext(os.path.basename(f))[0] + '-b.png' save_with_metadata(im, fn, metadata, False)
def main(): # 在这儿选择生成器 tflib.init_tf() with open('networks/generator_yellow-stylegan2-config-f.pkl', "rb") as f: generator_network, discriminator_network, Gs_network = pickle.load(f) # 这是一些配置参数,不要动它 w_avg = Gs_network.get_var('dlatent_avg') noise_vars = [ var for name, var in Gs_network.components.synthesis.vars.items() if name.startswith('noise') ] Gs_syn_kwargs = dnnlib.EasyDict() Gs_syn_kwargs.output_transform = dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) Gs_syn_kwargs.randomize_noise = False Gs_syn_kwargs.minibatch_size = 1 truncation_psi = 0.5 # 在这儿选择人物的潜码,注意要与生成器相匹配。潜码来自生成目录下有个generate_codes文件夹里的txt文件。 face_latent = read_feature('results/generate_codes/0000.txt') z = np.stack(face_latent for _ in range(1)) tflib.set_vars( {var: np.random.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] w = Gs_network.components.mapping.run(z, None) w = w_avg + (w - w_avg) * truncation_psi # 在这儿选择调整的方向,共有23种调整方式,它们的名称与分别对应的功能如下所示。 ''' age.npy - 调整年龄 angle_horizontal.npy - 在左右方向上调整人脸角度 angle_vertical.npy - 在上下方向上调整人脸角度 beauty.npy - 调整颜值 emotion_angry.npy - 调整此项可增添/减弱一些生气的情绪(调整步幅建议缩小) emotion_disgust.npy - 调整此项可增添/减弱一些厌恶的情绪(调整步幅建议缩小) emotion_easy.npy - 调整此项可增添/减弱一些平静的情绪(调整步幅建议缩小) emotion_fear.npy - 调整此项可增添/减弱一些害怕的情绪(调整步幅建议缩小) emotion_happy.npy - 调整此项可增添/减弱一些开心的情绪(调整步幅建议缩小) emotion_sad.npy - 调整此项可增添/减弱一些伤心的情绪(调整步幅建议缩小) emotion_surprise.npy - 调整此项可增添/减弱一些惊讶的情绪(调整步幅建议缩小) eyes_open.npy - 调整眼睛的闭合程度 face_shape.npy - 调整脸型 gender.npy - 调整性别 glasses.npy - 调整是否戴眼镜 height.npy - 调整脸的高度 race_black.npy - 调整此项可接近/远离向黑种人变化 race_white.npy - 调整此项可接近/远离向白种人变化 race_yellow.npy - 调整此项可接近/远离向黄种人变化 smile.npy - 调整笑容 width.npy - 调整脸的宽度 ''' direction_file = 'smile.npy' # 从上面的编辑向量中选择一个 # 在这儿选择调整的大小,向量里面的值表示调整幅度,可以自行编辑,对于每个值都会生成一张图片并保存。 coeffs = [-15., -12., -9., -6., -3., 0., 3., 6., 9., 12.] # 开始调整并保存图片 move_latent_and_save(w, direction_file, coeffs, Gs_network, Gs_syn_kwargs)
def start(self, target_images): assert self._Gs is not None # Prepare target images. self._info('Preparing target images...') target_images = np.asarray(target_images, dtype='float32') target_images = (target_images + 1) * (255 / 2) sh = target_images.shape assert sh[0] == self._minibatch_size if sh[2] > self._target_images_var.shape[2]: factor = sh[2] // self._target_images_var.shape[2] target_images = np.reshape( target_images, [-1, sh[1], sh[2] // factor, factor, sh[3] // factor, factor ]).mean((3, 5)) # Initialize optimization state. self._info('Initializing optimization state...') tflib.set_vars({ self._target_images_var: target_images, self._dlatents_var: np.tile(self._dlatent_avg, [self._minibatch_size, 1, 1]) }) tflib.run(self._noise_init_op) self._opt.reset_optimizer_state() self._cur_step = 0
def save_weights(network_pkl): print('Loading networks from "%s"...' % network_pkl) _G, _D, Gs = pretrained_networks.load_networks(network_pkl) noise_vars = [ var for name, var in Gs.components.synthesis.vars.items() if name.startswith('noise') ] with open("resolution.txt", "w") as f: f.write(",".join([str(i) for i in Gs.output_shape[-2:]])) #Gs_kwargs = dnnlib.EasyDict() #Gs_kwargs.output_transform = dict(func=to_png, nchw_to_nhwc=True) #dict(func=tflib.convert_images_to_uint8, nchw_to_nhwc=True) #Gs_kwargs.randomize_noise = False rnd = np.random.RandomState(0) z = rnd.randn(1, *Gs.input_shape[1:]) # [minibatch, component] tflib.set_vars( {var: rnd.randn(*var.shape.as_list()) for var in noise_vars}) # [height, width] #try: # images = Gs.run(z, None, **Gs_kwargs) # [minibatch, height, width, channel] #except TypeError: # pass saver = tf.train.Saver(var_list=tf.trainable_variables()) saver.save(sess=tf.get_default_session(), save_path="save_weights") """