This PR upgrades the space (model & parameters) (#1)

- This PR upgrades the space (model & parameters) (dd2990fe38032ac0e4816d5dfd552756dc849ce4)


Co-authored-by: Fabrice TIERCELIN <[email protected]>

README.md

@@ -3,10 +3,21 @@ title: Inpaint
 emoji: 🦀
 colorFrom: purple
 colorTo: gray
+tags:
+- Image-to-Image
+- Image-2-Image
+- Img-to-Img
+- Img-2-Img
+- SDXL
+- Stable Diffusion
+- language models
+- LLMs
 sdk: gradio
 sdk_version: 4.41.0
 app_file: app.py
 pinned: false
+license: mit
+short_description: Modifies one detail of your image, at any resolution, freely
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,56 +1,307 @@
 import gradio as gr
-from PIL import Image
 import numpy as np
-from diffusers import StableDiffusionInpaintPipeline
+import time
+import math
+import random
 import torch
-from diffusers.utils import load_image
-from diffusers.pipelines.stable_diffusion import safety_checker
-# Bypass the safety checker
-def sc(self, clip_input, images):
-    return images, [False for _ in images]
-safety_checker.StableDiffusionSafetyChecker.forward = sc
-
-# Initialize the inpainting pipeline
-pipe = StableDiffusionInpaintPipeline.from_pretrained(
-        "stabilityai/stable-diffusion-2-inpainting",
-        torch_dtype=torch.float32,
-)
-pipe.to('cpu')
-
-# Inpainting function
-def inpaint_image(image, mask, prompt, negative_prompt):
-    n_image = pipe(prompt, image=image, mask_image=mask, guidance_scale=5,
-                   height=int(8*round(image.height/8)), width=int(8*round(image.width/8)),
-                   num_inference_steps=70, negative_prompt=negative_prompt).images[0]  
-    return n_image
-
-# Processing uploaded files
-def process_files(image_file, mask_file, prompt, negative_prompt):
-    image = Image.open(image_file)
-    mask = Image.open(mask_file)
-    return inpaint_image(image, mask, prompt, negative_prompt)
-
-# Gradio UI
-with gr.Blocks() as demo:
-    gr.Markdown("## Inpainting App")
-
-    with gr.Row():
-        with gr.Column():
-            image_input = gr.File(label="Input Image", type="filepath")
-            mask_input = gr.File(label="Mask Image", type="filepath")
-            prompt_input = gr.Textbox(label="Prompt", placeholder="Enter your prompt here...")
-            negative_prompt_input = gr.Textbox(label="Negative Prompt", placeholder="Enter your negative prompt here...")
-
-            submit_button = gr.Button("Inpaint")
-
-        with gr.Column():
-            output_image = gr.Image(type="pil", label="Inpainted Image")
-
-    submit_button.click(
-        fn=process_files,
-        inputs=[image_input, mask_input, prompt_input, negative_prompt_input],
-        outputs=output_image
+import spaces
+
+from diffusers import StableDiffusionXLInpaintPipeline
+from PIL import Image, ImageFilter, ImageEnhance
+import PIL.ImageOps
+
+max_64_bit_int = 2**63 - 1
+
+if torch.cuda.is_available():
+    device = "cuda"
+    floatType = torch.float16
+    variant = "fp16"
+else:
+    device = "cpu"
+    floatType = torch.float32
+    variant = None
+
+pipe = StableDiffusionXLInpaintPipeline.from_pretrained("diffusers/stable-diffusion-xl-1.0-inpainting-0.1", torch_dtype = floatType, variant = variant)
+pipe = pipe.to(device)
+
+def update_seed(is_randomize_seed, seed):
+    if is_randomize_seed:
+        return random.randint(0, max_64_bit_int)
+    return seed
+
+def toggle_debug(is_debug_mode):
+    return [gr.update(visible = is_debug_mode)] * 2
+
+def check(
+    source_img,
+    prompt,
+    uploaded_mask,
+    negative_prompt,
+    num_inference_steps,
+    guidance_scale,
+    image_guidance_scale,
+    strength,
+    denoising_steps,
+    is_randomize_seed,
+    seed,
+    debug_mode,
+    progress = gr.Progress()
+):
+    if source_img is None:
+        raise gr.Error("Please provide an image.")
+
+    if prompt is None or prompt == "":
+        raise gr.Error("Please provide a prompt input.")
+
+def inpaint(
+    source_img,
+    prompt,
+    uploaded_mask,
+    negative_prompt,
+    num_inference_steps,
+    guidance_scale,
+    image_guidance_scale,
+    strength,
+    denoising_steps,
+    is_randomize_seed,
+    seed,
+    debug_mode,
+    progress = gr.Progress()
+):
+    check(
+        source_img,
+        prompt,
+        uploaded_mask,
+        negative_prompt,
+        num_inference_steps,
+        guidance_scale,
+        image_guidance_scale,
+        strength,
+        denoising_steps,
+        is_randomize_seed,
+        seed,
+        debug_mode
     )
+    start = time.time()
+    progress(0, desc = "Preparing data...")
+
+    if negative_prompt is None:
+        negative_prompt = ""
+
+    if num_inference_steps is None:
+        num_inference_steps = 25
+
+    if guidance_scale is None:
+        guidance_scale = 7
+
+    if image_guidance_scale is None:
+        image_guidance_scale = 1.1
+
+    if strength is None:
+        strength = 0.99
+
+    if denoising_steps is None:
+        denoising_steps = 1000
+
+    if seed is None:
+        seed = random.randint(0, max_64_bit_int)
+
+    random.seed(seed)
+    #pipe = pipe.manual_seed(seed)
+
+    input_image = source_img["background"].convert("RGB")
+
+    original_height, original_width, original_channel = np.array(input_image).shape
+    output_width = original_width
+    output_height = original_height
+
+    if uploaded_mask is None:
+        mask_image = source_img["layers"][0].convert("RGB")
+    else:
+        mask_image = uploaded_mask.convert("RGB")
+        mask_image = mask_image.resize((original_width, original_height))
+
+    # Limited to 1 million pixels
+    if 1024 * 1024 < output_width * output_height:
+        factor = ((1024 * 1024) / (output_width * output_height))**0.5
+        process_width = math.floor(output_width * factor)
+        process_height = math.floor(output_height * factor)
+
+        limitation = " Due to technical limitation, the image have been downscaled and then upscaled.";
+    else:
+        process_width = output_width
+        process_height = output_height
+
+        limitation = "";
+
+    # Width and height must be multiple of 8
+    if (process_width % 8) != 0 or (process_height % 8) != 0:
+        if ((process_width - (process_width % 8) + 8) * (process_height - (process_height % 8) + 8)) <= (1024 * 1024):
+            process_width = process_width - (process_width % 8) + 8
+            process_height = process_height - (process_height % 8) + 8
+        elif (process_height % 8) <= (process_width % 8) and ((process_width - (process_width % 8) + 8) * process_height) <= (1024 * 1024):
+            process_width = process_width - (process_width % 8) + 8
+            process_height = process_height - (process_height % 8)
+        elif (process_width % 8) <= (process_height % 8) and (process_width * (process_height - (process_height % 8) + 8)) <= (1024 * 1024):
+            process_width = process_width - (process_width % 8)
+            process_height = process_height - (process_height % 8) + 8
+        else:
+            process_width = process_width - (process_width % 8)
+            process_height = process_height - (process_height % 8)
+
+    progress(None, desc = "Processing...")
+    output_image = inpaint_on_gpu(
+        seed,
+        process_width,
+        process_height,
+        prompt,
+        negative_prompt,
+        input_image,
+        mask_image,
+        num_inference_steps,
+        guidance_scale,
+        image_guidance_scale,
+        strength,
+        denoising_steps
+    )
+
+    if limitation != "":
+        output_image = output_image.resize((output_width, output_height))
+
+    if debug_mode == False:
+        input_image = None
+        mask_image = None
+
+    end = time.time()
+    secondes = int(end - start)
+    minutes = math.floor(secondes / 60)
+    secondes = secondes - (minutes * 60)
+    hours = math.floor(minutes / 60)
+    minutes = minutes - (hours * 60)
+    return [
+        output_image,
+        ("Start again to get a different result. " if is_randomize_seed else "") + "The image has been generated in " + ((str(hours) + " h, ") if hours != 0 else "") + ((str(minutes) + " min, ") if hours != 0 or minutes != 0 else "") + str(secondes) + " sec." + limitation,
+        input_image,
+        mask_image
+    ]
+
+def inpaint_on_gpu2(
+        seed,
+        process_width,
+        process_height,
+        prompt,
+        negative_prompt,
+        input_image,
+        mask_image,
+        num_inference_steps,
+        guidance_scale,
+        image_guidance_scale,
+        strength,
+        denoising_steps
+):
+    return input_image
+
+@spaces.GPU(duration=420)
+def inpaint_on_gpu(
+        seed,
+        process_width,
+        process_height,
+        prompt,
+        negative_prompt,
+        input_image,
+        mask_image,
+        num_inference_steps,
+        guidance_scale,
+        image_guidance_scale,
+        strength,
+        denoising_steps
+):
+    return pipe(
+        seeds = [seed],
+        width = process_width,
+        height = process_height,
+        prompt = prompt,
+        negative_prompt = negative_prompt,
+        image = input_image,
+        mask_image = mask_image,
+        num_inference_steps = num_inference_steps,
+        guidance_scale = guidance_scale,
+        image_guidance_scale = image_guidance_scale,
+        strength = strength,
+        denoising_steps = denoising_steps,
+        show_progress_bar = True
+    ).images[0]
+
+with gr.Blocks() as interface:
+    gr.HTML(
+        """
+        <h1 style="text-align: center;">Inpaint</h1>
+        <p style="text-align: center;">Modifies one detail of your image, at any resolution, freely, without account, without watermark, without installation, which can be downloaded</p>
+        <br/>
+
+        """
+    )
+    with gr.Column():
+        source_img = gr.ImageMask(label = "Your image (click on the landscape 🌄 to upload your image; click on the pen 🖌️ to draw the mask)", type = "pil", brush=gr.Brush(colors=["white"], color_mode="fixed"))
+        prompt = gr.Textbox(label = "Prompt", info = "Describe the subject, the background and the style of image; 77 token limit", placeholder = "Describe what you want to see in the entire image", lines = 2)
+        with gr.Accordion("Upload a mask", open = False):
+             uploaded_mask = gr.Image(label = "Already made mask (black pixels will be preserved, white pixels will be redrawn)", sources = ["upload"], type = "pil")
+        with gr.Accordion("Advanced options", open = False):
+             negative_prompt = gr.Textbox(label = "Negative prompt", placeholder = "Describe what you do NOT want to see in the entire image", value = "Ugly, malformed, noise, blur, watermark")
+             num_inference_steps = gr.Slider(minimum = 10, maximum = 100, value = 25, step = 1, label = "Number of inference steps", info = "lower=faster, higher=image quality")
+             guidance_scale = gr.Slider(minimum = 1, maximum = 13, value = 7, step = 0.1, label = "Classifier-Free Guidance Scale", info = "lower=image quality, higher=follow the prompt")
+             image_guidance_scale = gr.Slider(minimum = 1, value = 1.1, step = 0.1, label = "Image Guidance Scale", info = "lower=image quality, higher=follow the image")
+             strength = gr.Slider(value = 0.99, minimum = 0.01, maximum = 1.0, step = 0.01, label = "Strength", info = "lower=follow the original area, higher=redraw from scratch")
+             denoising_steps = gr.Number(minimum = 0, value = 1000, step = 1, label = "Denoising", info = "lower=irrelevant result, higher=relevant result")
+             randomize_seed = gr.Checkbox(label = "\U0001F3B2 Randomize seed", value = True, info = "If checked, result is always different")
+             seed = gr.Slider(minimum = 0, maximum = max_64_bit_int, step = 1, randomize = True, label = "Seed")
+             debug_mode = gr.Checkbox(label = "Debug mode", value = False, info = "Show intermediate results")
+
+        submit = gr.Button("🚀 Inpaint", variant = "primary")
+
+        inpainted_image = gr.Image(label = "Inpainted image")
+        information = gr.HTML()
+        original_image = gr.Image(label = "Original image", visible = False)
+        mask_image = gr.Image(label = "Mask image", visible = False)
+
+    submit.click(update_seed, inputs = [
+        randomize_seed, seed
+    ], outputs = [
+        seed
+    ], queue = False, show_progress = False).then(toggle_debug, debug_mode, [
+        original_image,
+        mask_image
+    ], queue = False, show_progress = False).then(check, inputs = [
+        source_img,
+        prompt,
+        uploaded_mask,
+        negative_prompt,
+        num_inference_steps,
+        guidance_scale,
+        image_guidance_scale,
+        strength,
+        denoising_steps,
+        randomize_seed,
+        seed,
+        debug_mode
+    ], outputs = [], queue = False, show_progress = False).success(inpaint, inputs = [
+        source_img,
+        prompt,
+        uploaded_mask,
+        negative_prompt,
+        num_inference_steps,
+        guidance_scale,
+        image_guidance_scale,
+        strength,
+        denoising_steps,
+        randomize_seed,
+        seed,
+        debug_mode
+    ], outputs = [
+        inpainted_image,
+        information,
+        original_image,
+        mask_image
+    ], scroll_to_output = True)
 
-# Launch the interface
-demo.launch(show_error=True)
+    interface.queue().launch()

requirements.txt

@@ -1,7 +1,3 @@
-diffusers
 torch
-torchvision
-pillow
-numpy
 transformers
-accelerate
+diffusers