added files

FlowEdit_utils.py

@@ -0,0 +1,404 @@
+from typing import Optional, Tuple, Union
+import torch
+from diffusers import FlowMatchEulerDiscreteScheduler
+from tqdm import tqdm
+import numpy as np
+
+from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import retrieve_timesteps
+
+
+
+def scale_noise(
+    scheduler,
+    sample: torch.FloatTensor,
+    timestep: Union[float, torch.FloatTensor],
+    noise: Optional[torch.FloatTensor] = None,
+) -> torch.FloatTensor:
+    """
+    Foward process in flow-matching
+
+    Args:
+        sample (`torch.FloatTensor`):
+            The input sample.
+        timestep (`int`, *optional*):
+            The current timestep in the diffusion chain.
+
+    Returns:
+        `torch.FloatTensor`:
+            A scaled input sample.
+    """
+    # if scheduler.step_index is None:
+    scheduler._init_step_index(timestep)
+
+    sigma = scheduler.sigmas[scheduler.step_index]
+    sample = sigma * noise + (1.0 - sigma) * sample
+
+    return sample
+
+
+# for flux
+def calculate_shift(
+    image_seq_len,
+    base_seq_len: int = 256,
+    max_seq_len: int = 4096,
+    base_shift: float = 0.5,
+    max_shift: float = 1.16,
+):
+    m = (max_shift - base_shift) / (max_seq_len - base_seq_len)
+    b = base_shift - m * base_seq_len
+    mu = image_seq_len * m + b
+    return mu
+
+
+
+def calc_v_sd3(pipe, src_tar_latent_model_input, src_tar_prompt_embeds, src_tar_pooled_prompt_embeds, src_guidance_scale, tar_guidance_scale, t):
+    # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
+    timestep = t.expand(src_tar_latent_model_input.shape[0])
+    # joint_attention_kwargs = {}
+    # # add timestep to joint_attention_kwargs
+    # joint_attention_kwargs["timestep"] = timestep[0]
+    # joint_attention_kwargs["timestep_idx"] = i
+
+
+    with torch.no_grad():
+        # # predict the noise for the source prompt
+        noise_pred_src_tar = pipe.transformer(
+            hidden_states=src_tar_latent_model_input,
+            timestep=timestep,
+            encoder_hidden_states=src_tar_prompt_embeds,
+            pooled_projections=src_tar_pooled_prompt_embeds,
+            joint_attention_kwargs=None,
+            return_dict=False,
+        )[0]
+
+        # perform guidance source
+        if pipe.do_classifier_free_guidance:
+            src_noise_pred_uncond, src_noise_pred_text, tar_noise_pred_uncond, tar_noise_pred_text = noise_pred_src_tar.chunk(4)
+            noise_pred_src = src_noise_pred_uncond + src_guidance_scale * (src_noise_pred_text - src_noise_pred_uncond)
+            noise_pred_tar = tar_noise_pred_uncond + tar_guidance_scale * (tar_noise_pred_text - tar_noise_pred_uncond)
+
+    return noise_pred_src, noise_pred_tar
+
+
+
+def calc_v_flux(pipe, latents, prompt_embeds, pooled_prompt_embeds, guidance, text_ids, latent_image_ids, t):
+    # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
+    timestep = t.expand(latents.shape[0])
+    # joint_attention_kwargs = {}
+    # # add timestep to joint_attention_kwargs
+    # joint_attention_kwargs["timestep"] = timestep[0]
+    # joint_attention_kwargs["timestep_idx"] = i
+
+
+    with torch.no_grad():
+        # # predict the noise for the source prompt
+        noise_pred = pipe.transformer(
+            hidden_states=latents,
+            timestep=timestep / 1000,
+            guidance=guidance,
+            encoder_hidden_states=prompt_embeds,
+            txt_ids=text_ids,
+            img_ids=latent_image_ids,
+            pooled_projections=pooled_prompt_embeds,
+            joint_attention_kwargs=None,
+            return_dict=False,
+        )[0]
+
+    return noise_pred
+
+
+
+@torch.no_grad()
+def FlowEditSD3(pipe,
+    scheduler,
+    x_src,
+    src_prompt,
+    tar_prompt,
+    negative_prompt,
+    T_steps: int = 50,
+    n_avg: int = 1,
+    src_guidance_scale: float = 3.5,
+    tar_guidance_scale: float = 13.5,
+    n_min: int = 0,
+    n_max: int = 15,):
+    
+    device = x_src.device
+
+    timesteps, T_steps = retrieve_timesteps(scheduler, T_steps, device, timesteps=None)
+
+    num_warmup_steps = max(len(timesteps) - T_steps * scheduler.order, 0)
+    pipe._num_timesteps = len(timesteps)
+    pipe._guidance_scale = src_guidance_scale
+    
+    # src prompts
+    (
+        src_prompt_embeds,
+        src_negative_prompt_embeds,
+        src_pooled_prompt_embeds,
+        src_negative_pooled_prompt_embeds,
+    ) = pipe.encode_prompt(
+        prompt=src_prompt,
+        prompt_2=None,
+        prompt_3=None,
+        negative_prompt=negative_prompt,
+        do_classifier_free_guidance=pipe.do_classifier_free_guidance,
+        device=device,
+    )
+
+    # tar prompts
+    pipe._guidance_scale = tar_guidance_scale
+    (
+        tar_prompt_embeds,
+        tar_negative_prompt_embeds,
+        tar_pooled_prompt_embeds,
+        tar_negative_pooled_prompt_embeds,
+    ) = pipe.encode_prompt(
+        prompt=tar_prompt,
+        prompt_2=None,
+        prompt_3=None,
+        negative_prompt=negative_prompt,
+        do_classifier_free_guidance=pipe.do_classifier_free_guidance,
+        device=device,
+    )
+ 
+    # CFG prep
+    src_tar_prompt_embeds = torch.cat([src_negative_prompt_embeds, src_prompt_embeds, tar_negative_prompt_embeds, tar_prompt_embeds], dim=0)
+    src_tar_pooled_prompt_embeds = torch.cat([src_negative_pooled_prompt_embeds, src_pooled_prompt_embeds, tar_negative_pooled_prompt_embeds, tar_pooled_prompt_embeds], dim=0)
+    
+    # initialize our ODE Zt_edit_1=x_src
+    zt_edit = x_src.clone()
+
+    for i, t in tqdm(enumerate(timesteps)):
+        
+        if T_steps - i > n_max:
+            continue
+        
+        t_i = t/1000
+        if i+1 < len(timesteps): 
+            t_im1 = (timesteps[i+1])/1000
+        else:
+            t_im1 = torch.zeros_like(t_i).to(t_i.device)
+        
+        if T_steps - i > n_min:
+
+            # Calculate the average of the V predictions
+            V_delta_avg = torch.zeros_like(x_src)
+            for k in range(n_avg):
+
+                fwd_noise = torch.randn_like(x_src).to(x_src.device)
+                
+                zt_src = (1-t_i)*x_src + (t_i)*fwd_noise
+
+                zt_tar = zt_edit + zt_src - x_src
+
+                src_tar_latent_model_input = torch.cat([zt_src, zt_src, zt_tar, zt_tar]) if pipe.do_classifier_free_guidance else (zt_src, zt_tar) 
+
+                Vt_src, Vt_tar = calc_v_sd3(pipe, src_tar_latent_model_input,src_tar_prompt_embeds, src_tar_pooled_prompt_embeds, src_guidance_scale, tar_guidance_scale, t)
+
+                V_delta_avg += (1/n_avg) * (Vt_tar - Vt_src) # - (hfg-1)*( x_src))
+
+            # propagate direct ODE
+            zt_edit = zt_edit.to(torch.float32)
+
+            zt_edit = zt_edit + (t_im1 - t_i) * V_delta_avg
+            
+            zt_edit = zt_edit.to(V_delta_avg.dtype)
+
+        else: # i >= T_steps-n_min # regular sampling for last n_min steps
+
+            if i == T_steps-n_min:
+                # initialize SDEDIT-style generation phase
+                fwd_noise = torch.randn_like(x_src).to(x_src.device)
+                xt_src = scale_noise(scheduler, x_src, t, noise=fwd_noise)
+                xt_tar = zt_edit + xt_src - x_src
+                
+            src_tar_latent_model_input = torch.cat([xt_tar, xt_tar, xt_tar, xt_tar]) if pipe.do_classifier_free_guidance else (xt_src, xt_tar)
+
+            _, noise_pred_tar = calc_v_sd3(pipe, src_tar_latent_model_input,src_tar_prompt_embeds, src_tar_pooled_prompt_embeds, src_guidance_scale, tar_guidance_scale, t)
+
+            xt_tar = xt_tar.to(torch.float32)
+
+            prev_sample = xt_tar + (t_im1 - t_im1) * (noise_pred_tar)
+
+            prev_sample = prev_sample.to(noise_pred_tar.dtype)
+
+            xt_tar = prev_sample
+        
+    return zt_edit if n_min == 0 else xt_tar
+
+
+
+@torch.no_grad()
+def FlowEditFLUX(pipe,
+    scheduler,
+    x_src,
+    src_prompt,
+    tar_prompt,
+    negative_prompt,
+    T_steps: int = 28,
+    n_avg: int = 1,
+    src_guidance_scale: float = 1.5,
+    tar_guidance_scale: float = 5.5,
+    n_min: int = 0,
+    n_max: int = 24,):
+
+    device = x_src.device
+    orig_height, orig_width = x_src.shape[2]*pipe.vae_scale_factor//2, x_src.shape[3]*pipe.vae_scale_factor//2
+    num_channels_latents = pipe.transformer.config.in_channels // 4
+
+    pipe.check_inputs(
+        prompt=src_prompt,
+        prompt_2=None,
+        height=orig_height,
+        width=orig_width,
+        callback_on_step_end_tensor_inputs=None,
+        max_sequence_length=512,
+    )
+
+    x_src, latent_src_image_ids = pipe.prepare_latents(batch_size= x_src.shape[0], num_channels_latents=num_channels_latents, height=orig_height, width=orig_width, dtype=x_src.dtype, device=x_src.device, generator=None,latents=x_src)
+    x_src_packed = pipe._pack_latents(x_src, x_src.shape[0], num_channels_latents, x_src.shape[2], x_src.shape[3])
+    latent_tar_image_ids = latent_src_image_ids
+
+    # 5. Prepare timesteps
+    sigmas = np.linspace(1.0, 1 / T_steps, T_steps)
+    image_seq_len = x_src_packed.shape[1]
+    mu = calculate_shift(
+        image_seq_len,
+        scheduler.config.base_image_seq_len,
+        scheduler.config.max_image_seq_len,
+        scheduler.config.base_shift,
+        scheduler.config.max_shift,
+    )
+    timesteps, T_steps = retrieve_timesteps(
+        scheduler,
+        T_steps,
+        device,
+        timesteps=None,
+        sigmas=sigmas,
+        mu=mu,
+        )
+    
+    num_warmup_steps = max(len(timesteps) - T_steps * pipe.scheduler.order, 0)
+    pipe._num_timesteps = len(timesteps)
+
+    
+    # src prompts
+    (
+        src_prompt_embeds,
+        src_pooled_prompt_embeds,
+        src_text_ids,
+
+    ) = pipe.encode_prompt(
+        prompt=src_prompt,
+        prompt_2=None,
+        device=device,
+    )
+
+    # tar prompts
+    pipe._guidance_scale = tar_guidance_scale
+    (
+        tar_prompt_embeds,
+        tar_pooled_prompt_embeds,
+        tar_text_ids,
+    ) = pipe.encode_prompt(
+        prompt=tar_prompt,
+        prompt_2=None,
+        device=device,
+    )
+
+    # handle guidance
+    if pipe.transformer.config.guidance_embeds:
+        src_guidance = torch.tensor([src_guidance_scale], device=device)
+        src_guidance = src_guidance.expand(x_src_packed.shape[0])
+        tar_guidance = torch.tensor([tar_guidance_scale], device=device)
+        tar_guidance = tar_guidance.expand(x_src_packed.shape[0])
+    else:
+        src_guidance = None
+        tar_guidance = None
+
+    # initialize our ODE Zt_edit_1=x_src
+    zt_edit = x_src_packed.clone()
+
+    for i, t in tqdm(enumerate(timesteps)):
+        
+        if T_steps - i > n_max:
+            continue
+        
+        scheduler._init_step_index(t)
+        t_i = scheduler.sigmas[scheduler.step_index]
+        if i < len(timesteps):
+            t_im1 = scheduler.sigmas[scheduler.step_index + 1]
+        else:
+            t_im1 = t_i
+        
+        if T_steps - i > n_min:
+
+            # Calculate the average of the V predictions
+            V_delta_avg = torch.zeros_like(x_src_packed)
+
+            for k in range(n_avg):
+                                    
+
+                fwd_noise = torch.randn_like(x_src_packed).to(x_src_packed.device)
+                
+                zt_src = (1-t_i)*x_src_packed + (t_i)*fwd_noise
+
+                zt_tar = zt_edit + zt_src - x_src_packed
+
+                # Merge in the future to avoid double computation
+                Vt_src = calc_v_flux(pipe,
+                                                    latents=zt_src,
+                                                    prompt_embeds=src_prompt_embeds, 
+                                                    pooled_prompt_embeds=src_pooled_prompt_embeds, 
+                                                    guidance=src_guidance,
+                                                    text_ids=src_text_ids, 
+                                                    latent_image_ids=latent_src_image_ids, 
+                                                    t=t)
+                
+                Vt_tar = calc_v_flux(pipe,
+                                                    latents=zt_tar,
+                                                    prompt_embeds=tar_prompt_embeds, 
+                                                    pooled_prompt_embeds=tar_pooled_prompt_embeds, 
+                                                    guidance=tar_guidance,
+                                                    text_ids=tar_text_ids, 
+                                                    latent_image_ids=latent_tar_image_ids, 
+                                                    t=t)
+
+                V_delta_avg += (1/n_avg) * (Vt_tar - Vt_src) # - (hfg-1)*( x_src))
+
+            # propagate direct ODE
+            zt_edit = zt_edit.to(torch.float32)
+
+            zt_edit = zt_edit + (t_im1 - t_i) * V_delta_avg
+
+            zt_edit = zt_edit.to(V_delta_avg.dtype)
+
+        else: # i >= T_steps-n_min # regular sampling last n_min steps
+
+            if i == T_steps-n_min:
+                # initialize SDEDIT-style generation phase
+                fwd_noise = torch.randn_like(x_src_packed).to(x_src_packed.device)
+                xt_src = scale_noise(scheduler, x_src_packed, t, noise=fwd_noise)
+                xt_tar = zt_edit + xt_src - x_src_packed
+                
+            Vt_tar = calc_v_flux(pipe,
+                                    latents=xt_tar,
+                                    prompt_embeds=tar_prompt_embeds, 
+                                    pooled_prompt_embeds=tar_pooled_prompt_embeds, 
+                                    guidance=tar_guidance,
+                                    text_ids=tar_text_ids, 
+                                    latent_image_ids=latent_tar_image_ids, 
+                                    t=t)
+
+
+            xt_tar = xt_tar.to(torch.float32)
+
+            prev_sample = xt_tar + (t_im1 - t_i) * (Vt_tar)
+
+            prev_sample = prev_sample.to(Vt_tar.dtype)
+            xt_tar = prev_sample
+    out = zt_edit if n_min == 0 else xt_tar
+    unpacked_out = pipe._unpack_latents(out, orig_height, orig_width, pipe.vae_scale_factor)
+    return unpacked_out
+
+

