


import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu






class     UpperCamelCase(  unittest.TestCase   ):


					def 							SCREAMING_SNAKE_CASE_  (						self	:		str						)			->	Dict:




											'''simple docstring'''

											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple						)			->	Optional[Any]:




											'''simple docstring'''

											__snake_case				=		1
											__snake_case				=		3
											__snake_case				=		(3_2, 3_2)

											__snake_case				=		floats_tensor((batch_size, num_channels) + sizes     ,    rng=random.Random(0						)						).to(SCREAMING_SNAKE_CASE						)
											return image


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		int						)			->	Any:




											'''simple docstring'''

											torch.manual_seed(0						)
											__snake_case				=		UNetaDConditionModel(
											    block_out_channels=(3_2, 6_4)     ,    layers_per_block=2     ,    sample_size=3_2     ,    in_channels=4     ,    out_channels=4     ,    down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")     ,    up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")     ,    cross_attention_dim=3_2     ,    )
											return model


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	str:




											'''simple docstring'''

											torch.manual_seed(0						)
											__snake_case				=		AutoencoderKL(
											    block_out_channels=[3_2, 6_4]     ,    in_channels=3     ,    out_channels=3     ,    down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]     ,    up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]     ,    latent_channels=4     ,    )
											return model


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	int:




											'''simple docstring'''

											torch.manual_seed(0						)
											__snake_case				=		CLIPTextConfig(
											    bos_token_id=0     ,    eos_token_id=2     ,    hidden_size=3_2     ,    intermediate_size=3_7     ,    layer_norm_eps=1e-0_5     ,    num_attention_heads=4     ,    num_hidden_layers=5     ,    pad_token_id=1     ,    vocab_size=1_0_0_0     ,    )
											return CLIPTextModel(SCREAMING_SNAKE_CASE						)


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]						)			->	str:




											'''simple docstring'''

											def extract(*SCREAMING_SNAKE_CASE	:		List[str]     ,    **SCREAMING_SNAKE_CASE	:		List[Any]						):






																	class     UpperCamelCase:


																						def __init__(						self	:		Dict						)			->	Union[str, Any]:




																												'''simple docstring'''

																												__snake_case				=		torch.ones([0]						)






																						def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]						)			->	List[Any]:




																												'''simple docstring'''

																												self.pixel_values.to(SCREAMING_SNAKE_CASE						)
																												return self




																	return Out()

											return extract


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Dict						)			->	Dict:




											'''simple docstring'''

											__snake_case				=		"cpu"  # ensure determinism for the device-dependent torch.Generator
											__snake_case				=		self.dummy_cond_unet
											__snake_case				=		DDIMScheduler(
											    beta_start=0.00085     ,    beta_end=0.012     ,    beta_schedule="scaled_linear"     ,    clip_sample=SCREAMING_SNAKE_CASE     ,    set_alpha_to_one=SCREAMING_SNAKE_CASE     ,    )

											__snake_case				=		self.dummy_vae
											__snake_case				=		self.dummy_text_encoder
											__snake_case				=		CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)

											# make sure here that pndm scheduler skips prk
											__snake_case				=		StableDiffusionPipeline(
											    unet=SCREAMING_SNAKE_CASE     ,    scheduler=SCREAMING_SNAKE_CASE     ,    vae=SCREAMING_SNAKE_CASE     ,    text_encoder=SCREAMING_SNAKE_CASE     ,    tokenizer=SCREAMING_SNAKE_CASE     ,    safety_checker=SCREAMING_SNAKE_CASE     ,    feature_extractor=self.dummy_extractor     ,    )
											__snake_case				=		sd_pipe.to(SCREAMING_SNAKE_CASE						)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

											__snake_case				=		"A painting of a squirrel eating a burger"

											__snake_case				=		torch.Generator(device=SCREAMING_SNAKE_CASE						).manual_seed(0						)
											__snake_case				=		sd_pipe([prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=6.0     ,    num_inference_steps=2     ,    output_type="np"						)
											__snake_case				=		output.images

											__snake_case				=		torch.Generator(device=SCREAMING_SNAKE_CASE						).manual_seed(0						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=6.0     ,    num_inference_steps=2     ,    output_type="np"     ,    return_dict=SCREAMING_SNAKE_CASE     ,    )[0]

											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		image_from_tuple[0, -3:, -3:, -1]

											assert image.shape == (1, 6_4, 6_4, 3)
											__snake_case				=		np.array([0.5756, 0.6118, 0.5005, 0.5041, 0.5471, 0.4726, 0.4976, 0.4865, 0.4864]						)

											assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-2
											assert np.abs(image_from_tuple_slice.flatten() - expected_slice						).max() < 1e-2


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	Tuple:




											'''simple docstring'''

											__snake_case				=		"cpu"  # ensure determinism for the device-dependent torch.Generator
											__snake_case				=		self.dummy_cond_unet
											__snake_case				=		PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE						)
											__snake_case				=		self.dummy_vae
											__snake_case				=		self.dummy_text_encoder
											__snake_case				=		CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)

											# make sure here that pndm scheduler skips prk
											__snake_case				=		StableDiffusionPipeline(
											    unet=SCREAMING_SNAKE_CASE     ,    scheduler=SCREAMING_SNAKE_CASE     ,    vae=SCREAMING_SNAKE_CASE     ,    text_encoder=SCREAMING_SNAKE_CASE     ,    tokenizer=SCREAMING_SNAKE_CASE     ,    safety_checker=SCREAMING_SNAKE_CASE     ,    feature_extractor=self.dummy_extractor     ,    )
											__snake_case				=		sd_pipe.to(SCREAMING_SNAKE_CASE						)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

											__snake_case				=		"A painting of a squirrel eating a burger"
											__snake_case				=		torch.Generator(device=SCREAMING_SNAKE_CASE						).manual_seed(0						)
											__snake_case				=		sd_pipe([prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=6.0     ,    num_inference_steps=2     ,    output_type="np"						)

											__snake_case				=		output.images

											__snake_case				=		torch.Generator(device=SCREAMING_SNAKE_CASE						).manual_seed(0						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=6.0     ,    num_inference_steps=2     ,    output_type="np"     ,    return_dict=SCREAMING_SNAKE_CASE     ,    )[0]

											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		image_from_tuple[0, -3:, -3:, -1]

											assert image.shape == (1, 6_4, 6_4, 3)
											__snake_case				=		np.array([0.5125, 0.5716, 0.4828, 0.5060, 0.5650, 0.4768, 0.5185, 0.4895, 0.4993]						)

											assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-2
											assert np.abs(image_from_tuple_slice.flatten() - expected_slice						).max() < 1e-2


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	List[Any]:




											'''simple docstring'''

											__snake_case				=		StableDiffusionPipeline.from_pretrained(
											    "hf-internal-testing/tiny-stable-diffusion-lms-pipe"     ,    safety_checker=SCREAMING_SNAKE_CASE						)
											assert isinstance(SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE						)
											assert isinstance(pipe.scheduler     ,    SCREAMING_SNAKE_CASE						)
											assert pipe.safety_checker is None

											__snake_case				=		pipe("example prompt"     ,    num_inference_steps=2						).images[0]
											assert image is not None

											# check that there's no error when saving a pipeline with one of the models being None
											with tempfile.TemporaryDirectory() as tmpdirname:
																	pipe.save_pretrained(SCREAMING_SNAKE_CASE						)
																	__snake_case				=		StableDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE						)

											# sanity check that the pipeline still works
											assert pipe.safety_checker is None
											__snake_case				=		pipe("example prompt"     ,    num_inference_steps=2						).images[0]
											assert image is not None






					@unittest.skipIf(torch_device != "cuda"     ,    "This test requires a GPU"						)
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Union[str, Any]						)			->	int:




											'''simple docstring'''

											__snake_case				=		self.dummy_cond_unet
											__snake_case				=		PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE						)
											__snake_case				=		self.dummy_vae
											__snake_case				=		self.dummy_text_encoder
											__snake_case				=		CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)

											# put models in fp16
											__snake_case				=		unet.half()
											__snake_case				=		vae.half()
											__snake_case				=		bert.half()

											# make sure here that pndm scheduler skips prk
											__snake_case				=		StableDiffusionPipeline(
											    unet=SCREAMING_SNAKE_CASE     ,    scheduler=SCREAMING_SNAKE_CASE     ,    vae=SCREAMING_SNAKE_CASE     ,    text_encoder=SCREAMING_SNAKE_CASE     ,    tokenizer=SCREAMING_SNAKE_CASE     ,    safety_checker=SCREAMING_SNAKE_CASE     ,    feature_extractor=self.dummy_extractor     ,    )
											__snake_case				=		sd_pipe.to(SCREAMING_SNAKE_CASE						)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

											__snake_case				=		"A painting of a squirrel eating a burger"
											__snake_case				=		sd_pipe([prompt]     ,    num_inference_steps=2     ,    output_type="np"						).images

											assert image.shape == (1, 6_4, 6_4, 3)






