





"""simple docstring"""






import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotSmallConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
		import os

		# The slow tests are often failing with OOM error on GPU
		# This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
		# but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
		A	     =					'''platform'''

		import jax
		import jax.numpy as jnp

		from transformers.models.blenderbot_small.modeling_flax_blenderbot_small import (
		    FlaxBlenderbotSmallForConditionalGeneration,
		    FlaxBlenderbotSmallModel,
		    shift_tokens_right,
		)

def       __A (     a_  :Dict				,    a_  :Optional[int]				,    a_  :Tuple=None				,    a_  :Dict=None				,    a_  :Tuple=None				,    a_  :List[str]=None				,    a_  :Optional[int]=None				,    a_  :int=None				,    )						->						Any:
				if attention_mask is None:
								__a	:  str         =					np.where(input_ids != config.pad_token_id				,    1				,    0)
				if decoder_attention_mask is None:
								__a	:  int         =					np.where(decoder_input_ids != config.pad_token_id				,    1				,    0)
				if head_mask is None:
								__a	:  int         =					np.ones((config.encoder_layers, config.encoder_attention_heads))
				if decoder_head_mask is None:
								__a	:  List[str]         =					np.ones((config.decoder_layers, config.decoder_attention_heads))
				if cross_attn_head_mask is None:
								__a	:  List[str]         =					np.ones((config.decoder_layers, config.decoder_attention_heads))
				return {
				    "input_ids": input_ids,
				    "decoder_input_ids": decoder_input_ids,
				    "attention_mask": attention_mask,
				    "decoder_attention_mask": attention_mask,
				}




