Simplify prompt blending workshop UI

README.md

@@ -19,12 +19,11 @@ preload_from_hub:
 
 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:
+Instead of only calling `pipe(prompt)`, the app exposes a beginner-friendly custom denoising loop:
 
-- prompt embeddings can be used directly, averaged, or combined with vector arithmetic
-- three prompt embeddings can be explored as a clickable triangle between concepts
-- 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
+- three prompt embeddings can be blended with simple strength sliders
+- the live equation shows the exact weighted embedding blend being used
+- a few Diffusers levers are exposed: seed, denoising steps, prompt guidance, and optional noise mixing
 - 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:

app.py

@@ -22,45 +22,43 @@ import numpy as np
 import torch
 from PIL import Image, ImageDraw
 
-from diffusers import DDIMScheduler, DPMSolverMultistepScheduler, StableDiffusionPipeline
+from diffusers import DPMSolverMultistepScheduler, StableDiffusionPipeline
 
 
 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"
+DEFAULT_PROMPT_A = "a cozy treehouse in a forest"
+DEFAULT_PROMPT_B = "an underwater coral reef"
+DEFAULT_PROMPT_C = "a colorful outer space nebula"
+DEFAULT_NEGATIVE_PROMPT = "blurry, low quality, 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 == "triangle":
-    total = weight_a + weight_b + weight_c
-    prompt_embeds = (
-        (weight_a / total) * prompt_a
-        + (weight_b / total) * prompt_b
-        + (weight_c / total) * prompt_c
-    )
-elif mode == "analogy":
-    prompt_embeds = prompt_a + strength * (prompt_b - prompt_c)
+PROMPT_MATH_CODE = """# Diffusers normally hides this inside pipe(prompt).
+# In this app, each prompt becomes a CLIP text embedding first.
+embed_a, negative = encode_prompt(prompt_a, negative_prompt)
+embed_b, _ = encode_prompt(prompt_b, negative_prompt)
+embed_c, _ = encode_prompt(prompt_c, negative_prompt)
+
+# The sliders choose the strength of each idea.
+total = strength_a + strength_b + strength_c
+if total <= 0:
+    wa = wb = wc = 1 / 3
 else:
-    prompt_embeds = prompt_a
+    wa = strength_a / total
+    wb = strength_b / total
+    wc = strength_c / total
+
+prompt_embeds = wa * embed_a + wb * embed_b + wc * embed_c
 """
 
 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()
+# This hidden lever lets students mix the starting noise too.
+latents = (1 - noise_mix) * noise_a + noise_mix * noise_b
+latents = (latents - latents.mean()) / latents.std()
 
 latents = latents * scheduler.init_noise_sigma
 """
@@ -72,9 +70,7 @@ 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
+guided = noise_negative + guidance_scale * delta
 """
 
 
@@ -127,130 +123,43 @@ def blank_image(message="Run generation to make an image."):
     return image
 
 
-TRIANGLE_SIZE = 360
-TRIANGLE_A = (180, 32)
-TRIANGLE_B = (42, 300)
-TRIANGLE_C = (318, 300)
-
-
-def normalized_triangle_weights(weight_a, weight_b, weight_c):
+def normalized_prompt_weights(weight_a, weight_b, weight_c):
     weights = [max(0.0, float(weight_a)), max(0.0, float(weight_b)), max(0.0, float(weight_c))]
     total = sum(weights)
     if total <= 0:
-        return 1.0, 0.0, 0.0
+        return 1 / 3, 1 / 3, 1 / 3
     return tuple(weight / total for weight in weights)
 
 
-def weighted_triangle_point(weight_a, weight_b, weight_c):
-    weight_a, weight_b, weight_c = normalized_triangle_weights(weight_a, weight_b, weight_c)
-    x = weight_a * TRIANGLE_A[0] + weight_b * TRIANGLE_B[0] + weight_c * TRIANGLE_C[0]
-    y = weight_a * TRIANGLE_A[1] + weight_b * TRIANGLE_B[1] + weight_c * TRIANGLE_C[1]
-    return int(round(x)), int(round(y))
-
-
-def short_corner_label(text, fallback):
+def compact_prompt(text, fallback):
     text = " ".join(str(text or fallback).split())
