add theme, compare from 2 to 4 models, sd1.5, height & width diff per model

app.py

@@ -7,7 +7,7 @@ import numpy as np
 from PIL import Image
 import spaces
 
-HF_TOKEN = os.getenv("HF_TOKEN") # login with hf token to access sd gated models
+HF_TOKEN = os.getenv("HF_TOKEN")  # login with hf token to access sd gated models
 
 if torch.cuda.is_available():
     device = "cuda"
@@ -20,25 +20,52 @@ else:
 MAX_SEED = np.iinfo(np.int32).max
 
 # Initialize the pipelines for each sd model
-sd3_medium_pipe = StableDiffusion3Pipeline.from_pretrained("stabilityai/stable-diffusion-3-medium-diffusers", torch_dtype=torch.float16)
+
+# sd3 medium
+sd3_medium_pipe = StableDiffusion3Pipeline.from_pretrained(
+    "stabilityai/stable-diffusion-3-medium-diffusers", torch_dtype=torch.float16
+)
 sd3_medium_pipe.enable_model_cpu_offload()
 
-sd2_1_pipe = StableDiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16)
+# sd 2.1
+sd2_1_pipe = StableDiffusionPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-2-1", torch_dtype=torch.float16
+)
 sd2_1_pipe.enable_model_cpu_offload()
 
-sdxl_pipe = StableDiffusionXLPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16)
+# sdxl
+sdxl_pipe = StableDiffusionXLPipeline.from_pretrained(
+    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
+)
 sdxl_pipe.enable_model_cpu_offload()
 
-sdxl_flash_pipe = StableDiffusionXLPipeline.from_pretrained("sd-community/sdxl-flash", torch_dtype=torch.float16)
+# sdxl flash
+sdxl_flash_pipe = StableDiffusionXLPipeline.from_pretrained(
+    "sd-community/sdxl-flash", torch_dtype=torch.float16
+)
 sdxl_flash_pipe.enable_model_cpu_offload()
 # Ensure sampler uses "trailing" timesteps for sdxl flash.
-sdxl_flash_pipe.scheduler = DPMSolverSinglestepScheduler.from_config(sdxl_flash_pipe.scheduler.config, timestep_spacing="trailing")
+sdxl_flash_pipe.scheduler = DPMSolverSinglestepScheduler.from_config(
+    sdxl_flash_pipe.scheduler.config, timestep_spacing="trailing"
+)
 
-stable_cascade_prior_pipe = StableCascadePriorPipeline.from_pretrained("stabilityai/stable-cascade-prior", variant="bf16", torch_dtype=torch.bfloat16)
-stable_cascade_decoder_pipe = StableCascadeDecoderPipeline.from_pretrained("stabilityai/stable-cascade", variant="bf16", torch_dtype=torch.float16)
+# stable cascade
+stable_cascade_prior_pipe = StableCascadePriorPipeline.from_pretrained(
+    "stabilityai/stable-cascade-prior", variant="bf16", torch_dtype=torch.bfloat16
+)
+stable_cascade_decoder_pipe = StableCascadeDecoderPipeline.from_pretrained(
+    "stabilityai/stable-cascade", variant="bf16", torch_dtype=torch.float16
+)
 stable_cascade_prior_pipe.enable_model_cpu_offload()
 stable_cascade_decoder_pipe.enable_model_cpu_offload()
 
