


from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor




class 							lowerCamelCase   :


	def __init__(    self				,     lowercase__				,     lowercase__=3				,     lowercase__=3_2				,     lowercase__=3				,     lowercase__=1_0				,     lowercase__=[1_0, 2_0, 3_0, 4_0]				,     lowercase__=[1, 1, 2, 1]				,     lowercase__=True				,     lowercase__=True				,     lowercase__="relu"				,     lowercase__=3				,     lowercase__=None				,     ):
							__UpperCAmelCase			:							Optional[int]	    =	parent
							__UpperCAmelCase			:							Tuple	    =	batch_size
							__UpperCAmelCase			:							Any	    =	image_size
							__UpperCAmelCase			:							Optional[int]	    =	num_channels
							__UpperCAmelCase			:							Any	    =	embeddings_size
							__UpperCAmelCase			:							str	    =	hidden_sizes
							__UpperCAmelCase			:							Optional[Any]	    =	depths
							__UpperCAmelCase			:							Any	    =	is_training
							__UpperCAmelCase			:							Dict	    =	use_labels
							__UpperCAmelCase			:							Tuple	    =	hidden_act
							__UpperCAmelCase			:							Optional[Any]	    =	num_labels
							__UpperCAmelCase			:							Optional[Any]	    =	scope
							__UpperCAmelCase			:							List[str]	    =	len(lowercase__)


	def  A(    self):
							__UpperCAmelCase			:							Union[str, Any]	    =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

							__UpperCAmelCase			:							Union[str, Any]	    =	None
							if self.use_labels:
													__UpperCAmelCase			:							int	    =	ids_tensor([self.batch_size]				,     self.num_labels)

							__UpperCAmelCase			:							Union[str, Any]	    =	self.get_config()
							return config, pixel_values, labels


	def  A(    self):
							return RegNetConfig(
							    num_channels=self.num_channels				,     embeddings_size=self.embeddings_size				,     hidden_sizes=self.hidden_sizes				,     depths=self.depths				,     hidden_act=self.hidden_act				,     num_labels=self.num_labels				,     )


	def  A(    self				,     lowercase__				,     lowercase__				,     lowercase__):
							__UpperCAmelCase			:							Optional[Any]	    =	TFRegNetModel(config=lowercase__)
							__UpperCAmelCase			:							Union[str, Any]	    =	model(lowercase__				,     training=lowercase__)
							# expected last hidden states: B, C, H // 32, W // 32
							self.parent.assertEqual(
							    result.last_hidden_state.shape				,     (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2)				,     )


	def  A(    self				,     lowercase__				,     lowercase__				,     lowercase__):
							__UpperCAmelCase			:							int	    =	self.num_labels
							__UpperCAmelCase			:							List[str]	    =	TFRegNetForImageClassification(lowercase__)
							__UpperCAmelCase			:							Dict	    =	model(lowercase__				,     labels=lowercase__				,     training=lowercase__)
							self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels))


	def  A(    self):
							__UpperCAmelCase			:							Dict	    =	self.prepare_config_and_inputs()
							__UpperCAmelCase    ,      __UpperCAmelCase    ,      __UpperCAmelCase			:							Optional[Any]	    =	config_and_inputs
							__UpperCAmelCase			:							Optional[Any]	    =	{'''pixel_values''': pixel_values}
							return config, inputs_dict






