Upload 4 files

.gitignore

@@ -0,0 +1,7 @@
+__pycache__
+deprecated
+model
+output
+venv
+v1-*inference.yaml
+convert*

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,12 +1,105 @@
----
-title: Ljnhsdf
-emoji: 🔥
-colorFrom: yellow
-colorTo: blue
-sdk: gradio
-sdk_version: 3.35.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Stable Diffusion ONNX UI
+
+* [First installation](#first-installation)
+* [How to add models](#how-to-add-models)
+* [Run](#run)
+* [Updating](#updating)
+
+Dead simple gui with support for latest [Diffusers (v0.12.0)](https://github.com/huggingface/diffusers/) on Windows with AMD graphic cards (or CPU, thanks to ONNX and DirectML) with [Stable Diffusion 2.1](https://huggingface.co/stabilityai/stable-diffusion-2-1) or any other model, even inpainting finetuned ones.
+
+Supported schedulers: DDIM, LMS, PNDM, Euler.
+
+Built with Gradio.
+
+![image](./screenshots/app.png)
+
+![image](./screenshots/inpainting.png)
+
+## First installation
+
+Prerequisites
+
+* [Python 3.10](https://www.python.org/downloads/)
+* [Git for windows](https://git-scm.com/download/win)
+* An [huggingface.co](https://huggingface.co) account
+* For a better experience, the [latest version of Powershell](https://github.com/PowerShell/PowerShell/releases)
+
+From an empty folder:
+
+```ps1
+python -m venv venv
+.\venv\Scripts\activate
+python -m pip install --upgrade pip
+pip install wheel wget
+pip install git+https://github.com/huggingface/diffusers.git
+pip install transformers onnxruntime onnx gradio torch ftfy spacy scipy OmegaConf accelerate
+pip install onnxruntime-directml --force-reinstall
+pip install protobuf==3.20.2
+python -m wget https://raw.githubusercontent.com/JbPasquier/stable-diffusion-onnx-ui/main/app.py
+python -m wget https://raw.githubusercontent.com/huggingface/diffusers/main/scripts/convert_original_stable_diffusion_to_diffusers.py -o convert_original_stable_diffusion_to_diffusers.py
+python -m wget https://raw.githubusercontent.com/huggingface/diffusers/main/scripts/convert_stable_diffusion_checkpoint_to_onnx.py -o convert_stable_diffusion_checkpoint_to_onnx.py
+python -m wget https://raw.githubusercontent.com/runwayml/stable-diffusion/main/configs/stable-diffusion/v1-inference.yaml -o v1-inference.yaml
+python -m wget https://raw.githubusercontent.com/runwayml/stable-diffusion/main/configs/stable-diffusion/v1-inpainting-inference.yaml -o v1-inpainting-inference.yaml
+mkdir model
+```
+
+## How to add models
+
+### Stable Diffusion
+
+```ps1
+python convert_stable_diffusion_checkpoint_to_onnx.py --model_path="stabilityai/stable-diffusion-2-1" --output_path="model/stable_diffusion_onnx"
+```
+
+### Stable Diffusion Inpainting
+
+```ps1
+python convert_stable_diffusion_checkpoint_to_onnx.py --model_path="stabilityai/stable-diffusion-2-inpainting" --output_path="model/stable_diffusion_inpainting_onnx"
+```
+
+### Other from Hugging Face
+
+```ps1
+python convert_stable_diffusion_checkpoint_to_onnx.py --model_path="nitrosocke/Nitro-Diffusion" --output_path="model/nitro_diffusion_onnx"
+```
+
+### Other from somewhere else
+
+Replace `some_file.ckpt` with the path to your ckpt one.
+
+```ps1
+python convert_original_stable_diffusion_to_diffusers.py --checkpoint_path="./some_file.ckpt" --dump_path="./some_file"
+python convert_stable_diffusion_checkpoint_to_onnx.py --model_path="./some_file" --output_path="model/some_onnx"
+```
+
+## Run
+
+```ps1
+# Ensure that you are in the virtualenv
+.\venv\Scripts\activate
+
+# Your computer only
+python app.py
+
+# Local network
+python app.py --local
+
+# The whole internet
+python app.py --share
+
+# Use CPU instead of AMD GPU
+python app.py --cpu-only
+```
+
+Notice that inpainting provide way better results with a proper model like [stable-diffusion-inpainting](https://huggingface.co/stabilityai/stable-diffusion-2-inpainting)
+
+## Updating
+
+Remove `venv` folder and `*.py` files and restart the [First installation](#first-installation) process.
+
+## Credits
+
+Inspired by:
+
+* [azuritecoin/OnnxDiffusersUI](https://github.com/azuritecoin/OnnxDiffusersUI)
+* [averad/256c507baa3dcc9464203dc14610d674](https://gist.github.com/averad/256c507baa3dcc9464203dc14610d674)

app.py

@@ -0,0 +1,377 @@
+import argparse
+import gc
+import os
+import re
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Tuple
+
+from diffusers import OnnxStableDiffusionPipeline, OnnxStableDiffusionImg2ImgPipeline
+from diffusers import OnnxStableDiffusionInpaintPipeline, OnnxStableDiffusionInpaintPipelineLegacy
+from diffusers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, EulerDiscreteScheduler
+from diffusers import __version__ as _df_version
+import gradio as gr
+import numpy as np
+from packaging import version
+import PIL
+
+
+
+def get_latents_from_seed(seed: int, batch_size: int, height: int, width: int) -> np.ndarray:
+    latents_shape = (batch_size, 4, height // 8, width // 8)
+    rng = np.random.default_rng(seed)
+    image_latents = rng.standard_normal(latents_shape).astype(np.float32)
+    return image_latents
+
+
+def run_diffusers(
+    prompt: str,
+    neg_prompt: str,
+    init_image: PIL.Image.Image,
+    iteration_count: int,
+    batch_size: int,
+    steps: int,
+    guidance_scale: float,
+    height: int,
+    width: int,
+    eta: float,
+    denoise_strength: float,
+    seed: str,
+    mask_image: PIL.Image.Image
+) -> Tuple[list, str]:
+    global model_name
+    global current_pipe
+    global pipe
+
+    prompt.strip("\n")
+    neg_prompt.strip("\n")
+
+    if seed == "":
+        rng = np.random.default_rng()
+        seed = rng.integers(np.iinfo(np.uint32).max)
+    else:
+        try:
+            seed = int(seed) & np.iinfo(np.uint32).max
+        except ValueError:
+            seed = hash(seed) & np.iinfo(np.uint32).max
+    seeds = np.array([seed], dtype=np.uint32)
+    if iteration_count > 1:
+        seed_seq = np.random.SeedSequence(seed)
+        seeds = np.concatenate((seeds, seed_seq.generate_state(iteration_count - 1)))
+
+    output_path = "output"
+    os.makedirs(output_path, exist_ok=True)
+
+    sched_name = str(pipe.scheduler._class_name)
+    prompts = [prompt]*batch_size
+    neg_prompts = [neg_prompt]*batch_size if neg_prompt != "" else None
+    images = []
+    time_taken = 0
+    output_base_path = Path("./output")
+    for i in range(iteration_count):
+        dt_obj = datetime.now()
+        dt_cust = dt_obj.strftime("%Y-%m-%d_%H-%M-%S")
+        image_name = dt_cust + "_" + str(seed) + ".png"
+        text_name = dt_cust + "_" + str(seed) + "_info.txt"
+        image_path = output_base_path / image_name
+        text_path = output_base_path / text_name
+        info = f"Prompt: {prompt}\nNegative prompt: {neg_prompt}\nSeed: {seeds[i]}\n" + \
+            f"Scheduler: {sched_name}\nScale: {guidance_scale}\nHeight: {height}\nWidth: {width}\nETA: {eta}\n" + \
+            f"Model: {model_name}\nIteration size: {iteration_count}\nBatch size: {batch_size}\nSteps: {steps}"
+        if (current_pipe == "img2img" or current_pipe == "inpaint" ):
+            info = info + f" denoise: {denoise_strength}"
+        with open(text_path, 'w', encoding='utf-8') as f:
+            f.write(info)
+
+        if current_pipe == "txt2img":
+            # Generate our own latents so that we can provide a seed.
+            latents = get_latents_from_seed(seeds[i], batch_size, height, width)
+
+            start = time.time()
+            batch_images = pipe(
+                prompts, negative_prompt=neg_prompts, height=height, width=width, num_inference_steps=steps,
+                guidance_scale=guidance_scale, eta=eta, latents=latents).images
+            finish = time.time()
+        elif current_pipe == "img2img":
+            # NOTE: at this time there's no good way of setting the seed for the random noise added by the scheduler
+            # np.random.seed(seeds[i])
+            start = time.time()
+            batch_images = pipe(
+                prompts, negative_prompt=neg_prompts, init_image=init_image, height=height, width=width,
+                num_inference_steps=steps, guidance_scale=guidance_scale, eta=eta, strength=denoise_strength,
+                num_images_per_prompt=batch_size).images
+            finish = time.time()
+        elif current_pipe == "inpaint":
+            start = time.time()
+            # NOTE: legacy require init_image but inpainting use image
+            batch_images = pipe(
+                prompts, negative_prompt=neg_prompts, image=init_image, mask_image=mask_image, height=height, width=width,
+                num_inference_steps=steps, guidance_scale=guidance_scale, eta=eta, strength=denoise_strength,
+                num_images_per_prompt=batch_size, init_image=init_image).images
+            finish = time.time()
+
+        short_prompt = prompt.strip("<>:\"/\\|?*\n\t")
+        short_prompt = short_prompt[:99] if len(short_prompt) > 100 else short_prompt
+        for j in range(batch_size):
+            batch_images[j].save(image_path)
+
+        images.extend(batch_images)
+        time_taken = time_taken + (finish - start)
+
+    time_taken = time_taken / 60.0
+    if iteration_count > 1:
+        status = f"Run took {time_taken:.1f} minutes " + \
+            f"to generate {iteration_count} iterations with batch size of {batch_size}. seeds: " + \
+            np.array2string(seeds, separator=",")
+    else:
+        status = f"Run took {time_taken:.1f} minutes to generate a batch size of " + \
+            f"{batch_size}. seed: {seeds[0]}"
+
+    return images, status
+
+
+def clear_click():
+    return {
+        prompt: "", neg_prompt: "", image: None, mask: None, mask_mode: "Draw mask", sch: "Euler", iter: 1, batch: 1,
+        drawn_mask: None, steps: 25, guid: 11, height: 512, width: 512, eta: 0.0, denoise: 0.8, seed: ""}
+
+
+def generate_click(
+    model_drop, prompt, neg_prompt, sch, iter, batch, steps, guid, height, width, eta,
+    seed, image, denoise, mask, pipeline, mask_mode, drawn_mask
+):
+    global model_name
+    global provider
+    global current_pipe
+    global scheduler
+    global pipe
+    
+    # reset scheduler and pipeline if model is different
+    if model_name != model_drop:
+        model_name = model_drop
+        scheduler = None
+        pipe = None
+    model_path = os.path.join("model", model_name)
+
+    if sch == "PNDM" and type(scheduler) is not PNDMScheduler:
+        scheduler = PNDMScheduler.from_pretrained(model_path, subfolder="scheduler")
+    elif sch == "LMS" and type(scheduler) is not LMSDiscreteScheduler:
+        scheduler = LMSDiscreteScheduler.from_pretrained(model_path, subfolder="scheduler")
+    elif sch == "DDIM" and type(scheduler) is not DDIMScheduler:
+        scheduler = DDIMScheduler.from_pretrained(model_path, subfolder="scheduler")
+    elif sch == "Euler" and type(scheduler) is not EulerDiscreteScheduler:
+        scheduler = EulerDiscreteScheduler.from_pretrained(model_path, subfolder="scheduler")
+
+    # select which pipeline depending on current tab
+    if pipeline == "TEXT2IMG":
+        if current_pipe != "txt2img" or pipe is None:
+            pipe = OnnxStableDiffusionPipeline.from_pretrained(
+                model_path, provider=provider, scheduler=scheduler)
+            gc.collect()
+        current_pipe = "txt2img"
+
+        if type(pipe.scheduler) is not type(scheduler):
+            pipe.scheduler = scheduler
+
+        return run_diffusers(
+            prompt, neg_prompt, None, iter, batch, steps, guid, height, width, eta, 0,
+            seed, None)
+    elif pipeline == "IMG2IMG":
+        if current_pipe != "img2img" or pipe is None:
+            pipe = OnnxStableDiffusionImg2ImgPipeline.from_pretrained(
+                model_path, provider=provider, scheduler=scheduler)
+            gc.collect()
+        current_pipe = "img2img"
+
+        if type(pipe.scheduler) is not type(scheduler):
+            pipe.scheduler = scheduler
+
+        # input image resizing
+        input_image = image.convert("RGB")
+        input_width, input_height = input_image.size
+        if height / width > input_height / input_width:
+            adjust_width = int(input_width * height / input_height)
+            input_image = input_image.resize((adjust_width, height))
+            left = (adjust_width - width) // 2
+            right = left + width
+            input_image = input_image.crop((left, 0, right, height))
+        else:
+            adjust_height = int(input_height * width / input_width)
+            input_image = input_image.resize((width, adjust_height))
+            top = (adjust_height - height) // 2
+            bottom = top + height
+            input_image = input_image.crop((0, top, width, bottom))
+
+        return run_diffusers(
+            prompt, neg_prompt, input_image, iter, batch, steps, guid, height, width, eta,
+            denoise, seed, None)
+    elif pipeline == "Inpainting":
+        if current_pipe != "inpaint" or pipe is None:
+            # >=0.8.0: Model name must ends with "inpainting" to use the proper pipeline
+            # This allows usage of Legacy pipeline for models not finetuned for inpainting
+            # see huggingface/diffusers!51
+            if not model_name.endswith("inpainting"):
+                pipe = OnnxStableDiffusionInpaintPipelineLegacy.from_pretrained(
+                    model_path, provider=provider, scheduler=scheduler)
+            else:
+                # on >=0.7.0 & <0.8.0 or model finetuned for inpainting
+                pipe = OnnxStableDiffusionInpaintPipeline.from_pretrained(
+                    model_path, provider=provider, scheduler=scheduler)
+            gc.collect()
+        current_pipe = "inpaint"
+
+        if type(pipe.scheduler) is not type(scheduler):
+            pipe.scheduler = scheduler
+
+        if mask_mode == "Upload mask":
+            input_image = image.convert("RGB")
+
+            # input mask resizing
+            input_mask = mask.convert("RGB")
+            input_mask_width, input_mask_height = input_mask.size
+            if height / width > input_mask_height / input_mask_width:
+                adjust_mask_width = int(input_mask_width * height / input_mask_height)
+                input_mask = input_mask.resize((adjust_mask_width, height))
+                mask_left = (adjust_mask_width - width) // 2
+                mask_right = mask_left + width
+                input_mask = input_mask.crop((mask_left, 0, mask_right, height))
+            else:
+                adjust_height = int(input_mask_height * width / input_mask_width)
+                input_mask = input_mask.resize((width, adjust_height))
+                top = (adjust_height - height) // 2
+                bottom = top + height
+                input_mask = input_mask.crop((0, top, width, bottom))
+        else:
+            input_image = drawn_mask['image'].convert('RGB')
+            input_mask = drawn_mask['mask']
+
+        # input image resizing
+        input_width, input_height = input_image.size
+        if height / width > input_height / input_width:
+            adjust_width = int(input_width * height / input_height)
+            input_image = input_image.resize((adjust_width, height))
+            left = (adjust_width - width) // 2
+            right = left + width
+            input_image = input_image.crop((left, 0, right, height))
+        else:
+            adjust_height = int(input_height * width / input_width)
+            input_image = input_image.resize((width, adjust_height))
+            top = (adjust_height - height) // 2
+            bottom = top + height
+            input_image = input_image.crop((0, top, width, bottom))
+
+
+        return run_diffusers(
+            prompt, neg_prompt, input_image, iter, batch, steps, guid, height, width, eta,
+            denoise, seed, input_mask)
+
+
+def choose_sch(sched_name: str):
+    if sched_name == "DDIM":
+        return gr.update(visible=True)
+    else:
+        return gr.update(visible=False)
+
+def choose_pipeline(pipeline: str, mask_mode: str):
+    if(pipeline == "TEXT2IMG"):
+        return (gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False))
+    if(pipeline == "IMG2IMG"):
+        return (gr.update(visible=True), gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), gr.update(visible=False))
+    if(pipeline == "Inpainting"):
+        if mask_mode == "Draw mask":
+            return (gr.update(visible=False), gr.update(visible=False), gr.update(visible=True), gr.update(visible=True), gr.update(visible=True))
+        else:
+            return (gr.update(visible=True), gr.update(visible=True), gr.update(visible=True), gr.update(visible=True), gr.update(visible=False))
+
+def choose_mask_mode(mask_mode):
+    if mask_mode == "Draw mask":
+        return [gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)]
+    else:
+        return [gr.update(visible=True), gr.update(visible=True), gr.update(visible=False)]
+
+def size_512_lock(size):
+    if size != 512:
+        return gr.update(interactive=False)
+    return gr.update(interactive=True)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Gradio interface for ONNX based Stable Diffusion")
+    parser.add_argument("--cpu-only", action="store_true", default=False, help="Run ONNX with CPU")
+    parser.add_argument("--local", action="store_true", default=False, help="Open to local network")
+    parser.add_argument("--public", action="store_true", default=False, help="Create a publicly shareable link for the interface")
+    args = parser.parse_args()
+
+    # variables for ONNX pipelines
+    model_name = None
+    provider = "CPUExecutionProvider" if args.cpu_only else "DmlExecutionProvider"
+    current_pipe = "txt2img"
+
+    # diffusers objects
+    scheduler = None
+    pipe = None
+
+    # search the model folder
+    model_dir = "model"
+    model_list = []
+    with os.scandir(model_dir) as scan_it:
+        for entry in scan_it:
+            if entry.is_dir():
+                model_list.append(entry.name)
+    default_model = model_list[0] if len(model_list) > 0 else None
+
+    # create gradio block
+    title = "Stable Diffusion " + str(version.parse(_df_version))
+    possibilities = ['TEXT2IMG', 'IMG2IMG', 'Inpainting']
+    
+    with gr.Blocks(title=title) as app:
+        with gr.Row():
+            with gr.Column(scale=1, min_width=600):
+                with gr.Column(variant='panel'):
+                    with gr.Row():
+                        model_drop = gr.Dropdown(model_list, value=default_model, label="Model", interactive=True)
+                        pipeline = gr.Radio(possibilities, value="TEXT2IMG", label="Pipeline")
+                    sch = gr.Radio(["DDIM", "LMS", "PNDM", "Euler"], value="Euler", label="Scheduler")
+                    eta = gr.Slider(0, 1, value=0.0, step=0.01, label="DDIM eta", visible=False)
+                    seed = gr.Textbox(value="", max_lines=1, label="Seed")
+                with gr.Column():
+                    mask_mode = gr.Radio(label="Mask mode", show_label=False, choices=["Draw mask", "Upload mask"], value="Draw mask", visible=False)
+                    image = gr.Image(label="Input image", type="pil", visible=False)
+                    mask = gr.Image(label="Input mask", type="pil", visible=False)
+                    drawn_mask = gr.Image(label="Input image and mask", source="upload", tool="sketch", type="pil", visible=False)
+                    prompt = gr.Textbox(value="", lines=2, label="Prompt")
+                    neg_prompt = gr.Textbox(value="", lines=2, label="Negative prompt")
+                    steps = gr.Slider(1, 150, value=25, step=1, label="Steps")
+                    guid = gr.Slider(0, 20, value=11, step=0.5, label="Guidance")
+                with gr.Column():
+                    height = gr.Slider(16, 1920, value=512, step=8, label="Height")
+                    width = gr.Slider(16, 1920, value=512, step=8, label="Width")
+                    denoise = gr.Slider(0, 1, value=0.8, step=0.01, label="Denoise strength", visible=False)
+                with gr.Column():
+                    iter = gr.Slider(1, 24, value=1, step=1, label="Iteration count")
+                    batch = gr.Slider(1, 4, value=1, step=1, label="Batch size")
+            with gr.Column(scale=1, min_width=600):
+                with gr.Row():
+                    gen_btn = gr.Button("Generate", variant="primary")
+                    clear_btn = gr.Button("Clear", variant="secondary")
+                with gr.Row(variant='panel'):
+                    image_out = gr.Gallery(value=None, label="Images")
+                status_out = gr.Textbox(value="", label="Status")
+
+        # config components
+        all_inputs = [
+            model_drop, prompt, neg_prompt, sch, iter, batch, steps, guid, height, width,
+            eta, seed, image, denoise, mask, pipeline, mask_mode, drawn_mask]
+        clear_btn.click(fn=clear_click, inputs=None, outputs=all_inputs, queue=False)
+        gen_btn.click(fn=generate_click, inputs=all_inputs, outputs=[image_out, status_out])
+
+        height.change(fn=size_512_lock, inputs=height, outputs=width)
+        width.change(fn=size_512_lock, inputs=width, outputs=height)
+        mask_mode.change(fn=choose_mask_mode, inputs=mask_mode, outputs=[image, mask, drawn_mask])
+        pipeline.change(fn=choose_pipeline, inputs=[pipeline, mask_mode], outputs=[image, mask, denoise, mask_mode, drawn_mask])
+        sch.change(fn=choose_sch, inputs=sch, outputs=eta)
+
+        image_out.style(grid=2)
+
+    app.queue(concurrency_count=1, api_open=False)
+    app.launch(inbrowser=True, server_name="0.0.0.0" if args.local else "127.0.0.1", show_api=False, quiet=True, share=args.public) # open to local network: server_name="0.0.0.0"