Upload 3 files

README.md

@@ -1,14 +1,70 @@
 ---
-title: Logo Iteration
-emoji: 🔥
-colorFrom: purple
-colorTo: red
+title: Mass Iteration Studio
+emoji: 🌀
+colorFrom: indigo
+colorTo: pink
 sdk: gradio
-sdk_version: 6.22.0
-python_version: '3.12'
+sdk_version: 6.5.1
 app_file: app.py
 pinned: false
-short_description: 20 Logos iterations
+license: mit
+short_description: One image in, N PNG variants out
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Mass Iteration Studio
+
+Upload one image, get N variants back as PNG. Color, style and form are sampled
+per variant from editable prompt pools. Requires **ZeroGPU** hardware.
+
+> Set `sdk_version` above to the value Hugging Face wrote into the README it
+> generated for your Space.
+
+## Setup
+
+1. New Space → SDK **Gradio** → Settings → Hardware → **ZeroGPU**.
+2. Upload `app.py`, `requirements.txt`, `README.md`.
+3. First run downloads ~7 GB of weights and takes several minutes. Every run
+   after that starts instantly — the pipeline stays in memory.
+
+## How the run is structured
+
+A 20-image run is not one GPU call. Variants are grouped by denoising strength
+and rendered in batches, each batch its own `@spaces.GPU(duration=75)` call.
+That keeps every call well under the platform ceiling and lets results stream
+into the gallery as they finish, instead of appearing all at once at the end.
+
+## Models
+
+| Option | Time per image | 20 variants | License |
+|---|---|---|---|
+| SDXL-Lightning 4-step (default) | ~0.8 s | ~16 s | OpenRAIL++ base, Apache 2.0 LoRA |
+| SDXL-Turbo 2-step | ~0.45 s | ~9 s | non-commercial |
+| SD-Turbo 2-step | ~0.2 s | ~4 s | non-commercial |
+
+Pro quota is 1500 GPU-seconds per day, so the default model gives roughly 90
+runs of 20 variants before the window resets.
+
+## The reinvention slider
+
+One control decides everything about how far variants drift:
+
+- **0.2–0.35** — recolor and restyle, subject untouched
+- **0.4–0.55** — forms shift, proportions change, subject still recognizable
+- **0.65–0.85** — only the rough composition survives
+
+Each variant draws its own value between your minimum and maximum, snapped to
+six discrete levels so same-level variants can share a batched GPU call.
+
+## Prompt pools
+
+Three editable text boxes, one option per line. Sampling is either a random mix
+or a grid sweep that walks every combination in order — useful when you want
+systematic coverage rather than a lucky draw.
+
+Every run writes `manifest.csv` into the ZIP with the prompt, strength and seed
+behind each file. To rebuild a single variant exactly, set the base seed and
+turn off randomization.
+
+## Output
+
+PNG only. Individual downloads from the gallery, or the full run as a ZIP.

app.py

