update gradio version && improvements

app.py → app_mixture.py

@@ -1,102 +1,99 @@
 import random
+
 import gradio as gr
 import numpy as np
 import spaces
 import torch
+from pipeline.mixture_tiling_sdxl import StableDiffusionXLTilingPipeline
+from pipeline.util import SAMPLERS, create_hdr_effect, select_scheduler
+
 from diffusers import AutoencoderKL
-from mixture_tiling_sdxl import StableDiffusionXLTilingPipeline
+
 
 MAX_SEED = np.iinfo(np.int32).max
-SCHEDULERS = [
-                "LMSDiscreteScheduler",
-                "DEISMultistepScheduler",
-                "HeunDiscreteScheduler",
-                "EulerAncestralDiscreteScheduler",
-                "EulerDiscreteScheduler",
-                "DPMSolverMultistepScheduler",
-                "DPMSolverMultistepScheduler-Karras",
-                "DPMSolverMultistepScheduler-Karras-SDE",
-                "UniPCMultistepScheduler"
-]
-
-vae = AutoencoderKL.from_pretrained(
-    "madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16
-).to("cuda")
 
-model_id="stablediffusionapi/yamermix-v8-vae"
+vae = AutoencoderKL.from_pretrained("madebyollin/sdxl-vae-fp16-fix", torch_dtype=torch.float16).to("cuda")
+
+model_id = "stablediffusionapi/yamermix-v8-vae"
 pipe = StableDiffusionXLTilingPipeline.from_pretrained(
     model_id,
     torch_dtype=torch.float16,
     vae=vae,
-    use_safetensors=False, #for yammermix   
-    #variant="fp16",
+    use_safetensors=False,  # for yammermix
+    # variant="fp16",
 ).to("cuda")
 
-pipe.enable_model_cpu_offload() #<< Enable this if you have limited VRAM
+#pipe.enable_model_cpu_offload()  # << Enable this if you have limited VRAM
 pipe.enable_vae_tiling()
 pipe.enable_vae_slicing()
 
-#region functions
-def select_scheduler(scheduler_name):
-    scheduler = scheduler_name.split("-")
-    scheduler_class_name = scheduler[0]
-    add_kwargs = {"beta_start": 0.00085, "beta_end": 0.012, "beta_schedule": "scaled_linear", "num_train_timesteps": 1000}
-    if len(scheduler) > 1:
-        add_kwargs["use_karras_sigmas"] = True
-    if len(scheduler) > 2:
-        add_kwargs["algorithm_type"] = "sde-dpmsolver++"
-    import diffusers
-    scheduler = getattr(diffusers, scheduler_class_name)    
-    scheduler = scheduler.from_config(pipe.scheduler.config, **add_kwargs) 
-    return scheduler
-
-
 
+# region functions
 @spaces.GPU
-def predict(left_prompt, center_prompt, right_prompt, negative_prompt, left_gs, center_gs, right_gs, overlap_pixels, steps, generation_seed, scheduler, tile_height, tile_width, target_height, target_width):
+def predict(
+    left_prompt,
+    center_prompt,
+    right_prompt,
+    negative_prompt,
+    left_gs,
+    center_gs,
+    right_gs,
+    overlap_pixels,
+    steps,
+    generation_seed,
+    scheduler,
+    tile_height,
+    tile_width,
+    target_height,
+    target_width,
+    hdr,
+    progress=gr.Progress(track_tqdm=True),
+):
     global pipe
-    
+
     # Set selected scheduler
     print(f"Using scheduler: {scheduler}...")
-    pipe.scheduler = select_scheduler(scheduler)
+    pipe.scheduler = select_scheduler(pipe, scheduler)
 
     # Set seed
     generator = torch.Generator("cuda").manual_seed(generation_seed)
-    
+
     target_height = int(target_height)
     target_width = int(target_width)
     tile_height = int(tile_height)
     tile_width = int(tile_width)
-    
+
     # Mixture of Diffusers generation
     image = pipe(
         prompt=[
             [
                 left_prompt,
                 center_prompt,
-                right_prompt,            
+                right_prompt,
             ]
         ],
         negative_prompt=negative_prompt,
         tile_height=tile_height,
         tile_width=tile_width,
         tile_row_overlap=0,
-        tile_col_overlap=overlap_pixels,        
-        guidance_scale_tiles=[[left_gs, center_gs, right_gs]],     
+        tile_col_overlap=overlap_pixels,
+        guidance_scale_tiles=[[left_gs, center_gs, right_gs]],
         height=target_height,
-        width=target_width,               
+        width=target_width,
         generator=generator,
         num_inference_steps=steps,
     )["images"][0]
 
