Deploy Gradio app with multiple files

app.py

@@ -0,0 +1,166 @@
+import gradio as gr
+
+from config import (
+    APP_DESCRIPTION,
+    APP_TITLE,
+    DEFAULT_GUIDANCE,
+    DEFAULT_HEIGHT,
+    DEFAULT_NEGATIVE_PROMPT,
+    DEFAULT_NUM_IMAGES,
+    DEFAULT_NUM_STEPS,
+    DEFAULT_PROMPT,
+    DEFAULT_SEED,
+    DEFAULT_WIDTH,
+    EXAMPLE_PROMPTS,
+    MAX_GUIDANCE,
+    MAX_HEIGHT,
+    MAX_NUM_IMAGES,
+    MAX_NUM_STEPS,
+    MAX_WIDTH,
+    MIN_GUIDANCE,
+    MIN_NUM_STEPS,
+)
+from models import run_generation
+from utils import prepare_generator, sanitize_dimensions
+
+
+def generate_images(
+    prompt: str,
+    negative_prompt: str,
+    guidance_scale: float,
+    num_inference_steps: int,
+    width: int,
+    height: int,
+    num_images: int,
+    seed: int,
+):
+    if not prompt.strip():
+        raise gr.Error("Please provide a prompt to describe your image.")
+    width, height = sanitize_dimensions(width, height, MAX_WIDTH, MAX_HEIGHT)
+    generator, final_seed = prepare_generator(seed)
+    images = run_generation(
+        prompt=prompt.strip(),
+        negative_prompt=negative_prompt.strip() if negative_prompt else None,
+        guidance_scale=guidance_scale,
+        num_inference_steps=num_inference_steps,
+        width=width,
+        height=height,
+        num_images=num_images,
+        generator=generator,
+    )
+    return images, final_seed
+
+
+with gr.Blocks(fill_width=True) as demo:
+    gr.Markdown(
+        f"""
+# {APP_TITLE}
+
+{APP_DESCRIPTION}
+
+[Built with anycoder](https://huggingface.co/spaces/akhaliq/anycoder)
+"""
+    )
+
+    with gr.Row():
+        prompt_input = gr.Textbox(
+            label="Prompt",
+            value=DEFAULT_PROMPT,
+            placeholder="Describe what you want to see...",
+            lines=3,
+        )
+        negative_input = gr.Textbox(
+            label="Negative Prompt",
+            value=DEFAULT_NEGATIVE_PROMPT,
+            placeholder="Specify what to avoid (optional)",
+            lines=3,
+        )
+
+    with gr.Accordion("Generation Settings", open=False):
+        with gr.Row():
+            guidance_slider = gr.Slider(
+                minimum=MIN_GUIDANCE,
+                maximum=MAX_GUIDANCE,
+                step=0.1,
+                value=DEFAULT_GUIDANCE,
+                label="Guidance Scale",
+            )
+            steps_slider = gr.Slider(
+                minimum=MIN_NUM_STEPS,
+                maximum=MAX_NUM_STEPS,
+                step=1,
+                value=DEFAULT_NUM_STEPS,
+                label="Inference Steps",
+            )
+        with gr.Row():
+            width_slider = gr.Slider(
+                minimum=256,
+                maximum=MAX_WIDTH,
+                step=8,
+                value=DEFAULT_WIDTH,
+                label="Width (px)",
+            )
+            height_slider = gr.Slider(
+                minimum=256,
+                maximum=MAX_HEIGHT,
+                step=8,
+                value=DEFAULT_HEIGHT,
+                label="Height (px)",
+            )
+        with gr.Row():
+            num_images_slider = gr.Slider(
+                minimum=1,
+                maximum=MAX_NUM_IMAGES,
+                step=1,
+                value=DEFAULT_NUM_IMAGES,
+                label="Images per prompt",
+            )
+            seed_number = gr.Number(
+                value=DEFAULT_SEED,
+                label="Seed (-1 for random)",
+                precision=0,
+            )
+
+    generate_button = gr.Button("Generate", variant="primary")
+    gallery = gr.Gallery(
+        label="Generated Images",
+        columns=2,
+        height="auto",
+        object_fit="contain",
+        show_share_button=True,
+    )
+    seed_display = gr.Number(
+        label="Used Seed",
+        value=DEFAULT_SEED,
+        interactive=False,
+        precision=0,
+    )
+
+    generate_button.click(
+        fn=generate_images,
+        inputs=[
+            prompt_input,
+            negative_input,
+            guidance_slider,
+            steps_slider,
+            width_slider,
+            height_slider,
+            num_images_slider,
+            seed_number,
+        ],
+        outputs=[gallery, seed_display],
+        api_name="generate",
+    )
+
+    gr.Examples(
+        examples=[[example] for example in EXAMPLE_PROMPTS],
+        inputs=[prompt_input],
+        label="Prompt Ideas",
+    )
+
+    gr.ClearButton(
+        components=[prompt_input, negative_input, gallery],
+        value="Reset",
+    )
+
+demo.queue(max_size=40).launch()