class 			__lowercase     :







					'''simple docstring'''




					def __init__(  self		,     _UpperCAmelCase		,     _UpperCAmelCase=13		,     _UpperCAmelCase=7		,     _UpperCAmelCase=True		,     _UpperCAmelCase=False		,     _UpperCAmelCase=99		,     _UpperCAmelCase=16		,     _UpperCAmelCase=2		,     _UpperCAmelCase=4		,     _UpperCAmelCase=4		,     _UpperCAmelCase="gelu"		,     _UpperCAmelCase=0.1		,     _UpperCAmelCase=0.1		,     _UpperCAmelCase=32		,     _UpperCAmelCase=2		,     _UpperCAmelCase=1		,     _UpperCAmelCase=0		,     _UpperCAmelCase=0.0_2		,     ):
									__a	:  Dict         =					parent
									__a	:  Optional[int]         =					batch_size
									__a	:  str         =					seq_length
									__a	:  int         =					is_training
									__a	:  Optional[int]         =					use_labels
									__a	:  Any         =					vocab_size
									__a	:  str         =					hidden_size
									__a	:  Any         =					num_hidden_layers
									__a	:  Any         =					num_attention_heads
									__a	:  Union[str, Any]         =					intermediate_size
									__a	:  List[str]         =					hidden_act
									__a	:  Any         =					hidden_dropout_prob
									__a	:  Optional[int]         =					attention_probs_dropout_prob
									__a	:  Dict         =					max_position_embeddings
									__a	:  str         =					eos_token_id
									__a	:  Optional[int]         =					pad_token_id
									__a	:  List[Any]         =					bos_token_id
									__a	:  Tuple         =					initializer_range







					def 	_lowerCamelCase						(  self       ):
									__a	:  Tuple         =					np.clip(ids_tensor([self.batch_size, self.seq_length - 1]		,     self.vocab_size       )		,     3		,     self.vocab_size       )
									__a	:  int         =					np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)		,     dtype=np.intaa       ))		,     -1       )

									__a	:  int         =					shift_tokens_right(_UpperCAmelCase		,     1		,     2       )

									__a	:  Tuple         =					BlenderbotSmallConfig(
									    vocab_size=self.vocab_size		,     d_model=self.hidden_size		,     encoder_layers=self.num_hidden_layers		,     decoder_layers=self.num_hidden_layers		,     encoder_attention_heads=self.num_attention_heads		,     decoder_attention_heads=self.num_attention_heads		,     encoder_ffn_dim=self.intermediate_size		,     decoder_ffn_dim=self.intermediate_size		,     dropout=self.hidden_dropout_prob		,     attention_dropout=self.attention_probs_dropout_prob		,     max_position_embeddings=self.max_position_embeddings		,     eos_token_id=self.eos_token_id		,     bos_token_id=self.bos_token_id		,     pad_token_id=self.pad_token_id		,     initializer_range=self.initializer_range		,     use_cache=_UpperCAmelCase		,     )
									__a	:  str         =					prepare_blenderbot_inputs_dict(_UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       )
									return config, inputs_dict







					def 	_lowerCamelCase						(  self       ):
									__a    ,  __a	:  Any         =					self.prepare_config_and_inputs()
									return config, inputs_dict







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
									__a	:  Dict         =					20
									__a	:  List[Any]         =					model_class_name(_UpperCAmelCase       )

									__a	:  Any         =					model.encode(inputs_dict['''input_ids''']       )

									__a    ,  __a	:  List[Any]         =					(
									    inputs_dict['''decoder_input_ids'''],
									    inputs_dict['''decoder_attention_mask'''],
									)

									__a	:  Union[str, Any]         =					model.init_cache(decoder_input_ids.shape[0]		,     _UpperCAmelCase		,     _UpperCAmelCase       )
									__a	:  Union[str, Any]         =					jnp.ones((decoder_input_ids.shape[0], max_decoder_length)		,     dtype='''i4'''       )

									__a	:  List[str]         =					jnp.broadcast_to(
									    jnp.arange(decoder_input_ids.shape[-1] - 1       )[None, :]		,     (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)		,     )
									__a	:  Dict         =					model.decode(
									    decoder_input_ids[:, :-1]		,     _UpperCAmelCase		,     decoder_attention_mask=_UpperCAmelCase		,     past_key_values=_UpperCAmelCase		,     decoder_position_ids=_UpperCAmelCase		,     )

									__a	:  Optional[int]         =					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]		,     dtype='''i4'''       )
									__a	:  str         =					model.decode(
									    decoder_input_ids[:, -1:]		,     _UpperCAmelCase		,     decoder_attention_mask=_UpperCAmelCase		,     past_key_values=outputs_cache.past_key_values		,     decoder_position_ids=_UpperCAmelCase		,     )

									__a	:  Union[str, Any]         =					model.decode(_UpperCAmelCase		,     _UpperCAmelCase       )

									__a	:  Union[str, Any]         =					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])       )       )
									self.parent.assertTrue(diff < 1e-3		,     msg=f"""Max diff is {diff}"""       )







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
									__a	:  Optional[Any]         =					20
									__a	:  Optional[Any]         =					model_class_name(_UpperCAmelCase       )

									__a	:  Optional[int]         =					model.encode(inputs_dict['''input_ids''']       )

									__a    ,  __a	:  Tuple         =					(
									    inputs_dict['''decoder_input_ids'''],
									    inputs_dict['''decoder_attention_mask'''],
									)

									__a	:  Optional[Any]         =					jnp.concatenate(
									    [
									        decoder_attention_mask,
									        jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])       ),
									    ]		,     axis=-1		,     )

									__a	:  Any         =					model.init_cache(decoder_input_ids.shape[0]		,     _UpperCAmelCase		,     _UpperCAmelCase       )
									__a	:  int         =					jnp.broadcast_to(
									    jnp.arange(decoder_input_ids.shape[-1] - 1       )[None, :]		,     (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)		,     )

									__a	:  Optional[int]         =					model.decode(
									    decoder_input_ids[:, :-1]		,     _UpperCAmelCase		,     decoder_attention_mask=_UpperCAmelCase		,     past_key_values=_UpperCAmelCase		,     decoder_position_ids=_UpperCAmelCase		,     )
									__a	:  Any         =					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]		,     dtype='''i4'''       )
									__a	:  Optional[int]         =					model.decode(
									    decoder_input_ids[:, -1:]		,     _UpperCAmelCase		,     past_key_values=outputs_cache.past_key_values		,     decoder_attention_mask=_UpperCAmelCase		,     decoder_position_ids=_UpperCAmelCase		,     )

									__a	:  int         =					model.decode(_UpperCAmelCase		,     _UpperCAmelCase		,     decoder_attention_mask=_UpperCAmelCase       )

									__a	:  Optional[Any]         =					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])       )       )
									self.parent.assertTrue(diff < 1e-3		,     msg=f"""Max diff is {diff}"""       )






