


"""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_			     =  False
@skip_mps
class 					__lowerCAmelCase					(   __SCREAMING_SNAKE_CASE     ,			__SCREAMING_SNAKE_CASE     ,			__SCREAMING_SNAKE_CASE     ,			unittest.TestCase       ):


		'''simple docstring'''



		__UpperCAmelCase		:			Optional[int]										=				StableDiffusionAttendAndExcitePipeline
		__UpperCAmelCase		:			Union[str, Any]										=				False
		__UpperCAmelCase		:			Union[str, Any]										=				TEXT_TO_IMAGE_PARAMS
		__UpperCAmelCase		:			Dict										=				TEXT_TO_IMAGE_BATCH_PARAMS.union({'token_indices'}       )
		__UpperCAmelCase		:			Optional[Any]										=				TEXT_TO_IMAGE_IMAGE_PARAMS
		__UpperCAmelCase		:			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      )
				__a           =			UNetaDConditionModel(
				    block_out_channels=(32, 64)							, layers_per_block=1							, sample_size=32							, in_channels=4							, out_channels=4							, down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')							, up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')							, cross_attention_dim=32							, attention_head_dim=(2, 4)							, use_linear_projection=_a							, )
				__a           =			DDIMScheduler(
				    beta_start=0.0_0085							, beta_end=0.012							, beta_schedule='''scaled_linear'''							, clip_sample=_a							, set_alpha_to_one=_a							, )
				torch.manual_seed(0      )
				__a           =			AutoencoderKL(
				    block_out_channels=[32, 64]							, in_channels=3							, out_channels=3							, down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']							, up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']							, latent_channels=4							, sample_size=128							, )
				torch.manual_seed(0      )
				__a           =			CLIPTextConfig(
				    bos_token_id=0							, eos_token_id=2							, hidden_size=32							, intermediate_size=37							, layer_norm_eps=1E-05							, num_attention_heads=4							, num_hidden_layers=5							, pad_token_id=1							, vocab_size=1_000							, hidden_act='''gelu'''							, projection_dim=512							, )
				__a           =			CLIPTextModel(_a      )
				__a           =			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

				__a           =			{
				    '''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'''      ):
						__a           =			torch.manual_seed(_a      )
				else:
						__a           =			torch.Generator(device=_a      ).manual_seed(_a      )
				__a           =			__a           =			{
				    '''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      ):
				__a           =			'''cpu'''

				__a           =			self.get_dummy_components()
				__a           =			self.pipeline_class(**_a      )
				pipe.to(_a      )
				pipe.set_progress_bar_config(disable=_a      )

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

				self.assertEqual(image.shape							, (1, 64, 64, 3)      )
				__a           =			np.array(
				    [0.6390_5364, 0.6289_7307, 0.4859_9017, 0.513_3624, 0.555_0048, 0.4576_9516, 0.5032_6973, 0.502_3139, 0.4538_4496]      )
				__a           =			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 					__lowerCAmelCase					(   unittest.TestCase       ):


		'''simple docstring'''



		@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      ):
				__a           =			torch.manual_seed(51      )

				__a           =			StableDiffusionAttendAndExcitePipeline.from_pretrained(
				    '''CompVis/stable-diffusion-v1-4'''							, safety_checker=_a							, torch_dtype=torch.floataa      )
				pipe.to('''cuda'''      )

				__a           =			'''a painting of an elephant with glasses'''
				__a           =			[5, 7]

				__a           =			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]

				__a           =			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"""




import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation
class 					__lowerCAmelCase					(   unittest.TestCase       ):


		'''simple docstring'''



		def 			__UpperCAmelCase       (  self      ):
				__a           =			get_activation('''swish'''      )

				self.assertIsInstance(_a							, nn.SiLU      )

				self.assertEqual(act(torch.tensor(-100							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertNotEqual(act(torch.tensor(-1							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(0							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(20							, dtype=torch.floataa      )      ).item()							, 20      )

		def 			__UpperCAmelCase       (  self      ):
				__a           =			get_activation('''silu'''      )

				self.assertIsInstance(_a							, nn.SiLU      )

				self.assertEqual(act(torch.tensor(-100							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertNotEqual(act(torch.tensor(-1							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(0							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(20							, dtype=torch.floataa      )      ).item()							, 20      )

		def 			__UpperCAmelCase       (  self      ):
				__a           =			get_activation('''mish'''      )

				self.assertIsInstance(_a							, nn.Mish      )

				self.assertEqual(act(torch.tensor(-200							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertNotEqual(act(torch.tensor(-1							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(0							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(20							, dtype=torch.floataa      )      ).item()							, 20      )





		def 			__UpperCAmelCase       (  self      ):
				__a           =			get_activation('''gelu'''      )

				self.assertIsInstance(_a							, nn.GELU      )

				self.assertEqual(act(torch.tensor(-100							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertNotEqual(act(torch.tensor(-1							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(0							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(20							, dtype=torch.floataa      )      ).item()							, 20      )






