
'''simple docstring'''


import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


__lowercase							:   Optional[int]					=     False

@skip_mps
class 	__lowercase				(  _lowercase      ,     _lowercase      ,     _lowercase      ,     unittest.TestCase    ):
			lowerCamelCase			:		Any	      =			StableDiffusionAttendAndExcitePipeline
			lowerCamelCase			:		Union[str, Any]	      =			False
			lowerCamelCase			:		int	      =			TEXT_TO_IMAGE_PARAMS
			lowerCamelCase			:		Any	      =			TEXT_TO_IMAGE_BATCH_PARAMS.union({"token_indices"}    )
			lowerCamelCase			:		Any	      =			TEXT_TO_IMAGE_IMAGE_PARAMS
			lowerCamelCase			:		Optional[int]	      =			TEXT_TO_IMAGE_IMAGE_PARAMS

			@classmethod
			def        UpperCAmelCase__ (cls      ):
								super().setUpClass()
								torch.use_deterministic_algorithms(A      )

			@classmethod
			def        UpperCAmelCase__ (cls      ):
								super().tearDownClass()
								torch.use_deterministic_algorithms(A      )

			def        UpperCAmelCase__ (self      ):
								torch.manual_seed(0      )
								lowerCamelCase_					:      str     =		UNetaDConditionModel(
								    block_out_channels=(3_2, 6_4)			,   layers_per_block=1			,   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			,   attention_head_dim=(2, 4)			,   use_linear_projection=A			,   )
								lowerCamelCase_					:      List[Any]     =		DDIMScheduler(
								    beta_start=0.0_00_85			,   beta_end=0.0_12			,   beta_schedule='''scaled_linear'''			,   clip_sample=A			,   set_alpha_to_one=A			,   )
								torch.manual_seed(0      )
								lowerCamelCase_					:      Union[str, Any]     =		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			,   sample_size=1_2_8			,   )
								torch.manual_seed(0      )
								lowerCamelCase_					:      Tuple     =		CLIPTextConfig(
								    bos_token_id=0			,   eos_token_id=2			,   hidden_size=3_2			,   intermediate_size=3_7			,   layer_norm_eps=1E-05			,   num_attention_heads=4			,   num_hidden_layers=5			,   pad_token_id=1			,   vocab_size=1_0_0_0			,   hidden_act='''gelu'''			,   projection_dim=5_1_2			,   )
								lowerCamelCase_					:      List[Any]     =		CLIPTextModel(A      )
								lowerCamelCase_					:      int     =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

								lowerCamelCase_					:      Optional[int]     =		{
								    '''unet''': unet,
								    '''scheduler''': scheduler,
								    '''vae''': vae,
								    '''text_encoder''': text_encoder,
								    '''tokenizer''': tokenizer,
								    '''safety_checker''': None,
								    '''feature_extractor''': None,
								}

								return components

			def        UpperCAmelCase__ (self			,   A			,   A=0      ):
								if str(A      ).startswith('''mps'''      ):
													lowerCamelCase_					:      int     =		torch.manual_seed(A      )
								else:
													lowerCamelCase_					:      Any     =		torch.Generator(device=A      ).manual_seed(A      )
								lowerCamelCase_					:      Optional[int]     =		{
								    '''prompt''': '''a cat and a frog''',
								    '''token_indices''': [2, 5],
								    '''generator''': generator,
								    '''num_inference_steps''': 1,
								    '''guidance_scale''': 6.0,
								    '''output_type''': '''numpy''',
								    '''max_iter_to_alter''': 2,
								    '''thresholds''': {0: 0.7},
								}
								return inputs

			def        UpperCAmelCase__ (self      ):
								lowerCamelCase_					:      List[Any]     =		'''cpu'''

								lowerCamelCase_					:      Optional[int]     =		self.get_dummy_components()
								lowerCamelCase_					:      List[str]     =		self.pipeline_class(**A      )
								pipe.to(A      )
								pipe.set_progress_bar_config(disable=A      )

								lowerCamelCase_					:      str     =		self.get_dummy_inputs(A      )
								lowerCamelCase_					:      Dict     =		pipe(**A      ).images
								lowerCamelCase_					:      Optional[int]     =		image[0, -3:, -3:, -1]

								self.assertEqual(image.shape			,   (1, 6_4, 6_4, 3)      )
								lowerCamelCase_					:      str     =		np.array(
								    [0.63_90_53_64, 0.62_89_73_07, 0.48_59_90_17, 0.5_13_36_24, 0.5_55_00_48, 0.45_76_95_16, 0.50_32_69_73, 0.5_02_31_39, 0.45_38_44_96]      )
								lowerCamelCase_					:      Optional[Any]     =		np.abs(image_slice.flatten() - expected_slice      ).max()
								self.assertLessEqual(A			,   1E-3      )

			def        UpperCAmelCase__ (self      ):
								super().test_cpu_offload_forward_pass(expected_max_diff=5E-4      )

			def        UpperCAmelCase__ (self      ):
								# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
								self._test_inference_batch_consistent(batch_sizes=[1, 2]      )

			def        UpperCAmelCase__ (self      ):
								self._test_inference_batch_single_identical(batch_size=2			,   expected_max_diff=7E-4      )

			def        UpperCAmelCase__ (self      ):
								super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3      )

			def        UpperCAmelCase__ (self      ):
								super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4      )

			def        UpperCAmelCase__ (self      ):
								super().test_save_load_local(expected_max_difference=5E-4      )






			def        UpperCAmelCase__ (self      ):
								super().test_save_load_optional_components(expected_max_difference=4E-4      )