+# sd 1.5
+sd1_5_pipe = StableDiffusionPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16
+)
+sd1_5_pipe.enable_model_cpu_offload()
+
+
 # Helper function to generate images for a single model
 @spaces.GPU(duration=80)
 def generate_single_image(
@@ -68,9 +95,12 @@ def generate_single_image(
         pipe = sdxl_flash_pipe
     elif model_choice == "stable cascade":
         pipe = stable_cascade_prior_pipe
+    elif model_choice == "sd1.5":
+        pipe = sd1_5_pipe
     else:
         raise ValueError(f"Invalid model choice: {model_choice}")
 
+    # stable cascade has 2 different type of pipelines
     if model_choice == "stable cascade":
         prior_output = pipe(
             prompt=prompt,
@@ -90,6 +120,8 @@ def generate_single_image(
             num_inference_steps=decoder_num_inference_steps,
             guidance_scale=decoder_guidance_scale,
         ).images
+
+    # the rest of the models have similar pipeline
     else:
         output = pipe(
             prompt=prompt,
@@ -104,21 +136,35 @@ def generate_single_image(
 
     return output
 
+
 # Define the image generation function for the Arena tab
 @spaces.GPU(duration=80)
 def generate_arena_images(
     prompt,
     negative_prompt,
+    num_models_to_compare,
     num_inference_steps_a,
     guidance_scale_a,
     num_inference_steps_b,
     guidance_scale_b,
-    height,
-    width,
+    num_inference_steps_c,
+    guidance_scale_c,
+    num_inference_steps_d,
+    guidance_scale_d,
+    height_a,
+    width_a,
+    height_b,
+    width_b,
+    height_c,
+    width_c,
+    height_d,
+    width_d,
     seed,
     num_images_per_prompt,
     model_choice_a,
     model_choice_b,
+    model_choice_c,
+    model_choice_d,
     prior_num_inference_steps_a,
     prior_guidance_scale_a,
     decoder_num_inference_steps_a,
@@ -127,48 +173,97 @@ def generate_arena_images(
     prior_guidance_scale_b,
     decoder_num_inference_steps_b,
     decoder_guidance_scale_b,
+    prior_num_inference_steps_c,
+    prior_guidance_scale_c,
+    decoder_num_inference_steps_c,
+    decoder_guidance_scale_c,
+    prior_num_inference_steps_d,
+    prior_guidance_scale_d,
+    decoder_num_inference_steps_d,
+    decoder_guidance_scale_d,
     progress=gr.Progress(track_tqdm=True),
 ):
     if seed == 0:
-        seed = random.randint(1, 2**32 - 1)
+        seed = random.randint(1, MAX_SEED)
 
     generator = torch.Generator().manual_seed(seed)
 
-    # Generate images for both models
-    images_a = generate_single_image(
-        prompt,
-        negative_prompt,
-        num_inference_steps_a,
-        guidance_scale_a,
-        height,
-        width,
-        seed,
-        num_images_per_prompt,
-        model_choice_a,
-        generator,
-        prior_num_inference_steps_a,
-        prior_guidance_scale_a,
-        decoder_num_inference_steps_a,
-        decoder_guidance_scale_a,
-    )
-    images_b = generate_single_image(
-        prompt,
-        negative_prompt,
-        num_inference_steps_b,
-        guidance_scale_b,
-        height,
-        width,
-        seed,
-        num_images_per_prompt,
-        model_choice_b,
-        generator,
-        prior_num_inference_steps_b,
-        prior_guidance_scale_b,
-        decoder_num_inference_steps_b,
-        decoder_guidance_scale_b,
-    )
+    # Generate images for selected models
+    images = []
+    if num_models_to_compare >= 2:
+        images_a = generate_single_image(
+            prompt,
+            negative_prompt,
+            num_inference_steps_a,
+            guidance_scale_a,
+            height_a,
+            width_a,
+            seed,
+            num_images_per_prompt,
+            model_choice_a,
+            generator,
+            prior_num_inference_steps_a,
+            prior_guidance_scale_a,
+            decoder_num_inference_steps_a,
+            decoder_guidance_scale_a,
+        )
+        images.append(images_a)
+        images_b = generate_single_image(
+            prompt,
+            negative_prompt,
+            num_inference_steps_b,
+            guidance_scale_b,
+            height_b,
+            width_b,
+            seed,
+            num_images_per_prompt,
+            model_choice_b,
+            generator,
+            prior_num_inference_steps_b,
+            prior_guidance_scale_b,
+            decoder_num_inference_steps_b,
+            decoder_guidance_scale_b,
+        )
+        images.append(images_b)
+    if num_models_to_compare >= 3:
+        images_c = generate_single_image(
+            prompt,
+            negative_prompt,
+            num_inference_steps_c,
+            guidance_scale_c,
+            height_c,
+            width_c,
+            seed,
+            num_images_per_prompt,
+            model_choice_c,
+            generator,
+            prior_num_inference_steps_c,
+            prior_guidance_scale_c,
+            decoder_num_inference_steps_c,
+            decoder_guidance_scale_c,
+        )
+        images.append(images_c)
+    if num_models_to_compare >= 4:
+        images_d = generate_single_image(
+            prompt,
+            negative_prompt,
+            num_inference_steps_d,
+            guidance_scale_d,
+            height_d,
+            width_d,
+            seed,
+            num_images_per_prompt,
+            model_choice_d,
+            generator,
+            prior_num_inference_steps_d,
+            prior_guidance_scale_d,
+            decoder_num_inference_steps_d,
+            decoder_guidance_scale_d,
+        )
+        images.append(images_d)
+
+    return images
 
-    return images_a, images_b
 
 # Define the image generation function for the Individual tab
 @spaces.GPU(duration=80)
@@ -189,7 +284,7 @@ def generate_individual_image(
     progress=gr.Progress(track_tqdm=True),
 ):
     if seed == 0:
-        seed = random.randint(1, 2**32 - 1)
+        seed = random.randint(1, MAX_SEED)
 
     generator = torch.Generator().manual_seed(seed)
 
@@ -213,51 +308,93 @@ def generate_individual_image(
     return output
 
 
-# Create the Gradio interface
+# Gradio interface
 examples_arena = [
     [
         "A woman in a red dress singing on top of a building.",
         "deformed, distorted, disfigured, poorly drawn, bad anatomy, incorrect anatomy, extra limb, missing limb, floating limbs, mutated hands and fingers, disconnected limbs, mutation, mutated, ugly, disgusting, blurry, amputation",
+        2,  # num_models_to_compare
+        25,
+        7.5,
+        25,
+        7.5,
         25,
         7.5,
         25,
         7.5,
         1024,
         1024,
+        1024,
+        1024,
+        1024,
+        1024,
+        1024,
+        1024,
         42,
         2,
         "sd3 medium",
         "sdxl",
-        25, #prior_num_inference_steps_a
-        4.0, #prior_guidance_scale_a
-        12, #decoder_num_inference_steps_a
-        0.0, #decoder_guidance_scale_a
-        25, #prior_num_inference_steps_b
-        4.0, #prior_guidance_scale_b
-        12, #decoder_num_inference_steps_b
-        0.0 #decoder_guidance_scale_b
+        "sd3 medium",
+        "sdxl",
+        25,  # prior_num_inference_steps_a
+        4.0,  # prior_guidance_scale_a
+        12,  # decoder_num_inference_steps_a
+        0.0,  # decoder_guidance_scale_a
+        25,  # prior_num_inference_steps_b
+        4.0,  # prior_guidance_scale_b
+        12,  # decoder_num_inference_steps_b
+        0.0,  # decoder_guidance_scale_b
+        25,  # prior_num_inference_steps_c
+        4.0,  # prior_guidance_scale_c
+        12,  # decoder_num_inference_steps_c
+        0.0,  # decoder_guidance_scale_c
+        25,  # prior_num_inference_steps_d
+        4.0,  # prior_guidance_scale_d
+        12,  # decoder_num_inference_steps_d
+        0.0,  # decoder_guidance_scale_d
     ],
     [
         "An astronaut on mars in a futuristic cyborg suit.",
         "deformed, distorted, disfigured, poorly drawn, bad anatomy, incorrect anatomy, extra limb, missing limb, floating limbs, mutated hands and fingers, disconnected limbs, mutation, mutated, ugly, disgusting, blurry, amputation",
+        2,  # num_models_to_compare
+        25,
+        7.5,
+        25,
+        7.5,
         25,
         7.5,
         25,
         7.5,
         1024,
         1024,
+        1024,
+        1024,
+        1024,
+        1024,
+        1024,
+        1024,
         42,
         2,
         "sd3 medium",
         "sdxl",
-        25, #prior_num_inference_steps_a
-        4.0, #prior_guidance_scale_a
-        12, #decoder_num_inference_steps_a
-        0.0, #decoder_guidance_scale_a
-        25, #prior_num_inference_steps_b
-        4.0, #prior_guidance_scale_b
-        12, #decoder_num_inference_steps_b
-        0.0 #decoder_guidance_scale_b
+        "sd3 medium",
+        "sdxl",
+        25,  # prior_num_inference_steps_a
+        4.0,  # prior_guidance_scale_a
+        12,  # decoder_num_inference_steps_a
+        0.0,  # decoder_guidance_scale_a
+        25,  # prior_num_inference_steps_b
+        4.0,  # prior_guidance_scale_b
+        12,  # decoder_num_inference_steps_b
+        0.0,  # decoder_guidance_scale_b
+        25,  # prior_num_inference_steps_c
+        4.0,  # prior_guidance_scale_c
+        12,  # decoder_num_inference_steps_c
+        0.0,  # decoder_guidance_scale_c
+        25,  # prior_num_inference_steps_d
+        4.0,  # prior_guidance_scale_d
+        12,  # decoder_num_inference_steps_d
+        0.0,  # decoder_guidance_scale_d
     ],
 ]
 examples_individual = [
@@ -271,10 +408,10 @@ examples_individual = [
         42,
         2,
         "sdxl",
-        25, #prior_num_inference_steps
-        4.0, #prior_guidance_scale
-        12, #decoder_num_inference_steps
-        0.0 #decoder_guidance_scale
+        25,  # prior_num_inference_steps
+        4.0,  # prior_guidance_scale
+        12,  # decoder_num_inference_steps
+        0.0,  # decoder_guidance_scale
     ],
     [
         "An astronaut on mars in a futuristic cyborg suit.",
@@ -286,18 +423,42 @@ examples_individual = [
         42,
         2,
         "sdxl",
-        25, #prior_num_inference_steps
-        4.0, #prior_guidance_scale
-        12, #decoder_num_inference_steps
-        0.0 #decoder_guidance_scale
+        25,  # prior_num_inference_steps
+        4.0,  # prior_guidance_scale
+        12,  # decoder_num_inference_steps
+        0.0,  # decoder_guidance_scale
     ],
 ]
 
+theme = gr.themes.Soft(
+    primary_hue="emerald",
+    secondary_hue="blue",
+).set(
+    border_color_primary='*neutral_300',
+    block_border_width='1px',
+    block_border_width_dark='1px',
+    block_title_border_color='*secondary_100',
+    block_title_border_color_dark='*secondary_200',
+    input_background_fill_focus='*secondary_300',
+    input_border_color_focus='*secondary_500',
+    input_border_width='1px',
+    input_border_width_dark='1px',
+    slider_color='*secondary_500',
+    slider_color_dark='*secondary_600'
+)
+
 css = """
-.gradio-container{max-width: 1000px !important}
+.gradio-container{max-width: 1400px !important}
 h1{text-align:center}
+.extra-option {
+    display: none;
+}
+.extra-option.visible {
+    display: block;
+}
 """
-with gr.Blocks(css=css) as demo:
+
+with gr.Blocks(theme=theme, css=css) as demo:
     with gr.Row():
         with gr.Column():
             gr.HTML(
@@ -322,19 +483,78 @@ with gr.Blocks(css=css) as demo:
                         info="Describe the image you want",
                         placeholder="A cat...",
                     )
+                    num_models_to_compare = gr.Dropdown(
+                        label="How many models to compare",
+                        choices=[2, 3, 4],
+                        value=2,
+                    )
                     model_choice_a = gr.Dropdown(
                         label="Stable Diffusion Model A",
-                        choices=["sd3 medium", "sd2.1", "sdxl", "sdxl flash", "stable cascade"],
+                        choices=[
+                            "sd3 medium",
+                            "sd2.1",
+                            "sdxl",
+                            "sdxl flash",
+                            "stable cascade",
+                            "sd1.5",
+                        ],
                         value="sd3 medium",
                     )
                     model_choice_b = gr.Dropdown(
                         label="Stable Diffusion Model B",
-                        choices=["sd3 medium", "sd2.1", "sdxl", "sdxl flash", "stable cascade"],
+                        choices=[
+                            "sd3 medium",
+                            "sd2.1",
+                            "sdxl",
+                            "sdxl flash",
+                            "stable cascade",
+                            "sd1.5",
+                        ],
                         value="sdxl",
                     )
+                    model_choice_c = gr.Dropdown(
+                        label="Stable Diffusion Model C",
+                        choices=[
+                            "sd3 medium",
+                            "sd2.1",
+                            "sdxl",
+                            "sdxl flash",
+                            "stable cascade",
+                            "sd1.5",
+                        ],
+                        value="sdxl flash",
+                        visible=False,
+                    )
+                    model_choice_d = gr.Dropdown(
+                        label="Stable Diffusion Model D",
+                        choices=[
+                            "sd3 medium",
+                            "sd2.1",
+                            "sdxl",
+                            "sdxl flash",
+                            "stable cascade",
+                            "sd1.5",
+                        ],
+                        value="sd2.1",
+                        visible=False,
+                    )
                     run_button = gr.Button("Run")
-                result_1 = gr.Gallery(label="Generated Images (Model A)", elem_id="gallery_1")
-                result_2 = gr.Gallery(label="Generated Images (Model B)", elem_id="gallery_2")
+                result_1 = gr.Gallery(
+                    label="Generated Images (Model A)", elem_id="gallery_1"
+                )
+                result_2 = gr.Gallery(
+                    label="Generated Images (Model B)", elem_id="gallery_2"
+                )
+                result_3 = gr.Gallery(
+                    label="Generated Images (Model C)",
+                    elem_id="gallery_3",
+                    visible=False,
+                )
+                result_4 = gr.Gallery(
+                    label="Generated Images (Model D)",
+                    elem_id="gallery_4",
+                    visible=False,
+                )
             with gr.Accordion("Advanced options", open=False):
                 negative_prompt = gr.Textbox(
                     label="Negative Prompt",
@@ -351,7 +571,7 @@ with gr.Blocks(css=css) as demo:
                             maximum=50,
                             value=25,
                             step=1,
-                            visible=True
+                            visible=True,
                         )
                         guidance_scale_a = gr.Slider(
                             label="Guidance Scale (Model A)",
@@ -360,7 +580,7 @@ with gr.Blocks(css=css) as demo:
                             maximum=10.0,
                             value=7.5,
                             step=0.1,
-                            visible=True
+                            visible=True,
                         )
                         prior_num_inference_steps_a = gr.Slider(
                             label="Prior Inference Steps (Model A)",
@@ -369,7 +589,7 @@ with gr.Blocks(css=css) as demo:
                             maximum=50,
                             value=25,
                             step=1,
-                            visible=False
+                            visible=False,
                         )
                         prior_guidance_scale_a = gr.Slider(
                             label="Prior Guidance Scale (Model A)",
@@ -378,7 +598,7 @@ with gr.Blocks(css=css) as demo:
                             maximum=10.0,
                             value=4.0,
                             step=0.1,
-                            visible=False
+                            visible=False,
                         )
                         decoder_num_inference_steps_a = gr.Slider(
                             label="Decoder Inference Steps (Model A)",
@@ -387,7 +607,7 @@ with gr.Blocks(css=css) as demo:
                             maximum=15,
                             value=15,
                             step=1,
-                            visible=False
+                            visible=False,
                         )
                         decoder_guidance_scale_a = gr.Slider(
                             label="Decoder Guidance Scale (Model A)",
@@ -396,7 +616,23 @@ with gr.Blocks(css=css) as demo:
                             maximum=10.0,
                             value=0.0,
                             step=0.1,
-                            visible=False
+                            visible=False,
+                        )
+                        width_a = gr.Slider(
+                            label="Width (Model A)",
+                            info="Width of the Image",
+                            minimum=256,
+                            maximum=1344,
+                            step=32,
+                            value=1024,
+                        )
+                        height_a = gr.Slider(
+                            label="Height (Model A)",
+                            info="Height of the Image",
+                            minimum=256,
+                            maximum=1344,
+                            step=32,
+                            value=1024,
                         )
                     with gr.Column():
                         num_inference_steps_b = gr.Slider(
@@ -406,7 +642,7 @@ with gr.Blocks(css=css) as demo:
                             maximum=50,
                             value=25,
                             step=1,
-                            visible=True
+                            visible=True,
                         )
                         guidance_scale_b = gr.Slider(
                             label="Guidance Scale (Model B)",
@@ -415,7 +651,7 @@ with gr.Blocks(css=css) as demo:
                             maximum=10.0,
                             value=7.5,
                             step=0.1,
-                            visible=True
+                            visible=True,
                         )
                         prior_num_inference_steps_b = gr.Slider(
                             label="Prior Inference Steps (Model B)",
@@ -424,7 +660,7 @@ with gr.Blocks(css=css) as demo:
                             maximum=50,
                             value=25,
                             step=1,
-                            visible=False
+                            visible=False,
                         )
                         prior_guidance_scale_b = gr.Slider(
                             label="Prior Guidance Scale (Model B)",
@@ -433,7 +669,7 @@ with gr.Blocks(css=css) as demo:
                             maximum=10.0,
                             value=4.0,
                             step=0.1,
-                            visible=False
+                            visible=False,
                         )
                         decoder_num_inference_steps_b = gr.Slider(
                             label="Decoder Inference Steps (Model B)",
@@ -442,7 +678,7 @@ with gr.Blocks(css=css) as demo:
                             maximum=15,
                             value=12,
                             step=1,
-                            visible=False
+                            visible=False,
                         )
                         decoder_guidance_scale_b = gr.Slider(
                             label="Decoder Guidance Scale (Model B)",
@@ -451,25 +687,166 @@ with gr.Blocks(css=css) as demo:
                             maximum=10.0,
                             value=0.0,
                             step=0.1,
-                            visible=False
+                            visible=False,
+                        )
+                        width_b = gr.Slider(
+                            label="Width (Model B)",
+                            info="Width of the Image",
+                            minimum=256,
+                            maximum=1344,
+                            step=32,
+                            value=1024,
+                        )
+                        height_b = gr.Slider(
+                            label="Height (Model B)",
+                            info="Height of the Image",
+                            minimum=256,
+                            maximum=1344,
+                            step=32,
+                            value=1024,
+                        )
+                    with gr.Column(visible=False) as model_c_options:
+                        num_inference_steps_c = gr.Slider(
+                            label="Inference Steps (Model C)",
+                            info="The number of denoising steps of the image. More denoising steps usually lead to a higher quality image at the cost of slower inference",
+                            minimum=1,
+                            maximum=50,
+                            value=25,
+                            step=1,
+                            visible=True,
+                        )
+                        guidance_scale_c = gr.Slider(
+                            label="Guidance Scale (Model C)",
+                            info="Controls how much the image generation process follows the text prompt. Higher values make the image stick more closely to the input text.",
+                            minimum=0.0,
+                            maximum=10.0,
+                            value=7.5,
+                            step=0.1,
+                            visible=True,
+                        )
+                        prior_num_inference_steps_c = gr.Slider(
+                            label="Prior Inference Steps (Model C)",
+                            info="The number of denoising steps of the image. More denoising steps usually lead to a higher quality image at the cost of slower inference",
+                            minimum=1,
+                            maximum=50,
+                            value=25,
+                            step=1,
+                            visible=False,
+                        )
+                        prior_guidance_scale_c = gr.Slider(
+                            label="Prior Guidance Scale (Model C)",
+                            info="Controls how much the image generation process follows the text prompt. Higher values make the image stick more closely to the input text.",
+                            minimum=0.0,
+                            maximum=10.0,
+                            value=4.0,
+                            step=0.1,
+                            visible=False,
+                        )
+                        decoder_num_inference_steps_c = gr.Slider(
+                            label="Decoder Inference Steps (Model C)",
+                            info="The number of denoising steps of the image. More denoising steps usually lead to a higher quality image at the cost of slower inference",
+                            minimum=1,
+                            maximum=15,
+                            value=12,
+                            step=1,
+                            visible=False,
+                        )
+                        decoder_guidance_scale_c = gr.Slider(
+                            label="Decoder Guidance Scale (Model C)",
+                            info="Controls how much the image generation process follows the text prompt. Higher values make the image stick more closely to the input text.",
+                            minimum=0.0,
+                            maximum=10.0,
+                            value=0.0,
+                            step=0.1,
+                            visible=False,
+                        )
+                        width_c = gr.Slider(
+                            label="Width (Model C)",
+                            info="Width of the Image",
+                            minimum=256,
+                            maximum=1344,
+                            step=32,
+                            value=1024,
+                        )
+                        height_c = gr.Slider(
+                            label="Height (Model C)",
+                            info="Height of the Image",
+                            minimum=256,
+                            maximum=1344,
+                            step=32,
+                            value=1024,
+                        )
+                    with gr.Column(visible=False) as model_d_options:
+                        num_inference_steps_d = gr.Slider(
+                            label="Inference Steps (Model D)",
+                            info="The number of denoising steps of the image. More denoising steps usually lead to a higher quality image at the cost of slower inference",
+                            minimum=1,
+                            maximum=50,
+                            value=25,
+                            step=1,
+                            visible=True,
+                        )
+                        guidance_scale_d = gr.Slider(
+                            label="Guidance Scale (Model D)",
+                            info="Controls how much the image generation process follows the text prompt. Higher values make the image stick more closely to the input text.",
+                            minimum=0.0,
+                            maximum=10.0,
+                            value=7.5,
+                            step=0.1,
+                            visible=True,
+                        )
+                        prior_num_inference_steps_d = gr.Slider(
+                            label="Prior Inference Steps (Model D)",
+                            info="The number of denoising steps of the image. More denoising steps usually lead to a higher quality image at the cost of slower inference",
+                            minimum=1,
+                            maximum=50,
+                            value=25,
+                            step=1,
+                            visible=False,
+                        )
+                        prior_guidance_scale_d = gr.Slider(
+                            label="Prior Guidance Scale (Model D)",
+                            info="Controls how much the image generation process follows the text prompt. Higher values make the image stick more closely to the input text.",
+                            minimum=0.0,
+                            maximum=10.0,
+                            value=4.0,
+                            step=0.1,
+                            visible=False,
+                        )
+                        decoder_num_inference_steps_d = gr.Slider(
+                            label="Decoder Inference Steps (Model D)",
+                            info="The number of denoising steps of the image. More denoising steps usually lead to a higher quality image at the cost of slower inference",
+                            minimum=1,
+                            maximum=15,
+                            value=12,
+                            step=1,
+                            visible=False,
+                        )
+                        decoder_guidance_scale_d = gr.Slider(
+                            label="Decoder Guidance Scale (Model D)",
+                            info="Controls how much the image generation process follows the text prompt. Higher values make the image stick more closely to the input text.",
+                            minimum=0.0,
+                            maximum=10.0,
+                            value=0.0,
+                            step=0.1,
+                            visible=False,
+                        )
+                        width_d = gr.Slider(
+                            label="Width (Model D)",
+                            info="Width of the Image",
+                            minimum=256,
+                            maximum=1344,
+                            step=32,
+                            value=1024,
+                        )
+                        height_d = gr.Slider(
+                            label="Height (Model D)",
+                            info="Height of the Image",
+                            minimum=256,
+                            maximum=1344,
+                            step=32,
+                            value=1024,
                         )
-                with gr.Row():
-                    width = gr.Slider(
-                        label="Width",
-                        info="Width of the Image",
-                        minimum=256,
-                        maximum=1344,
-                        step=32,
-                        value=1024,
-                    )
-                    height = gr.Slider(
-                        label="Height",
-                        info="Height of the Image",
-                        minimum=256,
-                        maximum=1344,
-                        step=32,
-                        value=1024,
-                    )
                 with gr.Row():
                     seed = gr.Slider(
                         value=42,
@@ -507,6 +884,45 @@ with gr.Blocks(css=css) as demo:
                         decoder_num_inference_steps_a: gr.update(visible=False),
                         decoder_guidance_scale_a: gr.update(visible=False),
                     }
+                elif model_choice_a == "sd1.5":
+                    return {
+                        num_inference_steps_a: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale_a: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_guidance_scale_a: gr.update(visible=True),
+                        decoder_num_inference_steps_a: gr.update(visible=True),
+                        decoder_guidance_scale_a: gr.update(visible=True),
+                    }
+                elif model_choice_a == "sdxl flash":
+                    return {
+                        num_inference_steps_a: gr.update(visible=True, maximum=15, value=8),
+                        guidance_scale_a: gr.update(visible=True, maximum=6.0, value=3.5),
+                        prior_num_inference_steps_a: gr.update(visible=False),
+                        prior_guidance_scale_a: gr.update(visible=False),
+                        decoder_num_inference_steps_a: gr.update(visible=False),
+                        decoder_guidance_scale_a: gr.update(visible=False),
+                    }
+                elif model_choice_a == "sd1.5":
+                    return {
+                        num_inference_steps_a: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale_a: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_num_inference_steps_a: gr.update(visible=False),
+                        prior_guidance_scale_a: gr.update(visible=False),
+                        decoder_num_inference_steps_a: gr.update(visible=False),
+                        decoder_guidance_scale_a: gr.update(visible=False),
+                        width_a: gr.update(value=512, maximum=768),
+                        height_a: gr.update(value=512, maximum=768),
+                    }
+                elif model_choice_a == "sd2.1":
+                    return {
+                        num_inference_steps_a: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale_a: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_num_inference_steps_a: gr.update(visible=False),
+                        prior_guidance_scale_a: gr.update(visible=False),
+                        decoder_num_inference_steps_a: gr.update(visible=False),
+                        decoder_guidance_scale_a: gr.update(visible=False),
+                        width_a: gr.update(value=768, maximum=1024),
+                        height_a: gr.update(value=768, maximum=1024),
+                    }
                 else:
                     return {
                         num_inference_steps_a: gr.update(visible=True, maximum=50, value=25),
@@ -515,6 +931,8 @@ with gr.Blocks(css=css) as demo:
                         prior_guidance_scale_a: gr.update(visible=False),
                         decoder_num_inference_steps_a: gr.update(visible=False),
                         decoder_guidance_scale_a: gr.update(visible=False),
+                        width_a: gr.update(maximum=1344),
+                        height_a: gr.update(maximum=1344),
                     }
 
             def toggle_visibility_arena_b(model_choice_b):
@@ -536,6 +954,28 @@ with gr.Blocks(css=css) as demo:
                         decoder_num_inference_steps_b: gr.update(visible=False),
                         decoder_guidance_scale_b: gr.update(visible=False),
                     }
+                elif model_choice_b == "sd1.5":
+                    return {
+                        num_inference_steps_b: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale_b: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_num_inference_steps_b: gr.update(visible=False),
+                        prior_guidance_scale_b: gr.update(visible=False),
+                        decoder_num_inference_steps_b: gr.update(visible=False),
+                        decoder_guidance_scale_b: gr.update(visible=False),
+                        width_b: gr.update(value=512, maximum=768),
+                        height_b: gr.update(value=512, maximum=768),
+                    }
+                elif model_choice_b == "sd2.1":
+                    return {
+                        num_inference_steps_b: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale_b: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_num_inference_steps_b: gr.update(visible=False),
+                        prior_guidance_scale_b: gr.update(visible=False),
+                        decoder_num_inference_steps_b: gr.update(visible=False),
+                        decoder_guidance_scale_b: gr.update(visible=False),
+                        width_b: gr.update(value=768, maximum=1024),
+                        height_b: gr.update(value=768, maximum=1024),
+                    }
                 else:
                     return {
                         num_inference_steps_b: gr.update(visible=True, maximum=50, value=25),
@@ -544,6 +984,114 @@ with gr.Blocks(css=css) as demo:
                         prior_guidance_scale_b: gr.update(visible=False),
                         decoder_num_inference_steps_b: gr.update(visible=False),
                         decoder_guidance_scale_b: gr.update(visible=False),
+                        width_b: gr.update(maximum=1344),
+                        height_b: gr.update(maximum=1344),
+                    }
+
+            def toggle_visibility_arena_c(model_choice_c):
+                if model_choice_c == "stable cascade":
+                    return {
+                        num_inference_steps_c: gr.update(visible=False),
+                        guidance_scale_c: gr.update(visible=False),
+                        prior_num_inference_steps_c: gr.update(visible=True),
+                        prior_guidance_scale_c: gr.update(visible=True),
+                        decoder_num_inference_steps_c: gr.update(visible=True),
+                        decoder_guidance_scale_c: gr.update(visible=True),
+                    }
+                elif model_choice_c == "sdxl flash":
+                    return {
+                        num_inference_steps_c: gr.update(visible=True, maximum=15, value=8),
+                        guidance_scale_c: gr.update(visible=True, maximum=6.0, value=3.5),
+                        prior_num_inference_steps_c: gr.update(visible=False),
+                        prior_guidance_scale_c: gr.update(visible=False),
+                        decoder_num_inference_steps_c: gr.update(visible=False),
+                        decoder_guidance_scale_c: gr.update(visible=False),
+                    }
+                elif model_choice_c == "sd1.5":
+                    return {
+                        num_inference_steps_c: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale_c: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_num_inference_steps_c: gr.update(visible=False),
+                        prior_guidance_scale_c: gr.update(visible=False),
+                        decoder_num_inference_steps_c: gr.update(visible=False),
+                        decoder_guidance_scale_c: gr.update(visible=False),
+                        width_c: gr.update(value=512, maximum=768),
+                        height_c: gr.update(value=512, maximum=768),
+                    }
+                elif model_choice_c == "sd2.1":
+                    return {
+                        num_inference_steps_c: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale_c: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_num_inference_steps_c: gr.update(visible=False),
+                        prior_guidance_scale_c: gr.update(visible=False),
+                        decoder_num_inference_steps_c: gr.update(visible=False),
+                        decoder_guidance_scale_c: gr.update(visible=False),
+                        width_c: gr.update(value=768, maximum=1024),
+                        height_c: gr.update(value=768, maximum=1024),
+                    }
+                else:
+                    return {
+                        num_inference_steps_c: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale_c: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_num_inference_steps_c: gr.update(visible=False),
+                        prior_guidance_scale_c: gr.update(visible=False),
+                        decoder_num_inference_steps_c: gr.update(visible=False),
+                        decoder_guidance_scale_c: gr.update(visible=False),
+                        width_c: gr.update(maximum=1344),
+                        height_c: gr.update(maximum=1344),
+                    }
+
+            def toggle_visibility_arena_d(model_choice_d):
+                if model_choice_d == "stable cascade":
+                    return {
+                        num_inference_steps_d: gr.update(visible=False),
+                        guidance_scale_d: gr.update(visible=False),
+                        prior_num_inference_steps_d: gr.update(visible=True),
+                        prior_guidance_scale_d: gr.update(visible=True),
+                        decoder_num_inference_steps_d: gr.update(visible=True),
+                        decoder_guidance_scale_d: gr.update(visible=True),
+                    }
+                elif model_choice_d == "sdxl flash":
+                    return {
+                        num_inference_steps_d: gr.update(visible=True, maximum=15, value=8),
+                        guidance_scale_d: gr.update(visible=True, maximum=6.0, value=3.5),
+                        prior_num_inference_steps_d: gr.update(visible=False),
+                        prior_guidance_scale_d: gr.update(visible=False),
+                        decoder_num_inference_steps_d: gr.update(visible=False),
+                        decoder_guidance_scale_d: gr.update(visible=False),
+                    }
+                elif model_choice_d == "sd1.5":
+                    return {
+                        num_inference_steps_d: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale_d: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_num_inference_steps_d: gr.update(visible=False),
+                        prior_guidance_scale_d: gr.update(visible=False),
+                        decoder_num_inference_steps_d: gr.update(visible=False),
+                        decoder_guidance_scale_d: gr.update(visible=False),
+                        width_d: gr.update(value=512, maximum=768),
+                        height_d: gr.update(value=512, maximum=768),
+                    }
+                elif model_choice_d == "sd2.1":
+                    return {
+                        num_inference_steps_d: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale_d: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_num_inference_steps_d: gr.update(visible=False),
+                        prior_guidance_scale_d: gr.update(visible=False),
+                        decoder_num_inference_steps_d: gr.update(visible=False),
+                        decoder_guidance_scale_d: gr.update(visible=False),
+                        width_d: gr.update(value=768, maximum=1024),
+                        height_d: gr.update(value=768, maximum=1024),
+                    }
+                else:
+                    return {
+                        num_inference_steps_d: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale_d: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_num_inference_steps_d: gr.update(visible=False),
+                        prior_guidance_scale_d: gr.update(visible=False),
+                        decoder_num_inference_steps_d: gr.update(visible=False),
+                        decoder_guidance_scale_d: gr.update(visible=False),
+                        width_d: gr.update(maximum=1344),
+                        height_d: gr.update(maximum=1344),
                     }
 
             model_choice_a.change(
@@ -555,8 +1103,10 @@ with gr.Blocks(css=css) as demo:
                     prior_num_inference_steps_a,
                     prior_guidance_scale_a,
                     decoder_num_inference_steps_a,
-                    decoder_guidance_scale_a
-                ]
+                    decoder_guidance_scale_a,
+                    width_a,
+                    height_a,
+                ],
             )
             model_choice_b.change(
                 toggle_visibility_arena_b,
@@ -567,26 +1117,110 @@ with gr.Blocks(css=css) as demo:
                     prior_num_inference_steps_b,
                     prior_guidance_scale_b,
                     decoder_num_inference_steps_b,
-                    decoder_guidance_scale_b
-                ]
+                    decoder_guidance_scale_b,
+                    width_b,
+                    height_b,
+                ],
+            )
+            model_choice_c.change(
+                toggle_visibility_arena_c,
+                inputs=[model_choice_c],
+                outputs=[
+                    num_inference_steps_c,
+                    guidance_scale_c,
+                    prior_num_inference_steps_c,
+                    prior_guidance_scale_c,
+                    decoder_num_inference_steps_c,
+                    decoder_guidance_scale_c,
+                    width_c,
+                    height_c,
+                ],
+            )
+            model_choice_d.change(
+                toggle_visibility_arena_d,
+                inputs=[model_choice_d],
+                outputs=[
+                    num_inference_steps_d,
+                    guidance_scale_d,
+                    prior_num_inference_steps_d,
+                    prior_guidance_scale_d,
+                    decoder_num_inference_steps_d,
+                    decoder_guidance_scale_d,
+                    width_d,
+                    height_d,
+                ],
             )
 
+            def toggle_model_options(num_models):
+                if num_models == 2:
+                    return {
+                        model_choice_c: gr.update(visible=False),
+                        model_d_options: gr.update(visible=False),
+                        model_choice_d: gr.update(visible=False),
+                        result_3: gr.update(visible=False),
+                        result_4: gr.update(visible=False),
+                        model_c_options: gr.update(visible=False),
+                    }
+                elif num_models == 3:
+                    return {
+                        model_choice_c: gr.update(visible=True),
+                        model_d_options: gr.update(visible=False),
+                        model_choice_d: gr.update(visible=False),
+                        result_3: gr.update(visible=True),
+                        result_4: gr.update(visible=False),
+                        model_c_options: gr.update(visible=True),
+                    }
+                elif num_models == 4:
+                    return {
+                        model_choice_c: gr.update(visible=True),
+                        model_d_options: gr.update(visible=True),
+                        model_choice_d: gr.update(visible=True),
+                        result_3: gr.update(visible=True),
+                        result_4: gr.update(visible=True),
+                        model_c_options: gr.update(visible=True),
+                    }
+
+            num_models_to_compare.change(
+                toggle_model_options,
+                inputs=[num_models_to_compare],
+                outputs=[
+                    model_choice_c,
+                    model_d_options,
+                    model_choice_d,
+                    result_3,
+                    result_4,
+                    model_c_options,
+                ],
+            )
 
             gr.Examples(
                 examples=examples_arena,
                 inputs=[
                     prompt,
                     negative_prompt,
+                    num_models_to_compare,
                     num_inference_steps_a,
                     guidance_scale_a,
                     num_inference_steps_b,
                     guidance_scale_b,
-                    height,
-                    width,
+                    num_inference_steps_c,
+                    guidance_scale_c,
+                    num_inference_steps_d,
+                    guidance_scale_d,
+                    height_a,
+                    width_a,
+                    height_b,
+                    width_b,
+                    height_c,
+                    width_c,
+                    height_d,
+                    width_d,
                     seed,
                     num_images_per_prompt,
                     model_choice_a,
                     model_choice_b,
+                    model_choice_c,
+                    model_choice_d,
                     prior_num_inference_steps_a,
                     prior_guidance_scale_a,
                     decoder_num_inference_steps_a,
@@ -595,8 +1229,16 @@ with gr.Blocks(css=css) as demo:
                     prior_guidance_scale_b,
                     decoder_num_inference_steps_b,
                     decoder_guidance_scale_b,
+                    prior_num_inference_steps_c,
+                    prior_guidance_scale_c,
+                    decoder_num_inference_steps_c,
+                    decoder_guidance_scale_c,
+                    prior_num_inference_steps_d,
+                    prior_guidance_scale_d,
+                    decoder_num_inference_steps_d,
+                    decoder_guidance_scale_d,
                 ],
-                outputs=[result_1, result_2],
+                outputs=[result_1, result_2, result_3, result_4],
                 fn=generate_arena_images,
             )
 
@@ -609,16 +1251,29 @@ with gr.Blocks(css=css) as demo:
                 inputs=[
                     prompt,
                     negative_prompt,
+                    num_models_to_compare,
                     num_inference_steps_a,
                     guidance_scale_a,
                     num_inference_steps_b,
                     guidance_scale_b,
-                    height,
-                    width,
+                    num_inference_steps_c,
+                    guidance_scale_c,
+                    num_inference_steps_d,
+                    guidance_scale_d,
+                    height_a,
+                    width_a,
+                    height_b,
+                    width_b,
+                    height_c,
+                    width_c,
+                    height_d,
+                    width_d,
                     seed,
                     num_images_per_prompt,
                     model_choice_a,
                     model_choice_b,
+                    model_choice_c,
+                    model_choice_d,
                     prior_num_inference_steps_a,
                     prior_guidance_scale_a,
                     decoder_num_inference_steps_a,
@@ -627,8 +1282,16 @@ with gr.Blocks(css=css) as demo:
                     prior_guidance_scale_b,
                     decoder_num_inference_steps_b,
                     decoder_guidance_scale_b,
+                    prior_num_inference_steps_c,
+                    prior_guidance_scale_c,
+                    decoder_num_inference_steps_c,
+                    decoder_guidance_scale_c,
+                    prior_num_inference_steps_d,
+                    prior_guidance_scale_d,
+                    decoder_num_inference_steps_d,
+                    decoder_guidance_scale_d,
                 ],
-                outputs=[result_1, result_2],
+                outputs=[result_1, result_2, result_3, result_4],
             )
 
         with gr.TabItem("Individual"):
@@ -641,11 +1304,20 @@ with gr.Blocks(css=css) as demo:
                     )
                     model_choice = gr.Dropdown(
                         label="Stable Diffusion Model",
-                        choices=["sd3 medium", "sd2.1", "sdxl", "sdxl flash", "stable cascade"],
+                        choices=[
+                            "sd3 medium",
+                            "sd2.1",
+                            "sdxl",
+                            "sdxl flash",
+                            "stable cascade",
+                            "sd1.5",
+                        ],
                         value="sd3 medium",
                     )
                     run_button = gr.Button("Run")
-                result = gr.Gallery(label="Generated AI Images", elem_id="gallery")
+                result = gr.Gallery(
+                    label="Generated AI Images", elem_id="gallery"
+                )
             with gr.Accordion("Advanced options", open=False):
                 with gr.Row():
                     negative_prompt = gr.Textbox(
@@ -662,7 +1334,7 @@ with gr.Blocks(css=css) as demo:
                         maximum=50,
                         value=25,
                         step=1,
-                        visible=True
+                        visible=True,
                     )
                     guidance_scale = gr.Slider(
                         label="Guidance Scale",
@@ -671,7 +1343,7 @@ with gr.Blocks(css=css) as demo:
                         maximum=10.0,
                         value=7.5,
                         step=0.1,
-                        visible=True
+                        visible=True,
                     )
                     prior_num_inference_steps = gr.Slider(
                         label="Prior Inference Steps",
@@ -680,7 +1352,7 @@ with gr.Blocks(css=css) as demo:
                         maximum=50,
                         value=25,
                         step=1,
-                        visible=False
+                        visible=False,
                     )
                     prior_guidance_scale = gr.Slider(
                         label="Prior Guidance Scale",
@@ -689,7 +1361,7 @@ with gr.Blocks(css=css) as demo:
                         maximum=10.0,
                         value=4.0,
                         step=0.1,
-                        visible=False
+                        visible=False,
                     )
                     decoder_num_inference_steps = gr.Slider(
                         label="Decoder Inference Steps",
@@ -698,7 +1370,7 @@ with gr.Blocks(css=css) as demo:
                         maximum=15,
                         value=12,
                         step=1,
-                        visible=False
+                        visible=False,
                     )
                     decoder_guidance_scale = gr.Slider(
                         label="Decoder Guidance Scale",
@@ -707,7 +1379,7 @@ with gr.Blocks(css=css) as demo:
                         maximum=10.0,
                         value=0.0,
                         step=0.1,
-                        visible=False
+                        visible=False,
                     )
                 with gr.Row():
                     width = gr.Slider(
@@ -763,6 +1435,28 @@ with gr.Blocks(css=css) as demo:
                         decoder_num_inference_steps: gr.update(visible=False),
                         decoder_guidance_scale: gr.update(visible=False),
                     }
+                elif model_choice == "sd1.5":
+                    return {
+                        num_inference_steps: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_num_inference_steps: gr.update(visible=False),
+                        prior_guidance_scale: gr.update(visible=False),
+                        decoder_num_inference_steps: gr.update(visible=False),
+                        decoder_guidance_scale: gr.update(visible=False),
+                        width: gr.update(value=512, maximum=768),
+                        height: gr.update(value=512, maximum=768),
+                    }
+                elif model_choice == "sd2.1":
+                    return {
+                        num_inference_steps: gr.update(visible=True, maximum=50, value=25),
+                        guidance_scale: gr.update(visible=True, maximum=10.0, value=7.5),
+                        prior_num_inference_steps: gr.update(visible=False),
+                        prior_guidance_scale: gr.update(visible=False),
+                        decoder_num_inference_steps: gr.update(visible=False),
+                        decoder_guidance_scale: gr.update(visible=False),
+                        width: gr.update(value=768, maximum=1024),
+                        height: gr.update(value=768, maximum=1024),
+                    }
                 else:
                     return {
                         num_inference_steps: gr.update(visible=True, maximum=50, value=25),
@@ -771,6 +1465,8 @@ with gr.Blocks(css=css) as demo:
                         prior_guidance_scale: gr.update(visible=False),
                         decoder_num_inference_steps: gr.update(visible=False),
                         decoder_guidance_scale: gr.update(visible=False),
+                        width: gr.update(maximum=1344),
+                        height: gr.update(maximum=1344),
                     }
 
             model_choice.change(
@@ -782,8 +1478,10 @@ with gr.Blocks(css=css) as demo:
                     prior_num_inference_steps,
                     prior_guidance_scale,
                     decoder_num_inference_steps,
-                    decoder_guidance_scale
-                ]
+                    decoder_guidance_scale,
+                    width,
+                    height,
+                ],
             )
 
             gr.Examples(