Duplicate from LinoyTsaban/edit_friendly_ddpm_inversion

Co-authored-by: Linoy Tsaban <LinoyTsaban@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+Examples/source_a_ceramic_vase_with_yellow_flowers.jpeg filter=lfs diff=lfs merge=lfs -text
+Examples/source_a_model_on_a_runway.jpeg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,22 @@
+---
+title: Edit Friendly Ddpm Inversion
+emoji: 🖼️
+colorFrom: pink
+colorTo: orange
+sdk: gradio
+sdk_version: 3.32.0
+app_file: app.py
+pinned: false
+duplicated_from: LinoyTsaban/edit_friendly_ddpm_inversion
+---
+
+## BibTeX
+
+```
+@article{HubermanSpiegelglas2023,
+				title      = {An Edit Friendly DDPM Noise Space: Inversion and Manipulations},
+				author     = {Huberman-Spiegelglas, Inbar and Kulikov, Vladimir and Michaeli, Tomer},
+				journal    = {arXiv preprint arXiv:2304.06140},
+				year       = {2023}
+			}
+```

app.py

@@ -0,0 +1,246 @@
+import gradio as gr
+import torch
+import random
+import requests
+from io import BytesIO
+from diffusers import StableDiffusionPipeline
+from diffusers import DDIMScheduler
+from utils import *
+from inversion_utils import *
+from torch import autocast, inference_mode
+import re
+
+def randomize_seed_fn(seed, randomize_seed):
+    if randomize_seed:
+        seed = random.randint(0, np.iinfo(np.int32).max)
+    torch.manual_seed(seed)
+    return seed
+
+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, 
+  #  based on the code in https://github.com/inbarhub/DDPM_inversion
+   
+  #  returns wt, zs, wts:
+  #  wt - inverted latent
+  #  wts - intermediate inverted latents
+  #  zs - noise maps
+
+  sd_pipe.scheduler.set_timesteps(num_diffusion_steps)
+
+  # vae encode image
+  with autocast("cuda"), inference_mode():
+      w0 = (sd_pipe.vae.encode(x0).latent_dist.mode() * 0.18215).float()
+
+  # find Zs and wts - forward process
+  wt, zs, wts = inversion_forward_process(sd_pipe, w0, etas=eta, prompt=prompt_src, cfg_scale=cfg_scale_src, prog_bar=False, num_inference_steps=num_diffusion_steps)
+  return zs, wts
+
+
+
+def sample(zs, wts, prompt_tar="", skip=36, cfg_scale_tar=15, eta = 1):
+
+    # reverse process (via Zs and wT)
+    w0, _ = inversion_reverse_process(sd_pipe, xT=wts[skip], etas=eta, prompts=[prompt_tar], cfg_scales=[cfg_scale_tar], prog_bar=False, zs=zs[skip:])
+    
+    # vae decode image
+    with autocast("cuda"), inference_mode():
+        x0_dec = sd_pipe.vae.decode(1 / 0.18215 * w0).sample
+    if x0_dec.dim()<4:
+        x0_dec = x0_dec[None,:,:,:]
+    img = image_grid(x0_dec)
+    return img
+
+# load pipelines
+sd_model_id = "runwayml/stable-diffusion-v1-5"
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+sd_pipe = StableDiffusionPipeline.from_pretrained(sd_model_id).to(device)
+sd_pipe.scheduler = DDIMScheduler.from_config(sd_model_id, subfolder = "scheduler")
+
+
+
+def get_example():
+    case = [
+        [
+            'Examples/gnochi_mirror.jpeg', 
+            'Watercolor painting of a cat sitting next to a mirror',
+            'Examples/gnochi_mirror_watercolor_painting.png', 
+            '',
+            100,
+            3.5,
+            36,
+            15,
+ 
+             ],
+        [
+            'Examples/source_an_old_man.png', 
+            'A bronze statue of an old man',
+            'Examples/ddpm_a_bronze_statue_of_an_old_man.png', 
+            '',
+            100,
+            3.5,
+            36,
+            15,
+ 
+             ],
+        [
+            'Examples/source_a_ceramic_vase_with_yellow_flowers.jpeg', 
+            'A pink ceramic vase with a wheat bouquet',
+            'Examples/ddpm_a_pink_ceramic_vase_with_a_wheat_bouquet.png', 
+            '',
+            100,
+            3.5,
+            36,
+            15,
+ 
+             ],
+
+        [
+            'Examples/source_a_model_on_a_runway.jpeg', 
+            'A zebra on the runway',
+            'Examples/ddpm_a_zebra_on_the_run_way.png', 
+            '',
+            100,
+            3.5,
+            36,
+            15,
+ 
+             ]
+    
+    
+    ]
+    return case
+
+
+
+
+
+
+
+########
+# demo #
+########
+                        
+intro = """
+<h1 style="font-weight: 1400; text-align: center; margin-bottom: 7px;">
+   Edit Friendly DDPM Inversion
+</h1>
+<p style="font-size: 0.9rem; text-align: center; margin: 0rem; line-height: 1.2em; margin-top:1em">
+Based on the work introduced in:
+<a href="https://arxiv.org/abs/2304.06140" style="text-decoration: underline;" target="_blank">An Edit Friendly DDPM Noise Space:
+Inversion and Manipulations </a> 
+<p/>
+<p style="font-size: 0.9rem; margin: 0rem; line-height: 1.2em; margin-top:1em">
+For faster inference without waiting in queue, you may duplicate the space and upgrade to GPU in settings.
+<a href="https://huggingface.co/spaces/LinoyTsaban/edit_friendly_ddpm_inversion?duplicate=true">
+<img style="margin-top: 0em; margin-bottom: 0em" src="https://bit.ly/3gLdBN6" alt="Duplicate Space"></a>
+<p/>"""
+with gr.Blocks(css='style.css') as demo:
+    
+    def reset_do_inversion():
+        do_inversion = True
+        return do_inversion
+
+
+    def edit(input_image,
+            do_inversion, 
+             wts, zs,
+            src_prompt ="", 
+            tar_prompt="",
+            steps=100,
+            cfg_scale_src = 3.5,
+            cfg_scale_tar = 15,
+            skip=36,
+            seed = 0,
+            randomize_seed  = True):
+
+        x0 = load_512(input_image, device=device)
+    
+        if do_inversion or randomize_seed:
+            zs_tensor, wts_tensor = invert(x0 =x0 , prompt_src=src_prompt, num_diffusion_steps=steps, cfg_scale_src=cfg_scale_src)
+            wts = gr.State(value=wts_tensor)
+            zs = gr.State(value=zs_tensor)
+            do_inversion = False
+        
+        output = sample(zs.value, wts.value, prompt_tar=tar_prompt, skip=skip, cfg_scale_tar=cfg_scale_tar)    
+        return output, wts, zs, do_inversion
+    
+    gr.HTML(intro)
+    wts = gr.State()
+    zs = gr.State()
+    do_inversion = gr.State(value=True)
+    with gr.Row():
+        input_image = gr.Image(label="Input Image", interactive=True)
+        input_image.style(height=365, width=365)
+        output_image = gr.Image(label=f"Edited Image", interactive=False)
+        output_image.style(height=365, width=365)
+    
+    with gr.Row():
+        tar_prompt = gr.Textbox(lines=1, label="Describe your desired edited output", interactive=True)
+
+    with gr.Row():
+        with gr.Column(scale=1, min_width=100):
+            edit_button = gr.Button("Run")
+
+
+
+    with gr.Accordion("Advanced Options", open=False):
+        with gr.Row():
+            with gr.Column():
+                #inversion
+                src_prompt = gr.Textbox(lines=1, label="Source Prompt", interactive=True, placeholder="describe the original image")
+                steps = gr.Number(value=100, precision=0, label="Num Diffusion Steps", interactive=True)
+                cfg_scale_src = gr.Slider(minimum=1, maximum=15, value=3.5, label=f"Source Guidance Scale", interactive=True)
+            with gr.Column():
+                # reconstruction
+                skip = gr.Slider(minimum=0, maximum=60, value=36, step = 1, label="Skip Steps", interactive=True)
+                cfg_scale_tar = gr.Slider(minimum=7, maximum=18,value=15, label=f"Target Guidance Scale", interactive=True)
+                seed = gr.Number(value=0, precision=0, label="Seed", interactive=True)
+                randomize_seed = gr.Checkbox(label='Randomize seed', value=False)
+            
+
+    edit_button.click(
+        fn = randomize_seed_fn,
+        inputs = [seed, randomize_seed],
+        outputs = [seed], queue = False).then(
+        fn=edit,
+        inputs=[input_image,
+                do_inversion, wts, zs, 
+            src_prompt, 
+            tar_prompt,
+            steps,
+            cfg_scale_src,
+            cfg_scale_tar,
+            skip,
+            seed,randomize_seed 
+        ],
+        outputs=[output_image, wts, zs, do_inversion],
+    )
+
+    input_image.change(
+        fn = reset_do_inversion,
+        outputs = [do_inversion]
+    )
+
+    src_prompt.change(
+        fn = reset_do_inversion,
+        outputs = [do_inversion]
+    )
+
+
+    gr.Examples(
+        label='Examples', 
+        examples=get_example(), 
+        inputs=[input_image, tar_prompt,output_image, src_prompt,steps,
+                    cfg_scale_tar,
+                    skip,
+                    cfg_scale_tar
+                    
+               ],
+        outputs=[output_image ],
+    )
+
+
+
+demo.queue()
+demo.launch(share=False)