@require_flax
class 			__lowercase     (     unittest.TestCase							):







					'''simple docstring'''




					__lowerCAmelCase					=					99







					def 	_lowerCamelCase						(  self       ):
									__a	:  List[Any]         =					np.array(
									    [
									        [71, 82, 18, 33, 46, 91, 2],
									        [68, 34, 26, 58, 30, 82, 2],
									        [5, 97, 17, 39, 94, 40, 2],
									        [76, 83, 94, 25, 70, 78, 2],
									        [87, 59, 41, 35, 48, 66, 2],
									        [55, 13, 16, 58, 5, 2, 1],  # note padding
									        [64, 27, 31, 51, 12, 75, 2],
									        [52, 64, 86, 17, 83, 39, 2],
									        [48, 61, 9, 24, 71, 82, 2],
									        [26, 1, 60, 48, 22, 13, 2],
									        [21, 5, 62, 28, 14, 76, 2],
									        [45, 98, 37, 86, 59, 48, 2],
									        [70, 70, 50, 9, 28, 0, 2],
									    ]		,     dtype=np.intaa		,     )

									__a	:  Dict         =					input_ids.shape[0]
									__a	:  Optional[Any]         =					BlenderbotSmallConfig(
									    vocab_size=self.vocab_size		,     d_model=24		,     encoder_layers=2		,     decoder_layers=2		,     encoder_attention_heads=2		,     decoder_attention_heads=2		,     encoder_ffn_dim=32		,     decoder_ffn_dim=32		,     max_position_embeddings=48		,     eos_token_id=2		,     pad_token_id=1		,     bos_token_id=0		,     )
									return config, input_ids, batch_size







					def 	_lowerCamelCase						(  self       ):
									__a    ,  __a    ,  __a	:  Tuple         =					self._get_config_and_data()
									__a	:  List[Any]         =					FlaxBlenderbotSmallForConditionalGeneration(_UpperCAmelCase       )
									__a	:  Tuple         =					lm_model(input_ids=_UpperCAmelCase       )
									__a	:  List[Any]         =					(batch_size, input_ids.shape[1], config.vocab_size)
									self.assertEqual(outputs['''logits'''].shape		,     _UpperCAmelCase       )







					def 	_lowerCamelCase						(  self       ):
									__a	:  str         =					BlenderbotSmallConfig(
									    vocab_size=self.vocab_size		,     d_model=14		,     encoder_layers=2		,     decoder_layers=2		,     encoder_attention_heads=2		,     decoder_attention_heads=2		,     encoder_ffn_dim=8		,     decoder_ffn_dim=8		,     max_position_embeddings=48		,     )
									__a	:  Optional[Any]         =					FlaxBlenderbotSmallForConditionalGeneration(_UpperCAmelCase       )
									__a	:  Optional[Any]         =					np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]		,     dtype=np.intaa       )
									__a	:  Optional[Any]         =					np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]		,     dtype=np.intaa       )
									__a	:  Optional[int]         =					lm_model(input_ids=_UpperCAmelCase		,     decoder_input_ids=_UpperCAmelCase       )
									__a	:  str         =					(*summary.shape, config.vocab_size)
									self.assertEqual(outputs['''logits'''].shape		,     _UpperCAmelCase       )







					def 	_lowerCamelCase						(  self       ):
									__a	:  List[Any]         =					np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]		,     dtype=np.intaa       )
									__a	:  Union[str, Any]         =					shift_tokens_right(_UpperCAmelCase		,     1		,     2       )
									__a	:  Any         =					np.equal(_UpperCAmelCase		,     1       ).astype(np.floataa       ).sum()
									__a	:  Tuple         =					np.equal(_UpperCAmelCase		,     1       ).astype(np.floataa       ).sum()
									self.assertEqual(shifted.shape		,     input_ids.shape       )
									self.assertEqual(_UpperCAmelCase		,     n_pad_before - 1       )
									self.assertTrue(np.equal(shifted[:, 0]		,     2       ).all()       )






