




import random
import unittest

import numpy as np

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionImgaImgPipeline,
    PNDMScheduler,
)
from diffusers.utils import floats_tensor
from diffusers.utils.testing_utils import (
    is_onnx_available,
    load_image,
    nightly,
    require_onnxruntime,
    require_torch_gpu,
)

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
					import onnxruntime as ort
class       a__   ( snake_case__			,    unittest.TestCase				):
						_a							:   Union[str, Any] =   """hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"""






						def     __SCREAMING_SNAKE_CASE(       self		,      _A=0      ):




											"""simple docstring"""



											__lowerCAmelCase           =	floats_tensor((1, 3, 1_2_8, 1_2_8)		,      rng=random.Random(_A      )      )
											__lowerCAmelCase           =	np.random.RandomState(_A      )
											__lowerCAmelCase           =	{
											    "prompt": "A painting of a squirrel eating a burger",
											    "image": image,
											    "generator": generator,
											    "num_inference_steps": 3,
											    "strength": 0.75,
											    "guidance_scale": 7.5,
											    "output_type": "numpy",
											}
											return inputs






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,      provider="CPUExecutionProvider"      )
											pipe.set_progress_bar_config(disable=_A      )

											__lowerCAmelCase           =	self.get_dummy_inputs()
											__lowerCAmelCase           =	pipe(**_A      ).images
											__lowerCAmelCase           =	image[0, -3:, -3:, -1].flatten()

											assert image.shape == (1, 1_2_8, 1_2_8, 3)
											__lowerCAmelCase           =	np.array([0.6_96_43, 0.5_84_84, 0.5_03_14, 0.5_87_60, 0.5_53_68, 0.5_96_43, 0.5_15_29, 0.4_12_17, 0.4_90_87]      )
											assert np.abs(image_slice - expected_slice      ).max() < 1E-1






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,      provider="CPUExecutionProvider"      )
											__lowerCAmelCase           =	PNDMScheduler.from_config(pipe.scheduler.config		,      skip_prk_steps=_A      )
											pipe.set_progress_bar_config(disable=_A      )

											__lowerCAmelCase           =	self.get_dummy_inputs()
											__lowerCAmelCase           =	pipe(**_A      ).images
											__lowerCAmelCase           =	image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_2_8, 1_2_8, 3)
											__lowerCAmelCase           =	np.array([0.6_17_37, 0.5_46_42, 0.5_31_83, 0.5_44_65, 0.5_27_42, 0.6_05_25, 0.4_99_69, 0.4_06_55, 0.4_81_54]      )

											assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-1






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,      provider="CPUExecutionProvider"      )
											__lowerCAmelCase           =	LMSDiscreteScheduler.from_config(pipe.scheduler.config      )
											pipe.set_progress_bar_config(disable=_A      )

											# warmup pass to apply optimizations
											__lowerCAmelCase           =	pipe(**self.get_dummy_inputs()      )

											__lowerCAmelCase           =	self.get_dummy_inputs()
											__lowerCAmelCase           =	pipe(**_A      ).images
											__lowerCAmelCase           =	image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_2_8, 1_2_8, 3)
											__lowerCAmelCase           =	np.array([0.5_27_61, 0.5_99_77, 0.4_90_33, 0.4_96_19, 0.5_42_82, 0.5_03_11, 0.4_76_00, 0.4_09_18, 0.4_52_03]      )

											assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-1






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,      provider="CPUExecutionProvider"      )
											__lowerCAmelCase           =	EulerDiscreteScheduler.from_config(pipe.scheduler.config      )
											pipe.set_progress_bar_config(disable=_A      )

											__lowerCAmelCase           =	self.get_dummy_inputs()
											__lowerCAmelCase           =	pipe(**_A      ).images
											__lowerCAmelCase           =	image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_2_8, 1_2_8, 3)
											__lowerCAmelCase           =	np.array([0.5_29_11, 0.6_00_04, 0.4_92_29, 0.4_98_05, 0.5_45_02, 0.5_06_80, 0.4_77_77, 0.4_10_28, 0.4_53_04]      )

											assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-1






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,      provider="CPUExecutionProvider"      )
											__lowerCAmelCase           =	EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config      )
											pipe.set_progress_bar_config(disable=_A      )

											__lowerCAmelCase           =	self.get_dummy_inputs()
											__lowerCAmelCase           =	pipe(**_A      ).images
											__lowerCAmelCase           =	image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_2_8, 1_2_8, 3)
											__lowerCAmelCase           =	np.array([0.5_29_11, 0.6_00_04, 0.4_92_29, 0.4_98_05, 0.5_45_02, 0.5_06_80, 0.4_77_77, 0.4_10_28, 0.4_53_04]      )

											assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-1






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,      provider="CPUExecutionProvider"      )
											__lowerCAmelCase           =	DPMSolverMultistepScheduler.from_config(pipe.scheduler.config      )
											pipe.set_progress_bar_config(disable=_A      )

											__lowerCAmelCase           =	self.get_dummy_inputs()
											__lowerCAmelCase           =	pipe(**_A      ).images
											__lowerCAmelCase           =	image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_2_8, 1_2_8, 3)
											__lowerCAmelCase           =	np.array([0.6_53_31, 0.5_82_77, 0.4_82_04, 0.5_60_59, 0.5_36_65, 0.5_62_35, 0.5_09_69, 0.4_00_09, 0.4_65_52]      )

											assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-1






