Add Stable Diffusion equation playground

README.md

@@ -1,13 +1,47 @@
 ---
-title: Diffusers Playground
-emoji: 🐨
-colorFrom: purple
-colorTo: blue
+title: Stable Diffusion Equation Playground
+emoji: 🧪
+colorFrom: indigo
+colorTo: green
 sdk: gradio
-sdk_version: 6.19.0
-python_version: '3.12'
+sdk_version: 5.22.0
+python_version: 3.10
 app_file: app.py
 pinned: false
+license: mit
+models:
+  - stable-diffusion-v1-5/stable-diffusion-v1-5
+preload_from_hub:
+  - stable-diffusion-v1-5/stable-diffusion-v1-5
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Stable Diffusion Equation Playground
+
+A ZeroGPU-ready Gradio app for learning how Stable Diffusion works inside Diffusers.
+
+Instead of only calling `pipe(prompt)`, the app exposes a small custom denoising loop:
+
+- prompt embeddings can be used directly, averaged, or combined with vector arithmetic
+- initial latent noise can come from one seed or a blend of two seeds
+- classifier-free guidance can use standard CFG or a student-edited equation
+- intermediate latent snapshots show how the image emerges across denoising steps
+
+The core idea to teach: Stable Diffusion starts from noise in VAE latent space. The prompt does not literally become half of the pixels. The prompt changes the UNet's predicted noise at every denoising step, most commonly through classifier-free guidance:
+
+```python
+guided = negative_prediction + guidance_scale * (prompt_prediction - negative_prediction)
+```
+
+This app focuses on `StableDiffusionPipeline` checkpoints such as Stable Diffusion 1.5 because the embedding pathway is straightforward for students. SDXL uses two text encoders plus pooled prompt embeddings, so the same idea carries over, but the code is more complex.
+
+## Running
+
+On Hugging Face Spaces, select ZeroGPU hardware in the Space settings. The image generation function is decorated with `@spaces.GPU`, so it requests a GPU only while a generation is running.
+
+For local development, install the requirements, use a CUDA or MPS machine, then run:
+
+```bash
+python app.py
+```
+
+The default model is `stable-diffusion-v1-5/stable-diffusion-v1-5`. The first generation downloads the checkpoint from Hugging Face and may take a few minutes.

app.py

