


from typing import Dict, Iterable, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


lowerCAmelCase       		=    logging.get_logger(__name__)




class 							lowerCamelCase   (  _UpperCamelCase ):
	_lowerCAmelCase     :		int										=						['''pixel_values''']


	def __init__(    self				,     lowercase__ = True				,     lowercase__ = None				,     lowercase__ = PILImageResampling.BICUBIC				,     lowercase__ = True				,     lowercase__ = None				,     lowercase__ = True				,     lowercase__ = 1 / 2_5_5				,     lowercase__ = True				,     lowercase__ = IMAGENET_DEFAULT_MEAN				,     lowercase__ = IMAGENET_DEFAULT_STD				,     **lowercase__				,     ):
							super().__init__(**lowercase__)
							__UpperCAmelCase			:							List[str]	    =	size if size is not None else {'''shortest_edge''': 2_2_4}
							__UpperCAmelCase			:							str	    =	get_size_dict(lowercase__				,     default_to_square=lowercase__)
							__UpperCAmelCase			:							int	    =	crop_size if crop_size is not None else {'''height''': 2_2_4, '''width''': 2_2_4}
							__UpperCAmelCase			:							Optional[int]	    =	get_size_dict(lowercase__				,     param_name='''crop_size''')

							__UpperCAmelCase			:							Tuple	    =	do_resize
							__UpperCAmelCase			:							Optional[int]	    =	size
							__UpperCAmelCase			:							Dict	    =	resample
							__UpperCAmelCase			:							List[Any]	    =	do_center_crop
							__UpperCAmelCase			:							Any	    =	crop_size
							__UpperCAmelCase			:							Optional[int]	    =	do_rescale
							__UpperCAmelCase			:							Dict	    =	rescale_factor
							__UpperCAmelCase			:							List[str]	    =	do_normalize
							__UpperCAmelCase			:							str	    =	image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
							__UpperCAmelCase			:							Any	    =	image_std if image_std is not None else IMAGENET_DEFAULT_STD


	def  A(    self				,     lowercase__				,     lowercase__				,     lowercase__ = PILImageResampling.BICUBIC				,     lowercase__ = None				,     **lowercase__				,     ):
							__UpperCAmelCase			:							List[Any]	    =	get_size_dict(lowercase__				,     default_to_square=lowercase__)
							# size_dict is a dict with either keys "height" and "width" or "shortest_edge"
							if "shortest_edge" in size:
													__UpperCAmelCase			:							Dict	    =	int((2_5_6 / 2_2_4) * size['''shortest_edge'''])
													__UpperCAmelCase			:							List[str]	    =	get_resize_output_image_size(lowercase__				,     size=lowercase__				,     default_to_square=lowercase__)
													__UpperCAmelCase			:							Optional[Any]	    =	{'''height''': output_size[0], '''width''': output_size[1]}
							if "height" not in size_dict or "width" not in size_dict:
													raise ValueError(
													    F"Size dict must have keys 'height' and 'width' or 'shortest_edge'. Got {size_dict.keys()}")
							return resize(
							    lowercase__				,     size=(size_dict['''height'''], size_dict['''width'''])				,     resample=lowercase__				,     data_format=lowercase__				,     **lowercase__)


	def  A(    self				,     lowercase__				,     lowercase__				,     lowercase__ = None				,     **lowercase__				,     ):
							__UpperCAmelCase			:							List[str]	    =	get_size_dict(lowercase__)
							if "height" not in size or "width" not in size:
													raise ValueError(F"Size dict must have keys 'height' and 'width'. Got {size.keys()}")
							return center_crop(lowercase__				,     size=(size['''height'''], size['''width'''])				,     data_format=lowercase__				,     **lowercase__)


	def  A(    self				,     lowercase__				,     lowercase__				,     lowercase__ = None				,     **lowercase__				,     ):
							return rescale(lowercase__				,     scale=lowercase__				,     data_format=lowercase__				,     **lowercase__)


	def  A(    self				,     lowercase__				,     lowercase__				,     lowercase__				,     lowercase__ = None				,     **lowercase__				,     ):
							return normalize(lowercase__				,     mean=lowercase__				,     std=lowercase__				,     data_format=lowercase__				,     **lowercase__)


	def  A(    self				,     lowercase__				,     lowercase__ = None				,     lowercase__ = None				,     lowercase__ = None				,     lowercase__ = None				,     lowercase__ = None				,     lowercase__ = None				,     lowercase__ = None				,     lowercase__ = None				,     lowercase__ = None				,     lowercase__ = None				,     lowercase__ = None				,     lowercase__ = ChannelDimension.FIRST				,     **lowercase__				,     ):
							__UpperCAmelCase			:							Union[str, Any]	    =	do_resize if do_resize is not None else self.do_resize
							__UpperCAmelCase			:							Optional[int]	    =	resample if resample is not None else self.resample
							__UpperCAmelCase			:							List[Any]	    =	do_center_crop if do_center_crop is not None else self.do_center_crop
							__UpperCAmelCase			:							List[str]	    =	do_rescale if do_rescale is not None else self.do_rescale
							__UpperCAmelCase			:							Optional[Any]	    =	rescale_factor if rescale_factor is not None else self.rescale_factor
							__UpperCAmelCase			:							int	    =	do_normalize if do_normalize is not None else self.do_normalize
							__UpperCAmelCase			:							Any	    =	image_mean if image_mean is not None else self.image_mean
							__UpperCAmelCase			:							Optional[int]	    =	image_std if image_std is not None else self.image_std

							__UpperCAmelCase			:							Optional[Any]	    =	size if size is not None else self.size
							__UpperCAmelCase			:							Any	    =	get_size_dict(lowercase__				,     default_to_square=lowercase__)
							__UpperCAmelCase			:							int	    =	crop_size if crop_size is not None else self.crop_size
							__UpperCAmelCase			:							int	    =	get_size_dict(lowercase__				,     param_name='''crop_size''')

							__UpperCAmelCase			:							Tuple	    =	make_list_of_images(lowercase__)

							if not valid_images(lowercase__):
													raise ValueError(
													    '''Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '''
													    '''torch.Tensor, tf.Tensor or jax.ndarray.''')

							if do_resize and size is None:
													raise ValueError('''Size must be specified if do_resize is True.''')

							if do_center_crop and crop_size is None:
													raise ValueError('''Crop size must be specified if do_center_crop is True.''')

							if do_rescale and rescale_factor is None:
													raise ValueError('''Rescale factor must be specified if do_rescale is True.''')

							if do_normalize and (image_mean is None or image_std is None):
													raise ValueError('''Image mean and std must be specified if do_normalize is True.''')

							# All transformations expect numpy arrays.
							__UpperCAmelCase			:							List[str]	    =	[to_numpy_array(lowercase__) for image in images]

							if do_resize:
													__UpperCAmelCase			:							int	    =	[self.resize(lowercase__				,     lowercase__				,     lowercase__) for image in images]

							if do_center_crop:
													__UpperCAmelCase			:							int	    =	[self.center_crop(lowercase__				,     lowercase__) for image in images]

							if do_rescale:
													__UpperCAmelCase			:							List[str]	    =	[self.rescale(lowercase__				,     lowercase__) for image in images]

							if do_normalize:
													__UpperCAmelCase			:							str	    =	[self.normalize(lowercase__				,     lowercase__				,     lowercase__) for image in images]

							__UpperCAmelCase			:							int	    =	[to_channel_dimension_format(lowercase__				,     lowercase__) for image in images]

							__UpperCAmelCase			:							int	    =	{'''pixel_values''': images}
							return BatchFeature(data=lowercase__				,     tensor_type=lowercase__)





