




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


_A													=      False


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






   @classmethod
   def 	_lowerCAmelCase   (		cls       :		Union[str, Any]   )			->						Union[str, Any]:

         """simple docstring"""
         super().setUpClass()
         torch.use_deterministic_algorithms(UpperCamelCase   )






   @classmethod
   def 	_lowerCAmelCase   (		cls       :		Any   )			->						Dict:

         """simple docstring"""
         super().tearDownClass()
         torch.use_deterministic_algorithms(UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		Dict   )			->						str:

         """simple docstring"""
         torch.manual_seed(0   )
         lowerCAmelCase__      :			Optional[int]   =	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=UpperCamelCase   ,     )
         lowerCAmelCase__      :			Any   =	DDIMScheduler(
             beta_start=0.0_0085   ,     beta_end=0.012   ,     beta_schedule="""scaled_linear"""   ,     clip_sample=UpperCamelCase   ,     set_alpha_to_one=UpperCamelCase   ,     )
         torch.manual_seed(0   )
         lowerCAmelCase__      :			int   =	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=1_28   ,     )
         torch.manual_seed(0   )
         lowerCAmelCase__      :			Optional[int]   =	CLIPTextConfig(
             bos_token_id=0   ,     eos_token_id=2   ,     hidden_size=32   ,     intermediate_size=37   ,     layer_norm_eps=1E-0_5   ,     num_attention_heads=4   ,     num_hidden_layers=5   ,     pad_token_id=1   ,     vocab_size=10_00   ,     hidden_act="""gelu"""   ,     projection_dim=5_12   ,     )
         lowerCAmelCase__      :			Tuple   =	CLIPTextModel(UpperCamelCase   )
         lowerCAmelCase__      :			Optional[int]   =	CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""   )

         lowerCAmelCase__      :			List[Any]   =	{
             """unet""": unet,
             """scheduler""": scheduler,
             """vae""": vae,
             """text_encoder""": text_encoder,
             """tokenizer""": tokenizer,
             """safety_checker""": None,
             """feature_extractor""": None,
         }

         return components






   def 	_lowerCAmelCase   (		self       :		Optional[int]   ,     UpperCamelCase       :		int   ,     UpperCamelCase       :		Optional[int]=0   )			->						Tuple:

         """simple docstring"""
         if str(UpperCamelCase   ).startswith("""mps"""   ):
               lowerCAmelCase__      :			List[str]   =	torch.manual_seed(UpperCamelCase   )
         else:
               lowerCAmelCase__      :			Optional[int]   =	torch.Generator(device=UpperCamelCase   ).manual_seed(UpperCamelCase   )
         lowerCAmelCase__      :			Optional[Any]   =	{
             """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 	_lowerCAmelCase   (		self       :		Tuple   )			->						Union[str, Any]:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[int]   =	"""cpu"""

         lowerCAmelCase__      :			Optional[int]   =	self.get_dummy_components()
         lowerCAmelCase__      :			Dict   =	self.pipeline_class(**UpperCamelCase   )
         pipe.to(UpperCamelCase   )
         pipe.set_progress_bar_config(disable=UpperCamelCase   )

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

         self.assertEqual(image.shape   ,     (1, 64, 64, 3)   )
         lowerCAmelCase__      :			List[Any]   =	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]   )
         lowerCAmelCase__      :			Any   =	np.abs(image_slice.flatten() - expected_slice   ).max()
         self.assertLessEqual(UpperCamelCase   ,     1E-3   )






   def 	_lowerCAmelCase   (		self       :		Optional[int]   )			->						Dict:

         """simple docstring"""
         super().test_cpu_offload_forward_pass(expected_max_diff=5E-4   )






   def 	_lowerCAmelCase   (		self       :		str   )			->						Optional[Any]:

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






   def 	_lowerCAmelCase   (		self       :		Dict   )			->						List[Any]:

         """simple docstring"""
         self._test_inference_batch_single_identical(batch_size=2   ,     expected_max_diff=7E-4   )






   def 	_lowerCAmelCase   (		self       :		List[str]   )			->						int:

         """simple docstring"""
         super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3   )






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						Union[str, Any]:

         """simple docstring"""
         super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4   )






   def 	_lowerCAmelCase   (		self       :		str   )			->						Tuple:

         """simple docstring"""
         super().test_save_load_local(expected_max_difference=5E-4   )






   def 	_lowerCAmelCase   (		self       :		Union[str, Any]   )			->						Any:

         """simple docstring"""
         super().test_save_load_optional_components(expected_max_difference=4E-4   )






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






   @classmethod
   def 	_lowerCAmelCase   (		cls       :		int   )			->						str:

         """simple docstring"""
         super().setUpClass()
         torch.use_deterministic_algorithms(UpperCamelCase   )






   @classmethod
   def 	_lowerCAmelCase   (		cls       :		Dict   )			->						Any:

         """simple docstring"""
         super().tearDownClass()
         torch.use_deterministic_algorithms(UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		str   )			->						List[str]:

         """simple docstring"""
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()






   def 	_lowerCAmelCase   (		self       :		Any   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			Dict   =	torch.manual_seed(51   )

         lowerCAmelCase__      :			Dict   =	StableDiffusionAttendAndExcitePipeline.from_pretrained(
             """CompVis/stable-diffusion-v1-4"""   ,     safety_checker=UpperCamelCase   ,     torch_dtype=torch.floataa   )
         pipe.to("""cuda"""   )

         lowerCAmelCase__      :			Optional[Any]   =	"""a painting of an elephant with glasses"""
         lowerCAmelCase__      :			str   =	[5, 7]

         lowerCAmelCase__      :			List[str]   =	pipe(
             prompt=UpperCamelCase   ,     token_indices=UpperCamelCase   ,     guidance_scale=7.5   ,     generator=UpperCamelCase   ,     num_inference_steps=5   ,     max_iter_to_alter=5   ,     output_type="""numpy"""   ,     ).images[0]

         lowerCAmelCase__      :			Optional[int]   =	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"""


from .configuration_bert_masked import MaskedBertConfig
from .modeling_bert_masked import (
    MaskedBertForMultipleChoice,
    MaskedBertForQuestionAnswering,
    MaskedBertForSequenceClassification,
    MaskedBertForTokenClassification,
    MaskedBertModel,
)
from .modules import *