+    image = create_hdr_effect(image, hdr)
     return image
 
+
 def calc_tile_size(target_height, target_width, overlap_pixels, max_tile_width_size=1280):
-    num_cols=3
-    num_rows=1    
-    min_tile_dimension=8
-    reduction_step=8
-    max_tile_height_size=1024
+    num_cols = 3
+    num_rows = 1
+    min_tile_dimension = 8
+    reduction_step = 8
+    max_tile_height_size = 1024
     best_tile_width = 0
     best_tile_height = 0
     best_adjusted_target_width = 0
@@ -109,11 +106,11 @@ def calc_tile_size(target_height, target_width, overlap_pixels, max_tile_width_s
 
     while tile_width >= min_tile_dimension:
         horizontal_borders = num_cols - 1
-        total_horizontal_overlap_pixels = (overlap_pixels * horizontal_borders)
+        total_horizontal_overlap_pixels = overlap_pixels * horizontal_borders
         adjusted_target_width = tile_width * num_cols - total_horizontal_overlap_pixels
 
         vertical_borders = num_rows - 1
-        total_vertical_overlap_pixels = (overlap_pixels * vertical_borders)
+        total_vertical_overlap_pixels = overlap_pixels * vertical_borders
         adjusted_target_height = tile_height * num_rows - total_vertical_overlap_pixels
 
         if tile_width <= max_tile_width_size and adjusted_target_width <= target_width:
@@ -131,15 +128,15 @@ def calc_tile_size(target_height, target_width, overlap_pixels, max_tile_width_s
 
         while tile_height >= min_tile_dimension:
             horizontal_borders = num_cols - 1
-            total_horizontal_overlap_pixels = (overlap_pixels * horizontal_borders)
+            total_horizontal_overlap_pixels = overlap_pixels * horizontal_borders
             adjusted_target_width = tile_width * num_cols - total_horizontal_overlap_pixels
 
             vertical_borders = num_rows - 1
-            total_vertical_overlap_pixels = (overlap_pixels * vertical_borders)
+            total_vertical_overlap_pixels = overlap_pixels * vertical_borders
             adjusted_target_height = tile_height * num_rows - total_vertical_overlap_pixels
-        
+
             if tile_height <= max_tile_height_size and adjusted_target_height <= target_height:
-                 if adjusted_target_height > best_adjusted_target_height:
+                if adjusted_target_height > best_adjusted_target_height:
                     best_tile_height = tile_height
                     best_adjusted_target_height = adjusted_target_height
 
@@ -150,7 +147,7 @@ def calc_tile_size(target_height, target_width, overlap_pixels, max_tile_width_s
     tile_width = best_tile_width
     tile_height = best_tile_height
 
-    print("--- TILE SIZE CALCULATED VALUES ---")    
+    print("--- TILE SIZE CALCULATED VALUES ---")
     print(f"Overlap pixels (requested): {overlap_pixels}")
     print(f"Tile Height (divisible by 8, max {max_tile_height_size}): {tile_height}")
     print(f"Tile Width (divisible by 8, max {max_tile_width_size}): {tile_width}")
@@ -163,32 +160,122 @@ def calc_tile_size(target_height, target_width, overlap_pixels, max_tile_width_s
 
     return new_target_height, new_target_width, tile_height, tile_width
 
-def do_calc_tile(target_height, target_width, overlap_pixels, max_tile_size):    
-    new_target_height, new_target_width, tile_height, tile_width = calc_tile_size(target_height, target_width, overlap_pixels, max_tile_size)    
-    return gr.update(value=tile_height), gr.update(value=tile_width), gr.update(value=new_target_height), gr.update(value=new_target_width)
+
+def do_calc_tile(target_height, target_width, overlap_pixels, max_tile_size):
+    new_target_height, new_target_width, tile_height, tile_width = calc_tile_size(
+        target_height, target_width, overlap_pixels, max_tile_size
+    )
+    return (
+        gr.update(value=tile_height),
+        gr.update(value=tile_width),
+        gr.update(value=new_target_height),
+        gr.update(value=new_target_width),
+    )
+
 
 def clear_result():
     return gr.update(value=None)
 
-def run_for_examples(left_prompt, center_prompt, right_prompt, negative_prompt, left_gs, center_gs, right_gs, overlap_pixels, steps, generation_seed, scheduler, tile_height, tile_width, target_height, target_width, max_tile_width):
-    return predict(left_prompt, center_prompt, right_prompt, negative_prompt, left_gs, center_gs, right_gs, overlap_pixels, steps, generation_seed, scheduler, tile_height, tile_width, target_height, target_width)
+
+def run_for_examples(
+    left_prompt,
+    center_prompt,
+    right_prompt,
+    negative_prompt,
+    left_gs,
+    center_gs,
+    right_gs,
+    overlap_pixels,
+    steps,
+    generation_seed,
+    scheduler,
+    tile_height,
+    tile_width,
+    target_height,
+    target_width,
+    max_tile_width,
+    hdr,
+):
+    return predict(
+        left_prompt,
+        center_prompt,
+        right_prompt,
+        negative_prompt,
+        left_gs,
+        center_gs,
+        right_gs,
+        overlap_pixels,
+        steps,
+        generation_seed,
+        scheduler,
+        tile_height,
+        tile_width,
+        target_height,
+        target_width,
+        hdr,
+    )
+
 
 def randomize_seed_fn(generation_seed: int, randomize_seed: bool) -> int:
     if randomize_seed:
         generation_seed = random.randint(0, MAX_SEED)
     return generation_seed
 
+
 css = """
-.gradio-container .fillable { 
-    width: 95% !important;
+body {
+    font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
+    margin: 0;
+    padding: 0;
+}
+.gradio-container {
+    border-radius: 15px;
+    padding: 30px 40px;
+    box-shadow: 0 8px 30px rgba(0, 0, 0, 0.3);
+    margin: 40px 340px;
+}
+.gradio-container h1 {
+    text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.2);
+}
+.fillable {
+    width: 100% !important;
     max-width: unset !important;
 }
+#examples_container {
+    margin: auto;
+    width: 90%;
+}
+#examples_row {
+    justify-content: center;
+}
+#tips_row{
+    padding-left: 20px;
+}
+.sidebar {
+    border-radius: 10px;
+    padding: 10px;
+    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.2);
+}
+.sidebar .toggle-button {
+    background: linear-gradient(90deg, #fbbf24, #fcd34d) !important;
+    border: none;
+    padding: 12px 24px;
+    text-transform: uppercase;
+    font-weight: bold;
+    letter-spacing: 1px;
+    border-radius: 5px;
+    cursor: pointer;
+    transition: transform 0.2s ease-in-out;
+}
+.toggle-button:hover {
+    transform: scale(1.05);
+}
 """
-title = """<h1 align="center">Mixture-of-Diffusers for SDXL Tiling Pipeline🤗</h1>           
+title = """<h1 align="center">Mixture-of-Diffusers for SDXL Tiling Pipeline🤗</h1>
            <div style="display: flex; flex-direction: column; justify-content: center; align-items: center; text-align: center; overflow:hidden;">
-                <span>This <a href="https://github.com/DEVAIEXP/mixture-of-diffusers-sdxl-tiling">project</a> implements a SDXL tiling pipeline based on the original project: <a href='https://github.com/albarji/mixture-of-diffusers'>Mixture-of-Diffusers</a>. For more information, see the:                
+                <span>This <a href="https://github.com/DEVAIEXP/mixture-of-diffusers-sdxl-tiling">project</a> implements a SDXL tiling pipeline based on the original project: <a href='https://github.com/albarji/mixture-of-diffusers'>Mixture-of-Diffusers</a>. For more information, see the:
                 <a href="https://arxiv.org/pdf/2302.02412">📜 paper </a>
-           </div>           
+           </div>
            """
 
 tips = """
@@ -212,102 +299,67 @@ about = """
 If you have any questions or suggestions, feel free to send your question to <b>[email protected]</b>.
 """
 
-with gr.Blocks(css=css) as app:
-    gr.Markdown(title)    
+with gr.Blocks(css=css, theme=gr.themes.Citrus()) as app:
+    gr.Markdown(title)
     with gr.Row():
         with gr.Column(scale=7):
             generate_button = gr.Button("Generate")
             with gr.Row():
                 with gr.Column(scale=1):
                     gr.Markdown("### Left region")
-                    left_prompt = gr.Textbox(lines=4, 
-                                            label="Prompt for left side of the image")
-                    left_gs = gr.Slider(minimum=0, 
-                                        maximum=15, 
-                                        value=7, 
-                                        step=1, 
-                                        label="Left CFG scale")
+                    left_prompt = gr.Textbox(lines=4, label="Prompt for left side of the image")
+                    left_gs = gr.Slider(minimum=0, maximum=15, value=7, step=1, label="Left CFG scale")
                 with gr.Column(scale=1):
                     gr.Markdown("### Center region")
-                    center_prompt = gr.Textbox(lines=4, 
-                                            label="Prompt for the center of the image")
-                    center_gs = gr.Slider(minimum=0, 
-                                        maximum=15, 
-                                        value=7, 
-                                        step=1, 
-                                        label="Center CFG scale")
+                    center_prompt = gr.Textbox(lines=4, label="Prompt for the center of the image")
+                    center_gs = gr.Slider(minimum=0, maximum=15, value=7, step=1, label="Center CFG scale")
                 with gr.Column(scale=1):
                     gr.Markdown("### Right region")
-                    right_prompt = gr.Textbox(lines=4, 
-                                            label="Prompt for the right side of the image")
-                    right_gs = gr.Slider(minimum=0, 
-                                        maximum=15, 
-                                        value=7, 
-                                        step=1, 
-                                        label="Right CFG scale")
+                    right_prompt = gr.Textbox(lines=4, label="Prompt for the right side of the image")
+                    right_gs = gr.Slider(minimum=0, maximum=15, value=7, step=1, label="Right CFG scale")
             with gr.Row():
-                negative_prompt = gr.Textbox(lines=2, 
-                                            label="Negative prompt for the image",
-                                            value="nsfw, lowres, bad anatomy, bad hands, duplicate, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, blurry")
+                negative_prompt = gr.Textbox(
+                    lines=2,
+                    label="Negative prompt for the image",
+                    value="nsfw, lowres, bad anatomy, bad hands, duplicate, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, blurry",
+                )
             with gr.Row():
                 result = gr.Image(
                     label="Generated Image",
-                    show_label=True, 
+                    show_label=True,
                     format="png",
                     interactive=False,
                     # allow_preview=True,
                     # preview=True,
                     scale=1,
-
                 )
         with gr.Column():
             gr.Markdown(tips)
     with gr.Sidebar(label="Parameters", open=True):
         gr.Markdown("### General parameters")
         with gr.Row():
-            height = gr.Slider(label="Height", 
-                            value=1024,
-                            step=8, 
-                            visible=True,
-                            minimum=512,
-                            maximum=1024)            
-            width = gr.Slider(label="Width",
-                            value=1280,
-                            step=8, 
-                            visible=True,
-                            minimum=512,
-                            maximum=3840)
-            overlap = gr.Slider(minimum=0, 
-                                maximum=512, 
-                                value=128, 
-                                step=8, 
-                                label="Tile Overlap")
+            height = gr.Slider(label="Height", value=1024, step=8, visible=True, minimum=512, maximum=1024)
+            width = gr.Slider(label="Width", value=1280, step=8, visible=True, minimum=512, maximum=3840)
+            overlap = gr.Slider(minimum=0, maximum=512, value=128, step=8, label="Tile Overlap")
             max_tile_size = gr.Dropdown(label="Max. Tile Size", choices=[1024, 1280], value=1280)
-            calc_tile = gr.Button("Calculate Tile Size") 
-        with gr.Row():                       
-            tile_height = gr.Textbox(label="Tile height", value=1024, interactive=False)            
+            calc_tile = gr.Button("Calculate Tile Size")
+        with gr.Row():
+            tile_height = gr.Textbox(label="Tile height", value=1024, interactive=False)
             tile_width = gr.Textbox(label="Tile width", value=1024, interactive=False)
         with gr.Row():
             new_target_height = gr.Textbox(label="New image height", value=1024, interactive=False)
             new_target_width = gr.Textbox(label="New image width", value=1024, interactive=False)
         with gr.Row():
-            steps = gr.Slider(minimum=1,
-                            maximum=50, 
-                            value=30, 
-                            step=1, 
-                            label="Inference steps")
-            
-            generation_seed = gr.Slider(label="Seed",
-                                        minimum=0,
-                                        maximum=MAX_SEED,
-                                        step=1,
-                                        value=0)
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=False)        
+            steps = gr.Slider(minimum=1, maximum=50, value=30, step=1, label="Inference steps")
+
+            generation_seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0)
+            randomize_seed = gr.Checkbox(label="Randomize seed", value=False)
         with gr.Row():
+            hdr = gr.Slider(minimum=0, maximum=1, value=0, step=0.1, label="HDR Effect")
             scheduler = gr.Dropdown(
-                label="Schedulers",
-                choices=SCHEDULERS,
-                value=SCHEDULERS[0],
+                label="Sampler",
+                choices=list(SAMPLERS.keys()),
+                value="UniPC",
             )
     with gr.Row():
         gr.Examples(
@@ -317,81 +369,114 @@ with gr.Blocks(css=css) as app:
                     "Captain America charging forward, vibranium shield deflecting energy blasts in destroyed cityscape, collapsing buildings, rubble streets, battle-damaged suit, determined expression, distant explosions, cinematic composition, realistic rendering. Focus: Captain America.",
                     "Thor wielding Stormbreaker in destroyed cityscape, lightning crackling, powerful strike downwards, shattered buildings, burning debris, ground trembling, Asgardian armor, cinematic photography, realistic details. Focus: Thor.",
                     negative_prompt.value,
-                    5, 5, 5,
+                    5,
+                    5,
+                    5,
                     160,
                     30,
                     619517442,
-                    "UniPCMultistepScheduler",
+                    "UniPC",
                     1024,
                     1280,
-                    1024,                       
+                    1024,
                     3840,
-                    1024
+                    1024,
+                    0,
                 ],
                 [
                     "A charming house in the countryside, by jakub rozalski, sunset lighting, elegant, highly detailed, smooth, sharp focus, artstation, stunning masterpiece",
                     "A dirt road in the countryside crossing pastures, by jakub rozalski, sunset lighting, elegant, highly detailed, smooth, sharp focus, artstation, stunning masterpiece",
                     "An old and rusty giant robot lying on a dirt road, by jakub rozalski, dark sunset lighting, elegant, highly detailed, smooth, sharp focus, artstation, stunning masterpiece",
                     negative_prompt.value,
-                    7, 7, 7,
+                    7,
+                    7,
+                    7,
                     256,
                     30,
                     358867853,
-                    "DPMSolverMultistepScheduler-Karras-SDE",
+                    "DPM++ 3M Karras",
                     1024,
                     1280,
-                    1024,                       
+                    1024,
                     3840,
-                    1280
+                    1280,
+                    0,
                 ],
                 [
                     "Abstract decorative illustration, by joan miro and gustav klimt and marlina vera and loish, elegant, intricate, highly detailed, smooth, sharp focus, vibrant colors, artstation, stunning masterpiece",
                     "Abstract decorative illustration, by joan miro and gustav klimt and marlina vera and loish, elegant, intricate, highly detailed, smooth, sharp focus, vibrant colors, artstation, stunning masterpiece",
                     "Abstract decorative illustration, by joan miro and gustav klimt and marlina vera and loish, elegant, intricate, highly detailed, smooth, sharp focus, vibrant colors, artstation, stunning masterpiece",
                     negative_prompt.value,
-                    7, 7, 7,
+                    7,
+                    7,
+                    7,
                     128,
                     30,
                     580541206,
-                    "LMSDiscreteScheduler",
+                    "LMS",
                     1024,
                     768,
-                    1024,     
+                    1024,
                     2048,
-                    1280
+                    1280,
+                    0,
                 ],
                 [
                     "Magical diagrams and runes written with chalk on a blackboard, elegant, intricate, highly detailed, smooth, sharp focus, artstation, stunning masterpiece",
                     "Magical diagrams and runes written with chalk on a blackboard, elegant, intricate, highly detailed, smooth, sharp focus, artstation, stunning masterpiece",
                     "Magical diagrams and runes written with chalk on a blackboard, elegant, intricate, highly detailed, smooth, sharp focus, artstation, stunning masterpiece",
                     negative_prompt.value,
-                    9, 9, 9,
+                    9,
+                    9,
+                    9,
                     128,
                     30,
                     12591765619,
-                    "LMSDiscreteScheduler",
+                    "LMS",
                     1024,
                     768,
-                    1024,                                        
+                    1024,
                     2048,
-                    1280
-                ]
+                    1280,
+                    0,
+                ],
+            ],
+            inputs=[
+                left_prompt,
+                center_prompt,
+                right_prompt,
+                negative_prompt,
+                left_gs,
+                center_gs,
+                right_gs,
+                overlap,
+                steps,
+                generation_seed,
+                scheduler,
+                tile_height,
+                tile_width,
+                height,
+                width,
+                max_tile_size,
+                hdr,
             ],