import tempfile
import unittest

import numpy as np

from diffusers import (
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionPipeline,
    PNDMScheduler,
)
from diffusers.utils.testing_utils import is_onnx_available, nightly, require_onnxruntime, require_torch_gpu

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
				import onnxruntime as ort




class 							lowerCamelCase   (  _UpperCamelCase							,						unittest.TestCase ):
	_lowerCAmelCase     :		int										=						'''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''


	def  A(    self				,     lowercase__=0):
							__UpperCAmelCase			:							str	    =	np.random.RandomState(lowercase__)
							__UpperCAmelCase			:							Dict	    =	{
							    '''prompt''': '''A painting of a squirrel eating a burger''',
							    '''generator''': generator,
							    '''num_inference_steps''': 2,
							    '''guidance_scale''': 7.5,
							    '''output_type''': '''numpy''',
							}
							return inputs


	def  A(    self):
							__UpperCAmelCase			:							Optional[Any]	    =	OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,     provider='''CPUExecutionProvider''')
							pipe.set_progress_bar_config(disable=lowercase__)

							__UpperCAmelCase			:							Tuple	    =	self.get_dummy_inputs()
							__UpperCAmelCase			:							int	    =	pipe(**lowercase__).images
							__UpperCAmelCase			:							Tuple	    =	image[0, -3:, -3:, -1]

							assert image.shape == (1, 1_2_8, 1_2_8, 3)
							__UpperCAmelCase			:							Optional[Any]	    =	np.array([0.6_5_0_7_2, 0.5_8_4_9_2, 0.4_8_2_1_9, 0.5_5_5_2_1, 0.5_3_1_8_0, 0.5_5_9_3_9, 0.5_0_6_9_7, 0.3_9_8_0_0, 0.4_6_4_5_5])

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


	def  A(    self):
							__UpperCAmelCase			:							Optional[int]	    =	OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,     provider='''CPUExecutionProvider''')
							__UpperCAmelCase			:							Optional[int]	    =	PNDMScheduler.from_config(pipe.scheduler.config				,     skip_prk_steps=lowercase__)
							pipe.set_progress_bar_config(disable=lowercase__)

							__UpperCAmelCase			:							Union[str, Any]	    =	self.get_dummy_inputs()
							__UpperCAmelCase			:							int	    =	pipe(**lowercase__).images
							__UpperCAmelCase			:							Optional[int]	    =	image[0, -3:, -3:, -1]

							assert image.shape == (1, 1_2_8, 1_2_8, 3)
							__UpperCAmelCase			:							List[str]	    =	np.array([0.6_5_8_6_3, 0.5_9_4_2_5, 0.4_9_3_2_6, 0.5_6_3_1_3, 0.5_3_8_7_5, 0.5_6_6_2_7, 0.5_1_0_6_5, 0.3_9_7_7_7, 0.4_6_3_3_0])

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


	def  A(    self):
							__UpperCAmelCase			:							Tuple	    =	OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,     provider='''CPUExecutionProvider''')
							__UpperCAmelCase			:							List[Any]	    =	LMSDiscreteScheduler.from_config(pipe.scheduler.config)
							pipe.set_progress_bar_config(disable=lowercase__)

							__UpperCAmelCase			:							Union[str, Any]	    =	self.get_dummy_inputs()
							__UpperCAmelCase			:							Union[str, Any]	    =	pipe(**lowercase__).images
							__UpperCAmelCase			:							Any	    =	image[0, -3:, -3:, -1]

							assert image.shape == (1, 1_2_8, 1_2_8, 3)
							__UpperCAmelCase			:							Union[str, Any]	    =	np.array([0.5_3_7_5_5, 0.6_0_7_8_6, 0.4_7_4_0_2, 0.4_9_4_8_8, 0.5_1_8_6_9, 0.4_9_8_1_9, 0.4_7_9_8_5, 0.3_8_9_5_7, 0.4_4_2_7_9])

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


	def  A(    self):
							__UpperCAmelCase			:							Dict	    =	OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,     provider='''CPUExecutionProvider''')
							__UpperCAmelCase			:							Optional[Any]	    =	EulerDiscreteScheduler.from_config(pipe.scheduler.config)
							pipe.set_progress_bar_config(disable=lowercase__)

							__UpperCAmelCase			:							Union[str, Any]	    =	self.get_dummy_inputs()
							__UpperCAmelCase			:							Optional[Any]	    =	pipe(**lowercase__).images
							__UpperCAmelCase			:							str	    =	image[0, -3:, -3:, -1]

							assert image.shape == (1, 1_2_8, 1_2_8, 3)
							__UpperCAmelCase			:							int	    =	np.array([0.5_3_7_5_5, 0.6_0_7_8_6, 0.4_7_4_0_2, 0.4_9_4_8_8, 0.5_1_8_6_9, 0.4_9_8_1_9, 0.4_7_9_8_5, 0.3_8_9_5_7, 0.4_4_2_7_9])

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


	def  A(    self):
							__UpperCAmelCase			:							List[str]	    =	OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,     provider='''CPUExecutionProvider''')
							__UpperCAmelCase			:							List[str]	    =	EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
							pipe.set_progress_bar_config(disable=lowercase__)

							__UpperCAmelCase			:							Dict	    =	self.get_dummy_inputs()
							__UpperCAmelCase			:							Optional[int]	    =	pipe(**lowercase__).images
							__UpperCAmelCase			:							Optional[Any]	    =	image[0, -3:, -3:, -1]

							assert image.shape == (1, 1_2_8, 1_2_8, 3)
							__UpperCAmelCase			:							Dict	    =	np.array([0.5_3_8_1_7, 0.6_0_8_1_2, 0.4_7_3_8_4, 0.4_9_5_3_0, 0.5_1_8_9_4, 0.4_9_8_1_4, 0.4_7_9_8_4, 0.3_8_9_5_8, 0.4_4_2_7_1])

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


	def  A(    self):
							__UpperCAmelCase			:							Union[str, Any]	    =	OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,     provider='''CPUExecutionProvider''')
							__UpperCAmelCase			:							List[Any]	    =	DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
							pipe.set_progress_bar_config(disable=lowercase__)

							__UpperCAmelCase			:							Optional[int]	    =	self.get_dummy_inputs()
							__UpperCAmelCase			:							Optional[Any]	    =	pipe(**lowercase__).images
							__UpperCAmelCase			:							List[str]	    =	image[0, -3:, -3:, -1]

							assert image.shape == (1, 1_2_8, 1_2_8, 3)
							__UpperCAmelCase			:							Dict	    =	np.array([0.5_3_8_9_5, 0.6_0_8_0_8, 0.4_7_9_3_3, 0.4_9_6_0_8, 0.5_1_8_8_6, 0.4_9_9_5_0, 0.4_8_0_5_3, 0.3_8_9_5_7, 0.4_4_2_0_0])

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


	def  A(    self):
							__UpperCAmelCase			:							Optional[int]	    =	OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,     provider='''CPUExecutionProvider''')
							pipe.set_progress_bar_config(disable=lowercase__)

							__UpperCAmelCase			:							Any	    =	self.get_dummy_inputs()
							__UpperCAmelCase			:							List[Any]	    =	3 * [inputs['''prompt''']]

							# forward
							__UpperCAmelCase			:							Dict	    =	pipe(**lowercase__)
							__UpperCAmelCase			:							List[Any]	    =	output.images[0, -3:, -3:, -1]

							__UpperCAmelCase			:							Union[str, Any]	    =	self.get_dummy_inputs()
							__UpperCAmelCase			:							Dict	    =	3 * [inputs.pop('''prompt''')]

							__UpperCAmelCase			:							Tuple	    =	pipe.tokenizer(
							    lowercase__				,     padding='''max_length'''				,     max_length=pipe.tokenizer.model_max_length				,     truncation=lowercase__				,     return_tensors='''np'''				,     )
							__UpperCAmelCase			:							Optional[Any]	    =	text_inputs['''input_ids''']

							__UpperCAmelCase			:							Union[str, Any]	    =	pipe.text_encoder(input_ids=text_inputs.astype(np.intaa))[0]

							__UpperCAmelCase			:							Union[str, Any]	    =	prompt_embeds

							# forward
							__UpperCAmelCase			:							Union[str, Any]	    =	pipe(**lowercase__)
							__UpperCAmelCase			:							Union[str, Any]	    =	output.images[0, -3:, -3:, -1]

							assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()).max() < 1e-4


	def  A(    self):
							__UpperCAmelCase			:							List[Any]	    =	OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint				,     provider='''CPUExecutionProvider''')
							pipe.set_progress_bar_config(disable=lowercase__)

							__UpperCAmelCase			:							int	    =	self.get_dummy_inputs()
							__UpperCAmelCase			:							Any	    =	3 * ['''this is a negative prompt''']
							__UpperCAmelCase			:							Optional[int]	    =	negative_prompt
							__UpperCAmelCase			:							List[Any]	    =	3 * [inputs['''prompt''']]

							# forward
							__UpperCAmelCase			:							Any	    =	pipe(**lowercase__)
							__UpperCAmelCase			:							str	    =	output.images[0, -3:, -3:, -1]

							__UpperCAmelCase			:							Optional[int]	    =	self.get_dummy_inputs()
							__UpperCAmelCase			:							Any	    =	3 * [inputs.pop('''prompt''')]

							__UpperCAmelCase			:							Optional[int]	    =	[]
							for p in [prompt, negative_prompt]:
													__UpperCAmelCase			:							str	    =	pipe.tokenizer(
													    lowercase__				,     padding='''max_length'''				,     max_length=pipe.tokenizer.model_max_length				,     truncation=lowercase__				,     return_tensors='''np'''				,     )
													__UpperCAmelCase			:							List[Any]	    =	text_inputs['''input_ids''']

													embeds.append(pipe.text_encoder(input_ids=text_inputs.astype(np.intaa))[0])

							__UpperCAmelCase    ,      __UpperCAmelCase			:							Optional[int]	    =	embeds

							# forward
							__UpperCAmelCase			:							Union[str, Any]	    =	pipe(**lowercase__)
							__UpperCAmelCase			:							str	    =	output.images[0, -3:, -3:, -1]

							assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()).max() < 1e-4






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


	@property
	def  A(    self):
							return (
							    "CUDAExecutionProvider",
							    {
							        "gpu_mem_limit": "15000000000",  # 15GB
							        "arena_extend_strategy": "kSameAsRequested",
							    },
							)


	@property
	def  A(    self):
							__UpperCAmelCase			:							Optional[Any]	    =	ort.SessionOptions()
							__UpperCAmelCase			:							List[Any]	    =	False
							return options


	def  A(    self):
							# using the PNDM scheduler by default
							__UpperCAmelCase			:							Tuple	    =	OnnxStableDiffusionPipeline.from_pretrained(
							    '''CompVis/stable-diffusion-v1-4'''				,     revision='''onnx'''				,     safety_checker=lowercase__				,     feature_extractor=lowercase__				,     provider=self.gpu_provider				,     sess_options=self.gpu_options				,     )
							sd_pipe.set_progress_bar_config(disable=lowercase__)

							__UpperCAmelCase			:							int	    =	'''A painting of a squirrel eating a burger'''
							np.random.seed(0)
							__UpperCAmelCase			:							Dict	    =	sd_pipe([prompt]				,     guidance_scale=6.0				,     num_inference_steps=1_0				,     output_type='''np''')
							__UpperCAmelCase			:							Dict	    =	output.images

							__UpperCAmelCase			:							str	    =	image[0, -3:, -3:, -1]

							assert image.shape == (1, 5_1_2, 5_1_2, 3)
							__UpperCAmelCase			:							List[str]	    =	np.array([0.0_4_5_2, 0.0_3_9_0, 0.0_0_8_7, 0.0_3_5_0, 0.0_6_1_7, 0.0_3_6_4, 0.0_5_4_4, 0.0_5_2_3, 0.0_7_2_0])

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


	def  A(    self):
							__UpperCAmelCase			:							Optional[Any]	    =	DDIMScheduler.from_pretrained(
							    '''runwayml/stable-diffusion-v1-5'''				,     subfolder='''scheduler'''				,     revision='''onnx''')
							__UpperCAmelCase			:							Dict	    =	OnnxStableDiffusionPipeline.from_pretrained(
							    '''runwayml/stable-diffusion-v1-5'''				,     revision='''onnx'''				,     scheduler=lowercase__				,     safety_checker=lowercase__				,     feature_extractor=lowercase__				,     provider=self.gpu_provider				,     sess_options=self.gpu_options				,     )
							sd_pipe.set_progress_bar_config(disable=lowercase__)

							__UpperCAmelCase			:							Any	    =	'''open neural network exchange'''
							__UpperCAmelCase			:							Any	    =	np.random.RandomState(0)
							__UpperCAmelCase			:							List[Any]	    =	sd_pipe([prompt]				,     guidance_scale=7.5				,     num_inference_steps=1_0				,     generator=lowercase__				,     output_type='''np''')
							__UpperCAmelCase			:							List[str]	    =	output.images
							__UpperCAmelCase			:							Optional[int]	    =	image[0, -3:, -3:, -1]

							assert image.shape == (1, 5_1_2, 5_1_2, 3)
							__UpperCAmelCase			:							int	    =	np.array([0.2_8_6_7, 0.1_9_7_4, 0.1_4_8_1, 0.7_2_9_4, 0.7_2_5_1, 0.6_6_6_7, 0.4_1_9_4, 0.5_6_4_2, 0.6_4_8_6])

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


	def  A(    self):
							__UpperCAmelCase			:							Union[str, Any]	    =	LMSDiscreteScheduler.from_pretrained(
							    '''runwayml/stable-diffusion-v1-5'''				,     subfolder='''scheduler'''				,     revision='''onnx''')
							__UpperCAmelCase			:							Union[str, Any]	    =	OnnxStableDiffusionPipeline.from_pretrained(
							    '''runwayml/stable-diffusion-v1-5'''				,     revision='''onnx'''				,     scheduler=lowercase__				,     safety_checker=lowercase__				,     feature_extractor=lowercase__				,     provider=self.gpu_provider				,     sess_options=self.gpu_options				,     )
							sd_pipe.set_progress_bar_config(disable=lowercase__)

							__UpperCAmelCase			:							Optional[Any]	    =	'''open neural network exchange'''
							__UpperCAmelCase			:							Optional[int]	    =	np.random.RandomState(0)
							__UpperCAmelCase			:							Dict	    =	sd_pipe([prompt]				,     guidance_scale=7.5				,     num_inference_steps=1_0				,     generator=lowercase__				,     output_type='''np''')
							__UpperCAmelCase			:							Union[str, Any]	    =	output.images
							__UpperCAmelCase			:							str	    =	image[0, -3:, -3:, -1]

							assert image.shape == (1, 5_1_2, 5_1_2, 3)
							__UpperCAmelCase			:							Optional[int]	    =	np.array([0.2_3_0_6, 0.1_9_5_9, 0.1_5_9_3, 0.6_5_4_9, 0.6_3_9_4, 0.5_4_0_8, 0.5_0_6_5, 0.6_0_1_0, 0.6_1_6_1])

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


	def  A(    self):
							__UpperCAmelCase			:							Tuple	    =	0

							def test_callback_fn(lowercase__				,     lowercase__				,     lowercase__) -> None:
													__UpperCAmelCase			:							Optional[Any]	    =	True
													nonlocal number_of_steps
													number_of_steps += 1
													if step == 0:
																			assert latents.shape == (1, 4, 6_4, 6_4)
																			__UpperCAmelCase			:							Union[str, Any]	    =	latents[0, -3:, -3:, -1]
																			__UpperCAmelCase			:							Optional[Any]	    =	np.array(
																			    [-0.6_7_7_2, -0.3_8_3_5, -1.2_4_5_6, 0.1_9_0_5, -1.0_9_7_4, 0.6_9_6_7, -1.9_3_5_3, 0.0_1_7_8, 1.0_1_6_7])

																			assert np.abs(latents_slice.flatten() - expected_slice).max() < 1e-3
													elif step == 5:
																			assert latents.shape == (1, 4, 6_4, 6_4)
																			__UpperCAmelCase			:							Union[str, Any]	    =	latents[0, -3:, -3:, -1]
																			__UpperCAmelCase			:							Dict	    =	np.array(
																			    [-0.3_3_5_1, 0.2_2_4_1, -0.1_8_3_7, -0.2_3_2_5, -0.6_5_7_7, 0.3_3_9_3, -0.0_2_4_1, 0.5_8_9_9, 1.3_8_7_5])

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

							__UpperCAmelCase			:							str	    =	False

							__UpperCAmelCase			:							List[str]	    =	OnnxStableDiffusionPipeline.from_pretrained(
							    '''runwayml/stable-diffusion-v1-5'''				,     revision='''onnx'''				,     safety_checker=lowercase__				,     feature_extractor=lowercase__				,     provider=self.gpu_provider				,     sess_options=self.gpu_options				,     )
							pipe.set_progress_bar_config(disable=lowercase__)

							__UpperCAmelCase			:							Union[str, Any]	    =	'''Andromeda galaxy in a bottle'''

							__UpperCAmelCase			:							List[Any]	    =	np.random.RandomState(0)
							pipe(
							    prompt=lowercase__				,     num_inference_steps=5				,     guidance_scale=7.5				,     generator=lowercase__				,     callback=lowercase__				,     callback_steps=1				,     )
							assert test_callback_fn.has_been_called
							assert number_of_steps == 6


	def  A(    self):
							__UpperCAmelCase			:							Union[str, Any]	    =	OnnxStableDiffusionPipeline.from_pretrained(
							    '''runwayml/stable-diffusion-v1-5'''				,     revision='''onnx'''				,     safety_checker=lowercase__				,     feature_extractor=lowercase__				,     provider=self.gpu_provider				,     sess_options=self.gpu_options				,     )
							assert isinstance(lowercase__				,     lowercase__)
							assert pipe.safety_checker is None

							__UpperCAmelCase			:							Union[str, Any]	    =	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(lowercase__)
													__UpperCAmelCase			:							List[Any]	    =	OnnxStableDiffusionPipeline.from_pretrained(lowercase__)

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

