
"""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_					(   a_		,       a_		,       a_		,       unittest.TestCase     ):



						'''simple docstring'''


						_lowerCamelCase:     Optional[int]   =     StableDiffusionAttendAndExcitePipeline
						_lowerCamelCase:     Tuple   =     False
						_lowerCamelCase:     int   =     TEXT_TO_IMAGE_PARAMS
						_lowerCamelCase:     Any   =     TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}     )
						_lowerCamelCase:     List[Any]   =     TEXT_TO_IMAGE_IMAGE_PARAMS
						_lowerCamelCase:     List[Any]   =     TEXT_TO_IMAGE_IMAGE_PARAMS


						@classmethod
						def     _SCREAMING_SNAKE_CASE   (			cls  :   Optional[Any]   )  -> Union[str, Any]:
							super().setUpClass()
							torch.use_deterministic_algorithms(_lowercase   )


						@classmethod
						def     _SCREAMING_SNAKE_CASE   (			cls  :   List[Any]   )  -> str:
							super().tearDownClass()
							torch.use_deterministic_algorithms(_lowercase   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   int   )  -> Dict:
							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=_lowercase	,)
							A     = DDIMScheduler(
							    beta_start=0.0_00_85	,beta_end=0.0_12	,beta_schedule='scaled_linear'	,clip_sample=_lowercase	,set_alpha_to_one=_lowercase	,)
							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=1000	,hidden_act='gelu'	,projection_dim=512	,)
							A     = CLIPTextModel(_lowercase   )
							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     _SCREAMING_SNAKE_CASE   (			self  :   Dict	,A_  :   Union[str, Any]	,A_  :   Tuple=0   )  -> Any:
							if str(_lowercase   ).startswith('mps'   ):
								A     = torch.manual_seed(_lowercase   )
							else:
								A     = torch.Generator(device=_lowercase   ).manual_seed(_lowercase   )
							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     _SCREAMING_SNAKE_CASE   (			self  :   Optional[int]   )  -> Union[str, Any]:
							A     = """cpu"""

							A     = self.get_dummy_components()
							A     = self.pipeline_class(**_lowercase   )
							pipe.to(_lowercase   )
							pipe.set_progress_bar_config(disable=_lowercase   )

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

							self.assertEqual(image.shape	,(1, 64, 64, 3)   )
							A     = 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]   )
							A     = np.abs(image_slice.flatten() - expected_slice   ).max()
							self.assertLessEqual(_lowercase	,1e-3   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   str   )  -> Optional[int]:
							super().test_cpu_offload_forward_pass(expected_max_diff=5e-4   )


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


						def     _SCREAMING_SNAKE_CASE   (			self  :   int   )  -> Tuple:
							self._test_inference_batch_single_identical(batch_size=2	,expected_max_diff=7e-4   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   int   )  -> List[str]:
							super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   Tuple   )  -> Optional[Any]:
							super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   Any   )  -> List[str]:
							super().test_save_load_local(expected_max_difference=5e-4   )




						def     _SCREAMING_SNAKE_CASE   (			self  :   int   )  -> Optional[Any]:
							super().test_save_load_optional_components(expected_max_difference=4e-4   )







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



						'''simple docstring'''


						@classmethod
						def     _SCREAMING_SNAKE_CASE   (			cls  :   Optional[int]   )  -> Dict:
							super().setUpClass()
							torch.use_deterministic_algorithms(_lowercase   )


						@classmethod
						def     _SCREAMING_SNAKE_CASE   (			cls  :   Optional[int]   )  -> List[str]:
							super().tearDownClass()
							torch.use_deterministic_algorithms(_lowercase   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   List[str]   )  -> List[str]:
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()




						def     _SCREAMING_SNAKE_CASE   (			self  :   List[str]   )  -> int:
							A     = torch.manual_seed(51   )

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

							A     = """a painting of an elephant with glasses"""
							A     = [5, 7]

							A     = pipe(
							    prompt=_lowercase	,token_indices=_lowercase	,guidance_scale=7.5	,generator=_lowercase	,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


from ...configuration_utils import PretrainedConfig
from ...utils import logging


__snake_case				:      Any   		=			logging.get_logger(__name__)

__snake_case				:      Union[str, Any]   		=			{
    """microsoft/cvt-13""": """https://huggingface.co/microsoft/cvt-13/resolve/main/config.json""",
    # See all Cvt models at https://huggingface.co/models?filter=cvt
}



class        A__(a_							):
						"""simple docstring"""






						_A    :				Union[str, Any]       					=			'''cvt'''





						def __init__(    self  ,      _lowercase=3  ,      _lowercase=[7, 3, 3]  ,      _lowercase=[4, 2, 2]  ,      _lowercase=[2, 1, 1]  ,      _lowercase=[64, 192, 384]  ,      _lowercase=[1, 3, 6]  ,      _lowercase=[1, 2, 10]  ,      _lowercase=[4.0, 4.0, 4.0]  ,      _lowercase=[0.0, 0.0, 0.0]  ,      _lowercase=[0.0, 0.0, 0.0]  ,      _lowercase=[0.0, 0.0, 0.1]  ,      _lowercase=[True, True, True]  ,      _lowercase=[False, False, True]  ,      _lowercase=["dw_bn", "dw_bn", "dw_bn"]  ,      _lowercase=[3, 3, 3]  ,      _lowercase=[1, 1, 1]  ,      _lowercase=[2, 2, 2]  ,      _lowercase=[1, 1, 1]  ,      _lowercase=[1, 1, 1]  ,      _lowercase=0.0_2  ,      _lowercase=1e-12  ,      **_lowercase  ,      )     -> Tuple:
									super().__init__(**_lowercase    )
									a_						:						str 							= num_channels
									a_						:						Optional[int] 							= patch_sizes
									a_						:						Dict 							= patch_stride
									a_						:						int 							= patch_padding
									a_						:						int 							= embed_dim
									a_						:						Tuple 							= num_heads
									a_						:						Optional[Any] 							= depth
									a_						:						str 							= mlp_ratio
									a_						:						Optional[int] 							= attention_drop_rate
									a_						:						int 							= drop_rate
									a_						:						List[Any] 							= drop_path_rate
									a_						:						List[Any] 							= qkv_bias
									a_						:						Dict 							= cls_token
									a_						:						Union[str, Any] 							= qkv_projection_method
									a_						:						List[Any] 							= kernel_qkv
									a_						:						Optional[Any] 							= padding_kv
									a_						:						Any 							= stride_kv
									a_						:						Dict 							= padding_q
									a_						:						Optional[int] 							= stride_q
									a_						:						Tuple 							= initializer_range
									a_						:						int 							= layer_norm_eps