-            inputs=[left_prompt, center_prompt, right_prompt, negative_prompt, left_gs, center_gs, right_gs, overlap, steps, generation_seed, scheduler, tile_height, tile_width, height, width, max_tile_size],
             fn=run_for_examples,
             outputs=result,
-            cache_examples=True
+            cache_examples=True,
         )
-       
-    event_calc_tile_size={"fn": do_calc_tile, "inputs":[height, width, overlap, max_tile_size], "outputs":[tile_height, tile_width, new_target_height, new_target_width]}
+
+    event_calc_tile_size = {
+        "fn": do_calc_tile,
+        "inputs": [height, width, overlap, max_tile_size],
+        "outputs": [tile_height, tile_width, new_target_height, new_target_width],
+    }
     calc_tile.click(**event_calc_tile_size)
-    
+
     generate_button.click(
         fn=clear_result,
         inputs=None,
         outputs=result,
-    ).then(**event_calc_tile_size
-    ).then(                        
+    ).then(**event_calc_tile_size).then(
         fn=randomize_seed_fn,
         inputs=[generation_seed, randomize_seed],
         outputs=generation_seed,
@@ -399,7 +484,24 @@ with gr.Blocks(css=css) as app:
         api_name=False,
     ).then(
         fn=predict,
-        inputs=[left_prompt, center_prompt, right_prompt, negative_prompt, left_gs, center_gs, right_gs, overlap, steps, generation_seed, scheduler, tile_height, tile_width, new_target_height, new_target_width],
+        inputs=[
+            left_prompt,
+            center_prompt,
+            right_prompt,
+            negative_prompt,
+            left_gs,
+            center_gs,
+            right_gs,
+            overlap,
+            steps,
+            generation_seed,
+            scheduler,
+            tile_height,
+            tile_width,
+            new_target_height,
+            new_target_width,
+            hdr,
+        ],
         outputs=result,
     )
     gr.Markdown(about)