-    return text[:24] + ("..." if len(text) > 24 else "")
-
-
-def make_triangle_picker(prompt_a, prompt_b, prompt_c, weight_a=1 / 3, weight_b=1 / 3, weight_c=1 / 3):
-    image = Image.new("RGB", (TRIANGLE_SIZE, TRIANGLE_SIZE), (248, 250, 252))
-    draw = ImageDraw.Draw(image)
-    vertices = [TRIANGLE_A, TRIANGLE_B, TRIANGLE_C]
-
-    draw.polygon(vertices, fill=(235, 244, 255), outline=(43, 74, 111))
-    for i in range(1, 7):
-        t = i / 7
-        left = (
-            int((1 - t) * TRIANGLE_A[0] + t * TRIANGLE_B[0]),
-            int((1 - t) * TRIANGLE_A[1] + t * TRIANGLE_B[1]),
-        )
-        right = (
-            int((1 - t) * TRIANGLE_A[0] + t * TRIANGLE_C[0]),
-            int((1 - t) * TRIANGLE_A[1] + t * TRIANGLE_C[1]),
-        )
-        draw.line((left, right), fill=(190, 207, 225), width=1)
-
-        bottom = (
-            int((1 - t) * TRIANGLE_B[0] + t * TRIANGLE_C[0]),
-            int((1 - t) * TRIANGLE_B[1] + t * TRIANGLE_C[1]),
-        )
-        left_side = (
-            int((1 - t) * TRIANGLE_A[0] + t * TRIANGLE_B[0]),
-            int((1 - t) * TRIANGLE_A[1] + t * TRIANGLE_B[1]),
-        )
-        right_side = (
-            int((1 - t) * TRIANGLE_A[0] + t * TRIANGLE_C[0]),
-            int((1 - t) * TRIANGLE_A[1] + t * TRIANGLE_C[1]),
-        )
-        draw.line((TRIANGLE_B, right_side), fill=(214, 224, 236), width=1)
-        draw.line((TRIANGLE_C, left_side), fill=(214, 224, 236), width=1)
-        draw.line((bottom, TRIANGLE_A), fill=(214, 224, 236), width=1)
-
-    labels = [
-        (TRIANGLE_A, "A", short_corner_label(prompt_a, "Prompt A"), (55, 94, 151)),
-        (TRIANGLE_B, "B", short_corner_label(prompt_b, "Prompt B"), (5, 122, 85)),
-        (TRIANGLE_C, "C", short_corner_label(prompt_c, "Prompt C"), (154, 72, 174)),
-    ]
-    for (x, y), letter, label, color in labels:
-        draw.ellipse((x - 13, y - 13, x + 13, y + 13), fill=color, outline=(255, 255, 255), width=3)
-        draw.text((x - 4, y - 7), letter, fill=(255, 255, 255))
-        label_x = max(8, min(TRIANGLE_SIZE - 150, x - 70))
-        label_y = y - 34 if y < TRIANGLE_SIZE / 2 else y + 18
-        draw.text((label_x, label_y), label, fill=(30, 41, 59))
-
-    x, y = weighted_triangle_point(weight_a, weight_b, weight_c)
-    draw.ellipse((x - 9, y - 9, x + 9, y + 9), fill=(239, 68, 68), outline=(15, 23, 42), width=2)
-    draw.text((12, 12), "Click inside the triangle to choose the embedding blend.", fill=(51, 65, 85))
-    return image
-
-
-def barycentric_triangle_weights(x, y):
-    ax, ay = TRIANGLE_A
-    bx, by = TRIANGLE_B
-    cx, cy = TRIANGLE_C
-    denominator = (by - cy) * (ax - cx) + (cx - bx) * (ay - cy)
-    if denominator == 0:
-        return 1.0, 0.0, 0.0
-
-    weight_a = ((by - cy) * (x - cx) + (cx - bx) * (y - cy)) / denominator
-    weight_b = ((cy - ay) * (x - cx) + (ax - cx) * (y - cy)) / denominator
-    weight_c = 1.0 - weight_a - weight_b
-
-    if min(weight_a, weight_b, weight_c) < 0:
-        weight_a, weight_b, weight_c = normalized_triangle_weights(weight_a, weight_b, weight_c)
-
-    return normalized_triangle_weights(weight_a, weight_b, weight_c)
-
+    text = text.replace("`", "'").replace('"', "'")
+    return text[:52] + ("..." if len(text) > 52 else "")
 
-def triangle_status(weight_a, weight_b, weight_c):
-    weight_a, weight_b, weight_c = normalized_triangle_weights(weight_a, weight_b, weight_c)
-    return f"A: {weight_a:.2f}   B: {weight_b:.2f}   C: {weight_c:.2f}"
 
