Adv_app.py

import os
import random
import uuid

import gradio as gr
import numpy as np
from PIL import Image
import spaces
import torch
from diffusers import StableDiffusionPipeline, EulerAncestralDiscreteScheduler, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import load_dynamic_module

DESCRIPTION = """
# ImagesXL
"""

def save_image(img):
    unique_name = str(uuid.uuid4()) + ".png"
    img.save(unique_name)
    return unique_name

def randomize_seed_fn(seed: int, randomize_seed: bool) -> int:
    if randomize_seed:
        seed = random.randint(0, MAX_SEED)
    return seed

MAX_SEED = np.iinfo(np.int32).max

if not torch.cuda.is_available():
    DESCRIPTION += "\n<p>Running on CPU 🥶 This demo may work on CPU.</p>"

USE_TORCH_COMPILE = 0
ENABLE_CPU_OFFLOAD = 0

MODEL_CHOICES = {
    "Fluently-XL-v2": "fluently/Fluently-XL-v2",
    "Stable Diffusion v1-5": "runwayml/stable-diffusion-v1-5",
    "Stable Diffusion v2-1": "stabilityai/stable-diffusion-2-1",
}

SCHEDULER_CHOICES = {
    "Euler Ancestral Discrete": EulerAncestralDiscreteScheduler,
    "DDIM": DDIMScheduler,
    "LMS Discrete": LMSDiscreteScheduler,
    "PNDM": PNDMScheduler,
}

UPSCALER_CHOICES = {
    "None": None,
    "Real-ESRGAN": "stabilityai/real-esrgan",
    "Latent Diffusion": "stabilityai/latent-diffusion-upscaler",
}

def generate(
    prompt: str,
    negative_prompt: str = "",
    use_negative_prompt: bool = False,
    seed: int = 0,
    width: int = 512,
    height: int = 512,
    guidance_scale: float = 3,
    num_inference_steps: int = 25,
    scheduler: str = "Euler Ancestral Discrete",
    model_name: str = "Fluently-XL-v2",
    randomize_seed: bool = False,
    num_images_per_prompt: int = 1,
    use_lora: bool = False,
    lora_model_name: str = "",
    use_upscaler: bool = False,
    upscaler_model_name: str = "None",
    progress=gr.Progress(track_tqdm=True),
):
    seed = int(randomize_seed_fn(seed, randomize_seed))

    if not use_negative_prompt:
        negative_prompt = ""  # type: ignore

    if torch.cuda.is_available():
        pipe = StableDiffusionPipeline.from_pretrained(
            MODEL_CHOICES[model_name],
            torch_dtype=torch.float16,
            use_safetensors=True,
        )
    else:
        pipe = StableDiffusionPipeline.from_pretrained(
            MODEL_CHOICES[model_name],
            torch_dtype=torch.float32,
            use_safetensors=True,
        )

    pipe.scheduler = SCHEDULER_CHOICES[scheduler].from_config(pipe.scheduler.config)

    if use_lora and lora_model_name:
        pipe = load_dynamic_module("diffusers.loaders", "Lora", "lora")(pipe, lora_model_name, device_map="auto")

    images = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        width=width,
        height=height,
        guidance_scale=guidance_scale,
        num_inference_steps=num_inference_steps,
        num_images_per_prompt=num_images_per_prompt,
        output_type="pil",
    ).images

    if use_upscaler and upscaler_model_name:
        upscaler = StableDiffusionPipeline.from_pretrained(
            UPSCALER_CHOICES[upscaler_model_name],
            torch_dtype=torch.float16,
            use_safetensors=True,
        )
        images = [upscaler(image).images[0] for image in images]

    image_paths = [save_image(img) for img in images]
    print(image_paths)
    return image_paths, seed

examples = [
    "neon holography crystal cat",
    "a cat eating a piece of cheese",
    "an astronaut riding a horse in space",
    "a cartoon of a boy playing with a tiger",
    "a cute robot artist painting on an easel, concept art",
    "a close up of a woman wearing a transparent, prismatic, elaborate nemeses headdress, over the should pose, brown skin-tone"
]