@nightly
@require_torch_gpu
class     UpperCamelCase(  unittest.TestCase   ):


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	Tuple:




											'''simple docstring'''

											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[Any]						)			->	Optional[Any]:




											'''simple docstring'''

											__snake_case				=		StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"     ,    safety_checker=SCREAMING_SNAKE_CASE						)
											__snake_case				=		LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config						)
											__snake_case				=		sd_pipe.to(SCREAMING_SNAKE_CASE						)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

											__snake_case				=		(
											    "portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle"
											    " coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with"
											    " anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and"
											    " children from bahnhof zoo, detailed "
											)
											__snake_case				=		4_0_0_3_6_6_0_3_4_6
											__snake_case				=		7

											# without safety guidance (sld_guidance_scale = 0)
											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=0     ,    )

											__snake_case				=		output.images
											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		[0.2278, 0.2231, 0.2249, 0.2333, 0.2303, 0.1885, 0.2273, 0.2144, 0.2176]

											assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

											# without safety guidance (strong configuration)
											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=2_0_0_0     ,    sld_warmup_steps=7     ,    sld_threshold=0.025     ,    sld_momentum_scale=0.5     ,    sld_mom_beta=0.7     ,    )

											__snake_case				=		output.images
											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		[0.2383, 0.2276, 0.236, 0.2192, 0.2186, 0.2053, 0.1971, 0.1901, 0.1719]

											assert image.shape == (1, 5_1_2, 5_1_2, 3)

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


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple						)			->	List[str]:




											'''simple docstring'''

											__snake_case				=		StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"     ,    safety_checker=SCREAMING_SNAKE_CASE						)
											__snake_case				=		LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config						)
											__snake_case				=		sd_pipe.to(SCREAMING_SNAKE_CASE						)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

											__snake_case				=		"padme amidala taking a bath artwork, safe for work, no nudity"
											__snake_case				=		2_7_3_4_9_7_1_7_5_5
											__snake_case				=		7

											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=0     ,    )

											__snake_case				=		output.images
											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		[0.3502, 0.3622, 0.3396, 0.3642, 0.3478, 0.3318, 0.35, 0.3348, 0.3297]

											assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=2_0_0_0     ,    sld_warmup_steps=7     ,    sld_threshold=0.025     ,    sld_momentum_scale=0.5     ,    sld_mom_beta=0.7     ,    )

											__snake_case				=		output.images
											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		[0.5531, 0.5206, 0.4895, 0.5156, 0.5182, 0.4751, 0.4802, 0.4803, 0.4443]

											assert image.shape == (1, 5_1_2, 5_1_2, 3)

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






					def 							SCREAMING_SNAKE_CASE_  (						self	:		Dict						)			->	int:




											'''simple docstring'''

											__snake_case				=		StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"						)
											__snake_case				=		sd_pipe.to(SCREAMING_SNAKE_CASE						)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

											__snake_case				=		(
											    "the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."
											    " leyendecker"
											)
											__snake_case				=		1_0_4_4_3_5_5_2_3_4
											__snake_case				=		1_2

											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=0     ,    )

											__snake_case				=		output.images
											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]						)

											assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=2_0_0_0     ,    sld_warmup_steps=7     ,    sld_threshold=0.025     ,    sld_momentum_scale=0.5     ,    sld_mom_beta=0.7     ,    )

											__snake_case				=		output.images
											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		np.array([0.5818, 0.6285, 0.6835, 0.6019, 0.625, 0.6754, 0.6096, 0.6334, 0.6561]						)
											assert image.shape == (1, 5_1_2, 5_1_2, 3)

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