@require_torch_gpu
@slow
class 	__lowercase				(  unittest.TestCase    ):

			@classmethod
			def        UpperCAmelCase__ (cls      ):
								super().setUpClass()
								torch.use_deterministic_algorithms(A      )

			@classmethod
			def        UpperCAmelCase__ (cls      ):
								super().tearDownClass()
								torch.use_deterministic_algorithms(A      )

			def        UpperCAmelCase__ (self      ):
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()






			def        UpperCAmelCase__ (self      ):
								lowerCamelCase_					:      List[str]     =		torch.manual_seed(5_1      )

								lowerCamelCase_					:      Tuple     =		StableDiffusionAttendAndExcitePipeline.from_pretrained(
								    '''CompVis/stable-diffusion-v1-4'''			,   safety_checker=A			,   torch_dtype=torch.floataa      )
								pipe.to('''cuda'''      )

								lowerCamelCase_					:      Optional[Any]     =		'''a painting of an elephant with glasses'''
								lowerCamelCase_					:      Tuple     =		[5, 7]

								lowerCamelCase_					:      List[str]     =		pipe(
								    prompt=A			,   token_indices=A			,   guidance_scale=7.5			,   generator=A			,   num_inference_steps=5			,   max_iter_to_alter=5			,   output_type='''numpy'''			,   ).images[0]

								lowerCamelCase_					:      Tuple     =		load_numpy(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy'''      )
								assert np.abs((expected_image - image).max()      ) < 5E-1




'''simple docstring'''


def lowercase_	(   _lowercase			,       _lowercase				)     ->							Dict:
					'''simple docstring'''

					lowerCamelCase_					:      List[Any]     =		0
					while b > 0:
										if b & 1:
															res += a

										a += a
										b >>= 1

					return res




def lowercase_	(   _lowercase			,       _lowercase			,       _lowercase				)     ->							Optional[Any]:
					'''simple docstring'''

					lowerCamelCase_					:      str     =		0
					while b > 0:
										if b & 1:
															lowerCamelCase_					:      Optional[int]     =		((res % c) + (a % c)) % c

										a += a
										b >>= 1

					return res