app.py

@@ -0,0 +1,272 @@
+import gradio as gr
+import torch
+from diffusers import FluxPipeline, StableDiffusion3Pipeline
+from PIL import Image
+
+import random
+import numpy as np
+import spaces
+
+from FlowEdit_utils import FlowEditSD3, FlowEditFLUX
+
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+# device = "cpu"
+# model_type = 'SD3'
+
+pipe = StableDiffusion3Pipeline.from_pretrained("stabilityai/stable-diffusion-3-medium-diffusers", torch_dtype=torch.float16)
+scheduler = pipe.scheduler
+pipe = pipe.to(device)
+loaded_model = 'SD3'
+
+
+def on_model_change(model_type):
+    if model_type == 'SD3':
+
+        T_steps_value = 50
+
+        src_guidance_scale_value = 3.5
+
+        tar_guidance_scale_value = 13.5
+
+        n_max_value = 33
+
+    elif model_type == 'FLUX':
+
+        T_steps_value = 28
+
+        src_guidance_scale_value = 1.5
+
+        tar_guidance_scale_value = 5.5
+
+        n_max_value = 24
+
+    else:
+        raise NotImplementedError(f"Model type {model_type} not implemented")
+    
+    return T_steps_value, src_guidance_scale_value, tar_guidance_scale_value, n_max_value
+
+def get_examples():
+    case = [
+        ["inputs/cat.png", "SD3", 50,  3.5, 13.5, 33, "a cat sitting in the grass", "a puppy sitting in the grass", 0, 1, 42],
+        ["inputs/gas_station.png", "SD3", 50,  3.5, 13.5, 33, "cars are parked in front of a gas station with a sign that says \"CAFE\"", "cars are parked in front of a gas station with a sign that says \"CVPR\"", 0, 1, 42],
+        ["inputs/iguana.png", "SD3", 50,  3.5, 13.5, 31, "A large orange lizard sitting on a rock near the      ocean. The lizard is positioned in the center of the scene, with the ocean waves visible in the background. The rock is located close to the water, providing a picturesque setting for the lizard''s resting spot.", "A large dragon sitting on a rock near the ocean. The dragon is positioned in the center of the scene, with the ocean waves visible in the background. The rock is located close to the water, providing a picturesque setting for the dragon''s resting spot.", 0, 1, 42],
+        ["inputs/cat.png", "FLUX", 28,  1.5, 5.5, 24, "a cat sitting in the grass", "a puppy sitting in the grass", 0, 1, 42],
+        ["inputs/gas_station.png", "FLUX", 28,  1.5, 5.5, 24, "cars are parked in front of a gas station with a sign that says \"CAFE\"", "cars are parked in front of a gas station with a sign that says \"CVPR\"", 0, 1, 23],
+        ["inputs/steak.png", "FLUX", 28,  1.5, 5.5, 24, "A steak accompanied by a side of leaf salad.", "A bread roll accompanied by a side of leaf salad.", 0, 1, 42],
+    ]
+    return case
+
+
+@spaces.GPU()
+def FlowEditRun(
+    image_src: str,
+    model_type: str,
+    T_steps: int,
+    src_guidance_scale: float,
+    tar_guidance_scale: float,
+    n_max: int,
+    src_prompt: str,
+    tar_prompt: str,
+    n_min: int,
+    n_avg: int,
+    seed: int,
+
+    ):
+
+    if not len(src_prompt):
+        raise gr.Error("source prompt cannot be empty")
+    if not len(tar_prompt):
+        raise gr.Error("target prompt cannot be empty")
+
+    global pipe
+    global scheduler
+    global loaded_model
+
+    # reload model only if different from the loaded model
+    if loaded_model != model_type:
+
+        if model_type == 'FLUX':
+            # pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.float16) 
+            pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", torch_dtype=torch.float16)
+            loaded_model = 'FLUX'
+        elif model_type == 'SD3':
+            pipe = StableDiffusion3Pipeline.from_pretrained("stabilityai/stable-diffusion-3-medium-diffusers", torch_dtype=torch.float16)
+            loaded_model = 'SD3'
+        else:
+            raise NotImplementedError(f"Model type {model_type} not implemented")
+
+        scheduler = pipe.scheduler
+        pipe = pipe.to(device)
+
+
+
+
+    # set seed
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    # load image
+    image = Image.open(image_src)
+    # crop image to have both dimensions divisibe by 16 - avoids issues with resizing
+    image = image.crop((0, 0, image.width - image.width % 16, image.height - image.height % 16))
+    image_src = pipe.image_processor.preprocess(image)
+    # image_tar = pipe.image_processor.postprocess(image_src)
+    # return image_tar[0]
+
+    # cast image to half precision
+    image_src = image_src.to(device).half()
+
+    with torch.autocast("cuda"), torch.inference_mode():
+        x0_src_denorm = pipe.vae.encode(image_src).latent_dist.mode()
+    x0_src = (x0_src_denorm - pipe.vae.config.shift_factor) * pipe.vae.config.scaling_factor
+    # send to cuda
+    x0_src = x0_src.to(device)
+
+    negative_prompt =  "" # optionally add support for negative prompts (SD3)
+
+    if model_type == 'SD3':
+        x0_tar = FlowEditSD3(pipe,
+                            scheduler,
+                            x0_src,
+                            src_prompt,
+                            tar_prompt,
+                            negative_prompt,
+                            T_steps,
+                            n_avg,
+                            src_guidance_scale,
+                            tar_guidance_scale,
+                            n_min,
+                            n_max,)
+        
+    elif model_type == 'FLUX':
+        x0_tar = FlowEditFLUX(pipe,
+                            scheduler,
+                            x0_src,
+                            src_prompt,
+                            tar_prompt,
+                            negative_prompt,
+                            T_steps,
+                            n_avg,
+                            src_guidance_scale,
+                            tar_guidance_scale,
+                            n_min,
+                            n_max,)
+    else:
+        raise NotImplementedError(f"Sampler type {model_type} not implemented")
+
+
+    x0_tar_denorm = (x0_tar / pipe.vae.config.scaling_factor) + pipe.vae.config.shift_factor
+    with torch.autocast("cuda"), torch.inference_mode():
+        image_tar = pipe.vae.decode(x0_tar_denorm, return_dict=False)[0]
+    image_tar = pipe.image_processor.postprocess(image_tar)
+
+
+    return image_tar[0]
+
+
+# title = "FlowEdit: Inversion-Free Text-Based Editing Using Pre-Trained Flow Models"
+
+intro = """
+<h1 style="font-weight: 1000; text-align: center; margin: 0px;">FlowEdit: Inversion-Free Text-Based Editing Using Pre-Trained Flow Models</h1>
+<h3 style="margin-bottom: 10px; text-align: center;">
+    <a href="https://arxiv.org/">[Paper]</a>&nbsp;|&nbsp;
+    <a href="https://matankleiner.github.io/flowedit/">[Project Page]</a>&nbsp;|&nbsp;
+    <a href="https://github.com/fallenshock/FlowEdit">[Code]</a>
+</h3>
+Gradio demo for FlowEdit: Inversion-Free Text-Based Editing Using Pre-Trained Flow Models. See our project page for more details.
+
+<br>
+<br>Edit your image using Flow models! upload an image, add a description of it, and specify the edits you want to make.
+<h3>Notes:</h3>
+
+<ol>
+  <li>We use FLUX.1 dev and SD3 for the demo. The models are large and may take a while to load.</li>
+  <li>We recommend 1024x1024 images for the best results. If the input images are too large, there may be out-of-memory errors.</li>
+  <li>Default hyperparameters for each model used in the paper are provided as examples. Feel free to experiment with them as well.</li>
+</ol>  
+
+"""
+
+# article = """
+# 📝 **Citation**
+# ```bibtex
+# @article{aaa,
+#   author    = {},
+#   title     = {},
+#   journal   = {},
+#   year      = {2024},
+#   url       = {}
+# }
+# ```
+# """
+
+
+with gr.Blocks() as demo:
+    
+
+    gr.HTML(intro)
+
+    with gr.Row(equal_height=True):
+        image_src = gr.Image(type="filepath", label="Source Image", value="inputs/cat.png",)
+        image_tar = gr.Image(label="Output", type="pil", show_label=True, format="png",),
+
+    with gr.Row():
+        src_prompt = gr.Textbox(lines=2, label="Source Prompt", value="a cat sitting in the grass")
+
+    with gr.Row():
+        tar_prompt = gr.Textbox(lines=2, label="Target Prompt", value="a puppy sitting in the grass")
+
+    with gr.Row():
+        model_type = gr.Dropdown(["SD3", "FLUX"], label="Model Type", value="SD3")
+        T_steps = gr.Number(value=50, label="Total Steps", minimum=1, maximum=50)
+        n_max = gr.Number(value=33, label="n_max (control the strength of the edit)")
+
+    with gr.Row():
+        src_guidance_scale = gr.Slider(minimum=1.0, maximum=30.0, value=3.5, label="src_guidance_scale")
+        tar_guidance_scale = gr.Slider(minimum=1.0, maximum=30.0, value=13.5, label="tar_guidance_scale")
+    
+    with gr.Row():
+        submit_button = gr.Button("Run FlowEdit", variant="primary")
+
+    with gr.Accordion(label="Advanced Settings", open=False):
+        # additional inputs
+        n_min = gr.Number(value=0, label="n_min (for improved style edits)")
+        n_avg = gr.Number(value=1, label="n_avg (improve structure at the cost of runtime)", minimum=1)
+        seed = gr.Number(value=42, label="seed")
+
+
+
+    submit_button.click(
+                        fn=FlowEditRun, 
+                        inputs=[
+                        image_src,
+                        model_type,
+                        T_steps,
+                        src_guidance_scale,
+                        tar_guidance_scale,
+                        n_max,
+                        src_prompt,
+                        tar_prompt,
+                        n_min,
+                        n_avg,
+                        seed,
+                        ],
+                        outputs=[
+                        image_tar[0],
+                        ],
+                        )
+
+    gr.Examples(
+        label="Examples",
+        examples=get_examples(),
+        inputs=[image_src, model_type, T_steps, src_guidance_scale, tar_guidance_scale, n_max, src_prompt, tar_prompt, n_min, n_avg, seed],
+    )
+
+    model_type.input(fn=on_model_change, inputs=[model_type], outputs=[T_steps, src_guidance_scale, tar_guidance_scale, n_max])
+
+
+    # gr.HTML(article)
+demo.queue()
+demo.launch( )

