StudioAI — generate, refine, paint beyond the frame.

Understanding GenAI from the inside out.

Every tutorial shows a prompt going in and an image coming out. Nobody shows you what happens when you change guidance scale from 2 to 15 — or why 50 inference steps costs more than 5 but doesn't always look 10× better.

Two files, one responsibility each.

The Streamlit app separates generation logic from UI rendering. This wasn't over-engineering — it was the only way to keep the notebook-to-app translation manageable.

Model caching — why it matters.

SD v1.5 weighs 3.44 GB. Loading it takes 15–30 seconds on a T4 GPU. Without caching, every generation request reloads the full model from disk — making the app unusable. The solution: @st.cache_resource keyed by scheduler name. The model loads once per session. When the user switches from DPM++ to Euler A, only the sampler is swapped — U-Net weights stay in GPU memory.

# logic.py — cache model by scheduler to avoid full reload
@st.cache_resource
def load_pipeline(scheduler_name: str):
    pipe = StableDiffusionPipeline.from_pretrained(
        "runwayml/stable-diffusion-v1-5",
        torch_dtype=torch.float16,
        safety_checker=None
    ).to("cuda")

    schedulers = {
        "Euler A": EulerAncestralDiscreteScheduler,
        "DPM++":  DPMSolverMultistepScheduler,
        "DDIM":   DDIMScheduler,
    }
    pipe.scheduler = schedulers[scheduler_name].from_config(pipe.scheduler.config)
    return pipe

Three parameters, systematic comparison.

Before building anything interactive, I ran controlled experiments — one variable at a time, everything else fixed. The goal was to build a mental model of how each parameter shapes the output.

Guidance Scale — CFG 2.0 (loose) · 7.5 (optimal) · 15.0 (over-constrained)

Inference Steps — 5 (incoherent) · 15 · 30 (optimal) · 50 (diminishing returns)

Scheduler comparison — same prompt, same seed. Euler A (photorealistic) · DPM++ (flat illustration, chosen) · DDIM (balanced)

What building this actually taught me.

This was a class assignment I turned into a real engineering project. The key shifts in how I understand generative AI:

• The model stopped being a black box. Running experiments — not just reading docs — made Stable Diffusion legible. Once I understood that guidance scale adjusts the balance between text conditioning and image prior, and that inference steps are denoising iterations not quality multipliers, the model's behavior became predictable. I could look at a bad output and know exactly what dial to turn.
• Segmentation and generation are completely different problems. CLIPSeg produces soft probabilistic boundaries that require post-processing before they're usable for inpainting. The interface between two AI models requires explicit engineering decisions at every handoff — not just plumbing.
• Memory management is architecture, not polish. A notebook ignores GPU memory because each cell runs once. An interactive app runs arbitrary operation sequences and will crash without deliberate cleanup. The "Flush RAM" button wasn't a feature — it was infrastructure.
• The logic.py / app.py split paid off during debugging. When the outpainting chain produced wrong results, I could run the generation functions directly in a notebook — no Streamlit, no UI, no state. Separating logic from interface turned a 2-minute debugging loop into a 10-second one.

Single-pass (left) vs base+refiner (right) — edges and texture visibly sharper after refinement pass.

Inpainting result — broken satellite inserted into masked region using CLIPSeg auto-mask + new prompt.