|
import sys, argparse, glob, os |
|
import torch |
|
import numpy as np |
|
from tqdm import tqdm |
|
import gradio as gr |
|
from PIL import Image |
|
from omegaconf import OmegaConf |
|
from einops import repeat, rearrange |
|
from pytorch_lightning import seed_everything |
|
from imwatermark import WatermarkEncoder |
|
|
|
from scripts.txt2img import put_watermark |
|
from ldm.models.diffusion.ddim import DDIMSampler |
|
from ldm.models.diffusion.ddpm import LatentUpscaleDiffusion, LatentUpscaleFinetuneDiffusion |
|
from ldm.util import exists, instantiate_from_config |
|
|
|
|
|
torch.set_grad_enabled(False) |
|
|
|
|
|
def load_model_from_config(config, ckpt, verbose=False): |
|
print(f"Loading model from {ckpt}") |
|
pl_sd = torch.load(ckpt, map_location="cpu") |
|
if "global_step" in pl_sd: |
|
print(f"Global Step: {pl_sd['global_step']}") |
|
sd = pl_sd["state_dict"] |
|
model = instantiate_from_config(config.model) |
|
m, u = model.load_state_dict(sd, strict=False) |
|
if len(m) > 0 and verbose: |
|
print("missing keys:") |
|
print(m) |
|
if len(u) > 0 and verbose: |
|
print("unexpected keys:") |
|
print(u) |
|
|
|
model.cuda() |
|
model.eval() |
|
return model |
|
|
|
|
|
def make_batch_sd( image, txt, device,num_samples=1,size=(512,512)): |
|
image = Image.open(image).convert("RGB") |
|
image = image.resize(size) |
|
image = np.array(image) |
|
image = torch.from_numpy(image).to(dtype=torch.float32) / 127.5 - 1.0 |
|
batch = { |
|
"lr": rearrange(image, 'h w c -> 1 c h w'), |
|
"txt": num_samples * [txt], |
|
} |
|
batch["lr"] = repeat(batch["lr"].to(device=device), "1 ... -> n ...", n=num_samples) |
|
return batch |
|
|
|
|
|
def make_noise_augmentation(model, batch, noise_level=None): |
|
x_low = batch[model.low_scale_key] |
|
x_low = x_low.to(memory_format=torch.contiguous_format).float() |
|
x_aug, noise_level = model.low_scale_model(x_low, noise_level) |
|
return x_aug, noise_level |
|
|
|
|
|
def paint(sampler, image, prompt, seed, scale, h, w, steps, num_samples=1, callback=None, eta=0., noise_level=None): |
|
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") |
|
model = sampler.model |
|
seed_everything(seed) |
|
prng = np.random.RandomState(seed) |
|
start_code = prng.randn(num_samples, model.channels, h, w) |
|
start_code = torch.from_numpy(start_code).to(device=device, dtype=torch.float32) |
|
|
|
with torch.no_grad(), torch.autocast("cuda"): |
|
batch = make_batch_sd(image, txt=prompt, device=device, num_samples=num_samples, size=(h, w)) |
|
c = model.cond_stage_model.encode(batch["txt"]) |
|
c_cat = list() |
|
if isinstance(model, LatentUpscaleFinetuneDiffusion): |
|
for ck in model.concat_keys: |
|
cc = batch[ck] |
|
if exists(model.reshuffle_patch_size): |
|
assert isinstance(model.reshuffle_patch_size, int) |
|
cc = rearrange(cc, 'b c (p1 h) (p2 w) -> b (p1 p2 c) h w',p1=model.reshuffle_patch_size, p2=model.reshuffle_patch_size) |
|
c_cat.append(cc) |
|
c_cat = torch.cat(c_cat, dim=1) |
|
|
|
cond = {"c_concat": [c_cat], "c_crossattn": [c]} |
|
|
|
uc_cross = model.get_unconditional_conditioning(num_samples, "") |
|
uc_full = {"c_concat": [c_cat], "c_crossattn": [uc_cross]} |
|
elif isinstance(model, LatentUpscaleDiffusion): |
|
x_augment, noise_level = make_noise_augmentation(model, batch, noise_level) |
|
cond = {"c_concat": [x_augment], "c_crossattn": [c], "c_adm": noise_level} |
|
|
|
uc_cross = model.get_unconditional_conditioning(num_samples, "") |
|
uc_full = {"c_concat": [x_augment], "c_crossattn": [uc_cross], "c_adm": noise_level} |
|
else: |
|
raise NotImplementedError() |
|
|
|
shape = [model.channels, h, w] |
|
samples, intermediates = sampler.sample( |
|
steps, |
|
num_samples, |
|
shape, |
|
cond, |
|
verbose=False, |
|
eta=eta, |
|
unconditional_guidance_scale=scale, |
|
unconditional_conditioning=uc_full, |
|
x_T=start_code, |
|
callback=callback |
|
) |
|
with torch.no_grad(): |
|
x_samples_ddim = model.decode_first_stage(samples) |
|
result = torch.clamp((x_samples_ddim + 1.0) / 2.0, min=0.0, max=1.0) |
|
result = result.cpu().numpy().transpose(0, 2, 3, 1) * 255 |
|
return Image.fromarray(result.astype(np.uint8)[0]) |
|
|
|
|
|
if __name__ == "__main__": |
|
parser = argparse.ArgumentParser() |
|
parser.add_argument("--indir", type=str, nargs="?", help="dir containing image-mask pairs (`example.png` and `example_mask.png`)",) |
|
parser.add_argument("--num_imgs", type=int, default=None, help="number of images to generate",) |
|
parser.add_argument("--steps",type=int,default=50,help="number of ddim sampling steps",) |
|
parser.add_argument("--config",type=str,default="/checkpoint/pfz/autoencoders/sd/stable-diffusion-x4-upscaler/x4-upscaling.yaml",help="path to config which constructs model",) |
|
parser.add_argument("--ckpt",type=str,default="/checkpoint/pfz/autoencoders/sd/stable-diffusion-x4-upscaler/x4-upscaler-ema.ckpt",help="path to checkpoint of model",) |
|
parser.add_argument("--ldm_decoder_ckpt",default=None,type=str,help="path to checkpoint of LDM decoder") |
|
parser.add_argument("--num_samples",default=1,type=int,help="number of samples to generate") |
|
parser.add_argument("--scale", default=10.0, type=float, help="scale") |
|
parser.add_argument("--eta", default=0.0, type=float, help="eta") |
|
parser.add_argument("--noise_level", default=20, type=float, help="eta") |
|
parser.add_argument("--output_dir",type=str,default="outputs",nargs="?",help="dir to write results to",) |
|
parser.add_argument("--height",type=int,default=512,help="height of output image",) |
|
parser.add_argument("--width",type=int,default=512,help="width of output image",) |
|
parser.add_argument("--seed",type=int,default=0,help="random seed",) |
|
opt = parser.parse_args() |
|
|
|
print(f'>>> Building LDM model with config {opt.config} and weights from {opt.ckpt}...') |
|
config = OmegaConf.load(f"{opt.config}") |
|
model = load_model_from_config(config, f"{opt.ckpt}") |
|
|
|
|
|
print(f'reload decoder weights {opt.ldm_decoder_ckpt}...') |
|
if opt.ldm_decoder_ckpt is not None and opt.ldm_decoder_ckpt.lower() == "none": |
|
opt.ldm_decoder_ckpt = None |
|
if opt.ldm_decoder_ckpt is not None: |
|
state_dict = torch.load(opt.ldm_decoder_ckpt)['ldm_decoder'] |
|
msg = model.first_stage_model.load_state_dict(state_dict, strict=False) |
|
print(msg) |
|
|
|
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") |
|
model = model.to(device) |
|
model.eval() |
|
sampler = DDIMSampler(model) |
|
|
|
os.makedirs(opt.output_dir, exist_ok=True) |
|
|
|
images = sorted(glob.glob(os.path.join(opt.indir, "*.png"))) + sorted(glob.glob(os.path.join(opt.indir, "*.jpg"))) + sorted(glob.glob(os.path.join(opt.indir, "*.jpeg"))) |
|
images += sorted(glob.glob(os.path.join(opt.indir, "*.PNG"))) + sorted(glob.glob(os.path.join(opt.indir, "*.JPG"))) + sorted(glob.glob(os.path.join(opt.indir, "*.JPEG"))) |
|
print(f"Found {len(images)} inputs.") |
|
|
|
counter = 0 |
|
for image in tqdm(images): |
|
if opt.num_imgs is not None and counter >= opt.num_imgs: |
|
break |
|
noise_level = torch.Tensor( opt.num_samples * [opt.noise_level]).to(sampler.model.device).long() |
|
sampler.make_schedule(opt.steps, ddim_eta=opt.eta, verbose=True) |
|
result = paint( |
|
sampler=sampler, |
|
image=image, |
|
prompt="", |
|
seed=opt.seed, |
|
scale=opt.scale, |
|
h=opt.height, w=opt.width, steps=opt.steps, |
|
num_samples=opt.num_samples, |
|
callback=None, |
|
noise_level=noise_level |
|
) |
|
outpath = os.path.join(opt.output_dir, os.path.split(image)[1]).replace('.jpg', '.png').replace('.jpeg', '.png').replace('.JPG', '.png').replace('.JPEG', '.png') |
|
result.save(outpath) |
|
counter += 1 |
|
|