mixture_tiling_sdxl.py → pipeline/mixture_tiling_sdxl.py

@@ -1,4 +1,4 @@
-# Copyright 2025 The HuggingFace Team. All rights reserved.
+# Copyright 2025 The DEVAIEXP Team and The HuggingFace Team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -1067,32 +1067,32 @@ class StableDiffusionXLTilingPipeline(
                     text_encoder_projection_dim = int(pooled_prompt_embeds.shape[-1])
                 else:
                     text_encoder_projection_dim = self.text_encoder_2.config.projection_dim
-                    add_time_ids = self._get_add_time_ids(
-                        original_size,
-                        crops_coords_top_left[row][col],
-                        target_size,
+                add_time_ids = self._get_add_time_ids(
+                    original_size,
+                    crops_coords_top_left[row][col],
+                    target_size,
+                    dtype=prompt_embeds.dtype,
+                    text_encoder_projection_dim=text_encoder_projection_dim,
+                )
+                if negative_original_size is not None and negative_target_size is not None:
+                    negative_add_time_ids = self._get_add_time_ids(
+                        negative_original_size,
+                        negative_crops_coords_top_left[row][col],
+                        negative_target_size,
                         dtype=prompt_embeds.dtype,
                         text_encoder_projection_dim=text_encoder_projection_dim,
                     )
-                    if negative_original_size is not None and negative_target_size is not None:
-                        negative_add_time_ids = self._get_add_time_ids(
-                            negative_original_size,
-                            negative_crops_coords_top_left[row][col],
-                            negative_target_size,
-                            dtype=prompt_embeds.dtype,
-                            text_encoder_projection_dim=text_encoder_projection_dim,
-                        )
-                    else:
-                        negative_add_time_ids = add_time_ids
+                else:
+                    negative_add_time_ids = add_time_ids
 
-                    if self.do_classifier_free_guidance:
-                        prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0)
-                        add_text_embeds = torch.cat([negative_pooled_prompt_embeds, add_text_embeds], dim=0)
-                        add_time_ids = torch.cat([negative_add_time_ids, add_time_ids], dim=0)
+                if self.do_classifier_free_guidance:
+                    prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0)
+                    add_text_embeds = torch.cat([negative_pooled_prompt_embeds, add_text_embeds], dim=0)
+                    add_time_ids = torch.cat([negative_add_time_ids, add_time_ids], dim=0)
 