config.py

@@ -0,0 +1,30 @@
+APP_TITLE = "Stable Diffusion 2.1 Turbocharged"
+APP_DESCRIPTION = (
+    "Generate stunning visuals using the `Comfy-Org/stable_diffusion_2.1_repackaged` weights with ZeroGPU AoT acceleration."
+)
+
+MODEL_ID = "Comfy-Org/stable_diffusion_2.1_repackaged"
+
+DEFAULT_PROMPT = "A futuristic city skyline at sunset, ultra detailed, cinematic lighting"
+DEFAULT_NEGATIVE_PROMPT = "blurry, low quality, distorted, watermark"
+DEFAULT_GUIDANCE = 7.5
+DEFAULT_NUM_STEPS = 30
+DEFAULT_WIDTH = 768
+DEFAULT_HEIGHT = 512
+DEFAULT_NUM_IMAGES = 2
+DEFAULT_SEED = -1
+
+MIN_GUIDANCE = 1.0
+MAX_GUIDANCE = 15.0
+MIN_NUM_STEPS = 10
+MAX_NUM_STEPS = 50
+MAX_WIDTH = 1024
+MAX_HEIGHT = 1024
+MAX_NUM_IMAGES = 4
+
+EXAMPLE_PROMPTS = [
+    "A watercolor painting of a cozy reading nook with plants",
+    "An astronaut riding a horse on Mars in vibrant comic style",
+    "Dark fantasy castle on a cliff, volumetric fog, dramatic lighting",
+    "Macro photograph of a dew-covered flower, ultra sharp",
+]

models.py

@@ -0,0 +1,68 @@
+import spaces
+import torch
+from diffusers import DPMSolverMultistepScheduler, StableDiffusionPipeline
+
+from config import MODEL_ID, DEFAULT_GUIDANCE, DEFAULT_HEIGHT, DEFAULT_PROMPT, DEFAULT_WIDTH
+
+
+def _load_pipeline() -> StableDiffusionPipeline:
+    dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+    pipe = StableDiffusionPipeline.from_pretrained(
+        MODEL_ID,
+        torch_dtype=dtype,
+        safety_checker=None,
+        requires_safety_checker=False,
+    )
+    pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
+    if torch.cuda.is_available():
+        pipe = pipe.to("cuda")
+    pipe.set_progress_bar_config(disable=True)
+    pipe.enable_xformers_memory_efficient_attention()
+    return pipe
+
+
+pipe = _load_pipeline()
+
+
+@spaces.GPU(duration=1500)
+def compile_unet():
+    with spaces.aoti_capture(pipe.unet) as call:
+        pipe(
+            prompt=DEFAULT_PROMPT,
+            negative_prompt=None,
+            guidance_scale=DEFAULT_GUIDANCE,
+            num_inference_steps=5,
+            width=DEFAULT_WIDTH,
+            height=DEFAULT_HEIGHT,
+            num_images_per_prompt=1,
+        )
+    exported = torch.export.export(pipe.unet, args=call.args, kwargs=call.kwargs)
+    return spaces.aoti_compile(exported)
+
+
+compiled_unet = compile_unet()
+spaces.aoti_apply(compiled_unet, pipe.unet)
+
+
+@spaces.GPU(duration=90)
+def run_generation(
+    prompt: str,
+    negative_prompt: str | None,
+    guidance_scale: float,
+    num_inference_steps: int,
+    width: int,
+    height: int,
+    num_images: int,
+    generator: torch.Generator,
+):
+    result = pipe(
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        guidance_scale=guidance_scale,
+        num_inference_steps=num_inference_steps,
+        width=width,
+        height=height,
+        num_images_per_prompt=num_images,
+        generator=generator,
+    )
+    return result.images

requirements.txt

@@ -0,0 +1,9 @@
+gradio
+torch
+git+https://github.com/huggingface/diffusers
+transformers
+accelerate
+safetensors
+numpy
+spaces
+Pillow

utils.py

@@ -0,0 +1,18 @@
+import random
+from typing import Tuple
+
+import torch
+
+
+def prepare_generator(seed: int) -> Tuple[torch.Generator, int]:
+    final_seed = seed
+    if final_seed is None or final_seed < 0:
+        final_seed = random.randint(0, 2**31 - 1)
+    generator = torch.Generator(device="cuda" if torch.cuda.is_available() else "cpu").manual_seed(final_seed)
+    return generator, final_seed
+
+
+def sanitize_dimensions(width: int, height: int, max_width: int, max_height: int) -> Tuple[int, int]:
+    width = max(256, min(max_width, int(width // 8 * 8)))
+    height = max(256, min(max_height, int(height // 8 * 8)))
+    return width, height