Update app.py

testing interm yielding

app.py

@@ -5,317 +5,11 @@ from io import BytesIO
 from diffusers import StableDiffusionPipeline
 from diffusers import DDIMScheduler
 from utils import *
-# from inversion_utils import *
+from inversion_utils import *
 from torch import autocast, inference_mode
 import re
 
 
-############################################################################################################################################################################
-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
-import gradio as gr
-
-
-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)
-
-        # interm denoised img
-            with autocast("cuda"), inference_mode():
-                x0_dec = sd_pipe.vae.decode(1 / 0.18215 * xt).sample
-                if x0_dec.dim()<4:
-                    x0_dec = x0_dec[None,:,:,:]
-                interm_img = image_grid(x0_dec)
-                yield interm_img
-            
-        if controller is not None:
-            xt = controller.step_callback(xt)        
-    return xt, zs
-############################################################################################################################################################################
-
 def invert(x0, prompt_src="", num_diffusion_steps=100, cfg_scale_src = 3.5, eta = 1):
 
   #  inverts a real image according to Algorihm 1 in https://arxiv.org/pdf/2304.06140.pdf, 
@@ -408,15 +102,15 @@ def edit(input_image,
 
     batch_size = len(prompts)
 
-    cfg_scales_tensor = torch.Tensor(cfg_scales).view(-1,1,1,1).to(model.device)
+    cfg_scales_tensor = torch.Tensor(cfg_scales).view(-1,1,1,1).to(sd_pipe.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)
+    if type(etas) in [int, float]: etas = [etas]*sd_pipe.scheduler.num_inference_steps
+    assert len(etas) == sd_pipe.scheduler.num_inference_steps
+    timesteps = sd_pipe.scheduler.timesteps.to(sd_pipe.device)
 
     xt = xT.expand(batch_size, -1, -1, -1)
     op = tqdm(timesteps[-zs.shape[0]:]) if prog_bar else timesteps[-zs.shape[0]:] 
@@ -427,13 +121,13 @@ def edit(input_image,
         idx = t_to_idx[int(t)]        
         ## Unconditional embedding
         with torch.no_grad():
-            uncond_out = model.unet.forward(xt, timestep =  t, 
+            uncond_out = sd_pipe.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, 
+                cond_out = sd_pipe.unet.forward(xt, timestep =  t, 
                                                 encoder_hidden_states = text_embeddings)
             
         
@@ -445,7 +139,7 @@ def edit(input_image,
         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)
+        xt = reverse_step(sd_pipe, noise_pred, t, xt, eta = etas[idx], variance_noise = z)
 
         # interm denoised img
         with autocast("cuda"), inference_mode():