inversion_utils.py

@@ -0,0 +1,295 @@
+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
+
+# This file was copied from the DDPM inversion Repo - https://github.com/inbarhub/DDPM_inversion #
+
+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

requirements.txt

@@ -0,0 +1,5 @@
+diffusers
+accelerate
+transformers
+torch
+torchvision

style.css

@@ -0,0 +1,121 @@
+/*
+This CSS file is modified from:
+https://huggingface.co/spaces/DeepFloyd/IF/blob/main/style.css
+*/
+
+h1 {
+  text-align: center;
+}
+
+.gradio-container {
+  font-family: 'IBM Plex Sans', sans-serif;
+}
+
+.gr-button {
+  color: white;
+  border-color: black;
+  background: black;
+}
+
+input[type='range'] {
+  accent-color: black;
+}
+
+.dark input[type='range'] {
+  accent-color: #dfdfdf;
+}
+
+.container {
+  max-width: 730px;
+  margin: auto;
+  padding-top: 1.5rem;
+}
+
+
+.gr-button:focus {
+  border-color: rgb(147 197 253 / var(--tw-border-opacity));
+  outline: none;
+  box-shadow: var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow, 0 0 #0000);
+  --tw-border-opacity: 1;
+  --tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);
+  --tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(3px var(--tw-ring-offset-width)) var(--tw-ring-color);
+  --tw-ring-color: rgb(191 219 254 / var(--tw-ring-opacity));
+  --tw-ring-opacity: .5;
+}
+
+
+/* .footer {
+  margin-bottom: 45px;
+  margin-top: 35px;
+  text-align: center;
+  border-bottom: 1px solid #e5e5e5;
+}
+
+.footer>p {
+  font-size: .8rem;
+  display: inline-block;
+  padding: 0 10px;
+  transform: translateY(10px);
+  background: white;
+}
+
+.dark .footer {
+  border-color: #303030;
+}
+
+.dark .footer>p {
+  background: #0b0f19;
+}
+
+.acknowledgments h4 {
+  margin: 1.25em 0 .25em 0;
+  font-weight: bold;
+  font-size: 115%;
+}
+
+.animate-spin {
+  animation: spin 1s linear infinite;
+} */
+/* 
+@keyframes spin {
+  from {
+    transform: rotate(0deg);
+  }
+
+  to {
+    transform: rotate(360deg);
+  }
+} */
+
+.gr-form {
+  flex: 1 1 50%;
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+
+#prompt-container {
+  gap: 0;
+}
+
+#prompt-text-input,
+#negative-prompt-text-input {
+  padding: .45rem 0.625rem
+}
+
+#component-16 {
+  border-top-width: 1px !important;
+  margin-top: 1em
+}
+
+.image_duplication {
+  position: absolute;
+  width: 100px;
+  left: 50px
+}
+
+#component-0 {
+  max-width: 730px;
+  margin: auto;
+  padding-top: 1.5rem;
+}
+