-
-def update_triangle_from_weights(prompt_a, prompt_b, prompt_c, weight_a, weight_b, weight_c):
-    weight_a, weight_b, weight_c = normalized_triangle_weights(weight_a, weight_b, weight_c)
+def prompt_equation(prompt_a, prompt_b, prompt_c, weight_a, weight_b, weight_c):
+    weight_a, weight_b, weight_c = normalized_prompt_weights(weight_a, weight_b, weight_c)
     return (
-        make_triangle_picker(prompt_a, prompt_b, prompt_c, weight_a, weight_b, weight_c),
-        triangle_status(weight_a, weight_b, weight_c),
+        f"prompt_embedding = {weight_a:.2f} * A + {weight_b:.2f} * B + {weight_c:.2f} * C",
         weight_a,
         weight_b,
         weight_c,
     )
 
 
-def select_triangle_point(prompt_a, prompt_b, prompt_c, evt: gr.SelectData):
-    index = evt.index
-    if isinstance(index, dict):
-        x, y = index.get("x", TRIANGLE_A[0]), index.get("y", TRIANGLE_A[1])
-    else:
-        x, y = index[:2]
-    weight_a, weight_b, weight_c = barycentric_triangle_weights(float(x), float(y))
-    return update_triangle_from_weights(prompt_a, prompt_b, prompt_c, weight_a, weight_b, weight_c)
+def equation_markdown(prompt_a, prompt_b, prompt_c, weight_a, weight_b, weight_c):
+    equation, weight_a, weight_b, weight_c = prompt_equation(prompt_a, prompt_b, prompt_c, weight_a, weight_b, weight_c)
+    return (
+        "### Current Equation\n"
+        f"`{equation}`\n\n"
+        f"**A** = {compact_prompt(prompt_a, 'Prompt A')}  \n"
+        f"**B** = {compact_prompt(prompt_b, 'Prompt B')}  \n"
+        f"**C** = {compact_prompt(prompt_c, 'Prompt C')}"
+    )
 
 
 @lru_cache(maxsize=2)
