src/app.py

from pathlib import Path

import gradio as gr
import pi_heif
import spaces
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from refiners.foundationals.latent_diffusion import Solver, solvers

from enhancer import ESRGANUpscaler, ESRGANUpscalerCheckpoints

pi_heif.register_heif_opener()


TITLE = """ """

CHECKPOINTS = ESRGANUpscalerCheckpoints(
    unet=Path(
        hf_hub_download(
            repo_id="refiners/juggernaut.reborn.sd1_5.unet",
            filename="model.safetensors",
            revision="347d14c3c782c4959cc4d1bb1e336d19f7dda4d2",
        )
    ),
    clip_text_encoder=Path(
        hf_hub_download(
            repo_id="refiners/juggernaut.reborn.sd1_5.text_encoder",
            filename="model.safetensors",
            revision="744ad6a5c0437ec02ad826df9f6ede102bb27481",
        )
    ),
    lda=Path(
        hf_hub_download(
            repo_id="refiners/juggernaut.reborn.sd1_5.autoencoder",
            filename="model.safetensors",
            revision="3c1aae3fc3e03e4a2b7e0fa42b62ebb64f1a4c19",
        )
    ),
    controlnet_tile=Path(
        hf_hub_download(
            repo_id="refiners/controlnet.sd1_5.tile",
            filename="model.safetensors",
            revision="48ced6ff8bfa873a8976fa467c3629a240643387",
        )
    ),
    esrgan=Path(
        hf_hub_download(
            repo_id="philz1337x/upscaler",
            filename="4x-UltraSharp.pth",
            revision="011deacac8270114eb7d2eeff4fe6fa9a837be70",
        )
    ),
    negative_embedding=Path(
        hf_hub_download(
            repo_id="philz1337x/embeddings",
            filename="JuggernautNegative-neg.pt",
            revision="203caa7e9cc2bc225031a4021f6ab1ded283454a",
        )
    ),
    negative_embedding_key="string_to_param.*",
    loras={
        "more_details": Path(
            hf_hub_download(
                repo_id="philz1337x/loras",
                filename="more_details.safetensors",
                revision="a3802c0280c0d00c2ab18d37454a8744c44e474e",
            )
        ),
        "sdxl_render": Path(
            hf_hub_download(
                repo_id="philz1337x/loras",
                filename="SDXLrender_v2.0.safetensors",
                revision="a3802c0280c0d00c2ab18d37454a8744c44e474e",
            )
        ),
    },
)

# initialize the enhancer, on the cpu
DEVICE_CPU = torch.device("cpu")
DTYPE = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float32
enhancer = ESRGANUpscaler(checkpoints=CHECKPOINTS, device=DEVICE_CPU, dtype=DTYPE)

# "move" the enhancer to the gpu, this is handled by Zero GPU
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
enhancer.to(device=DEVICE, dtype=DTYPE)


@spaces.GPU
def process(
    input_image: Image.Image,
    seed: int = 1000,
    upscale_factor: int = 4,
    controlnet_scale: float = 0.8,
    controlnet_decay: float = 1.0,
    condition_scale: int = 2,
    tile_width: int = 128,
    tile_height: int = 128,
    denoise_strength: float = 0.3,
    num_inference_steps: int = 15,
    solver: str = "DDIM",
) -> tuple[Image.Image, Image.Image]:
    solver_type: type[Solver] = getattr(solvers, solver)

    generator = torch.Generator(device=DEVICE)
    generator.manual_seed(seed)

    # Resize to avoid using too much VRAM.
    # If you have a bug GPU you can go higher.
    side_size = min(input_image.size)
    if side_size > 768:
        scale = 768 / side_size
        new_size = (int(input_image.width * scale), int(input_image.height * scale))
        resized_image = input_image.resize(new_size, resample=Image.Resampling.LANCZOS)
    else:
        resized_image = input_image

    output_image = enhancer.upscale(
        image=resized_image,
        upscale_factor=upscale_factor,
        controlnet_scale=controlnet_scale,
        controlnet_scale_decay=controlnet_decay,
        condition_scale=condition_scale,
        tile_size=(tile_height, tile_width),
        denoise_strength=denoise_strength,
        num_inference_steps=num_inference_steps,
        loras_scale={"more_details": 0.5, "sdxl_render": 1.0},
        solver_type=solver_type,
        generator=generator,
    )

    return (input_image, output_image)


with gr.Blocks() as demo:
    gr.HTML(TITLE)

    with gr.Row():
        with gr.Column():
            input_image = gr.Image(type="pil", label=" ")
            run_button = gr.ClearButton(components=None, value="Enhance")
        with gr.Column():
            output_slider = gr.ImageSlider(label=" ", show_fullscreen_button=True, show_download_button=True)
            run_button.add(output_slider)

    with gr.Accordion("Advanced Options", open=True):
        seed = gr.Slider(
            minimum=0,
            maximum=10_000,
            value=1000,
            step=1000,
            label="Seed",
        )
        upscale_factor = gr.Slider(
            minimum=1,
            maximum=4,
            value=4,
            step=1,
            label="Upscale",
        )
        controlnet_scale = gr.Slider(
            minimum=0,
            maximum=1.5,
            value=0.8,
            step=0.1,
            label="ControlNet Scale",
        )
        controlnet_decay = gr.Slider(
            minimum=0.5,
            maximum=1.0,
            value=1.0,
            step=0.1,
            label="ControlNet Scale Decay",
        )
        condition_scale = gr.Slider(
            minimum=1,
            maximum=20,
            value=2,
            step=1,
            label="Condition Scale",
        )
        tile_width = gr.Slider(
            minimum=0,
            maximum=512,
            value=128,
            step=64,
            label="Tile Width",
        )
        tile_height = gr.Slider(
            minimum=0,
            maximum=512,
            value=128,
            step=64,
            label="Tile Height",
        )
        denoise_strength = gr.Slider(
            minimum=0,
            maximum=1.0,
            value=0.3,
            step=0.1,
            label="Denoise Strength",
        )
        num_inference_steps = gr.Slider(
            minimum=1,
            maximum=30,
            value=15,
            step=1,
            label="Number of Inference Steps",
        )
        solver = gr.Radio(
            choices=["DDIM", "DPMSolver"],
            value="DDIM",
            label="Solver",
        )

    run_button.click(
        fn=process,
        inputs=[
            input_image,
            seed,
            upscale_factor,
            controlnet_scale,
            controlnet_decay,
            condition_scale,
            tile_width,
            tile_height,
            denoise_strength,
            num_inference_steps,
            solver,
        ],
        outputs=output_slider,
    )

    demo.launch(share=False, ssr_mode=False)