utils.py

@@ -0,0 +1,116 @@
+import PIL
+from PIL import Image, ImageDraw ,ImageFont
+from matplotlib import pyplot as plt
+import torchvision.transforms as T
+import os
+import torch 
+import yaml
+
+# This file was copied from the DDPM inversion Repo - https://github.com/inbarhub/DDPM_inversion #
+
+def show_torch_img(img):
+    img = to_np_image(img)
+    plt.imshow(img)
+    plt.axis("off")
+
+def to_np_image(all_images):
+    all_images = (all_images.permute(0, 2, 3, 1) * 127.5 + 128).clamp(0, 255).to(torch.uint8).cpu().numpy()[0]
+    return all_images
+
+def tensor_to_pil(tensor_imgs):
+    if type(tensor_imgs) == list:
+        tensor_imgs = torch.cat(tensor_imgs)
+    tensor_imgs = (tensor_imgs / 2 + 0.5).clamp(0, 1)
+    to_pil = T.ToPILImage()
+    pil_imgs = [to_pil(img) for img in tensor_imgs]    
+    return pil_imgs
+
+def pil_to_tensor(pil_imgs):
+    to_torch = T.ToTensor()
+    if type(pil_imgs) == PIL.Image.Image:
+        tensor_imgs = to_torch(pil_imgs).unsqueeze(0)*2-1
+    elif type(pil_imgs) == list:    
+        tensor_imgs = torch.cat([to_torch(pil_imgs).unsqueeze(0)*2-1 for img in pil_imgs]).to(device)
+    else:
+        raise Exception("Input need to be PIL.Image or list of PIL.Image")
+    return tensor_imgs
+
+
+## TODO implement this
+# n = 10
+# num_rows = 4
+# num_col = n // num_rows
+# num_col  = num_col + 1 if n % num_rows else num_col
+# num_col
+def add_margin(pil_img, top = 0, right = 0, bottom = 0, 
+                    left = 0, color = (255,255,255)):
+    width, height = pil_img.size
+    new_width = width + right + left
+    new_height = height + top + bottom
+    result = Image.new(pil_img.mode, (new_width, new_height), color)
+    
+    result.paste(pil_img, (left, top))
+    return result
+
+def image_grid(imgs, rows = 1, cols = None, 
+                    size = None,
+                   titles = None, text_pos = (0, 0)):
+    if type(imgs) == list and type(imgs[0]) == torch.Tensor:
+        imgs = torch.cat(imgs)
+    if type(imgs) == torch.Tensor:
+        imgs = tensor_to_pil(imgs)
+        
+    if not size is None:
+        imgs = [img.resize((size,size)) for img in imgs]
+    if cols is None:
+        cols = len(imgs)
+    assert len(imgs) >= rows*cols
+    
+    top=20
+    w, h = imgs[0].size
+    delta = 0
+    if len(imgs)> 1 and not imgs[1].size[1] == h:
+        delta = top
+        h = imgs[1].size[1]
+    if not titles is  None:
+        font = ImageFont.truetype("/usr/share/fonts/truetype/freefont/FreeMono.ttf", 
+                                    size = 20, encoding="unic")
+        h = top + h 
+    grid = Image.new('RGB', size=(cols*w, rows*h+delta))    
+    for i, img in enumerate(imgs):
+        
+        if not titles is  None:
+            img = add_margin(img, top = top, bottom = 0,left=0)
+            draw = ImageDraw.Draw(img)
+            draw.text(text_pos, titles[i],(0,0,0), 
+            font = font)
+        if not delta == 0 and i > 0:
+           grid.paste(img, box=(i%cols*w, i//cols*h+delta))
+        else:
+            grid.paste(img, box=(i%cols*w, i//cols*h))
+        
+    return grid    
+
+
+"""
+input_folder - dataset folder
+"""
+def load_dataset(input_folder):
+    # full_file_names = glob.glob(input_folder)
+    # class_names = [x[0] for x in os.walk(input_folder)]
+    class_names = next(os.walk(input_folder))[1]
+    class_names[:] = [d for d in class_names if not d[0] == '.']
+    file_names=[]
+    for class_name in class_names:
+        cur_path = os.path.join(input_folder, class_name)
+        filenames = next(os.walk(cur_path), (None, None, []))[2]
+        filenames = [f for f in filenames if not f[0] == '.']
+        file_names.append(filenames)
+    return class_names, file_names
+
+
+def dataset_from_yaml(yaml_location):
+    with open(yaml_location, 'r') as stream:
+        data_loaded = yaml.safe_load(stream)
+
+    return data_loaded