-def load_pipe(model_id, scheduler_name, device_type):
+def load_pipe(model_id, device_type):
     device = torch.device(device_type)
     dtype = model_dtype(device)
     pipe = StableDiffusionPipeline.from_pretrained(
@@ -259,11 +168,7 @@ def load_pipe(model_id, scheduler_name, device_type):
         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.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
     pipe = pipe.to(device)
     pipe.set_progress_bar_config(disable=True)
     pipe.enable_vae_slicing()
@@ -312,38 +217,17 @@ def mix_prompt_embeddings(
     prompt_b,
     prompt_c,
     negative_prompt,
-    embedding_mode,
-    prompt_mix,
-    triangle_weight_a,
-    triangle_weight_b,
-    triangle_weight_c,
-    analogy_strength,
+    weight_a,
+    weight_b,
+    weight_c,
     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 == "Triangle blend: A/B/C":
-        triangle_weight_a, triangle_weight_b, triangle_weight_c = normalized_triangle_weights(
-            triangle_weight_a,
-            triangle_weight_b,
-            triangle_weight_c,
-        )
-        mixed = triangle_weight_a * emb_a + triangle_weight_b * emb_b + triangle_weight_c * emb_c
-        formula = (
-            f"prompt = {triangle_weight_a:.2f} * A + {triangle_weight_b:.2f} * B "
-            f"+ {triangle_weight_c:.2f} * C"
-        )
-    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"
+    formula, weight_a, weight_b, weight_c = prompt_equation(prompt_a, prompt_b, prompt_c, weight_a, weight_b, weight_c)
+    mixed = weight_a * emb_a + weight_b * emb_b + weight_c * emb_c
 
     original_norm = emb_a.detach().float().norm()
     mixed_norm = mixed.detach().float().norm()
@@ -389,37 +273,10 @@ def prepare_latents(pipe, device, height, width, seed_a, seed_b, noise_mix, reno
     return latents, formula, metrics
 
 
-def combine_noise_predictions(
-    noise_negative,
-    noise_prompt,
-    equation_mode,
-    guidance_scale,
-    prediction_mix,
-    negative_coeff,
-    prompt_coeff,
-    delta_coeff,
-):
+def apply_classifier_free_guidance(noise_negative, noise_prompt, guidance_scale):
     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)"
-        )
-
+    guided = noise_negative + guidance_scale * delta
+    formula = f"guided = negative + {guidance_scale:.2f} * (prompt - negative)"
     return guided, formula
 
 
@@ -452,29 +309,17 @@ def gpu_duration(*args):
 @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,
-    triangle_weight_a,
-    triangle_weight_b,
-    triangle_weight_c,
-    analogy_strength,
-    renormalize_prompt,
+    weight_a,
+    weight_b,
+    weight_c,
     seed_a,
     seed_b,
     noise_mix,
-    renormalize_noise,
-    equation_mode,
+    negative_prompt,
     guidance_scale,
-    prediction_mix,
-    negative_coeff,
-    prompt_coeff,
-    delta_coeff,
     num_steps,
     width,
     height,
@@ -486,13 +331,13 @@ def generate(
             [],
             "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)
+    scheduler_name = "DPM++ 2M"
+    pipe = load_pipe(DEFAULT_MODEL, device.type)
 
     prompt_embeds, negative_prompt_embeds, prompt_formula, prompt_metrics = mix_prompt_embeddings(
         pipe,
@@ -501,13 +346,10 @@ def generate(
         prompt_b or "",
         prompt_c or "",
         negative_prompt or "",
-        embedding_mode,
-        float(prompt_mix),
-        float(triangle_weight_a),
-        float(triangle_weight_b),
-        float(triangle_weight_c),
-        float(analogy_strength),
-        bool(renormalize_prompt),
+        float(weight_a),
+        float(weight_b),
+        float(weight_c),
+        True,
     )
 
     pipe.scheduler.set_timesteps(num_steps, device=device)
@@ -519,12 +361,11 @@ def generate(
         int(seed_a),
         int(seed_b),
         float(noise_mix),
-        bool(renormalize_noise),
+        True,
     )
 
     text_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])
     snapshots = []
-    trace_rows = []
     save_at = checkpoint_indices(num_steps)
     last_formula = ""
 
@@ -539,30 +380,14 @@ def generate(
             return_dict=False,
         )[0]
         noise_negative, noise_prompt = noise_pred.chunk(2)
-        guided, last_formula = combine_noise_predictions(
+        guided, last_formula = apply_classifier_free_guidance(
             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}"))
@@ -575,19 +400,18 @@ def generate(
         ["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."
+        f"Prompt blend: {prompt_formula}\n\n"
+        f"Starting noise: {latent_formula}\n\n"
+        f"Guidance: {last_formula}\n\n"
+        f"Steps: {num_steps}; size: {width}x{height}; scheduler: {scheduler_name}\n\n"
+        "The sliders blend text embeddings, not pixels. Stable Diffusion starts from noise and uses this blended prompt "
+        "to steer each denoising step."
     )
 
     if device.type == "cuda":
         torch.cuda.empty_cache()
     gc.collect()
-    return final_image, snapshots, summary, metrics, trace_rows
+    return final_image, snapshots, summary, metrics
 
 
 def randomize_seeds():
@@ -609,91 +433,46 @@ def build_app():
     """
 
     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."
+            "Blend three ideas, then watch Stable Diffusion turn noise into an image using that blended prompt embedding."
         )
+        equation_preview = gr.Markdown(
+            equation_markdown(DEFAULT_PROMPT_A, DEFAULT_PROMPT_B, DEFAULT_PROMPT_C, 1, 1, 1)
+        )
+        width = gr.State(512)
+        height = gr.State(512)
 
         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)
+                with gr.Group():
+                    prompt_a = gr.Textbox(value=DEFAULT_PROMPT_A, label="Prompt A", lines=2)
+                    strength_a = gr.Slider(0, 3, value=1, step=0.05, label="Strength A")
+                    prompt_b = gr.Textbox(value=DEFAULT_PROMPT_B, label="Prompt B", lines=2)
+                    strength_b = gr.Slider(0, 3, value=1, step=0.05, label="Strength B")
+                    prompt_c = gr.Textbox(value=DEFAULT_PROMPT_C, label="Prompt C", lines=2)
+                    strength_c = gr.Slider(0, 3, value=1, step=0.05, label="Strength C")
+
+                with gr.Accordion("A Few Diffusers Levers", open=True):
+                    guidance_scale = gr.Slider(1, 14, value=7.5, step=0.5, label="Prompt guidance")
+                    num_steps = gr.Slider(8, 35, value=20, step=1, label="Denoising steps")
+                    with gr.Row():
+                        seed_a = gr.Number(value=11, precision=0, label="Starting noise seed")
+                        random_seeds = gr.Button("Random seed")
                     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",
-                            "Triangle blend: A/B/C",
-                            "Vector arithmetic: A + s * (B - C)",
-                        ],
-                        value="Triangle blend: A/B/C",
-                        label="Embedding equation",
-                    )
-                    prompt_mix = gr.Slider(0, 1, value=0.5, step=0.05, label="Prompt B weight")
-                    triangle_picker = gr.Image(
-                        value=make_triangle_picker(DEFAULT_PROMPT_A, DEFAULT_PROMPT_B, DEFAULT_PROMPT_C),
-                        label="Triangle embedding mixer",
-                        type="pil",
-                        interactive=False,
-                    )
-                    triangle_status_box = gr.Textbox(
-                        value=triangle_status(1 / 3, 1 / 3, 1 / 3),
-                        label="Triangle weights",
-                        interactive=False,
+                        value=DEFAULT_NEGATIVE_PROMPT,
+                        label="Things to avoid",
+                        lines=1,
                     )
-                    with gr.Row():
-                        triangle_weight_a = gr.Slider(0, 1, value=1 / 3, step=0.01, label="A weight")
-                        triangle_weight_b = gr.Slider(0, 1, value=1 / 3, step=0.01, label="B weight")
-                        triangle_weight_c = gr.Slider(0, 1, value=1 / 3, step=0.01, label="C 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.Accordion("Extra Noise Mixer", open=False):
                     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")
+                        seed_b = gr.Number(value=2222, precision=0, label="Second noise seed")
+                        noise_mix = gr.Slider(0, 1, value=0.0, step=0.05, label="Second seed strength")
 
-                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")
+                generate_button = gr.Button("Generate", variant="primary")
 
             with gr.Column(scale=1, min_width=420):
                 output_image = gr.Image(
@@ -703,27 +482,23 @@ def build_app():
                     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.Accordion("Denoising Snapshots", open=False):
+                    snapshots = gr.Gallery(
+                        label="Decoded latent snapshots",
+                        columns=2,
+                        height=420,
+                        object_fit="contain",
+                        elem_classes=["snapshot-gallery"],
+                    )
+                with gr.Accordion("Embedding Measurements", open=False):
+                    metrics = gr.Dataframe(
+                        headers=metric_headers,
+                        datatype=["str", "str"],
+                        label="Embedding and latent measurements",
+                        interactive=False,
+                    )
 
-        with gr.Tab("Code cells"):
+        with gr.Accordion("Code Cells", open=False):
             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"])
@@ -735,50 +510,32 @@ def build_app():
             outputs=[seed_a, seed_b],
             show_progress="hidden",
         )
-        triangle_picker.select(
-            select_triangle_point,
-            inputs=[prompt_a, prompt_b, prompt_c],
-            outputs=[triangle_picker, triangle_status_box, triangle_weight_a, triangle_weight_b, triangle_weight_c],
-            show_progress="hidden",
-        )
-        for triangle_input in [prompt_a, prompt_b, prompt_c, triangle_weight_a, triangle_weight_b, triangle_weight_c]:
-            triangle_input.change(
-                update_triangle_from_weights,
-                inputs=[prompt_a, prompt_b, prompt_c, triangle_weight_a, triangle_weight_b, triangle_weight_c],
-                outputs=[triangle_picker, triangle_status_box, triangle_weight_a, triangle_weight_b, triangle_weight_c],
+        for equation_input in [prompt_a, prompt_b, prompt_c, strength_a, strength_b, strength_c]:
+            equation_input.change(
+                equation_markdown,
+                inputs=[prompt_a, prompt_b, prompt_c, strength_a, strength_b, strength_c],
+                outputs=[equation_preview],
                 show_progress="hidden",
             )
         generate_button.click(
             generate,
             inputs=[
-                model_id,
-                scheduler_name,
                 prompt_a,
                 prompt_b,
                 prompt_c,
-                negative_prompt,
-                embedding_mode,
-                prompt_mix,
-                triangle_weight_a,
-                triangle_weight_b,
-                triangle_weight_c,
-                analogy_strength,
-                renormalize_prompt,
+                strength_a,
+                strength_b,
+                strength_c,
                 seed_a,
                 seed_b,
                 noise_mix,
-                renormalize_noise,
-                equation_mode,
+                negative_prompt,
                 guidance_scale,
-                prediction_mix,
-                negative_coeff,
-                prompt_coeff,
-                delta_coeff,
                 num_steps,
                 width,
                 height,
             ],
-            outputs=[output_image, snapshots, summary, metrics, trace],
+            outputs=[output_image, snapshots, summary, metrics],
             show_progress="full",
         )