edit_friendly_ddpm_inversion / inversion_utils.py
Linoy Tsaban
Create inversion_utils.py
acc80f0
raw
history blame
12 kB
import torch
import os
from tqdm import tqdm
from PIL import Image, ImageDraw ,ImageFont
from matplotlib import pyplot as plt
import torchvision.transforms as T
import os
import yaml
import numpy as np
def load_512(image_path, left=0, right=0, top=0, bottom=0, device=None):
if type(image_path) is str:
image = np.array(Image.open(image_path).convert('RGB'))[:, :, :3]
else:
image = image_path
h, w, c = image.shape
left = min(left, w-1)
right = min(right, w - left - 1)
top = min(top, h - left - 1)
bottom = min(bottom, h - top - 1)
image = image[top:h-bottom, left:w-right]
h, w, c = image.shape
if h < w:
offset = (w - h) // 2
image = image[:, offset:offset + h]
elif w < h:
offset = (h - w) // 2
image = image[offset:offset + w]
image = np.array(Image.fromarray(image).resize((512, 512)))
image = torch.from_numpy(image).float() / 127.5 - 1
image = image.permute(2, 0, 1).unsqueeze(0).to(device)
return image
def load_real_image(folder = "data/", img_name = None, idx = 0, img_size=512, device='cuda'):
from PIL import Image
from glob import glob
if img_name is not None:
path = os.path.join(folder, img_name)
else:
path = glob(folder + "*")[idx]
img = Image.open(path).resize((img_size,
img_size))
img = pil_to_tensor(img).to(device)
if img.shape[1]== 4:
img = img[:,:3,:,:]
return img
def mu_tilde(model, xt,x0, timestep):
"mu_tilde(x_t, x_0) DDPM paper eq. 7"
prev_timestep = timestep - model.scheduler.config.num_train_timesteps // model.scheduler.num_inference_steps
alpha_prod_t_prev = model.scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else model.scheduler.final_alpha_cumprod
alpha_t = model.scheduler.alphas[timestep]
beta_t = 1 - alpha_t
alpha_bar = model.scheduler.alphas_cumprod[timestep]
return ((alpha_prod_t_prev ** 0.5 * beta_t) / (1-alpha_bar)) * x0 + ((alpha_t**0.5 *(1-alpha_prod_t_prev)) / (1- alpha_bar))*xt
def sample_xts_from_x0(model, x0, num_inference_steps=50):
"""
Samples from P(x_1:T|x_0)
"""
# torch.manual_seed(43256465436)
alpha_bar = model.scheduler.alphas_cumprod
sqrt_one_minus_alpha_bar = (1-alpha_bar) ** 0.5
alphas = model.scheduler.alphas
betas = 1 - alphas
variance_noise_shape = (
num_inference_steps,
model.unet.in_channels,
model.unet.sample_size,
model.unet.sample_size)
timesteps = model.scheduler.timesteps.to(model.device)
t_to_idx = {int(v):k for k,v in enumerate(timesteps)}
xts = torch.zeros(variance_noise_shape).to(x0.device)
for t in reversed(timesteps):
idx = t_to_idx[int(t)]
xts[idx] = x0 * (alpha_bar[t] ** 0.5) + torch.randn_like(x0) * sqrt_one_minus_alpha_bar[t]
xts = torch.cat([xts, x0 ],dim = 0)
return xts
def encode_text(model, prompts):
text_input = model.tokenizer(
prompts,
padding="max_length",
max_length=model.tokenizer.model_max_length,
truncation=True,
return_tensors="pt",
)
with torch.no_grad():
text_encoding = model.text_encoder(text_input.input_ids.to(model.device))[0]
return text_encoding
def forward_step(model, model_output, timestep, sample):
next_timestep = min(model.scheduler.config.num_train_timesteps - 2,
timestep + model.scheduler.config.num_train_timesteps // model.scheduler.num_inference_steps)
# 2. compute alphas, betas
alpha_prod_t = model.scheduler.alphas_cumprod[timestep]
# alpha_prod_t_next = self.scheduler.alphas_cumprod[next_timestep] if next_ltimestep >= 0 else self.scheduler.final_alpha_cumprod
beta_prod_t = 1 - alpha_prod_t
# 3. compute predicted original sample from predicted noise also called
# "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
pred_original_sample = (sample - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)
# 5. TODO: simple noising implementatiom
next_sample = model.scheduler.add_noise(pred_original_sample,
model_output,
torch.LongTensor([next_timestep]))
return next_sample
def get_variance(model, timestep): #, prev_timestep):
prev_timestep = timestep - model.scheduler.config.num_train_timesteps // model.scheduler.num_inference_steps
alpha_prod_t = model.scheduler.alphas_cumprod[timestep]
alpha_prod_t_prev = model.scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else model.scheduler.final_alpha_cumprod
beta_prod_t = 1 - alpha_prod_t
beta_prod_t_prev = 1 - alpha_prod_t_prev
variance = (beta_prod_t_prev / beta_prod_t) * (1 - alpha_prod_t / alpha_prod_t_prev)
return variance
def inversion_forward_process(model, x0,
etas = None,
prog_bar = False,
prompt = "",
cfg_scale = 3.5,
num_inference_steps=50, eps = None):
if not prompt=="":
text_embeddings = encode_text(model, prompt)
uncond_embedding = encode_text(model, "")
timesteps = model.scheduler.timesteps.to(model.device)
variance_noise_shape = (
num_inference_steps,
model.unet.in_channels,
model.unet.sample_size,
model.unet.sample_size)
if etas is None or (type(etas) in [int, float] and etas == 0):
eta_is_zero = True
zs = None
else:
eta_is_zero = False
if type(etas) in [int, float]: etas = [etas]*model.scheduler.num_inference_steps
xts = sample_xts_from_x0(model, x0, num_inference_steps=num_inference_steps)
alpha_bar = model.scheduler.alphas_cumprod
zs = torch.zeros(size=variance_noise_shape, device=model.device)
t_to_idx = {int(v):k for k,v in enumerate(timesteps)}
xt = x0
op = tqdm(reversed(timesteps)) if prog_bar else reversed(timesteps)
for t in op:
idx = t_to_idx[int(t)]
# 1. predict noise residual
if not eta_is_zero:
xt = xts[idx][None]
with torch.no_grad():
out = model.unet.forward(xt, timestep = t, encoder_hidden_states = uncond_embedding)
if not prompt=="":
cond_out = model.unet.forward(xt, timestep=t, encoder_hidden_states = text_embeddings)
if not prompt=="":
## classifier free guidance
noise_pred = out.sample + cfg_scale * (cond_out.sample - out.sample)
else:
noise_pred = out.sample
if eta_is_zero:
# 2. compute more noisy image and set x_t -> x_t+1
xt = forward_step(model, noise_pred, t, xt)
else:
xtm1 = xts[idx+1][None]
# pred of x0
pred_original_sample = (xt - (1-alpha_bar[t]) ** 0.5 * noise_pred ) / alpha_bar[t] ** 0.5
# direction to xt
prev_timestep = t - model.scheduler.config.num_train_timesteps // model.scheduler.num_inference_steps
alpha_prod_t_prev = model.scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else model.scheduler.final_alpha_cumprod
variance = get_variance(model, t)
pred_sample_direction = (1 - alpha_prod_t_prev - etas[idx] * variance ) ** (0.5) * noise_pred
mu_xt = alpha_prod_t_prev ** (0.5) * pred_original_sample + pred_sample_direction
z = (xtm1 - mu_xt ) / ( etas[idx] * variance ** 0.5 )
zs[idx] = z
# correction to avoid error accumulation
xtm1 = mu_xt + ( etas[idx] * variance ** 0.5 )*z
xts[idx+1] = xtm1
if not zs is None:
zs[-1] = torch.zeros_like(zs[-1])
return xt, zs, xts
def reverse_step(model, model_output, timestep, sample, eta = 0, variance_noise=None):
# 1. get previous step value (=t-1)
prev_timestep = timestep - model.scheduler.config.num_train_timesteps // model.scheduler.num_inference_steps
# 2. compute alphas, betas
alpha_prod_t = model.scheduler.alphas_cumprod[timestep]
alpha_prod_t_prev = model.scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else model.scheduler.final_alpha_cumprod
beta_prod_t = 1 - alpha_prod_t
# 3. compute predicted original sample from predicted noise also called
# "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
pred_original_sample = (sample - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)
# 5. compute variance: "sigma_t(Ξ·)" -> see formula (16)
# Οƒ_t = sqrt((1 βˆ’ Ξ±_tβˆ’1)/(1 βˆ’ Ξ±_t)) * sqrt(1 βˆ’ Ξ±_t/Ξ±_tβˆ’1)
# variance = self.scheduler._get_variance(timestep, prev_timestep)
variance = get_variance(model, timestep) #, prev_timestep)
std_dev_t = eta * variance ** (0.5)
# Take care of asymetric reverse process (asyrp)
model_output_direction = model_output
# 6. compute "direction pointing to x_t" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
# pred_sample_direction = (1 - alpha_prod_t_prev - std_dev_t**2) ** (0.5) * model_output_direction
pred_sample_direction = (1 - alpha_prod_t_prev - eta * variance) ** (0.5) * model_output_direction
# 7. compute x_t without "random noise" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
prev_sample = alpha_prod_t_prev ** (0.5) * pred_original_sample + pred_sample_direction
# 8. Add noice if eta > 0
if eta > 0:
if variance_noise is None:
variance_noise = torch.randn(model_output.shape, device=model.device)
sigma_z = eta * variance ** (0.5) * variance_noise
prev_sample = prev_sample + sigma_z
return prev_sample
def inversion_reverse_process(model,
xT,
etas = 0,
prompts = "",
cfg_scales = None,
prog_bar = False,
zs = None,
controller=None,
asyrp = False):
batch_size = len(prompts)
cfg_scales_tensor = torch.Tensor(cfg_scales).view(-1,1,1,1).to(model.device)
text_embeddings = encode_text(model, prompts)
uncond_embedding = encode_text(model, [""] * batch_size)
if etas is None: etas = 0
if type(etas) in [int, float]: etas = [etas]*model.scheduler.num_inference_steps
assert len(etas) == model.scheduler.num_inference_steps
timesteps = model.scheduler.timesteps.to(model.device)
xt = xT.expand(batch_size, -1, -1, -1)
op = tqdm(timesteps[-zs.shape[0]:]) if prog_bar else timesteps[-zs.shape[0]:]
t_to_idx = {int(v):k for k,v in enumerate(timesteps[-zs.shape[0]:])}
for t in op:
idx = t_to_idx[int(t)]
## Unconditional embedding
with torch.no_grad():
uncond_out = model.unet.forward(xt, timestep = t,
encoder_hidden_states = uncond_embedding)
## Conditional embedding
if prompts:
with torch.no_grad():
cond_out = model.unet.forward(xt, timestep = t,
encoder_hidden_states = text_embeddings)
z = zs[idx] if not zs is None else None
z = z.expand(batch_size, -1, -1, -1)
if prompts:
## classifier free guidance
noise_pred = uncond_out.sample + cfg_scales_tensor * (cond_out.sample - uncond_out.sample)
else:
noise_pred = uncond_out.sample
# 2. compute less noisy image and set x_t -> x_t-1
xt = reverse_step(model, noise_pred, t, xt, eta = etas[idx], variance_noise = z)
if controller is not None:
xt = controller.step_callback(xt)
return xt, zs