Spaces:
Sleeping
Sleeping
from diffusers import ( | |
StableDiffusionControlNetImg2ImgPipeline, | |
ControlNetModel, | |
LCMScheduler, | |
AutoencoderTiny, | |
) | |
from compel import Compel | |
import torch | |
from pipelines.utils.canny_gpu import SobelOperator | |
try: | |
import intel_extension_for_pytorch as ipex # type: ignore | |
except: | |
pass | |
import psutil | |
from config import Args | |
from pydantic import BaseModel, Field | |
from PIL import Image | |
import math | |
import time | |
# | |
taesd_model = "madebyollin/taesd" | |
controlnet_model = "thibaud/controlnet-sd21-canny-diffusers" | |
base_model = "stabilityai/sd-turbo" | |
default_prompt = "Portrait of The Joker halloween costume, face painting, with , glare pose, detailed, intricate, full of colour, cinematic lighting, trending on artstation, 8k, hyperrealistic, focused, extreme details, unreal engine 5 cinematic, masterpiece" | |
page_content = """ | |
<h1 class="text-3xl font-bold">Real-Time SDv2.1 Turbo</h1> | |
<h3 class="text-xl font-bold">Image-to-Image ControlNet</h3> | |
<p class="text-sm"> | |
This demo showcases | |
<a | |
href="https://huggingface.co/stabilityai/sd-turbo" | |
target="_blank" | |
class="text-blue-500 underline hover:no-underline">SD Turbo</a> | |
Image to Image pipeline using | |
<a | |
href="https://huggingface.co/docs/diffusers/main/en/using-diffusers/sdxl_turbo" | |
target="_blank" | |
class="text-blue-500 underline hover:no-underline">Diffusers</a | |
> with a MJPEG stream server. | |
</p> | |
<p class="text-sm text-gray-500"> | |
Change the prompt to generate different images, accepts <a | |
href="https://github.com/damian0815/compel/blob/main/doc/syntax.md" | |
target="_blank" | |
class="text-blue-500 underline hover:no-underline">Compel</a | |
> syntax. | |
</p> | |
""" | |
class Pipeline: | |
class Info(BaseModel): | |
name: str = "controlnet+sd15Turbo" | |
title: str = "SDv1.5 Turbo + Controlnet" | |
description: str = "Generates an image from a text prompt" | |
input_mode: str = "image" | |
page_content: str = page_content | |
class InputParams(BaseModel): | |
prompt: str = Field( | |
default_prompt, | |
title="Prompt", | |
field="textarea", | |
id="prompt", | |
) | |
seed: int = Field( | |
4402026899276587, min=0, title="Seed", field="seed", hide=True, id="seed" | |
) | |
steps: int = Field( | |
1, min=1, max=15, title="Steps", field="range", hide=True, id="steps" | |
) | |
width: int = Field( | |
512, min=2, max=15, title="Width", disabled=True, hide=True, id="width" | |
) | |
height: int = Field( | |
512, min=2, max=15, title="Height", disabled=True, hide=True, id="height" | |
) | |
guidance_scale: float = Field( | |
1.0, | |
min=0, | |
max=10, | |
step=0.001, | |
title="Guidance Scale", | |
field="range", | |
hide=True, | |
id="guidance_scale", | |
) | |
strength: float = Field( | |
0.8, | |
min=0.10, | |
max=1.0, | |
step=0.001, | |
title="Strength", | |
field="range", | |
hide=True, | |
id="strength", | |
) | |
controlnet_scale: float = Field( | |
0.325, | |
min=0, | |
max=1.0, | |
step=0.001, | |
title="Controlnet Scale", | |
field="range", | |
hide=True, | |
id="controlnet_scale", | |
) | |
controlnet_start: float = Field( | |
0.0, | |
min=0, | |
max=1.0, | |
step=0.001, | |
title="Controlnet Start", | |
field="range", | |
hide=True, | |
id="controlnet_start", | |
) | |
controlnet_end: float = Field( | |
1.0, | |
min=0, | |
max=1.0, | |
step=0.001, | |
title="Controlnet End", | |
field="range", | |
hide=True, | |
id="controlnet_end", | |
) | |
canny_low_threshold: float = Field( | |
0.31, | |
min=0, | |
max=1.0, | |
step=0.001, | |
title="Canny Low Threshold", | |
field="range", | |
hide=True, | |
id="canny_low_threshold", | |
) | |
canny_high_threshold: float = Field( | |
0.125, | |
min=0, | |
max=1.0, | |
step=0.001, | |
title="Canny High Threshold", | |
field="range", | |
hide=True, | |
id="canny_high_threshold", | |
) | |
debug_canny: bool = Field( | |
False, | |
title="Debug Canny", | |
field="checkbox", | |
hide=True, | |
id="debug_canny", | |
) | |
def __init__(self, args: Args, device: torch.device, torch_dtype: torch.dtype): | |
controlnet_canny = ControlNetModel.from_pretrained( | |
controlnet_model, torch_dtype=torch_dtype | |
).to(device) | |
self.pipes = {} | |
if args.safety_checker: | |
self.pipe = StableDiffusionControlNetImg2ImgPipeline.from_pretrained( | |
base_model, | |
controlnet=controlnet_canny, | |
) | |
else: | |
self.pipe = StableDiffusionControlNetImg2ImgPipeline.from_pretrained( | |
base_model, | |
controlnet=controlnet_canny, | |
safety_checker=None, | |
) | |
if args.taesd: | |
self.pipe.vae = AutoencoderTiny.from_pretrained( | |
taesd_model, torch_dtype=torch_dtype, use_safetensors=True | |
).to(device) | |
if args.sfast: | |
print("\nRunning sfast compile\n") | |
from sfast.compilers.stable_diffusion_pipeline_compiler import ( | |
compile, | |
CompilationConfig, | |
) | |
config = CompilationConfig.Default() | |
config.enable_xformers = True | |
config.enable_triton = True | |
config.enable_cuda_graph = True | |
self.pipe = compile(self.pipe, config=config) | |
if args.onediff: | |
print("\nRunning onediff compile\n") | |
from onediff.infer_compiler import oneflow_compile | |
self.pipe.unet = oneflow_compile(self.pipe.unet) | |
self.pipe.vae.encoder = oneflow_compile(self.pipe.vae.encoder) | |
self.pipe.vae.decoder = oneflow_compile(self.pipe.vae.decoder) | |
self.pipe.controlnet = oneflow_compile(self.pipe.controlnet) | |
self.canny_torch = SobelOperator(device=device) | |
self.pipe.scheduler = LCMScheduler.from_config(self.pipe.scheduler.config) | |
self.pipe.set_progress_bar_config(disable=True) | |
self.pipe.to(device=device, dtype=torch_dtype).to(device) | |
if device.type != "mps": | |
self.pipe.unet.to(memory_format=torch.channels_last) | |
if args.compel: | |
from compel import Compel | |
self.pipe.compel_proc = Compel( | |
tokenizer=self.pipe.tokenizer, | |
text_encoder=self.pipe.text_encoder, | |
truncate_long_prompts=True, | |
) | |
if args.taesd: | |
self.pipe.vae = AutoencoderTiny.from_pretrained( | |
taesd_model, torch_dtype=torch_dtype, use_safetensors=True | |
).to(device) | |
if args.torch_compile: | |
self.pipe.unet = torch.compile( | |
self.pipe.unet, mode="reduce-overhead", fullgraph=True | |
) | |
self.pipe.vae = torch.compile( | |
self.pipe.vae, mode="reduce-overhead", fullgraph=True | |
) | |
self.pipe( | |
prompt="warmup", | |
image=[Image.new("RGB", (768, 768))], | |
control_image=[Image.new("RGB", (768, 768))], | |
) | |
def predict(self, params: "Pipeline.InputParams") -> Image.Image: | |
generator = torch.manual_seed(params.seed) | |
prompt = params.prompt | |
prompt_embeds = None | |
if hasattr(self.pipe, "compel_proc"): | |
prompt_embeds = self.pipe.compel_proc( | |
[params.prompt, params.negative_prompt] | |
) | |
prompt = None | |
control_image = self.canny_torch( | |
params.image, params.canny_low_threshold, params.canny_high_threshold | |
) | |
steps = params.steps | |
strength = params.strength | |
if int(steps * strength) < 1: | |
steps = math.ceil(1 / max(0.10, strength)) | |
results = self.pipe( | |
image=params.image, | |
control_image=control_image, | |
prompt=prompt, | |
prompt_embeds=prompt_embeds, | |
generator=generator, | |
strength=strength, | |
num_inference_steps=steps, | |
guidance_scale=params.guidance_scale, | |
width=params.width, | |
height=params.height, | |
output_type="pil", | |
controlnet_conditioning_scale=params.controlnet_scale, | |
control_guidance_start=params.controlnet_start, | |
control_guidance_end=params.controlnet_end, | |
) | |
nsfw_content_detected = ( | |
results.nsfw_content_detected[0] | |
if "nsfw_content_detected" in results | |
else False | |
) | |
if nsfw_content_detected: | |
return None | |
result_image = results.images[0] | |
if params.debug_canny: | |
# paste control_image on top of result_image | |
w0, h0 = (200, 200) | |
control_image = control_image.resize((w0, h0)) | |
w1, h1 = result_image.size | |
result_image.paste(control_image, (w1 - w0, h1 - h0)) | |
return result_image | |