@require_flax
class 			__lowercase     (     _UpperCamelCase				, unittest.TestCase				, _UpperCamelCase							):







					'''simple docstring'''




					__lowerCAmelCase					=					True
					__lowerCAmelCase					=					(
					    (
					        FlaxBlenderbotSmallModel,
					        FlaxBlenderbotSmallForConditionalGeneration,
					    )
					    if is_flax_available()
					    else ()
					)
					__lowerCAmelCase					=					(FlaxBlenderbotSmallForConditionalGeneration,) if is_flax_available() else ()







					def 	_lowerCamelCase						(  self       ):
									__a	:  Any         =					FlaxBlenderbotSmallModelTester(self       )







					def 	_lowerCamelCase						(  self       ):
									__a    ,  __a	:  str         =					self.model_tester.prepare_config_and_inputs()
									for model_class in self.all_model_classes:
													self.model_tester.check_use_cache_forward(_UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       )







					def 	_lowerCamelCase						(  self       ):
									__a    ,  __a	:  Optional[Any]         =					self.model_tester.prepare_config_and_inputs()
									for model_class in self.all_model_classes:
													self.model_tester.check_use_cache_forward_with_attn_mask(_UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       )







					def 	_lowerCamelCase						(  self       ):
									__a    ,  __a	:  int         =					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													with self.subTest(model_class.__name__       ):
																	__a	:  Optional[int]         =					self._prepare_for_class(_UpperCAmelCase		,     _UpperCAmelCase       )
																	__a	:  Union[str, Any]         =					model_class(_UpperCAmelCase       )

																	@jax.jit
																	def encode_jitted(_UpperCAmelCase		,     _UpperCAmelCase=None		,     **_UpperCAmelCase       ):
																					return model.encode(input_ids=_UpperCAmelCase		,     attention_mask=_UpperCAmelCase       )

																	with self.subTest('''JIT Enabled'''       ):
																					__a	:  List[Any]         =					encode_jitted(**_UpperCAmelCase       ).to_tuple()

																	with self.subTest('''JIT Disabled'''       ):
																					with jax.disable_jit():
																									__a	:  str         =					encode_jitted(**_UpperCAmelCase       ).to_tuple()

																	self.assertEqual(len(_UpperCAmelCase       )		,     len(_UpperCAmelCase       )       )
																	for jitted_output, output in zip(_UpperCAmelCase		,     _UpperCAmelCase       ):
																					self.assertEqual(jitted_output.shape		,     output.shape       )







					def 	_lowerCamelCase						(  self       ):
									__a    ,  __a	:  Dict         =					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													with self.subTest(model_class.__name__       ):
																	__a	:  Dict         =					model_class(_UpperCAmelCase       )
																	__a	:  int         =					model.encode(inputs_dict['''input_ids''']		,     inputs_dict['''attention_mask''']       )

																	__a	:  List[str]         =					{
																	    '''decoder_input_ids''': inputs_dict['''decoder_input_ids'''],
																	    '''decoder_attention_mask''': inputs_dict['''decoder_attention_mask'''],
																	    '''encoder_outputs''': encoder_outputs,
																	}

																	@jax.jit
																	def decode_jitted(_UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
																					return model.decode(
																					    decoder_input_ids=_UpperCAmelCase		,     decoder_attention_mask=_UpperCAmelCase		,     encoder_outputs=_UpperCAmelCase		,     )

																	with self.subTest('''JIT Enabled'''       ):
																					__a	:  Tuple         =					decode_jitted(**_UpperCAmelCase       ).to_tuple()

																	with self.subTest('''JIT Disabled'''       ):
																					with jax.disable_jit():
																									__a	:  Any         =					decode_jitted(**_UpperCAmelCase       ).to_tuple()

																	self.assertEqual(len(_UpperCAmelCase       )		,     len(_UpperCAmelCase       )       )
																	for jitted_output, output in zip(_UpperCAmelCase		,     _UpperCAmelCase       ):
																					self.assertEqual(jitted_output.shape		,     output.shape       )







					@slow
					def 	_lowerCamelCase						(  self       ):
									for model_class_name in self.all_model_classes:
													__a	:  Tuple         =					model_class_name.from_pretrained('''facebook/blenderbot_small-90M'''       )
													# FlaxBlenderbotForSequenceClassification expects eos token in input_ids
													__a	:  Dict         =					np.ones((1, 1)       ) * model.config.eos_token_id
													__a	:  Union[str, Any]         =					model(_UpperCAmelCase       )
													self.assertIsNotNone(_UpperCAmelCase       )






"""simple docstring"""






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 			__lowercase     (     _UpperCamelCase				, unittest.TestCase							):







					'''simple docstring'''




					__lowerCAmelCase					=					'''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase=0       ):
									__a	:  Tuple         =					floats_tensor((1, 3, 128, 128)		,     rng=random.Random(_UpperCAmelCase       )       )
									__a	:  Any         =					np.random.RandomState(_UpperCAmelCase       )
									__a	:  Any         =					{
									    '''prompt''': '''A painting of a squirrel eating a burger''',
									    '''image''': image,
									    '''generator''': generator,
									    '''num_inference_steps''': 3,
									    '''strength''': 0.7_5,
									    '''guidance_scale''': 7.5,
									    '''output_type''': '''numpy''',
									}
									return inputs







					def 	_lowerCamelCase						(  self       ):
									__a	:  int         =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,     provider='''CPUExecutionProvider'''       )
									pipe.set_progress_bar_config(disable=_UpperCAmelCase       )

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

									assert image.shape == (1, 128, 128, 3)
									__a	:  List[Any]         =					np.array([0.6_9_6_4_3, 0.5_8_4_8_4, 0.5_0_3_1_4, 0.5_8_7_6_0, 0.5_5_3_6_8, 0.5_9_6_4_3, 0.5_1_5_2_9, 0.4_1_2_1_7, 0.4_9_0_8_7]       )
									assert np.abs(image_slice - expected_slice       ).max() < 1e-1







					def 	_lowerCamelCase						(  self       ):
									__a	:  int         =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,     provider='''CPUExecutionProvider'''       )
									__a	:  Tuple         =					PNDMScheduler.from_config(pipe.scheduler.config		,     skip_prk_steps=_UpperCAmelCase       )
									pipe.set_progress_bar_config(disable=_UpperCAmelCase       )

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

									assert image.shape == (1, 128, 128, 3)
									__a	:  Optional[int]         =					np.array([0.6_1_7_3_7, 0.5_4_6_4_2, 0.5_3_1_8_3, 0.5_4_4_6_5, 0.5_2_7_4_2, 0.6_0_5_2_5, 0.4_9_9_6_9, 0.4_0_6_5_5, 0.4_8_1_5_4]       )

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







					def 	_lowerCamelCase						(  self       ):
									__a	:  List[str]         =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,     provider='''CPUExecutionProvider'''       )
									__a	:  Any         =					LMSDiscreteScheduler.from_config(pipe.scheduler.config       )
									pipe.set_progress_bar_config(disable=_UpperCAmelCase       )

									# warmup pass to apply optimizations
									__a	:  Any         =					pipe(**self.get_dummy_inputs()       )

									__a	:  List[str]         =					self.get_dummy_inputs()
									__a	:  Tuple         =					pipe(**_UpperCAmelCase       ).images
									__a	:  Tuple         =					image[0, -3:, -3:, -1]

									assert image.shape == (1, 128, 128, 3)
									__a	:  int         =					np.array([0.5_2_7_6_1, 0.5_9_9_7_7, 0.4_9_0_3_3, 0.4_9_6_1_9, 0.5_4_2_8_2, 0.5_0_3_1_1, 0.4_7_6_0_0, 0.4_0_9_1_8, 0.4_5_2_0_3]       )

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







					def 	_lowerCamelCase						(  self       ):
									__a	:  int         =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,     provider='''CPUExecutionProvider'''       )
									__a	:  Any         =					EulerDiscreteScheduler.from_config(pipe.scheduler.config       )
									pipe.set_progress_bar_config(disable=_UpperCAmelCase       )

									__a	:  List[Any]         =					self.get_dummy_inputs()
									__a	:  Any         =					pipe(**_UpperCAmelCase       ).images
									__a	:  List[Any]         =					image[0, -3:, -3:, -1]

									assert image.shape == (1, 128, 128, 3)
									__a	:  Optional[Any]         =					np.array([0.5_2_9_1_1, 0.6_0_0_0_4, 0.4_9_2_2_9, 0.4_9_8_0_5, 0.5_4_5_0_2, 0.5_0_6_8_0, 0.4_7_7_7_7, 0.4_1_0_2_8, 0.4_5_3_0_4]       )

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







					def 	_lowerCamelCase						(  self       ):
									__a	:  int         =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,     provider='''CPUExecutionProvider'''       )
									__a	:  Any         =					EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config       )
									pipe.set_progress_bar_config(disable=_UpperCAmelCase       )

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

									assert image.shape == (1, 128, 128, 3)
									__a	:  Optional[int]         =					np.array([0.5_2_9_1_1, 0.6_0_0_0_4, 0.4_9_2_2_9, 0.4_9_8_0_5, 0.5_4_5_0_2, 0.5_0_6_8_0, 0.4_7_7_7_7, 0.4_1_0_2_8, 0.4_5_3_0_4]       )

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







					def 	_lowerCamelCase						(  self       ):
									__a	:  int         =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint		,     provider='''CPUExecutionProvider'''       )
									__a	:  str         =					DPMSolverMultistepScheduler.from_config(pipe.scheduler.config       )
									pipe.set_progress_bar_config(disable=_UpperCAmelCase       )

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

									assert image.shape == (1, 128, 128, 3)
									__a	:  Optional[Any]         =					np.array([0.6_5_3_3_1, 0.5_8_2_7_7, 0.4_8_2_0_4, 0.5_6_0_5_9, 0.5_3_6_6_5, 0.5_6_2_3_5, 0.5_0_9_6_9, 0.4_0_0_0_9, 0.4_6_5_5_2]       )

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






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







					'''simple docstring'''




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







					@property
					def 	_lowerCamelCase						(  self       ):
									__a	:  Optional[Any]         =					ort.SessionOptions()
									__a	:  Any         =					False
									return options







					def 	_lowerCamelCase						(  self       ):
									__a	:  str         =					load_image(
									    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
									    '''/img2img/sketch-mountains-input.jpg'''       )
									__a	:  Tuple         =					init_image.resize((768, 512)       )
									# using the PNDM scheduler by default
									__a	:  List[str]         =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(
									    '''CompVis/stable-diffusion-v1-4'''		,     revision='''onnx'''		,     safety_checker=_UpperCAmelCase		,     feature_extractor=_UpperCAmelCase		,     provider=self.gpu_provider		,     sess_options=self.gpu_options		,     )
									pipe.set_progress_bar_config(disable=_UpperCAmelCase       )

									__a	:  Tuple         =					'''A fantasy landscape, trending on artstation'''

									__a	:  Tuple         =					np.random.RandomState(0       )
									__a	:  int         =					pipe(
									    prompt=_UpperCAmelCase		,     image=_UpperCAmelCase		,     strength=0.7_5		,     guidance_scale=7.5		,     num_inference_steps=10		,     generator=_UpperCAmelCase		,     output_type='''np'''		,     )
									__a	:  List[Any]         =					output.images
									__a	:  int         =					images[0, 255:258, 383:386, -1]

									assert images.shape == (1, 512, 768, 3)
									__a	:  Any         =					np.array([0.4_9_0_9, 0.5_0_5_9, 0.5_3_7_2, 0.4_6_2_3, 0.4_8_7_6, 0.5_0_4_9, 0.4_8_2_0, 0.4_9_5_6, 0.5_0_1_9]       )
									# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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







					def 	_lowerCamelCase						(  self       ):
									__a	:  List[str]         =					load_image(
									    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
									    '''/img2img/sketch-mountains-input.jpg'''       )
									__a	:  Tuple         =					init_image.resize((768, 512)       )
									__a	:  str         =					LMSDiscreteScheduler.from_pretrained(
									    '''runwayml/stable-diffusion-v1-5'''		,     subfolder='''scheduler'''		,     revision='''onnx'''       )
									__a	:  Optional[int]         =					OnnxStableDiffusionImgaImgPipeline.from_pretrained(
									    '''runwayml/stable-diffusion-v1-5'''		,     revision='''onnx'''		,     scheduler=_UpperCAmelCase		,     safety_checker=_UpperCAmelCase		,     feature_extractor=_UpperCAmelCase		,     provider=self.gpu_provider		,     sess_options=self.gpu_options		,     )
									pipe.set_progress_bar_config(disable=_UpperCAmelCase       )

									__a	:  List[str]         =					'''A fantasy landscape, trending on artstation'''

									__a	:  str         =					np.random.RandomState(0       )
									__a	:  str         =					pipe(
									    prompt=_UpperCAmelCase		,     image=_UpperCAmelCase		,     strength=0.7_5		,     guidance_scale=7.5		,     num_inference_steps=20		,     generator=_UpperCAmelCase		,     output_type='''np'''		,     )
									__a	:  Dict         =					output.images
									__a	:  List[Any]         =					images[0, 255:258, 383:386, -1]

									assert images.shape == (1, 512, 768, 3)
									__a	:  Dict         =					np.array([0.8_0_4_3, 0.9_2_6, 0.9_5_8_1, 0.8_1_1_9, 0.8_9_5_4, 0.9_1_3, 0.7_2_0_9, 0.7_4_6_3, 0.7_4_3_1]       )
									# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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