import random
import unittest

import numpy as np
import torch

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionUpscalePipeline,
    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     UpperCamelCase(  _a     ,							unittest.TestCase   ):
					# TODO: is there an appropriate internal test set?
					snake_case_		:				Dict										=	"""ssube/stable-diffusion-x4-upscaler-onnx"""


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Dict     ,    SCREAMING_SNAKE_CASE	:		List[str]=0						)			->	Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		floats_tensor((1, 3, 1_2_8, 1_2_8)     ,    rng=random.Random(SCREAMING_SNAKE_CASE						)						)
											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		{
											    "prompt": "A painting of a squirrel eating a burger",
											    "image": image,
											    "generator": generator,
											    "num_inference_steps": 3,
											    "guidance_scale": 7.5,
											    "output_type": "numpy",
											}
											return inputs


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	List[str]:




											'''simple docstring'''

											__snake_case				=		OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint     ,    provider="CPUExecutionProvider"						)
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

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

											# started as 128, should now be 512
											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											__snake_case				=		np.array(
											    [0.6974782, 0.68902093, 0.70135885, 0.7583618, 0.7804545, 0.7854912, 0.78667426, 0.78743863, 0.78070223]						)
											assert np.abs(image_slice - expected_slice						).max() < 1e-1


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	Optional[Any]:




											'''simple docstring'''

											__snake_case				=		OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint     ,    provider="CPUExecutionProvider"						)
											__snake_case				=		PNDMScheduler.from_config(pipe.scheduler.config     ,    skip_prk_steps=SCREAMING_SNAKE_CASE						)
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											__snake_case				=		np.array(
											    [0.6898892, 0.59240556, 0.52499527, 0.58866215, 0.52258235, 0.52572715, 0.62414473, 0.6174387, 0.6214964]						)
											assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-1


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	Optional[int]:




											'''simple docstring'''

											__snake_case				=		OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint     ,    provider="CPUExecutionProvider"						)
											__snake_case				=		DPMSolverMultistepScheduler.from_config(pipe.scheduler.config						)
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											__snake_case				=		np.array(
											    [0.7659278, 0.76437664, 0.75579107, 0.7691116, 0.77666986, 0.7727672, 0.7758664, 0.7812226, 0.76942515]						)

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


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Dict						)			->	Dict:




											'''simple docstring'''

											__snake_case				=		OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint     ,    provider="CPUExecutionProvider"						)
											__snake_case				=		EulerDiscreteScheduler.from_config(pipe.scheduler.config						)
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											__snake_case				=		np.array(
											    [0.6974782, 0.68902093, 0.70135885, 0.7583618, 0.7804545, 0.7854912, 0.78667426, 0.78743863, 0.78070223]						)
											assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-1






					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[Any]						)			->	List[str]:




											'''simple docstring'''

											__snake_case				=		OnnxStableDiffusionUpscalePipeline.from_pretrained(self.hub_checkpoint     ,    provider="CPUExecutionProvider"						)
											__snake_case				=		EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config						)
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											__snake_case				=		np.array(
											    [0.77424496, 0.773601, 0.7645288, 0.7769598, 0.7772739, 0.7738688, 0.78187233, 0.77879584, 0.767043]						)

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






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


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		str						)			->	List[Any]:




											'''simple docstring'''

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


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple						)			->	Tuple:




											'''simple docstring'''

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


					def 							SCREAMING_SNAKE_CASE_  (						self	:		int						)			->	Optional[int]:




											'''simple docstring'''

											__snake_case				=		load_image(
											    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
											    "/img2img/sketch-mountains-input.jpg"						)
											__snake_case				=		init_image.resize((1_2_8, 1_2_8)						)
											# using the PNDM scheduler by default
											__snake_case				=		OnnxStableDiffusionUpscalePipeline.from_pretrained(
											    "ssube/stable-diffusion-x4-upscaler-onnx"     ,    provider=self.gpu_provider     ,    sess_options=self.gpu_options     ,    )
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

											__snake_case				=		"A fantasy landscape, trending on artstation"

											__snake_case				=		torch.manual_seed(0						)
											__snake_case				=		pipe(
											    prompt=SCREAMING_SNAKE_CASE     ,    image=SCREAMING_SNAKE_CASE     ,    guidance_scale=7.5     ,    num_inference_steps=1_0     ,    generator=SCREAMING_SNAKE_CASE     ,    output_type="np"     ,    )
											__snake_case				=		output.images
											__snake_case				=		images[0, 2_5_5:2_5_8, 3_8_3:3_8_6, -1]

											assert images.shape == (1, 5_1_2, 5_1_2, 3)
											__snake_case				=		np.array([0.4883, 0.4947, 0.4980, 0.4975, 0.4982, 0.4980, 0.5000, 0.5006, 0.4972]						)
											# 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	:		Tuple						)			->	Optional[int]:




											'''simple docstring'''

											__snake_case				=		load_image(
											    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
											    "/img2img/sketch-mountains-input.jpg"						)
											__snake_case				=		init_image.resize((1_2_8, 1_2_8)						)
											__snake_case				=		LMSDiscreteScheduler.from_pretrained(
											    "ssube/stable-diffusion-x4-upscaler-onnx"     ,    subfolder="scheduler"						)
											__snake_case				=		OnnxStableDiffusionUpscalePipeline.from_pretrained(
											    "ssube/stable-diffusion-x4-upscaler-onnx"     ,    scheduler=SCREAMING_SNAKE_CASE     ,    provider=self.gpu_provider     ,    sess_options=self.gpu_options     ,    )
											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

											__snake_case				=		"A fantasy landscape, trending on artstation"

											__snake_case				=		torch.manual_seed(0						)
											__snake_case				=		pipe(
											    prompt=SCREAMING_SNAKE_CASE     ,    image=SCREAMING_SNAKE_CASE     ,    guidance_scale=7.5     ,    num_inference_steps=2_0     ,    generator=SCREAMING_SNAKE_CASE     ,    output_type="np"     ,    )
											__snake_case				=		output.images
											__snake_case				=		images[0, 2_5_5:2_5_8, 3_8_3:3_8_6, -1]

											assert images.shape == (1, 5_1_2, 5_1_2, 3)
											__snake_case				=		np.array(
											    [0.50173753, 0.50223356, 0.502039, 0.50233036, 0.5023725, 0.5022601, 0.5018758, 0.50234085, 0.50241566]						)
											# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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