@nightly
@require_onnxruntime
@require_torch_gpu
class       a__   ( unittest.TestCase				):






						@property
						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											return (
											    "CUDAExecutionProvider",
											    {
											        "gpu_mem_limit": "15000000000",  # 15GB
											        "arena_extend_strategy": "kSameAsRequested",
											    },
											)






						@property
						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	ort.SessionOptions()
											__lowerCAmelCase           =	False
											return options






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	load_image(
											    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
											    "/img2img/sketch-mountains-input.jpg"      )
											__lowerCAmelCase           =	init_image.resize((7_6_8, 5_1_2)      )
											# using the PNDM scheduler by default
											__lowerCAmelCase           =	OnnxStableDiffusionImgaImgPipeline.from_pretrained(
											    "CompVis/stable-diffusion-v1-4"		,      revision="onnx"		,      safety_checker=_A		,      feature_extractor=_A		,      provider=self.gpu_provider		,      sess_options=self.gpu_options		,      )
											pipe.set_progress_bar_config(disable=_A      )

											__lowerCAmelCase           =	"A fantasy landscape, trending on artstation"

											__lowerCAmelCase           =	np.random.RandomState(0      )
											__lowerCAmelCase           =	pipe(
											    prompt=_A		,      image=_A		,      strength=0.75		,      guidance_scale=7.5		,      num_inference_steps=1_0		,      generator=_A		,      output_type="np"		,      )
											__lowerCAmelCase           =	output.images
											__lowerCAmelCase           =	images[0, 2_5_5:2_5_8, 3_8_3:3_8_6, -1]

											assert images.shape == (1, 5_1_2, 7_6_8, 3)
											__lowerCAmelCase           =	np.array([0.49_09, 0.50_59, 0.53_72, 0.46_23, 0.48_76, 0.50_49, 0.48_20, 0.49_56, 0.50_19]      )
											# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

											assert np.abs(image_slice.flatten() - expected_slice      ).max() < 2E-2






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	load_image(
											    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
											    "/img2img/sketch-mountains-input.jpg"      )
											__lowerCAmelCase           =	init_image.resize((7_6_8, 5_1_2)      )
											__lowerCAmelCase           =	LMSDiscreteScheduler.from_pretrained(
											    "runwayml/stable-diffusion-v1-5"		,      subfolder="scheduler"		,      revision="onnx"      )
											__lowerCAmelCase           =	OnnxStableDiffusionImgaImgPipeline.from_pretrained(
											    "runwayml/stable-diffusion-v1-5"		,      revision="onnx"		,      scheduler=_A		,      safety_checker=_A		,      feature_extractor=_A		,      provider=self.gpu_provider		,      sess_options=self.gpu_options		,      )
											pipe.set_progress_bar_config(disable=_A      )

											__lowerCAmelCase           =	"A fantasy landscape, trending on artstation"

											__lowerCAmelCase           =	np.random.RandomState(0      )
											__lowerCAmelCase           =	pipe(
											    prompt=_A		,      image=_A		,      strength=0.75		,      guidance_scale=7.5		,      num_inference_steps=2_0		,      generator=_A		,      output_type="np"		,      )
											__lowerCAmelCase           =	output.images
											__lowerCAmelCase           =	images[0, 2_5_5:2_5_8, 3_8_3:3_8_6, -1]

											assert images.shape == (1, 5_1_2, 7_6_8, 3)
											__lowerCAmelCase           =	np.array([0.80_43, 0.9_26, 0.95_81, 0.81_19, 0.89_54, 0.9_13, 0.72_09, 0.74_63, 0.74_31]      )
											# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

											assert np.abs(image_slice.flatten() - expected_slice      ).max() < 2E-2