css = '''
.gradio-container{max-width: 800px !important}
h1{text-align:center}
footer {
    visibility: hidden
}
'''
with gr.Blocks(css=css, theme="pseudolab/huggingface-korea-theme") as demo:
    gr.Markdown(DESCRIPTION)
    gr.DuplicateButton(
        value="Duplicate Space for private use",
        elem_id="duplicate-button",
        visible=False,
    )

    with gr.Group():
        with gr.Row():
            prompt = gr.Text(
                label="Prompt",
                show_label=False,
                max_lines=2,
                placeholder="Enter your prompt",
                container=False,
            )
            run_button = gr.Button("Run", scale=0)
        result = gr.Gallery(label="Result", columns=1, preview=True, show_label=False)
    with gr.Accordion("Advanced options", open=False):
        with gr.Row():
            use_negative_prompt = gr.Checkbox(label="Use negative prompt", value=True)
            negative_prompt = gr.Text(
                label="Negative prompt",
                lines=4,
                max_lines=6,
                value="""(deformed, distorted, disfigured:1.3), poorly drawn, bad anatomy, wrong anatomy, extra limb, missing limb, floating limbs, (mutated hands and fingers:1.4), disconnected limbs, mutation, mutated, ugly, disgusting, blurry, amputation, (NSFW:1.25)""",
                placeholder="Enter a negative prompt",
                visible=True,
            )
        with gr.Row():
            seed = gr.Slider(
                label="Seed",
                minimum=0,
                maximum=MAX_SEED,
                step=1,
                value=0,
                visible=True
            )
            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
        with gr.Row(visible=True):
            width = gr.Slider(
                label="Width",
                minimum=512,
                maximum=1024,
                step=8,
                value=512,
            )
            height = gr.Slider(
                label="Height",
                minimum=512,
                maximum=1024,
                step=8,
                value=512,
            )
        with gr.Row():
            guidance_scale = gr.Slider(
                label="Guidance Scale",
                minimum=0.1,
                maximum=20.0,
                step=0.1,
                value=6,
            )
            num_inference_steps = gr.Slider(
                label="Inference Steps",
                minimum=1,
                maximum=100,
                step=1,
                value=25,
            )
        with gr.Row():
            scheduler = gr.Dropdown(
                label="Scheduler",
                choices=list(SCHEDULER_CHOICES.keys()),
                value="Euler Ancestral Discrete",
            )
            model_name = gr.Dropdown(
                label="Model",
                choices=list(MODEL_CHOICES.keys()),
                value="Fluently-XL-v2",
            )
        with gr.Row():
            num_images_per_prompt = gr.Slider(
                label="Images per Prompt",
                minimum=1,
                maximum=8,
                step=1,
                value=1,
            )
        with gr.Row():
            use_lora = gr.Checkbox(label="Use LoRA Model", value=False)
            lora_model_name = gr.Text(
                label="LoRA Model Name",
                placeholder="Enter a LoRA model name (e.g., 'runwayml/stable-diffusion-v1-5-lora')",
                visible=False,
            )
        with gr.Row():
            use_upscaler = gr.Checkbox(label="Use Upscaler", value=False)
            upscaler_model_name = gr.Dropdown(
                label="Upscaler Model",
                choices=list(UPSCALER_CHOICES.keys()),
                value="None",
                visible=False,
            )

    gr.Examples(
        examples=examples,
        inputs=prompt,
        outputs=[result, seed],
        fn=generate,
        cache_examples=False,
    )

    use_negative_prompt.change(
        fn=lambda x: gr.update(visible=x),
        inputs=use_negative_prompt,
        outputs=negative_prompt,
        api_name=False,
    )

    use_lora.change(
        fn=lambda x: gr.update(visible=x),
        inputs=use_lora,
        outputs=lora_model_name,
        api_name=False,
    )

    use_upscaler.change(
        fn=lambda x: gr.update(visible=x),
        inputs=use_upscaler,
        outputs=upscaler_model_name,
        api_name=False,
    )

    gr.on(
        triggers=[
            prompt.submit,
            negative_prompt.submit,
            run_button.click,
        ],
        fn=generate,
        inputs=[
            prompt,
            negative_prompt,
            use_negative_prompt,
            seed,
            width,
            height,
            guidance_scale,
            num_inference_steps,
            scheduler,
            model_name,
            randomize_seed,
            num_images_per_prompt,
            use_lora,
            lora_model_name,
            use_upscaler,
            upscaler_model_name,
        ],
        outputs=[result, seed],
        api_name="run",
    )
    
if __name__ == "__main__":
    demo.queue(max_size=20).launch(show_api=False, debug=False)