-                    prompt_embeds = prompt_embeds.to(device)
-                    add_text_embeds = add_text_embeds.to(device)
-                    add_time_ids = add_time_ids.to(device).repeat(batch_size * num_images_per_prompt, 1)
+                prompt_embeds = prompt_embeds.to(device)
+                add_text_embeds = add_text_embeds.to(device)
+                add_time_ids = add_time_ids.to(device).repeat(batch_size * num_images_per_prompt, 1)
                 addition_embed_type_row.append((prompt_embeds, add_text_embeds, add_time_ids))
             embeddings_and_added_time.append(addition_embed_type_row)
 

pipeline/util.py

@@ -0,0 +1,171 @@
+# Copyright 2025 The DEVAIEXP Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import gc
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+
+
+MAX_SEED = np.iinfo(np.int32).max
+SAMPLERS = {
+    "DDIM": ("DDIMScheduler", {}),
+    "DDIM trailing": ("DDIMScheduler", {"timestep_spacing": "trailing"}),
+    "DDPM": ("DDPMScheduler", {}),
+    "DEIS": ("DEISMultistepScheduler", {}),
+    "Heun": ("HeunDiscreteScheduler", {}),
+    "Heun Karras": ("HeunDiscreteScheduler", {"use_karras_sigmas": True}),
+    "Euler": ("EulerDiscreteScheduler", {}),
+    "Euler trailing": ("EulerDiscreteScheduler", {"timestep_spacing": "trailing", "prediction_type": "sample"}),
+    "Euler Ancestral": ("EulerAncestralDiscreteScheduler", {}),
+    "Euler Ancestral trailing": ("EulerAncestralDiscreteScheduler", {"timestep_spacing": "trailing"}),
+    "DPM++ 1S": ("DPMSolverMultistepScheduler", {"solver_order": 1}),
+    "DPM++ 1S Karras": ("DPMSolverMultistepScheduler", {"solver_order": 1, "use_karras_sigmas": True}),
+    "DPM++ 2S": ("DPMSolverSinglestepScheduler", {"use_karras_sigmas": False}),
+    "DPM++ 2S Karras": ("DPMSolverSinglestepScheduler", {"use_karras_sigmas": True}),
+    "DPM++ 2M": ("DPMSolverMultistepScheduler", {"use_karras_sigmas": False}),
+    "DPM++ 2M Karras": ("DPMSolverMultistepScheduler", {"use_karras_sigmas": True}),
+    "DPM++ 2M SDE": ("DPMSolverMultistepScheduler", {"use_karras_sigmas": False, "algorithm_type": "sde-dpmsolver++"}),
+    "DPM++ 2M SDE Karras": (
+        "DPMSolverMultistepScheduler",
+        {"use_karras_sigmas": True, "algorithm_type": "sde-dpmsolver++"},
+    ),
+    "DPM++ 3M": ("DPMSolverMultistepScheduler", {"solver_order": 3}),
+    "DPM++ 3M Karras": ("DPMSolverMultistepScheduler", {"solver_order": 3, "use_karras_sigmas": True}),
+    "DPM++ SDE": ("DPMSolverSDEScheduler", {"use_karras_sigmas": False}),
+    "DPM++ SDE Karras": ("DPMSolverSDEScheduler", {"use_karras_sigmas": True}),
+    "DPM2": ("KDPM2DiscreteScheduler", {}),
+    "DPM2 Karras": ("KDPM2DiscreteScheduler", {"use_karras_sigmas": True}),
+    "DPM2 Ancestral": ("KDPM2AncestralDiscreteScheduler", {}),
+    "DPM2 Ancestral Karras": ("KDPM2AncestralDiscreteScheduler", {"use_karras_sigmas": True}),
+    "LMS": ("LMSDiscreteScheduler", {}),
+    "LMS Karras": ("LMSDiscreteScheduler", {"use_karras_sigmas": True}),
+    "UniPC": ("UniPCMultistepScheduler", {}),
+    "UniPC Karras": ("UniPCMultistepScheduler", {"use_karras_sigmas": True}),
+    "PNDM": ("PNDMScheduler", {}),
+    "Euler EDM": ("EDMEulerScheduler", {}),
+    "Euler EDM Karras": ("EDMEulerScheduler", {"use_karras_sigmas": True}),
+    "DPM++ 2M EDM": (
+        "EDMDPMSolverMultistepScheduler",
+        {"solver_order": 2, "solver_type": "midpoint", "final_sigmas_type": "zero", "algorithm_type": "dpmsolver++"},
+    ),
+    "DPM++ 2M EDM Karras": (
+        "EDMDPMSolverMultistepScheduler",
+        {
+            "use_karras_sigmas": True,
+            "solver_order": 2,
+            "solver_type": "midpoint",
+            "final_sigmas_type": "zero",
+            "algorithm_type": "dpmsolver++",
+        },
+    ),
+    "DPM++ 2M Lu": ("DPMSolverMultistepScheduler", {"use_lu_lambdas": True}),
+    "DPM++ 2M Ef": ("DPMSolverMultistepScheduler", {"euler_at_final": True}),
+    "DPM++ 2M SDE Lu": ("DPMSolverMultistepScheduler", {"use_lu_lambdas": True, "algorithm_type": "sde-dpmsolver++"}),
+    "DPM++ 2M SDE Ef": ("DPMSolverMultistepScheduler", {"algorithm_type": "sde-dpmsolver++", "euler_at_final": True}),
+    "LCM": ("LCMScheduler", {}),
+    "LCM trailing": ("LCMScheduler", {"timestep_spacing": "trailing"}),
+    "TCD": ("TCDScheduler", {}),
+    "TCD trailing": ("TCDScheduler", {"timestep_spacing": "trailing"}),
+}
+
+def select_scheduler(pipe, selected_sampler):
+    import diffusers
+
+    scheduler_class_name, add_kwargs = SAMPLERS[selected_sampler]
+    config = pipe.scheduler.config
+    scheduler = getattr(diffusers, scheduler_class_name)
+    if selected_sampler in ("LCM", "LCM trailing"):
+        config = {
+            x: config[x] for x in config if x not in ("skip_prk_steps", "interpolation_type", "use_karras_sigmas")
+        }
+    elif selected_sampler in ("TCD", "TCD trailing"):
+        config = {x: config[x] for x in config if x not in ("skip_prk_steps")}
+
+    return scheduler.from_config(config, **add_kwargs)
+
+
+# This function was copied and adapted from https://huggingface.co/spaces/gokaygokay/TileUpscalerV2, licensed under Apache 2.0.
+def create_hdr_effect(original_image, hdr):
+    """
+    Applies an HDR (High Dynamic Range) effect to an image based on the specified intensity.
+
+    Args:
+        original_image (PIL.Image.Image): The original image to which the HDR effect will be applied.
+        hdr (float): The intensity of the HDR effect, ranging from 0 (no effect) to 1 (maximum effect).
+
+    Returns:
+        PIL.Image.Image: The image with the HDR effect applied.
+    """
+    if hdr == 0:
+        return original_image  # No effect applied if hdr is 0
+
+    # Convert the PIL image to a NumPy array in BGR format (OpenCV format)
+    cv_original = cv2.cvtColor(np.array(original_image), cv2.COLOR_RGB2BGR)
+
+    # Define scaling factors for creating multiple exposures
+    factors = [
+        1.0 - 0.9 * hdr,
+        1.0 - 0.7 * hdr,
+        1.0 - 0.45 * hdr,
+        1.0 - 0.25 * hdr,
+        1.0,
+        1.0 + 0.2 * hdr,
+        1.0 + 0.4 * hdr,
+        1.0 + 0.6 * hdr,
+        1.0 + 0.8 * hdr,
+    ]
+
+    # Generate multiple exposure images by scaling the original image
+    images = [cv2.convertScaleAbs(cv_original, alpha=factor) for factor in factors]
+
+    # Merge the images using the Mertens algorithm to create an HDR effect
+    merge_mertens = cv2.createMergeMertens()
+    hdr_image = merge_mertens.process(images)
+
+    # Convert the HDR image to 8-bit format (0-255 range)
+    hdr_image_8bit = np.clip(hdr_image * 255, 0, 255).astype("uint8")
+
+    torch_gc()
+    
+    # Convert the image back to RGB format and return as a PIL image
+    return Image.fromarray(cv2.cvtColor(hdr_image_8bit, cv2.COLOR_BGR2RGB))
+
+
+def torch_gc():
+    gc.collect()
+    if torch.cuda.is_available():
+        with torch.cuda.device("cuda"):
+            torch.cuda.empty_cache()
+            torch.cuda.ipc_collect()
+
+def quantize_8bit(unet):
+    if unet is None:
+        return
+
+    from peft.tuners.tuners_utils import BaseTunerLayer
+
+    dtype = unet.dtype
+    unet.to(torch.float8_e4m3fn)
+    for module in unet.modules():  # revert lora modules to prevent errors with fp8
+        if isinstance(module, BaseTunerLayer):
+            module.to(dtype)
+
+    if hasattr(unet, "encoder_hid_proj"):  # revert ip adapter modules to prevent errors with fp8
+        if unet.encoder_hid_proj is not None:
+            for module in unet.encoder_hid_proj.modules():
+                module.to(dtype)
+    torch_gc()

requirements.txt

@@ -1,7 +1,9 @@
 torch
+peft
 spaces
 scipy
-gradio==5.15.0
+gradio==5.20.1
+opencv-python
 numpy==1.26.4
 transformers
 accelerate