import argparse

from diffusers.pipelines.stable_diffusion.convert_from_ckpt import download_controlnet_from_original_ckpt


if __name__ == "__main__":
					UpperCamelCase__         =      argparse.ArgumentParser()

					parser.add_argument(
					    """--checkpoint_path""", default=None, type=str, required=True, help="""Path to the checkpoint to convert."""
					)
					parser.add_argument(
					    """--original_config_file""",
					    type=str,
					    required=True,
					    help="""The YAML config file corresponding to the original architecture.""",
					)
					parser.add_argument(
					    """--num_in_channels""",
					    default=None,
					    type=int,
					    help="""The number of input channels. If `None` number of input channels will be automatically inferred.""",
					)
					parser.add_argument(
					    """--image_size""",
					    default=512,
					    type=int,
					    help=(
					        """The image size that the model was trained on. Use 512 for Stable Diffusion v1.X and Stable Siffusion v2"""
					        """ Base. Use 768 for Stable Diffusion v2."""
					    ),
					)
					parser.add_argument(
					    """--extract_ema""",
					    action="""store_true""",
					    help=(
					        """Only relevant for checkpoints that have both EMA and non-EMA weights. Whether to extract the EMA weights"""
					        """ or not. Defaults to `False`. Add `--extract_ema` to extract the EMA weights. EMA weights usually yield"""
					        """ higher quality images for inference. Non-EMA weights are usually better to continue fine-tuning."""
					    ),
					)
					parser.add_argument(
					    """--upcast_attention""",
					    action="""store_true""",
					    help=(
					        """Whether the attention computation should always be upcasted. This is necessary when running stable"""
					        """ diffusion 2.1."""
					    ),
					)
					parser.add_argument(
					    """--from_safetensors""",
					    action="""store_true""",
					    help="""If `--checkpoint_path` is in `safetensors` format, load checkpoint with safetensors instead of PyTorch.""",
					)
					parser.add_argument(
					    """--to_safetensors""",
					    action="""store_true""",
					    help="""Whether to store pipeline in safetensors format or not.""",
					)
					parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""")
					parser.add_argument("""--device""", type=str, help="""Device to use (e.g. cpu, cuda:0, cuda:1, etc.)""")







					def      _a				(						SCREAMING_SNAKE_CASE_							:    List[Any]					):
										if string == "True":
															return True
										elif string == "False":
															return False
										else:
															raise ValueError(F"""could not parse string as bool {string}"""					)

					parser.add_argument(
					    """--use_linear_projection""", help="""Override for use linear projection""", required=False, type=parse_bool
					)

					parser.add_argument("""--cross_attention_dim""", help="""Override for cross attention_dim""", required=False, type=int)

					UpperCamelCase__         =      parser.parse_args()

					UpperCamelCase__         =      download_controlnet_from_original_ckpt(
					    checkpoint_path=args.checkpoint_path,
					    original_config_file=args.original_config_file,
					    image_size=args.image_size,
					    extract_ema=args.extract_ema,
					    num_in_channels=args.num_in_channels,
					    upcast_attention=args.upcast_attention,
					    from_safetensors=args.from_safetensors,
					    device=args.device,
					    use_linear_projection=args.use_linear_projection,
					    cross_attention_dim=args.cross_attention_dim,
					)


					controlnet.save_pretrained(args.dump_path, safe_serialization=args.to_safetensors)




