import os import subprocess from typing import List, Optional from argparse import Namespace from tqdm import tqdm from einops import rearrange import numpy as np import torch from torch import autocast from PIL import Image from omegaconf import OmegaConf from pytorch_lightning import seed_everything from contextlib import nullcontext subprocess.run(["mkdir", "-p", "/root/.cache/torch/hub/checkpoints"]) subprocess.run(["cp", "-r", "huggingface", "/root/.cache"]) subprocess.run(["cp", "checkpoint_liberty_with_aug.pth", "/root/.cache/torch/hub/checkpoints"]) # https://github.com/DagnyT/hardnet/raw/master/pretrained/train_liberty_with_aug/checkpoint_liberty_with_aug.pth # from pnp_utils import check_safety from pnp_ldm.models.diffusion.ddim import DDIMSampler from run_features_extraction import load_model_from_config, load_img from cog import BasePredictor, Path, Input, BaseModel device = torch.device("cuda" if torch.cuda.is_available() else "cpu") class Predictor(BasePredictor): def setup(self): subprocess.run(["mkdir", "-p", "/root/.cache/torch/hub/checkpoints"]) subprocess.run(["cp", "-r", "huggingface", "/root/.cache"]) subprocess.run(["cp", "checkpoint_liberty_with_aug.pth", "/root/.cache/torch/hub/checkpoints"]) common_config = Namespace() common_config.ddim_eta = 0.0 common_config.H = common_config.W = 512 common_config.C = 4 # Latent channels common_config.f = 8 # downsampling factor common_config.precision = "autocast" common_config.save_all_features = False common_config.check_safety = False model_config = OmegaConf.load("configs/stable-diffusion/v1-inference.yaml") self.model = load_model_from_config(model_config, "models/ldm/stable-diffusion-v1/model.ckpt") self.common_config = common_config def predict( self, input_image: Path = Input(description="Image to edit (instead of generation prompt"), # ddim_inversion_steps: int = Input(description="Number of forward steps in diffusion process for invering the image (if supplied)", default=999), generation_prompt: str = Input(description="Instead of input_image, generate an image from a text prompt" " (Input image is ignored if this is supplied)", default=""), # num_ddim_steps: int = Input(description="Number of timesteps in the underlying diffusion process. default for generation from text is 50", ge=1, le=999, default=999), translation_prompts: str = Input( description="Text to Image prompts. A list of edit texts (separated by ';')" " an image will be output for each edit txt", default="A photo of a robot horse"), scale: float = Input( description="Unconditional guidance scale. Note that a higher value encourages deviation from the source image " "(10 is the default for tranlsation from image 7.5 for text", default=10.), feature_injection_threshold: float = Input( description="Control the level of structure preservation. What timestep to stop Injecting" " the saved features into the translation diffusion process. " "(0 is first and 1 is final timestep meaning more preservation) ", ge=0., le=1., default=0.8), negative_prompt: str = Input(description="Control the level of deviation from the source image", default=""), negative_prompt_alpha: float = Input(description="Strength of the effect of the negative prompt " "(lower is stronger)", ge=0., le=1., default=1.) ) -> List[Path]: self.common_config.generation_prompt = str(generation_prompt) extraction_config = Namespace() extraction_config.ddim_inversion_steps = 999 pnp_config = Namespace() pnp_config.translation_prompts = str(translation_prompts).split(';') pnp_config.feature_injection_threshold = float(feature_injection_threshold) pnp_config.negative_prompt = str(negative_prompt) pnp_config.negative_prompt_alpha = float(negative_prompt_alpha) pnp_config.negative_prompt_schedule = "linear" # ∈ {"linear", "constant", "exp"}, determines the attenuation schedule of negative-prompting # setting negative_prompt_alpha = 1.0, negative_prompt_schedule = "constant" is equivalent to not using negative prompting if generation_prompt == '': # From Image self.common_config.seed = 50 self.common_config.output_dir = "./outputs_real" # Extraction extraction_config.init_img = str(input_image) extraction_config.ddim_steps = 999 extraction_config.save_feature_timesteps = 50 extraction_config.scale = 1.0 extract_features(self.model, self.common_config, extraction_config) # Translation pnp_config.scale = float(scale) pnp_config.num_ddim_sampling_steps = extraction_config.save_feature_timesteps image_paths = run_pnp(self.model, self.common_config, pnp_config) return [Path(x) for x in image_paths] else: # From text self.common_config.seed = 50 self.common_config.output_dir = "./outputs_gen" # Extraction extraction_config.init_img = "" extraction_config.save_feature_timesteps = extraction_config.ddim_steps = 50 extraction_config.scale = 5.0 gen_paths = extract_features(self.model, self.common_config, extraction_config) # Translation pnp_config.scale = float(scale) pnp_config.num_ddim_sampling_steps = extraction_config.save_feature_timesteps image_paths = run_pnp(self.model, self.common_config, pnp_config) return [Path(x) for x in gen_paths] + [Path(x) for x in image_paths] def extract_features(model, opt, exp_config): seed_everything(opt.seed) device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") model = model.to(device) unet_model = model.model.diffusion_model sampler = DDIMSampler(model) predicted_samples_path = os.path.join(opt.output_dir, "predicted_samples") feature_maps_path = os.path.join(opt.output_dir, "feature_maps") sample_path = os.path.join(opt.output_dir, "samples") os.makedirs(opt.output_dir, exist_ok=True) os.makedirs(predicted_samples_path, exist_ok=True) os.makedirs(feature_maps_path, exist_ok=True) os.makedirs(sample_path, exist_ok=True) def save_sampled_img(x, i, save_path): x_samples_ddim = model.decode_first_stage(x) x_samples_ddim = torch.clamp((x_samples_ddim + 1.0) / 2.0, min=0.0, max=1.0) x_samples_ddim = x_samples_ddim.cpu().permute(0, 2, 3, 1).numpy() x_image_torch = torch.from_numpy(x_samples_ddim).permute(0, 3, 1, 2) x_sample = x_image_torch[0] x_sample = 255. * rearrange(x_sample.cpu().numpy(), 'c h w -> h w c') img = Image.fromarray(x_sample.astype(np.uint8)) img.save(os.path.join(save_path, f"{i}.png")) def ddim_sampler_callback(pred_x0, xt, i): save_feature_maps_callback(i) save_sampled_img(pred_x0, i, predicted_samples_path) def save_feature_maps(blocks, i, feature_type="input_block"): block_idx = 0 for block in tqdm(blocks, desc="Saving input blocks feature maps"): if not opt.save_all_features and block_idx < 4: block_idx += 1 continue if "ResBlock" in str(type(block[0])): if opt.save_all_features or block_idx == 4: save_feature_map(block[0].in_layers_features, f"{feature_type}_{block_idx}_in_layers_features_time_{i}") save_feature_map(block[0].out_layers_features, f"{feature_type}_{block_idx}_out_layers_features_time_{i}") if len(block) > 1 and "SpatialTransformer" in str(type(block[1])): save_feature_map(block[1].transformer_blocks[0].attn1.k, f"{feature_type}_{block_idx}_self_attn_k_time_{i}") save_feature_map(block[1].transformer_blocks[0].attn1.q, f"{feature_type}_{block_idx}_self_attn_q_time_{i}") block_idx += 1 def save_feature_maps_callback(i): if opt.save_all_features: save_feature_maps(unet_model.input_blocks, i, "input_block") save_feature_maps(unet_model.output_blocks, i, "output_block") def save_feature_map(feature_map, filename): save_path = os.path.join(feature_maps_path, f"{filename}.pt") torch.save(feature_map, save_path) prompts = [opt.generation_prompt] precision_scope = autocast if opt.precision == "autocast" else nullcontext with torch.no_grad(): with precision_scope("cuda"): with model.ema_scope(): uc = model.get_learned_conditioning([""]) c = model.get_learned_conditioning(prompts) shape = [opt.C, opt.H // opt.f, opt.W // opt.f] z_enc = None if exp_config.init_img != '': assert os.path.isfile(exp_config.init_img) init_image = load_img(exp_config.init_img).to(device) init_latent = model.get_first_stage_encoding(model.encode_first_stage(init_image)) z_enc, _ = sampler.encode_ddim(init_latent, num_steps=exp_config.ddim_inversion_steps, conditioning=c, unconditional_conditioning=uc, unconditional_guidance_scale=exp_config.scale) else: z_enc = torch.randn([1, opt.C, opt.H // opt.f, opt.W // opt.f], device=device) torch.save(z_enc, f"{opt.output_dir}/z_enc.pt") samples_ddim, _ = sampler.sample(S=exp_config.ddim_steps, conditioning=c, batch_size=1, shape=shape, verbose=False, unconditional_guidance_scale=exp_config.scale, unconditional_conditioning=uc, eta=opt.ddim_eta, x_T=z_enc, img_callback=ddim_sampler_callback, callback_ddim_timesteps=exp_config.save_feature_timesteps, outpath=opt.output_dir) x_samples_ddim = model.decode_first_stage(samples_ddim) x_samples_ddim = torch.clamp((x_samples_ddim + 1.0) / 2.0, min=0.0, max=1.0) x_samples_ddim = x_samples_ddim.cpu().permute(0, 2, 3, 1).numpy() # if opt.check_safety: # x_samples_ddim = check_safety(x_samples_ddim) x_image_torch = torch.from_numpy(x_samples_ddim).permute(0, 3, 1, 2) sample_idx = 0 png_paths = [] for x_sample in x_image_torch: x_sample = 255. * rearrange(x_sample.cpu().numpy(), 'c h w -> h w c') img = Image.fromarray(x_sample.astype(np.uint8)) png_path = os.path.join(sample_path, f"{sample_idx}.png") img.save(png_path) png_paths.append(png_path) sample_idx += 1 print(f"Sampled images and extracted features saved in: {opt.output_dir}") return png_paths def run_pnp(model, opt, exp_config): exp_config.feature_injection_threshold = int( exp_config.feature_injection_threshold * exp_config.num_ddim_sampling_steps) seed_everything(opt.seed) negative_prompt = opt.generation_prompt if exp_config.negative_prompt is None else exp_config.negative_prompt ddim_steps = exp_config.num_ddim_sampling_steps # TODO in generated scenario this shoud ddim_steps device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") model = model.to(device) sampler = DDIMSampler(model) sampler.make_schedule(ddim_num_steps=ddim_steps, ddim_eta=opt.ddim_eta, verbose=False) seed = torch.initial_seed() opt.seed = seed translation_folders = [p.replace(' ', '_') for p in exp_config.translation_prompts] outpaths = [os.path.join(f"{opt.output_dir}/translations", f"{exp_config.scale}_{translation_folder}") for translation_folder in translation_folders] out_label = f"INJECTION_T_{exp_config.feature_injection_threshold}_STEPS_{ddim_steps}" out_label += f"_NP-ALPHA_{exp_config.negative_prompt_alpha}_SCHEDULE_{exp_config.negative_prompt_schedule}_NP_{negative_prompt.replace(' ', '_')}" predicted_samples_paths = [os.path.join(outpath, f"predicted_samples_{out_label}") for outpath in outpaths] for i in range(len(outpaths)): os.makedirs(outpaths[i], exist_ok=True) os.makedirs(predicted_samples_paths[i], exist_ok=True) def save_sampled_img(x, i, save_paths): for im in range(x.shape[0]): x_samples_ddim = model.decode_first_stage(x[im].unsqueeze(0)) x_samples_ddim = torch.clamp((x_samples_ddim + 1.0) / 2.0, min=0.0, max=1.0) x_samples_ddim = x_samples_ddim.cpu().permute(0, 2, 3, 1).numpy() x_image_torch = torch.from_numpy(x_samples_ddim).permute(0, 3, 1, 2) x_sample = x_image_torch[0] x_sample = 255. * rearrange(x_sample.cpu().numpy(), 'c h w -> h w c') img = Image.fromarray(x_sample.astype(np.uint8)) img.save(os.path.join(save_paths[im], f"{i}.png")) def ddim_sampler_callback(pred_x0, xt, i): save_sampled_img(pred_x0, i, predicted_samples_paths) def load_target_features(): self_attn_output_block_indices = [4, 5, 6, 7, 8, 9, 10, 11] out_layers_output_block_indices = [4] output_block_self_attn_map_injection_thresholds = [ddim_steps // 2] * len(self_attn_output_block_indices) feature_injection_thresholds = [exp_config.feature_injection_threshold] target_features = [] source_experiment_out_layers_path = os.path.join(opt.output_dir, "feature_maps") source_experiment_qkv_path = os.path.join(opt.output_dir, "feature_maps") time_range = np.flip(sampler.ddim_timesteps) total_steps = sampler.ddim_timesteps.shape[0] iterator = tqdm(time_range, desc="loading source experiment features", total=total_steps) for i, t in enumerate(iterator): current_features = {} for (output_block_idx, output_block_self_attn_map_injection_threshold) in zip( self_attn_output_block_indices, output_block_self_attn_map_injection_thresholds): if i <= int(output_block_self_attn_map_injection_threshold): output_q = torch.load(os.path.join(source_experiment_qkv_path, f"output_block_{output_block_idx}_self_attn_q_time_{t}.pt")) output_k = torch.load(os.path.join(source_experiment_qkv_path, f"output_block_{output_block_idx}_self_attn_k_time_{t}.pt")) current_features[f'output_block_{output_block_idx}_self_attn_q'] = output_q current_features[f'output_block_{output_block_idx}_self_attn_k'] = output_k for (output_block_idx, feature_injection_threshold) in zip(out_layers_output_block_indices, feature_injection_thresholds): if i <= int(feature_injection_threshold): output = torch.load(os.path.join(source_experiment_out_layers_path, f"output_block_{output_block_idx}_out_layers_features_time_{t}.pt")) current_features[f'output_block_{output_block_idx}_out_layers'] = output target_features.append(current_features) return target_features batch_size = len(exp_config.translation_prompts) translation_prompts = exp_config.translation_prompts start_code_path = f"{opt.output_dir}/z_enc.pt" start_code = torch.load(start_code_path).cuda() if os.path.exists(start_code_path) else None if start_code is not None: start_code = start_code.repeat(batch_size, 1, 1, 1) precision_scope = autocast if opt.precision == "autocast" else nullcontext injected_features = load_target_features() unconditional_prompt = "" with torch.no_grad(): with precision_scope("cuda"): with model.ema_scope(): uc = None nc = None if exp_config.scale != 1.0: uc = model.get_learned_conditioning(batch_size * [unconditional_prompt]) nc = model.get_learned_conditioning(batch_size * [negative_prompt]) c = model.get_learned_conditioning(translation_prompts) shape = [opt.C, opt.H // opt.f, opt.W // opt.f] samples_ddim, _ = sampler.sample(S=ddim_steps, conditioning=c, negative_conditioning=nc, batch_size=len(translation_prompts), shape=shape, verbose=False, unconditional_guidance_scale=exp_config.scale, unconditional_conditioning=uc, eta=opt.ddim_eta, x_T=start_code, img_callback=ddim_sampler_callback, injected_features=injected_features, negative_prompt_alpha=exp_config.negative_prompt_alpha, negative_prompt_schedule=exp_config.negative_prompt_schedule, ) x_samples_ddim = model.decode_first_stage(samples_ddim) x_samples_ddim = torch.clamp((x_samples_ddim + 1.0) / 2.0, min=0.0, max=1.0) x_samples_ddim = x_samples_ddim.cpu().permute(0, 2, 3, 1).numpy() # if opt.check_safety: # x_samples_ddim = check_safety(x_samples_ddim) x_image_torch = torch.from_numpy(x_samples_ddim).permute(0, 3, 1, 2) png_paths = [] sample_idx = 0 for k, x_sample in enumerate(x_image_torch): x_sample = 255. * rearrange(x_sample.cpu().numpy(), 'c h w -> h w c') img = Image.fromarray(x_sample.astype(np.uint8)) png_path = os.path.join(outpaths[k], f"{out_label}_sample_{sample_idx}.png") png_paths.append(png_path) img.save(png_path) sample_idx += 1 print(f"PnP results saved in: {'; '.join(outpaths)}") return png_paths