@@ -0,0 +1,607 @@
+import gc
+from functools import lru_cache
+
+import gradio as gr
+import numpy as np
+import torch
+from PIL import Image, ImageDraw
+
+from diffusers import DDIMScheduler, DPMSolverMultistepScheduler, StableDiffusionPipeline
+
+try:
+    import spaces
+except ImportError:
+    class _SpacesFallback:
+        @staticmethod
+        def GPU(*decorator_args, **decorator_kwargs):
+            if decorator_args and callable(decorator_args[0]) and not decorator_kwargs:
+                return decorator_args[0]
+
+            def decorator(func):
+                return func
+
+            return decorator
+
+    spaces = _SpacesFallback()
+
+
+APP_TITLE = "Stable Diffusion Equation Playground"
+DEFAULT_MODEL = "stable-diffusion-v1-5/stable-diffusion-v1-5"
+DEFAULT_PROMPT_A = "a small glass greenhouse filled with glowing ferns, watercolor"
+DEFAULT_PROMPT_B = "a futuristic train station at sunrise, cinematic lighting"
+DEFAULT_PROMPT_C = "low quality, blurry, distorted"
+MAX_SEED = 2_147_483_647
+
+PROMPT_MATH_CODE = """# Diffusers usually does this inside pipe(prompt).
+# Here we expose the text embeddings so we can edit them directly.
+prompt_a, negative = encode_prompt(prompt_a, negative_prompt)
+prompt_b, _ = encode_prompt(prompt_b, negative_prompt)
+prompt_c, _ = encode_prompt(prompt_c, negative_prompt)
+
+if mode == "average":
+    prompt_embeds = (1 - mix) * prompt_a + mix * prompt_b
+elif mode == "analogy":
+    prompt_embeds = prompt_a + strength * (prompt_b - prompt_c)
+else:
+    prompt_embeds = prompt_a
+"""
+
+LATENT_MATH_CODE = """# Stable Diffusion does not start from pixels.
+# It starts from noisy latents in the VAE's compressed image space.
+noise_a = torch.randn(latent_shape, generator=seed_a)
+noise_b = torch.randn(latent_shape, generator=seed_b)
+latents = (1 - noise_mix) * noise_a + noise_mix * noise_b
+
+if renormalize_noise:
+    latents = (latents - latents.mean()) / latents.std()
+
+latents = latents * scheduler.init_noise_sigma
+"""
+
+GUIDANCE_MATH_CODE = """# Classifier-free guidance combines two UNet predictions:
+# one conditioned on the negative/unconditional prompt, one on the prompt.
+noise_negative, noise_prompt = noise_pred.chunk(2)
+delta = noise_prompt - noise_negative
+
+# Standard CFG is:
+# guided = noise_negative + guidance_scale * delta
+guided = negative_coeff * noise_negative
+guided = guided + prompt_coeff * noise_prompt
+guided = guided + delta_coeff * delta
+"""
+
+
+def current_device():
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    if getattr(torch.backends, "mps", None) and torch.backends.mps.is_available():
+        return torch.device("mps")
+    return torch.device("cpu")
+
+
+def model_dtype(device):
+    if device.type == "cuda":
+        return torch.float16
+    return torch.float32
+
+
+def device_label(device):
+    if device.type == "cuda":
+        name = torch.cuda.get_device_name(0)
+        return f"CUDA GPU: {name}"
+    if device.type == "mps":
+        return "Apple MPS GPU"
+    return "CPU only. This app will load, but image generation will be very slow."
+
+
+def round_to_multiple_of_8(value):
+    value = int(value)
+    return max(256, min(768, 8 * round(value / 8)))
+
+
+def seed_generator(seed, device):
+    seed = int(seed) % MAX_SEED
+    if device.type == "cuda":
+        return torch.Generator(device=device).manual_seed(seed)
+    return torch.Generator(device="cpu").manual_seed(seed)
+
+
+def randn_tensor(shape, seed, device, dtype):
+    generator = seed_generator(seed, device)
+    if device.type == "cuda":
+        return torch.randn(shape, generator=generator, device=device, dtype=dtype)
+    return torch.randn(shape, generator=generator, device="cpu", dtype=dtype).to(device)
+
+
+def blank_image(message="Run generation to make an image."):
+    image = Image.new("RGB", (512, 512), (25, 29, 36))
+    draw = ImageDraw.Draw(image)
+    draw.text((32, 236), message, fill=(230, 235, 240))
+    return image
+
+
+@lru_cache(maxsize=2)
+def load_pipe(model_id, scheduler_name, device_type):
+    device = torch.device(device_type)
+    dtype = model_dtype(device)
+    pipe = StableDiffusionPipeline.from_pretrained(
+        model_id,
+        torch_dtype=dtype,
+        use_safetensors=True,
+    )
+
+    if scheduler_name == "DDIM":
+        pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
+    else:
+        pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
+
+    pipe = pipe.to(device)
+    pipe.set_progress_bar_config(disable=True)
+    pipe.enable_vae_slicing()
+
+    if device.type == "cuda":
+        try:
+            pipe.enable_xformers_memory_efficient_attention()
+        except Exception:
+            pass
+
+    return pipe
+
+
+def encode_prompt(pipe, prompt, negative_prompt, device):
+    if hasattr(pipe, "encode_prompt"):
+        prompt_embeds, negative_prompt_embeds = pipe.encode_prompt(
+            prompt=prompt,
+            device=device,
+            num_images_per_prompt=1,
+            do_classifier_free_guidance=True,
+            negative_prompt=negative_prompt,
+        )
+        return prompt_embeds, negative_prompt_embeds
+
+    combined = pipe._encode_prompt(
+        prompt=prompt,
+        device=device,
+        num_images_per_prompt=1,
+        do_classifier_free_guidance=True,
+        negative_prompt=negative_prompt,
+    )
+    negative_prompt_embeds, prompt_embeds = combined.chunk(2)
+    return prompt_embeds, negative_prompt_embeds
+
+
+def cosine_similarity(a, b):
+    a = a.detach().float().flatten()
+    b = b.detach().float().flatten()
+    return float(torch.nn.functional.cosine_similarity(a, b, dim=0).cpu())
+
+
+def mix_prompt_embeddings(
+    pipe,
+    device,
+    prompt_a,
+    prompt_b,
+    prompt_c,
+    negative_prompt,
+    embedding_mode,
+    prompt_mix,
+    analogy_strength,
+    renormalize_prompt,
+):
+    emb_a, negative_embeds = encode_prompt(pipe, prompt_a, negative_prompt, device)
+    emb_b, _ = encode_prompt(pipe, prompt_b, negative_prompt, device)
+    emb_c, _ = encode_prompt(pipe, prompt_c or "", negative_prompt, device)
+
+    if embedding_mode == "Average prompt A and B":
+        mixed = (1.0 - prompt_mix) * emb_a + prompt_mix * emb_b
+        formula = f"prompt = {(1.0 - prompt_mix):.2f} * A + {prompt_mix:.2f} * B"
+    elif embedding_mode == "Vector arithmetic: A + s * (B - C)":
+        mixed = emb_a + analogy_strength * (emb_b - emb_c)
+        formula = f"prompt = A + {analogy_strength:.2f} * (B - C)"
+    else:
+        mixed = emb_a
+        formula = "prompt = A"
+
+    original_norm = emb_a.detach().float().norm()
+    mixed_norm = mixed.detach().float().norm()
+    if renormalize_prompt and float(mixed_norm.cpu()) > 0:
+        mixed = mixed * (original_norm / mixed_norm)
+        formula += "; then rescale to A's embedding norm"
+
+    metrics = [
+        ["cosine(A, B)", round(cosine_similarity(emb_a, emb_b), 4)],
+        ["cosine(A, mixed)", round(cosine_similarity(emb_a, mixed), 4)],
+        ["cosine(B, mixed)", round(cosine_similarity(emb_b, mixed), 4)],
+        ["norm(A)", round(float(original_norm.cpu()), 3)],
+        ["norm(mixed)", round(float(mixed.detach().float().norm().cpu()), 3)],
+    ]
+    return mixed, negative_embeds, formula, metrics
+
+
+def prepare_latents(pipe, device, height, width, seed_a, seed_b, noise_mix, renormalize_noise):
+    channels = int(pipe.unet.config.in_channels)
+    latent_shape = (1, channels, height // pipe.vae_scale_factor, width // pipe.vae_scale_factor)
+    dtype = model_dtype(device)
+    noise_a = randn_tensor(latent_shape, seed_a, device, dtype)
+    noise_b = randn_tensor(latent_shape, seed_b, device, dtype)
+    latents = (1.0 - noise_mix) * noise_a + noise_mix * noise_b
+
+    before_std = float(latents.detach().float().std().cpu())
+    if renormalize_noise:
+        latents = (latents - latents.mean()) / (latents.std() + 1e-6)
+    after_std = float(latents.detach().float().std().cpu())
+
+    latents = latents * pipe.scheduler.init_noise_sigma
+    formula = f"noise = {(1.0 - noise_mix):.2f} * seed A + {noise_mix:.2f} * seed B"
+    if renormalize_noise:
+        formula += "; then renormalize to unit standard deviation"
+
+    metrics = [
+        ["latent shape", str(tuple(latent_shape))],
+        ["std before scheduler scale", round(before_std, 4)],
+        ["std after optional renorm", round(after_std, 4)],
+        ["scheduler init sigma", round(float(pipe.scheduler.init_noise_sigma), 4)],
+    ]
+    return latents, formula, metrics
+
+
+def combine_noise_predictions(
+    noise_negative,
+    noise_prompt,
+    equation_mode,
+    guidance_scale,
+    prediction_mix,
+    negative_coeff,
+    prompt_coeff,
+    delta_coeff,
+):
+    delta = noise_prompt - noise_negative
+
+    if equation_mode == "Standard CFG: negative + scale * (prompt - negative)":
+        guided = noise_negative + guidance_scale * delta
+        formula = f"guided = negative + {guidance_scale:.2f} * (prompt - negative)"
+    elif equation_mode == "Direct blend: (1 - mix) * negative + mix * prompt":
+        guided = (1.0 - prediction_mix) * noise_negative + prediction_mix * noise_prompt
+        formula = f"guided = {(1.0 - prediction_mix):.2f} * negative + {prediction_mix:.2f} * prompt"
+    elif equation_mode == "Prompt prediction only":
+        guided = noise_prompt
+        formula = "guided = prompt"
+    elif equation_mode == "Negative prediction only":
+        guided = noise_negative
+        formula = "guided = negative"
+    else:
+        guided = negative_coeff * noise_negative + prompt_coeff * noise_prompt + delta_coeff * delta
+        formula = (
+            f"guided = {negative_coeff:.2f} * negative + {prompt_coeff:.2f} * prompt "
+            f"+ {delta_coeff:.2f} * (prompt - negative)"
+        )
+
+    return guided, formula
+
+
+def decode_latents(pipe, latents):
+    latents = latents / pipe.vae.config.scaling_factor
+    image = pipe.vae.decode(latents, return_dict=False)[0]
+    image = (image / 2 + 0.5).clamp(0, 1)
+    image = image.detach().cpu().permute(0, 2, 3, 1).float().numpy()
+    image = (image * 255).round().astype("uint8")
+    return [Image.fromarray(frame) for frame in image]
+
+
+def checkpoint_indices(num_steps):
+    last = max(0, int(num_steps) - 1)
+    return sorted({0, last // 3, (2 * last) // 3, last})
+
+
+def gpu_duration(*args):
+    try:
+        steps = int(args[-3])
+        width = int(args[-2])
+        height = int(args[-1])
+    except Exception:
+        return 90
+
+    pixel_factor = max(1.0, (width * height) / (512 * 512))
+    return min(180, max(60, int(35 + steps * 2.5 * pixel_factor)))
+
+
+@spaces.GPU(duration=gpu_duration)
+@torch.inference_mode()
+def generate(
+    model_id,
+    scheduler_name,
+    prompt_a,
+    prompt_b,
+    prompt_c,
+    negative_prompt,
+    embedding_mode,
+    prompt_mix,
+    analogy_strength,
+    renormalize_prompt,
+    seed_a,
+    seed_b,
+    noise_mix,
+    renormalize_noise,
+    equation_mode,
+    guidance_scale,
+    prediction_mix,
+    negative_coeff,
+    prompt_coeff,
+    delta_coeff,
+    num_steps,
+    width,
+    height,
+):
+    device = current_device()
+    if device.type == "cpu":
+        return (
+            blank_image("GPU recommended."),
+            [],
+            "No GPU was detected. The app is designed for CUDA or MPS. It can run on CPU, but it may take a very long time.",
+            [],
+            [],
+        )
+
+    width = round_to_multiple_of_8(width)
+    height = round_to_multiple_of_8(height)
+    num_steps = int(num_steps)
+    pipe = load_pipe(model_id.strip() or DEFAULT_MODEL, scheduler_name, device.type)
+
+    prompt_embeds, negative_prompt_embeds, prompt_formula, prompt_metrics = mix_prompt_embeddings(
+        pipe,
+        device,
+        prompt_a or "",
+        prompt_b or "",
+        prompt_c or "",
+        negative_prompt or "",
+        embedding_mode,
+        float(prompt_mix),
+        float(analogy_strength),
+        bool(renormalize_prompt),
+    )
+
+    pipe.scheduler.set_timesteps(num_steps, device=device)
+    latents, latent_formula, latent_metrics = prepare_latents(
+        pipe,
+        device,
+        height,
+        width,
+        int(seed_a),
+        int(seed_b),
+        float(noise_mix),
+        bool(renormalize_noise),
+    )
+
+    text_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])
+    snapshots = []
+    trace_rows = []
+    save_at = checkpoint_indices(num_steps)
+    last_formula = ""
+
+    for step_index, timestep in enumerate(pipe.scheduler.timesteps):
+        latent_model_input = torch.cat([latents] * 2)
+        latent_model_input = pipe.scheduler.scale_model_input(latent_model_input, timestep)
+
+        noise_pred = pipe.unet(
+            latent_model_input,
+            timestep,
+            encoder_hidden_states=text_embeds,
+            return_dict=False,
+        )[0]
+        noise_negative, noise_prompt = noise_pred.chunk(2)
+        guided, last_formula = combine_noise_predictions(
+            noise_negative,
+            noise_prompt,
+            equation_mode,
+            float(guidance_scale),
+            float(prediction_mix),
+            float(negative_coeff),
+            float(prompt_coeff),
+            float(delta_coeff),
+        )
+
+        latents = pipe.scheduler.step(guided, timestep, latents, return_dict=False)[0]
+
+        delta_norm = float((noise_prompt - noise_negative).detach().float().norm().cpu())
+        guided_norm = float(guided.detach().float().norm().cpu())
+        trace_rows.append(
+            [
+                step_index + 1,
+                int(timestep.detach().cpu()) if torch.is_tensor(timestep) else int(timestep),
+                round(delta_norm, 3),
+                round(guided_norm, 3),
+            ]
+        )
+
+        if step_index in save_at:
+            snapshot = decode_latents(pipe, latents)[0]
+            snapshots.append((snapshot, f"step {step_index + 1} of {num_steps}"))
+
+    final_image = decode_latents(pipe, latents)[0]
+    metrics = prompt_metrics + latent_metrics + [
+        ["device", device_label(device)],
+        ["prompt formula", prompt_formula],
+        ["noise formula", latent_formula],
+        ["guidance formula", last_formula],
+    ]
+    summary = (
+        f"Model: {model_id.strip() or DEFAULT_MODEL}\n"
+        f"Scheduler: {scheduler_name}; steps: {num_steps}; size: {width}x{height}\n\n"
+        f"Prompt embedding math:\n{prompt_formula}\n\n"
+        f"Initial latent noise math:\n{latent_formula}\n\n"
+        f"Guidance equation used at each denoising step:\n{last_formula}\n\n"
+        "Stable Diffusion starts from noise in latent space. The prompt does not get averaged with pixels; "
+        "it changes the UNet's predicted noise at every step."
+    )
+
+    if device.type == "cuda":
+        torch.cuda.empty_cache()
+    gc.collect()
+    return final_image, snapshots, summary, metrics, trace_rows
+
+
+def randomize_seeds():
+    rng = np.random.default_rng()
+    return int(rng.integers(0, MAX_SEED)), int(rng.integers(0, MAX_SEED))
+
+
+def build_app():
+    theme = gr.themes.Soft(
+        primary_hue="indigo",
+        secondary_hue="emerald",
+        neutral_hue="slate",
+        radius_size="sm",
+    )
+
+    css = """
+    .snapshot-gallery img { object-fit: contain !important; }
+    .code-panel textarea, .code-panel pre { font-size: 13px !important; }
+    """
+
+    metric_headers = ["quantity", "value"]
+    trace_headers = ["step", "timestep", "prompt minus negative norm", "guided prediction norm"]
+
+    with gr.Blocks(title=APP_TITLE, theme=theme, css=css) as demo:
+        gr.Markdown(
+            f"# {APP_TITLE}\n"
+            "Change the starting noise, average prompt embeddings, and edit the classifier-free guidance equation. "
+            "This is a GPU-oriented teaching app built on Diffusers."
+        )
+
+        with gr.Row(equal_height=False):
+            with gr.Column(scale=1, min_width=320):
+                model_id = gr.Textbox(value=DEFAULT_MODEL, label="Diffusers model id")
+                scheduler_name = gr.Radio(["DPM++ 2M", "DDIM"], value="DPM++ 2M", label="Scheduler")
+
+                with gr.Accordion("Prompt embeddings", open=True):
+                    prompt_a = gr.Textbox(value=DEFAULT_PROMPT_A, label="Prompt A", lines=3)
+                    prompt_b = gr.Textbox(value=DEFAULT_PROMPT_B, label="Prompt B", lines=3)
+                    prompt_c = gr.Textbox(value=DEFAULT_PROMPT_C, label="Prompt C for vector arithmetic", lines=2)
+                    negative_prompt = gr.Textbox(
+                        value="blurry, low quality, distorted",
+                        label="Negative prompt",
+                        lines=2,
+                    )
+                    embedding_mode = gr.Dropdown(
+                        [
+                            "Prompt A only",
+                            "Average prompt A and B",
+                            "Vector arithmetic: A + s * (B - C)",
+                        ],
+                        value="Average prompt A and B",
+                        label="Embedding equation",
+                    )
+                    prompt_mix = gr.Slider(0, 1, value=0.5, step=0.05, label="Prompt B weight")
+                    analogy_strength = gr.Slider(-2, 2, value=0.8, step=0.1, label="Vector arithmetic strength")
+                    renormalize_prompt = gr.Checkbox(value=True, label="Keep mixed prompt embedding norm near prompt A")
+
+                with gr.Accordion("Starting latent noise", open=True):
+                    with gr.Row():
+                        seed_a = gr.Number(value=11, precision=0, label="Seed A")
+                        seed_b = gr.Number(value=2222, precision=0, label="Seed B")
+                    random_seeds = gr.Button("Randomize seeds")
+                    noise_mix = gr.Slider(0, 1, value=0.0, step=0.05, label="Seed B noise weight")
+                    renormalize_noise = gr.Checkbox(value=True, label="Renormalize mixed noise")
+
+                with gr.Accordion("Guidance equation", open=True):
+                    equation_mode = gr.Dropdown(
+                        [
+                            "Standard CFG: negative + scale * (prompt - negative)",
+                            "Direct blend: (1 - mix) * negative + mix * prompt",
+                            "Prompt prediction only",
+                            "Negative prediction only",
+                            "Custom coefficients",
+                        ],
+                        value="Standard CFG: negative + scale * (prompt - negative)",
+                        label="Noise prediction equation",
+                    )
+                    guidance_scale = gr.Slider(0, 15, value=7.5, step=0.25, label="CFG scale")
+                    prediction_mix = gr.Slider(0, 2, value=0.5, step=0.05, label="Direct blend prompt weight")
+                    with gr.Row():
+                        negative_coeff = gr.Slider(-3, 3, value=1, step=0.1, label="negative coeff")
+                        prompt_coeff = gr.Slider(-3, 3, value=0, step=0.1, label="prompt coeff")
+                        delta_coeff = gr.Slider(-3, 15, value=7.5, step=0.25, label="delta coeff")
+
+                with gr.Accordion("Render settings", open=True):
+                    with gr.Row():
+                        width = gr.Slider(256, 768, value=512, step=8, label="Width")
+                        height = gr.Slider(256, 768, value=512, step=8, label="Height")
+                    num_steps = gr.Slider(4, 50, value=20, step=1, label="Denoising steps")
+                    generate_button = gr.Button("Generate", variant="primary")
+
+            with gr.Column(scale=1, min_width=420):
+                output_image = gr.Image(
+                    value=blank_image(),
+                    label="Generated image",
+                    type="pil",
+                    interactive=False,
+                )
+                summary = gr.Textbox(label="What happened", lines=12, interactive=False)
+                snapshots = gr.Gallery(
+                    label="Decoded latent snapshots",
+                    columns=2,
+                    height=420,
+                    object_fit="contain",
+                    elem_classes=["snapshot-gallery"],
+                )
+                metrics = gr.Dataframe(
+                    headers=metric_headers,
+                    datatype=["str", "str"],
+                    label="Embedding and latent measurements",
+                    interactive=False,
+                )
+                trace = gr.Dataframe(
+                    headers=trace_headers,
+                    datatype=["number", "number", "number", "number"],
+                    label="Denoising trace",
+                    interactive=False,
+                )
+
+        with gr.Tab("Code cells"):
+            with gr.Row(equal_height=False):
+                gr.Code(PROMPT_MATH_CODE, language="python", label="Prompt embedding math", interactive=False, elem_classes=["code-panel"])
+                gr.Code(LATENT_MATH_CODE, language="python", label="Latent noise math", interactive=False, elem_classes=["code-panel"])
+                gr.Code(GUIDANCE_MATH_CODE, language="python", label="Guidance equation", interactive=False, elem_classes=["code-panel"])
+
+        random_seeds.click(
+            randomize_seeds,
+            inputs=None,
+            outputs=[seed_a, seed_b],
+            show_progress="hidden",
+        )
+        generate_button.click(
+            generate,
+            inputs=[
+                model_id,
+                scheduler_name,
+                prompt_a,
+                prompt_b,
+                prompt_c,
+                negative_prompt,
+                embedding_mode,
+                prompt_mix,
+                analogy_strength,
+                renormalize_prompt,
+                seed_a,
+                seed_b,
+                noise_mix,
+                renormalize_noise,
+                equation_mode,
+                guidance_scale,
+                prediction_mix,
+                negative_coeff,
+                prompt_coeff,
+                delta_coeff,
+                num_steps,
+                width,
+                height,
+            ],
+            outputs=[output_image, snapshots, summary, metrics, trace],
+            show_progress="full",
+        )
+
+    return demo
+
+
+if __name__ == "__main__":
+    build_app().queue(max_size=8).launch()

requirements.txt

@@ -0,0 +1,9 @@
+gradio>=5.22.0
+spaces
+torch>=2.8.0
+diffusers>=0.35.0
+transformers
+accelerate
+safetensors
+pillow
+numpy