@require_tf
class 							lowerCamelCase   (  _UpperCamelCase							,						_UpperCamelCase							,						unittest.TestCase ):
	_lowerCAmelCase     :		Tuple										=						(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
	_lowerCAmelCase     :		Any										=						(
	    {'''feature-extraction''': TFRegNetModel, '''image-classification''': TFRegNetForImageClassification}
	    if is_tf_available()
	    else {}
	)

	_lowerCAmelCase     :		Optional[Any]										=						False
	_lowerCAmelCase     :		Any										=						False
	_lowerCAmelCase     :		Optional[int]										=						False
	_lowerCAmelCase     :		List[str]										=						False
	_lowerCAmelCase     :		Any										=						False


	def  A(    self):
							__UpperCAmelCase			:							Tuple	    =	TFRegNetModelTester(self)
							__UpperCAmelCase			:							Optional[Any]	    =	ConfigTester(self				,     config_class=lowercase__				,     has_text_modality=lowercase__)


	def  A(    self):
							return


	@unittest.skip(reason='''RegNet does not use inputs_embeds''')
	def  A(    self):
							pass


	@unittest.skipIf(
	    not is_tf_available() or len(tf.config.list_physical_devices('''GPU''')) == 0				,     reason='''TF does not support backprop for grouped convolutions on CPU.'''				,     )
	@slow
	def  A(    self):
							super().test_keras_fit()


	@unittest.skip(reason='''RegNet does not support input and output embeddings''')
	def  A(    self):
							pass


	def  A(    self):
							__UpperCAmelCase    ,      __UpperCAmelCase			:							Tuple	    =	self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													__UpperCAmelCase			:							Optional[Any]	    =	model_class(lowercase__)
													__UpperCAmelCase			:							Union[str, Any]	    =	inspect.signature(model.call)
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													__UpperCAmelCase			:							Any	    =	[*signature.parameters.keys()]

													__UpperCAmelCase			:							Tuple	    =	['''pixel_values''']
													self.assertListEqual(arg_names[:1]				,     lowercase__)


	def  A(    self):
							__UpperCAmelCase			:							str	    =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowercase__)


	def  A(    self):
							def check_hidden_states_output(lowercase__				,     lowercase__				,     lowercase__):
													__UpperCAmelCase			:							Union[str, Any]	    =	model_class(lowercase__)
													__UpperCAmelCase			:							List[str]	    =	model(**self._prepare_for_class(lowercase__				,     lowercase__)				,     training=lowercase__)

													__UpperCAmelCase			:							int	    =	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													__UpperCAmelCase			:							List[Any]	    =	self.model_tester.num_stages
													self.assertEqual(len(lowercase__)				,     expected_num_stages + 1)

													# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
													self.assertListEqual(
													    list(hidden_states[0].shape[-2:])				,     [self.model_tester.image_size // 2, self.model_tester.image_size // 2]				,     )

							__UpperCAmelCase    ,      __UpperCAmelCase			:							Tuple	    =	self.model_tester.prepare_config_and_inputs_for_common()
							__UpperCAmelCase			:							List[Any]	    =	['''basic''', '''bottleneck''']
							for model_class in self.all_model_classes:
													for layer_type in layers_type:
																			__UpperCAmelCase			:							Optional[int]	    =	layer_type
																			__UpperCAmelCase			:							int	    =	True
																			check_hidden_states_output(lowercase__				,     lowercase__				,     lowercase__)

																			# check that output_hidden_states also work using config
																			del inputs_dict["output_hidden_states"]
																			__UpperCAmelCase			:							List[str]	    =	True

																			check_hidden_states_output(lowercase__				,     lowercase__				,     lowercase__)


	def  A(    self):
							__UpperCAmelCase    ,      __UpperCAmelCase			:							int	    =	self.model_tester.prepare_config_and_inputs_for_common()

							def check_equivalence(lowercase__				,     lowercase__				,     lowercase__				,     lowercase__={}):
													__UpperCAmelCase			:							Dict	    =	model(lowercase__				,     return_dict=lowercase__				,     **lowercase__)
													__UpperCAmelCase			:							int	    =	model(lowercase__				,     return_dict=lowercase__				,     **lowercase__).to_tuple()

													def recursive_check(lowercase__				,     lowercase__):
																			if isinstance(lowercase__				,     (List, Tuple)):
																									for tuple_iterable_value, dict_iterable_value in zip(lowercase__				,     lowercase__):
																															recursive_check(lowercase__				,     lowercase__)
																			elif tuple_object is None:
																									return
																			else:
																									self.assertTrue(
																									    all(tf.equal(lowercase__				,     lowercase__))				,     msg=(
																									        '''Tuple and dict output are not equal. Difference:'''
																									        F" {tf.math.reduce_max(tf.abs(tuple_object - dict_object))}"
																									    )				,     )

																			recursive_check(lowercase__				,     lowercase__)

							for model_class in self.all_model_classes:
													__UpperCAmelCase			:							Optional[Any]	    =	model_class(lowercase__)

													__UpperCAmelCase			:							List[str]	    =	self._prepare_for_class(lowercase__				,     lowercase__)
													__UpperCAmelCase			:							Any	    =	self._prepare_for_class(lowercase__				,     lowercase__)
													check_equivalence(lowercase__				,     lowercase__				,     lowercase__)

													__UpperCAmelCase			:							Dict	    =	self._prepare_for_class(lowercase__				,     lowercase__				,     return_labels=lowercase__)
													__UpperCAmelCase			:							Optional[int]	    =	self._prepare_for_class(lowercase__				,     lowercase__				,     return_labels=lowercase__)
													check_equivalence(lowercase__				,     lowercase__				,     lowercase__)

													__UpperCAmelCase			:							Tuple	    =	self._prepare_for_class(lowercase__				,     lowercase__)
													__UpperCAmelCase			:							Any	    =	self._prepare_for_class(lowercase__				,     lowercase__)
													check_equivalence(lowercase__				,     lowercase__				,     lowercase__				,     {'''output_hidden_states''': True})

													__UpperCAmelCase			:							Dict	    =	self._prepare_for_class(lowercase__				,     lowercase__				,     return_labels=lowercase__)
													__UpperCAmelCase			:							str	    =	self._prepare_for_class(lowercase__				,     lowercase__				,     return_labels=lowercase__)
													check_equivalence(lowercase__				,     lowercase__				,     lowercase__				,     {'''output_hidden_states''': True})


	def  A(    self):
							__UpperCAmelCase			:							str	    =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*lowercase__)


	@slow
	def  A(    self):
							for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__UpperCAmelCase			:							int	    =	TFRegNetModel.from_pretrained(lowercase__)
													self.assertIsNotNone(lowercase__)






def     __SCREAMING_SNAKE_CASE							(       )		->     List[Any]:




						'''simple docstring'''







						__UpperCAmelCase			:							str	    =	Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
						return image





@require_tf
@require_vision
class 							lowerCamelCase   (  unittest.TestCase ):


	@cached_property
	def  A(    self):
							return (
							    AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0])
							    if is_vision_available()
							    else None
							)


	@slow
	def  A(    self):
							__UpperCAmelCase			:							Optional[int]	    =	TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0])

							__UpperCAmelCase			:							Tuple	    =	self.default_image_processor
							__UpperCAmelCase			:							str	    =	prepare_img()
							__UpperCAmelCase			:							Tuple	    =	image_processor(images=lowercase__				,     return_tensors='''tf''')

							# forward pass
							__UpperCAmelCase			:							Tuple	    =	model(**lowercase__				,     training=lowercase__)

							# verify the logits
							__UpperCAmelCase			:							Tuple	    =	tf.TensorShape((1, 1_0_0_0))
							self.assertEqual(outputs.logits.shape				,     lowercase__)

							__UpperCAmelCase			:							Any	    =	tf.constant([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6])

							tf.debugging.assert_near(outputs.logits[0, :3]				,     lowercase__				,     atol=1e-4)





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