requirements.txt

@@ -0,0 +1,81 @@
+accelerate==1.2.0
+aiofiles==23.2.1
+annotated-types==0.7.0
+anyio==4.7.0
+certifi==2024.8.30
+charset-normalizer==3.4.0
+click==8.1.7
+diffusers==0.31.0
+fastapi==0.115.6
+ffmpy==0.4.0
+filelock==3.16.1
+fsspec==2024.10.0
+gradio==5.8.0
+gradio_client==1.5.1
+h11==0.14.0
+httpcore==1.0.7
+httpx==0.28.1
+huggingface-hub==0.26.5
+idna==3.10
+importlib_metadata==8.5.0
+Jinja2==3.1.4
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+mdurl==0.1.2
+mpmath==1.3.0
+networkx==3.4.2
+numpy==2.2.0
+nvidia-cublas-cu12==12.1.3.1
+nvidia-cuda-cupti-cu12==12.1.105
+nvidia-cuda-nvrtc-cu12==12.1.105
+nvidia-cuda-runtime-cu12==12.1.105
+nvidia-cudnn-cu12==9.1.0.70
+nvidia-cufft-cu12==11.0.2.54
+nvidia-curand-cu12==10.3.2.106
+nvidia-cusolver-cu12==11.4.5.107
+nvidia-cusparse-cu12==12.1.0.106
+nvidia-nccl-cu12==2.20.5
+nvidia-nvjitlink-cu12==12.6.85
+nvidia-nvtx-cu12==12.1.105
+orjson==3.10.12
+packaging==24.2
+pandas==2.2.3
+pillow==11.0.0
+protobuf==5.29.1
+psutil==5.9.8
+pydantic==2.10.3
+pydantic_core==2.27.1
+pydub==0.25.1
+Pygments==2.18.0
+python-dateutil==2.9.0.post0
+python-multipart==0.0.19
+pytz==2024.2
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.32.3
+rich==13.9.4
+ruff==0.8.2
+safehttpx==0.1.6
+safetensors==0.4.5
+semantic-version==2.10.0
+sentencepiece==0.2.0
+setuptools==75.6.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+spaces==0.31.0
+starlette==0.41.3
+sympy==1.13.3
+tokenizers==0.21.0
+tomlkit==0.13.2
+torch==2.4.1
+tqdm==4.67.1
+transformers==4.47.0
+triton==3.0.0
+typer==0.15.1
+typing_extensions==4.12.2
+tzdata==2024.2
+urllib3==2.2.3
+uvicorn==0.32.1
+websockets==14.1
+zipp==3.21.0