@@ -0,0 +1,367 @@
+"""
+Mass Iteration Studio — one image in, N variants out (PNG only).
+
+Built for ZeroGPU: work is split into short GPU calls so a 100+ image run
+never exceeds the per-call duration limit.
+"""
+
+import os
+import csv
+import math
+import random
+import tempfile
+import zipfile
+from datetime import datetime
+
+import gradio as gr
+import spaces
+import torch
+from PIL import Image
+from diffusers import AutoPipelineForImage2Image, EulerDiscreteScheduler
+from huggingface_hub import hf_hub_download
+
+# --------------------------------------------------------------------------
+# Models
+# --------------------------------------------------------------------------
+MODELS = {
+    "SDXL-Lightning · 4 steps · 1024px": {
+        "base": "stabilityai/stable-diffusion-xl-base-1.0",
+        "lora": ("ByteDance/SDXL-Lightning", "sdxl_lightning_4step_lora.safetensors"),
+        "steps": 4,
+        "guidance": 1.0,
+        "size": 1024,
+        "trailing": True,
+        "sec_per_image": 0.8,
+    },
+    "SDXL-Turbo · 2 steps · 768px": {
+        "base": "stabilityai/sdxl-turbo",
+        "lora": None,
+        "steps": 2,
+        "guidance": 0.0,
+        "size": 768,
+        "trailing": False,
+        "sec_per_image": 0.45,
+    },
+    "SD-Turbo · 2 steps · 512px": {
+        "base": "stabilityai/sd-turbo",
+        "lora": None,
+        "steps": 2,
+        "guidance": 0.0,
+        "size": 512,
+        "trailing": False,
+        "sec_per_image": 0.2,
+    },
+}
+DEFAULT_MODEL = "SDXL-Lightning · 4 steps · 1024px"
+
+DTYPE = torch.float16
+_pipes = {}
+
+
+def get_pipe(name: str):
+    """Load once, keep in memory. First call downloads several GB."""
+    if name in _pipes:
+        return _pipes[name]
+
+    cfg = MODELS[name]
+    pipe = AutoPipelineForImage2Image.from_pretrained(
+        cfg["base"], torch_dtype=DTYPE, variant="fp16", use_safetensors=True
+    )
+    if cfg["lora"]:
+        repo, ckpt = cfg["lora"]
+        pipe.load_lora_weights(hf_hub_download(repo, ckpt))
+        pipe.fuse_lora()
+    if cfg["trailing"]:
+        pipe.scheduler = EulerDiscreteScheduler.from_config(
+            pipe.scheduler.config, timestep_spacing="trailing"
+        )
+    pipe.set_progress_bar_config(disable=True)
+    pipe.to("cuda")
+    _pipes[name] = pipe
+    return pipe
+
+
+# --------------------------------------------------------------------------
+# Prompt pools — this is where the "mass" in mass iteration comes from
+# --------------------------------------------------------------------------
+POOL_COLOR = """warm terracotta and bone white
+cold teal and graphite
+monochrome charcoal on paper
+acid green on deep black
+dusty lilac and sand
+indigo with brass gold
+faded coral and sea foam
+oxblood red and cream
+electric cyan and magenta
+muted olive and clay"""
+
+POOL_STYLE = """flat vector illustration
+risograph print with grain
+thick ink outlines, cel shaded
+soft airbrush gradients
+woodcut engraving
+matte gouache painting
+chrome and glass render
+halftone comic print
+minimal bauhaus poster
+chalk on blackboard"""
+
+POOL_SHAPE = """rounded organic shapes
+sharp angular geometry
+elongated slender proportions
+chunky bold silhouettes
+fragmented and shattered forms
+symmetrical and centered
+loose hand drawn contours
+tightly packed dense composition"""
+
+NEGATIVE = "blurry, low quality, watermark, text artifacts, jpeg artifacts, deformed"
+
+
+def as_list(text: str):
+    return [line.strip() for line in text.splitlines() if line.strip()]
+
+
+def build_recipes(n, base_prompt, colors, styles, shapes, strat, seed,
+                  smin, smax):
+    """One recipe per variant: prompt, strength and seed."""
+    rng = random.Random(seed)
+    pools = [p for p in (colors, styles, shapes) if p]
+    combos = []
+
+    if strat.startswith("Grid") and pools:
+        # walk every combination in order, cycle if n exceeds the product
+        total = 1
+        for p in pools:
+            total *= len(p)
+        for i in range(n):
+            idx, parts = i % total, []
+            for p in reversed(pools):
+                parts.append(p[idx % len(p)])
+                idx //= len(p)
+            combos.append(list(reversed(parts)))
+    else:
+        for _ in range(n):
+            combos.append([rng.choice(p) for p in pools])
+
+    # snap strength onto a few discrete levels — variants that share a level
+    # can be denoised in one batched GPU call, which is most of the speed
+    levels, step = 6, 0.0
+    if smax > smin:
+        step = (smax - smin) / (levels - 1)
+
+    recipes = []
+    for i, parts in enumerate(combos):
+        bits = ([base_prompt.strip()] if base_prompt.strip() else []) + parts
+        if step:
+            strength = smin + round((rng.uniform(smin, smax) - smin) / step) * step
+        else:
+            strength = smin
+        recipes.append({
+            "index": i + 1,
+            "prompt": ", ".join(bits),
+            "strength": round(strength, 3),
+            "seed": seed + i,
+        })
+    return recipes
+
+
+def fit(img: Image.Image, target: int) -> Image.Image:
+    """Scale so the long edge hits the model's native size, snapped to /8."""
+    img = img.convert("RGB")
+    w, h = img.size
+    s = target / max(w, h)
+    return img.resize((max(64, int(w * s) // 8 * 8),
+                       max(64, int(h * s) // 8 * 8)), Image.LANCZOS)
+
+
+# --------------------------------------------------------------------------
+# GPU work — one short call per batch keeps us under the duration ceiling
+# --------------------------------------------------------------------------
+@spaces.GPU(duration=75)
+def render_batch(model_name, image, recipes, negative):
+    cfg = MODELS[model_name]
+    pipe = get_pipe(model_name)
+
+    prompts = [r["prompt"] for r in recipes]
+    strength = float(recipes[0]["strength"])
+    # few-step schedulers need steps*strength >= 1 to denoise at all
+    steps = min(14, max(cfg["steps"], math.ceil(cfg["steps"] / max(strength, 0.15))))
+    gens = [torch.Generator("cuda").manual_seed(r["seed"]) for r in recipes]
+
+    out = pipe(
+        prompt=prompts,
+        negative_prompt=[negative] * len(prompts) if cfg["guidance"] > 0 else None,
+        image=[image] * len(prompts),
+        strength=strength,
+        num_inference_steps=steps,
+        guidance_scale=cfg["guidance"],
+        generator=gens,
+    )
+    return out.images
+
+
+# --------------------------------------------------------------------------
+# Orchestration — runs on CPU, streams results as they land
+# --------------------------------------------------------------------------
+def generate(image, model_name, count, base_prompt, colors_raw, styles_raw,
+             shapes_raw, strat, smin, smax, seed, randomize, batch_size,
+             negative, progress=gr.Progress()):
+
+    if image is None:
+        raise gr.Error("Upload an image first.")
+    if smax < smin:
+        smin, smax = smax, smin
+
+    count = int(count)
+    if randomize:
+        seed = random.randint(0, 2**31 - 1)
+    seed = int(seed)
+
+    cfg = MODELS[model_name]
+    src = fit(image, cfg["size"])
+    recipes = build_recipes(
+        count, base_prompt, as_list(colors_raw), as_list(styles_raw),
+        as_list(shapes_raw), strat, seed, float(smin), float(smax),
+    )
+
+    # group by strength so every batch shares one denoising schedule
+    for r in recipes:
+        r["strength"] = round(r["strength"], 2)
+    recipes.sort(key=lambda r: r["strength"])
+
+    run_dir = os.path.join(tempfile.gettempdir(),
+                           f"run_{datetime.now():%H%M%S}_{seed}")
+    os.makedirs(run_dir, exist_ok=True)
+
+    gallery, done = [], 0
+    bs = int(batch_size)
+    batches = []
+    i = 0
+    while i < len(recipes):
+        chunk = [recipes[i]]
+        i += 1
+        while i < len(recipes) and len(chunk) < bs and \
+                recipes[i]["strength"] == chunk[0]["strength"]:
+            chunk.append(recipes[i])
+            i += 1
+        batches.append(chunk)
+
+    for chunk in batches:
+        images = render_batch(model_name, src, chunk, negative)
+        for r, img in zip(chunk, images):
+            path = os.path.join(run_dir, f"variant_{r['index']:03d}.png")
+            img.save(path, "PNG")
+            r["file"] = os.path.basename(path)
+            gallery.append((path, f"#{r['index']} · str {r['strength']} · {r['prompt'][:60]}"))
+        done += len(chunk)
+        progress(done / count, desc=f"{done} / {count} rendered")
+        yield gallery, None, f"Rendering… {done} / {count}"
+
+    manifest = os.path.join(run_dir, "manifest.csv")
+    with open(manifest, "w", newline="", encoding="utf-8") as f:
+        w = csv.DictWriter(f, fieldnames=["index", "file", "prompt", "strength", "seed"])
+        w.writeheader()
+        for r in sorted(recipes, key=lambda x: x["index"]):
+            w.writerow({k: r.get(k, "") for k in w.fieldnames})
+
+    bundle = os.path.join(run_dir, f"variants_{seed}.zip")
+    with zipfile.ZipFile(bundle, "w", zipfile.ZIP_DEFLATED) as z:
+        for r in recipes:
+            z.write(os.path.join(run_dir, r["file"]), r["file"])
+        z.write(manifest, "manifest.csv")
+
+    gpu_s = count * cfg["sec_per_image"]
+    yield (gallery, bundle,
+           f"**{count} variants** · base seed `{seed}` · "
+           f"~{gpu_s:.0f} s GPU used (~{1500 / max(gpu_s, 1):.0f} runs/day on Pro quota)")
+
+
+def estimate(model_name, count):
+    s = MODELS[model_name]["sec_per_image"] * int(count)
+    return (f"≈ {s:.0f} s GPU · {s / 1500 * 100:.0f} % of a Pro day "
+            f"· ≈ {1500 // max(s, 1):.0f} runs before the quota resets")
+
+
+# --------------------------------------------------------------------------
+# Interface
+# --------------------------------------------------------------------------
+CSS = """
+.mi-note { font-size: 0.86rem; opacity: 0.75; line-height: 1.5; }
+footer { display: none !important; }
+"""
+_MAJOR = int(gr.__version__.split(".")[0])
+_STYLE = {"theme": gr.themes.Soft(), "css": CSS}
+_BLOCKS_KW = {} if _MAJOR >= 6 else _STYLE
+_LAUNCH_KW = _STYLE if _MAJOR >= 6 else {}
+
+with gr.Blocks(title="Mass Iteration Studio", **_BLOCKS_KW) as demo:
+    gr.Markdown(
+        "## Mass Iteration Studio\n"
+        "One image in, as many PNG variants out as you ask for. "
+        "Colors, style and form are sampled per variant from editable pools."
+    )
+
+    with gr.Row():
+        with gr.Column(scale=4):
+            image = gr.Image(label="Source image", type="pil", height=260,
+                             sources=["upload", "clipboard"])
+            model_name = gr.Dropdown(list(MODELS), value=DEFAULT_MODEL, label="Model")
+            count = gr.Slider(4, 200, 20, step=2, label="Number of variants")
+            budget = gr.Markdown(estimate(DEFAULT_MODEL, 20), elem_classes="mi-note")
+            run = gr.Button("Generate variants", variant="primary")
+
+            with gr.Accordion("How far it may drift", open=True):
+                smin = gr.Slider(0.15, 0.95, 0.35, step=0.05,
+                                 label="Minimum reinvention")
+                smax = gr.Slider(0.15, 0.95, 0.70, step=0.05,
+                                 label="Maximum reinvention")
+                gr.Markdown(
+                    "0.2 recolors and restyles, 0.5 reshapes, 0.8 keeps only "
+                    "the composition. Each variant draws a value in between.",
+                    elem_classes="mi-note",
+                )
+
+            with gr.Accordion("Variation pools — one option per line", open=False):
+                base_prompt = gr.Textbox(
+                    label="Constant part of the prompt",
+                    placeholder="e.g. a stylized owl mascot, centered",
+                    lines=2,
+                )
+                colors_raw = gr.Textbox(POOL_COLOR, label="Color", lines=6)
+                styles_raw = gr.Textbox(POOL_STYLE, label="Style", lines=6)
+                shapes_raw = gr.Textbox(POOL_SHAPE, label="Form", lines=5)
+                strat = gr.Radio(
+                    ["Random mix", "Grid sweep (every combination in order)"],
+                    value="Random mix", label="Sampling",
+                )
+
+            with gr.Accordion("Advanced", open=False):
+                seed = gr.Number(1234, label="Base seed", precision=0)
+                randomize = gr.Checkbox(True, label="New random seed each run")
+                batch_size = gr.Slider(1, 8, 4, step=1, label="Batch size per GPU call")
+                negative = gr.Textbox(NEGATIVE, label="Negative prompt", lines=2)
+
+        with gr.Column(scale=6):
+            gallery = gr.Gallery(label="Variants", columns=4, height=620,
+                                 object_fit="contain", preview=True)
+            status = gr.Markdown("")
+            bundle = gr.File(label="Download all as ZIP (+ manifest.csv)", height=90)
+
+    for c in (model_name, count):
+        c.change(estimate, [model_name, count], budget)
+
+    run.click(
+        generate,
+        [image, model_name, count, base_prompt, colors_raw, styles_raw, shapes_raw,
+         strat, smin, smax, seed, randomize, batch_size, negative],
+        [gallery, bundle, status],
+    )
+
+if __name__ == "__main__":
+    demo.queue(max_size=12).launch(
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("PORT", 7860)),
+        ssr_mode=False,
+        **_LAUNCH_KW,
+    )

requirements.txt

@@ -0,0 +1,9 @@
+# gradio comes from the Space itself (sdk_version in README) - do not pin here
+spaces
+torch
+diffusers>=0.31.0
+transformers
+accelerate
+peft
+safetensors
+pillow